# SOME DESCRIPTIVE TITLE. # Copyright (C) 2001-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-04-02 22:11+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: ../Doc/reference/expressions.rst:6 msgid "Expressions" msgstr "" #: ../Doc/reference/expressions.rst:10 msgid "" "This chapter explains the meaning of the elements of expressions in Python." msgstr "" #: ../Doc/reference/expressions.rst:12 msgid "" "**Syntax Notes:** In this and the following chapters, extended BNF notation " "will be used to describe syntax, not lexical analysis. When (one " "alternative of) a syntax rule has the form" msgstr "" #: ../Doc/reference/expressions.rst:19 msgid "" "and no semantics are given, the semantics of this form of ``name`` are the " "same as for ``othername``." msgstr "" #: ../Doc/reference/expressions.rst:26 msgid "Arithmetic conversions" msgstr "" #: ../Doc/reference/expressions.rst:30 msgid "" "When a description of an arithmetic operator below uses the phrase \"the " "numeric arguments are converted to a common type,\" this means that the " "operator implementation for built-in types works as follows:" msgstr "" #: ../Doc/reference/expressions.rst:34 msgid "" "If either argument is a complex number, the other is converted to complex;" msgstr "" #: ../Doc/reference/expressions.rst:36 msgid "" "otherwise, if either argument is a floating point number, the other is " "converted to floating point;" msgstr "" #: ../Doc/reference/expressions.rst:39 msgid "otherwise, both must be integers and no conversion is necessary." msgstr "" #: ../Doc/reference/expressions.rst:41 msgid "" "Some additional rules apply for certain operators (e.g., a string as a left " "argument to the '%' operator). Extensions must define their own conversion " "behavior." msgstr "" #: ../Doc/reference/expressions.rst:49 msgid "Atoms" msgstr "" #: ../Doc/reference/expressions.rst:53 msgid "" "Atoms are the most basic elements of expressions. The simplest atoms are " "identifiers or literals. Forms enclosed in parentheses, brackets or braces " "are also categorized syntactically as atoms. The syntax for atoms is:" msgstr "" #: ../Doc/reference/expressions.rst:66 msgid "Identifiers (Names)" msgstr "" #: ../Doc/reference/expressions.rst:70 msgid "" "An identifier occurring as an atom is a name. See section :ref:" "`identifiers` for lexical definition and section :ref:`naming` for " "documentation of naming and binding." msgstr "" #: ../Doc/reference/expressions.rst:76 msgid "" "When the name is bound to an object, evaluation of the atom yields that " "object. When a name is not bound, an attempt to evaluate it raises a :exc:" "`NameError` exception." msgstr "" #: ../Doc/reference/expressions.rst:84 msgid "" "**Private name mangling:** When an identifier that textually occurs in a " "class definition begins with two or more underscore characters and does not " "end in two or more underscores, it is considered a :dfn:`private name` of " "that class. Private names are transformed to a longer form before code is " "generated for them. The transformation inserts the class name, with leading " "underscores removed and a single underscore inserted, in front of the name. " "For example, the identifier ``__spam`` occurring in a class named ``Ham`` " "will be transformed to ``_Ham__spam``. This transformation is independent " "of the syntactical context in which the identifier is used. If the " "transformed name is extremely long (longer than 255 characters), " "implementation defined truncation may happen. If the class name consists " "only of underscores, no transformation is done." msgstr "" #: ../Doc/reference/expressions.rst:100 msgid "Literals" msgstr "" #: ../Doc/reference/expressions.rst:104 msgid "Python supports string and bytes literals and various numeric literals:" msgstr "" #: ../Doc/reference/expressions.rst:110 msgid "" "Evaluation of a literal yields an object of the given type (string, bytes, " "integer, floating point number, complex number) with the given value. The " "value may be approximated in the case of floating point and imaginary " "(complex) literals. See section :ref:`literals` for details." msgstr "" #: ../Doc/reference/expressions.rst:119 msgid "" "All literals correspond to immutable data types, and hence the object's " "identity is less important than its value. Multiple evaluations of literals " "with the same value (either the same occurrence in the program text or a " "different occurrence) may obtain the same object or a different object with " "the same value." msgstr "" #: ../Doc/reference/expressions.rst:129 msgid "Parenthesized forms" msgstr "" #: ../Doc/reference/expressions.rst:133 msgid "" "A parenthesized form is an optional expression list enclosed in parentheses:" msgstr "" #: ../Doc/reference/expressions.rst:138 msgid "" "A parenthesized expression list yields whatever that expression list yields: " "if the list contains at least one comma, it yields a tuple; otherwise, it " "yields the single expression that makes up the expression list." msgstr "" #: ../Doc/reference/expressions.rst:144 msgid "" "An empty pair of parentheses yields an empty tuple object. Since tuples are " "immutable, the rules for literals apply (i.e., two occurrences of the empty " "tuple may or may not yield the same object)." msgstr "" #: ../Doc/reference/expressions.rst:152 msgid "" "Note that tuples are not formed by the parentheses, but rather by use of the " "comma operator. The exception is the empty tuple, for which parentheses " "*are* required --- allowing unparenthesized \"nothing\" in expressions would " "cause ambiguities and allow common typos to pass uncaught." msgstr "" #: ../Doc/reference/expressions.rst:161 msgid "Displays for lists, sets and dictionaries" msgstr "" #: ../Doc/reference/expressions.rst:163 msgid "" "For constructing a list, a set or a dictionary Python provides special " "syntax called \"displays\", each of them in two flavors:" msgstr "" #: ../Doc/reference/expressions.rst:166 msgid "either the container contents are listed explicitly, or" msgstr "" #: ../Doc/reference/expressions.rst:168 msgid "" "they are computed via a set of looping and filtering instructions, called a :" "dfn:`comprehension`." msgstr "" #: ../Doc/reference/expressions.rst:171 msgid "Common syntax elements for comprehensions are:" msgstr "" #: ../Doc/reference/expressions.rst:179 msgid "" "The comprehension consists of a single expression followed by at least one :" "keyword:`for` clause and zero or more :keyword:`for` or :keyword:`if` " "clauses. In this case, the elements of the new container are those that " "would be produced by considering each of the :keyword:`for` or :keyword:`if` " "clauses a block, nesting from left to right, and evaluating the expression " "to produce an element each time the innermost block is reached." msgstr "" #: ../Doc/reference/expressions.rst:186 msgid "" "Note that the comprehension is executed in a separate scope, so names " "assigned to in the target list don't \"leak\" into the enclosing scope." msgstr "" #: ../Doc/reference/expressions.rst:189 msgid "" "Since Python 3.6, in an :keyword:`async def` function, an :keyword:`async " "for` clause may be used to iterate over a :term:`asynchronous iterator`. A " "comprehension in an :keyword:`async def` function may consist of either a :" "keyword:`for` or :keyword:`async for` clause following the leading " "expression, may contain additional :keyword:`for` or :keyword:`async for` " "clauses, and may also use :keyword:`await` expressions. If a comprehension " "contains either :keyword:`async for` clauses or :keyword:`await` expressions " "it is called an :dfn:`asynchronous comprehension`. An asynchronous " "comprehension may suspend the execution of the coroutine function in which " "it appears. See also :pep:`530`." msgstr "" #: ../Doc/reference/expressions.rst:204 msgid "List displays" msgstr "" #: ../Doc/reference/expressions.rst:212 msgid "" "A list display is a possibly empty series of expressions enclosed in square " "brackets:" msgstr "" #: ../Doc/reference/expressions.rst:218 msgid "" "A list display yields a new list object, the contents being specified by " "either a list of expressions or a comprehension. When a comma-separated " "list of expressions is supplied, its elements are evaluated from left to " "right and placed into the list object in that order. When a comprehension " "is supplied, the list is constructed from the elements resulting from the " "comprehension." msgstr "" #: ../Doc/reference/expressions.rst:228 msgid "Set displays" msgstr "" #: ../Doc/reference/expressions.rst:233 msgid "" "A set display is denoted by curly braces and distinguishable from dictionary " "displays by the lack of colons separating keys and values:" msgstr "" #: ../Doc/reference/expressions.rst:239 msgid "" "A set display yields a new mutable set object, the contents being specified " "by either a sequence of expressions or a comprehension. When a comma-" "separated list of expressions is supplied, its elements are evaluated from " "left to right and added to the set object. When a comprehension is " "supplied, the set is constructed from the elements resulting from the " "comprehension." msgstr "" #: ../Doc/reference/expressions.rst:245 msgid "" "An empty set cannot be constructed with ``{}``; this literal constructs an " "empty dictionary." msgstr "" #: ../Doc/reference/expressions.rst:252 msgid "Dictionary displays" msgstr "" #: ../Doc/reference/expressions.rst:258 msgid "" "A dictionary display is a possibly empty series of key/datum pairs enclosed " "in curly braces:" msgstr "" #: ../Doc/reference/expressions.rst:267 msgid "A dictionary display yields a new dictionary object." msgstr "" #: ../Doc/reference/expressions.rst:269 msgid "" "If a comma-separated sequence of key/datum pairs is given, they are " "evaluated from left to right to define the entries of the dictionary: each " "key object is used as a key into the dictionary to store the corresponding " "datum. This means that you can specify the same key multiple times in the " "key/datum list, and the final dictionary's value for that key will be the " "last one given." msgstr "" #: ../Doc/reference/expressions.rst:277 msgid "" "A double asterisk ``**`` denotes :dfn:`dictionary unpacking`. Its operand " "must be a :term:`mapping`. Each mapping item is added to the new " "dictionary. Later values replace values already set by earlier key/datum " "pairs and earlier dictionary unpackings." msgstr "" #: ../Doc/reference/expressions.rst:282 msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`." msgstr "" #: ../Doc/reference/expressions.rst:285 msgid "" "A dict comprehension, in contrast to list and set comprehensions, needs two " "expressions separated with a colon followed by the usual \"for\" and \"if\" " "clauses. When the comprehension is run, the resulting key and value elements " "are inserted in the new dictionary in the order they are produced." msgstr "" #: ../Doc/reference/expressions.rst:293 msgid "" "Restrictions on the types of the key values are listed earlier in section :" "ref:`types`. (To summarize, the key type should be :term:`hashable`, which " "excludes all mutable objects.) Clashes between duplicate keys are not " "detected; the last datum (textually rightmost in the display) stored for a " "given key value prevails." msgstr "" #: ../Doc/reference/expressions.rst:303 msgid "Generator expressions" msgstr "Générateurs (expressions)" #: ../Doc/reference/expressions.rst:308 msgid "A generator expression is a compact generator notation in parentheses:" msgstr "" #: ../Doc/reference/expressions.rst:313 msgid "" "A generator expression yields a new generator object. Its syntax is the " "same as for comprehensions, except that it is enclosed in parentheses " "instead of brackets or curly braces." msgstr "" #: ../Doc/reference/expressions.rst:317 msgid "" "Variables used in the generator expression are evaluated lazily when the :" "meth:`~generator.__next__` method is called for the generator object (in the " "same fashion as normal generators). However, the leftmost :keyword:`for` " "clause is immediately evaluated, so that an error produced by it can be seen " "before any other possible error in the code that handles the generator " "expression. Subsequent :keyword:`for` clauses cannot be evaluated " "immediately since they may depend on the previous :keyword:`for` loop. For " "example: ``(x*y for x in range(10) for y in bar(x))``." msgstr "" #: ../Doc/reference/expressions.rst:326 msgid "" "The parentheses can be omitted on calls with only one argument. See " "section :ref:`calls` for details." msgstr "" #: ../Doc/reference/expressions.rst:329 msgid "" "Since Python 3.6, if the generator appears in an :keyword:`async def` " "function, then :keyword:`async for` clauses and :keyword:`await` expressions " "are permitted as with an asynchronous comprehension. If a generator " "expression contains either :keyword:`async for` clauses or :keyword:`await` " "expressions it is called an :dfn:`asynchronous generator expression`. An " "asynchronous generator expression yields a new asynchronous generator " "object, which is an asynchronous iterator (see :ref:`async-iterators`)." msgstr "" #: ../Doc/reference/expressions.rst:341 msgid "Yield expressions" msgstr "" #: ../Doc/reference/expressions.rst:352 msgid "" "The yield expression is used when defining a :term:`generator` function or " "an :term:`asynchronous generator` function and thus can only be used in the " "body of a function definition. Using a yield expression in a function's " "body causes that function to be a generator, and using it in an :keyword:" "`async def` function's body causes that coroutine function to be an " "asynchronous generator. For example::" msgstr "" #: ../Doc/reference/expressions.rst:365 msgid "" "Generator functions are described below, while asynchronous generator " "functions are described separately in section :ref:`asynchronous-generator-" "functions`." msgstr "" #: ../Doc/reference/expressions.rst:369 msgid "" "When a generator function is called, it returns an iterator known as a " "generator. That generator then controls the execution of the generator " "function. The execution starts when one of the generator's methods is " "called. At that time, the execution proceeds to the first yield expression, " "where it is suspended again, returning the value of :token:`expression_list` " "to the generator's caller. By suspended, we mean that all local state is " "retained, including the current bindings of local variables, the instruction " "pointer, the internal evaluation stack, and the state of any exception " "handling. When the execution is resumed by calling one of the generator's " "methods, the function can proceed exactly as if the yield expression were " "just another external call. The value of the yield expression after " "resuming depends on the method which resumed the execution. If :meth:" "`~generator.__next__` is used (typically via either a :keyword:`for` or the :" "func:`next` builtin) then the result is :const:`None`. Otherwise, if :meth:" "`~generator.send` is used, then the result will be the value passed in to " "that method." msgstr "" #: ../Doc/reference/expressions.rst:388 msgid "" "All of this makes generator functions quite similar to coroutines; they " "yield multiple times, they have more than one entry point and their " "execution can be suspended. The only difference is that a generator " "function cannot control where the execution should continue after it yields; " "the control is always transferred to the generator's caller." msgstr "" #: ../Doc/reference/expressions.rst:394 msgid "" "Yield expressions are allowed anywhere in a :keyword:`try` construct. If " "the generator is not resumed before it is finalized (by reaching a zero " "reference count or by being garbage collected), the generator-iterator's :" "meth:`~generator.close` method will be called, allowing any pending :keyword:" "`finally` clauses to execute." msgstr "" #: ../Doc/reference/expressions.rst:400 msgid "" "When ``yield from `` is used, it treats the supplied expression as a " "subiterator. All values produced by that subiterator are passed directly to " "the caller of the current generator's methods. Any values passed in with :" "meth:`~generator.send` and any exceptions passed in with :meth:`~generator." "throw` are passed to the underlying iterator if it has the appropriate " "methods. If this is not the case, then :meth:`~generator.send` will raise :" "exc:`AttributeError` or :exc:`TypeError`, while :meth:`~generator.throw` " "will just raise the passed in exception immediately." msgstr "" #: ../Doc/reference/expressions.rst:409 msgid "" "When the underlying iterator is complete, the :attr:`~StopIteration.value` " "attribute of the raised :exc:`StopIteration` instance becomes the value of " "the yield expression. It can be either set explicitly when raising :exc:" "`StopIteration`, or automatically when the sub-iterator is a generator (by " "returning a value from the sub-generator)." msgstr "" #: ../Doc/reference/expressions.rst:415 msgid "Added ``yield from `` to delegate control flow to a subiterator." msgstr "" #: ../Doc/reference/expressions.rst:418 msgid "" "The parentheses may be omitted when the yield expression is the sole " "expression on the right hand side of an assignment statement." msgstr "" #: ../Doc/reference/expressions.rst:424 msgid ":pep:`255` - Simple Generators" msgstr ":pep:`255`: Générateurs simples" #: ../Doc/reference/expressions.rst:424 msgid "" "The proposal for adding generators and the :keyword:`yield` statement to " "Python." msgstr "" #: ../Doc/reference/expressions.rst:428 msgid ":pep:`342` - Coroutines via Enhanced Generators" msgstr "" #: ../Doc/reference/expressions.rst:427 msgid "" "The proposal to enhance the API and syntax of generators, making them usable " "as simple coroutines." msgstr "" #: ../Doc/reference/expressions.rst:431 msgid ":pep:`380` - Syntax for Delegating to a Subgenerator" msgstr "" #: ../Doc/reference/expressions.rst:431 msgid "" "The proposal to introduce the :token:`yield_from` syntax, making delegation " "to sub-generators easy." msgstr "" #: ../Doc/reference/expressions.rst:438 msgid "Generator-iterator methods" msgstr "" #: ../Doc/reference/expressions.rst:440 msgid "" "This subsection describes the methods of a generator iterator. They can be " "used to control the execution of a generator function." msgstr "" #: ../Doc/reference/expressions.rst:443 msgid "" "Note that calling any of the generator methods below when the generator is " "already executing raises a :exc:`ValueError` exception." msgstr "" #: ../Doc/reference/expressions.rst:451 msgid "" "Starts the execution of a generator function or resumes it at the last " "executed yield expression. When a generator function is resumed with a :" "meth:`~generator.__next__` method, the current yield expression always " "evaluates to :const:`None`. The execution then continues to the next yield " "expression, where the generator is suspended again, and the value of the :" "token:`expression_list` is returned to :meth:`__next__`'s caller. If the " "generator exits without yielding another value, a :exc:`StopIteration` " "exception is raised." msgstr "" #: ../Doc/reference/expressions.rst:460 msgid "" "This method is normally called implicitly, e.g. by a :keyword:`for` loop, or " "by the built-in :func:`next` function." msgstr "" #: ../Doc/reference/expressions.rst:466 msgid "" "Resumes the execution and \"sends\" a value into the generator function. " "The *value* argument becomes the result of the current yield expression. " "The :meth:`send` method returns the next value yielded by the generator, or " "raises :exc:`StopIteration` if the generator exits without yielding another " "value. When :meth:`send` is called to start the generator, it must be " "called with :const:`None` as the argument, because there is no yield " "expression that could receive the value." msgstr "" #: ../Doc/reference/expressions.rst:477 msgid "" "Raises an exception of type ``type`` at the point where the generator was " "paused, and returns the next value yielded by the generator function. If " "the generator exits without yielding another value, a :exc:`StopIteration` " "exception is raised. If the generator function does not catch the passed-in " "exception, or raises a different exception, then that exception propagates " "to the caller." msgstr "" #: ../Doc/reference/expressions.rst:488 msgid "" "Raises a :exc:`GeneratorExit` at the point where the generator function was " "paused. If the generator function then exits gracefully, is already closed, " "or raises :exc:`GeneratorExit` (by not catching the exception), close " "returns to its caller. If the generator yields a value, a :exc:" "`RuntimeError` is raised. If the generator raises any other exception, it " "is propagated to the caller. :meth:`close` does nothing if the generator " "has already exited due to an exception or normal exit." msgstr "" #: ../Doc/reference/expressions.rst:499 msgid "Examples" msgstr "Exemples" #: ../Doc/reference/expressions.rst:501 msgid "" "Here is a simple example that demonstrates the behavior of generators and " "generator functions::" msgstr "" #: ../Doc/reference/expressions.rst:528 msgid "" "For examples using ``yield from``, see :ref:`pep-380` in \"What's New in " "Python.\"" msgstr "" #: ../Doc/reference/expressions.rst:534 msgid "Asynchronous generator functions" msgstr "" #: ../Doc/reference/expressions.rst:536 msgid "" "The presence of a yield expression in a function or method defined using :" "keyword:`async def` further defines the function as a :term:`asynchronous " "generator` function." msgstr "" #: ../Doc/reference/expressions.rst:540 msgid "" "When an asynchronous generator function is called, it returns an " "asynchronous iterator known as an asynchronous generator object. That object " "then controls the execution of the generator function. An asynchronous " "generator object is typically used in an :keyword:`async for` statement in a " "coroutine function analogously to how a generator object would be used in a :" "keyword:`for` statement." msgstr "" #: ../Doc/reference/expressions.rst:547 msgid "" "Calling one of the asynchronous generator's methods returns an :term:" "`awaitable` object, and the execution starts when this object is awaited on. " "At that time, the execution proceeds to the first yield expression, where it " "is suspended again, returning the value of :token:`expression_list` to the " "awaiting coroutine. As with a generator, suspension means that all local " "state is retained, including the current bindings of local variables, the " "instruction pointer, the internal evaluation stack, and the state of any " "exception handling. When the execution is resumed by awaiting on the next " "object returned by the asynchronous generator's methods, the function can " "proceed exactly as if the yield expression were just another external call. " "The value of the yield expression after resuming depends on the method which " "resumed the execution. If :meth:`~agen.__anext__` is used then the result " "is :const:`None`. Otherwise, if :meth:`~agen.asend` is used, then the result " "will be the value passed in to that method." msgstr "" #: ../Doc/reference/expressions.rst:563 msgid "" "In an asynchronous generator function, yield expressions are allowed " "anywhere in a :keyword:`try` construct. However, if an asynchronous " "generator is not resumed before it is finalized (by reaching a zero " "reference count or by being garbage collected), then a yield expression " "within a :keyword:`try` construct could result in a failure to execute " "pending :keyword:`finally` clauses. In this case, it is the responsibility " "of the event loop or scheduler running the asynchronous generator to call " "the asynchronous generator-iterator's :meth:`~agen.aclose` method and run " "the resulting coroutine object, thus allowing any pending :keyword:`finally` " "clauses to execute." msgstr "" #: ../Doc/reference/expressions.rst:574 msgid "" "To take care of finalization, an event loop should define a *finalizer* " "function which takes an asynchronous generator-iterator and presumably " "calls :meth:`~agen.aclose` and executes the coroutine. This *finalizer* may " "be registered by calling :func:`sys.set_asyncgen_hooks`. When first iterated " "over, an asynchronous generator-iterator will store the registered " "*finalizer* to be called upon finalization. For a reference example of a " "*finalizer* method see the implementation of ``asyncio.Loop." "shutdown_asyncgens`` in :source:`Lib/asyncio/base_events.py`." msgstr "" #: ../Doc/reference/expressions.rst:583 msgid "" "The expression ``yield from `` is a syntax error when used in an " "asynchronous generator function." msgstr "" #: ../Doc/reference/expressions.rst:590 msgid "Asynchronous generator-iterator methods" msgstr "" #: ../Doc/reference/expressions.rst:592 msgid "" "This subsection describes the methods of an asynchronous generator iterator, " "which are used to control the execution of a generator function." msgstr "" #: ../Doc/reference/expressions.rst:600 msgid "" "Returns an awaitable which when run starts to execute the asynchronous " "generator or resumes it at the last executed yield expression. When an " "asynchronous generator function is resumed with a :meth:`~agen.__anext__` " "method, the current yield expression always evaluates to :const:`None` in " "the returned awaitable, which when run will continue to the next yield " "expression. The value of the :token:`expression_list` of the yield " "expression is the value of the :exc:`StopIteration` exception raised by the " "completing coroutine. If the asynchronous generator exits without yielding " "another value, the awaitable instead raises an :exc:`StopAsyncIteration` " "exception, signalling that the asynchronous iteration has completed." msgstr "" #: ../Doc/reference/expressions.rst:612 msgid "" "This method is normally called implicitly by a :keyword:`async for` loop." msgstr "" #: ../Doc/reference/expressions.rst:617 msgid "" "Returns an awaitable which when run resumes the execution of the " "asynchronous generator. As with the :meth:`~generator.send()` method for a " "generator, this \"sends\" a value into the asynchronous generator function, " "and the *value* argument becomes the result of the current yield expression. " "The awaitable returned by the :meth:`asend` method will return the next " "value yielded by the generator as the value of the raised :exc:" "`StopIteration`, or raises :exc:`StopAsyncIteration` if the asynchronous " "generator exits without yielding another value. When :meth:`asend` is " "called to start the asynchronous generator, it must be called with :const:" "`None` as the argument, because there is no yield expression that could " "receive the value." msgstr "" #: ../Doc/reference/expressions.rst:632 msgid "" "Returns an awaitable that raises an exception of type ``type`` at the point " "where the asynchronous generator was paused, and returns the next value " "yielded by the generator function as the value of the raised :exc:" "`StopIteration` exception. If the asynchronous generator exits without " "yielding another value, an :exc:`StopAsyncIteration` exception is raised by " "the awaitable. If the generator function does not catch the passed-in " "exception, or raises a different exception, then when the awaitalbe is run " "that exception propagates to the caller of the awaitable." msgstr "" #: ../Doc/reference/expressions.rst:647 msgid "" "Returns an awaitable that when run will throw a :exc:`GeneratorExit` into " "the asynchronous generator function at the point where it was paused. If the " "asynchronous generator function then exits gracefully, is already closed, or " "raises :exc:`GeneratorExit` (by not catching the exception), then the " "returned awaitable will raise a :exc:`StopIteration` exception. Any further " "awaitables returned by subsequent calls to the asynchronous generator will " "raise a :exc:`StopAsyncIteration` exception. If the asynchronous generator " "yields a value, a :exc:`RuntimeError` is raised by the awaitable. If the " "asynchronous generator raises any other exception, it is propagated to the " "caller of the awaitable. If the asynchronous generator has already exited " "due to an exception or normal exit, then further calls to :meth:`aclose` " "will return an awaitable that does nothing." msgstr "" #: ../Doc/reference/expressions.rst:663 msgid "Primaries" msgstr "" #: ../Doc/reference/expressions.rst:667 msgid "" "Primaries represent the most tightly bound operations of the language. Their " "syntax is:" msgstr "" #: ../Doc/reference/expressions.rst:677 msgid "Attribute references" msgstr "" #: ../Doc/reference/expressions.rst:681 msgid "An attribute reference is a primary followed by a period and a name:" msgstr "" #: ../Doc/reference/expressions.rst:691 msgid "" "The primary must evaluate to an object of a type that supports attribute " "references, which most objects do. This object is then asked to produce the " "attribute whose name is the identifier. This production can be customized " "by overriding the :meth:`__getattr__` method. If this attribute is not " "available, the exception :exc:`AttributeError` is raised. Otherwise, the " "type and value of the object produced is determined by the object. Multiple " "evaluations of the same attribute reference may yield different objects." msgstr "" #: ../Doc/reference/expressions.rst:703 msgid "Subscriptions" msgstr "" #: ../Doc/reference/expressions.rst:716 msgid "" "A subscription selects an item of a sequence (string, tuple or list) or " "mapping (dictionary) object:" msgstr "" #: ../Doc/reference/expressions.rst:722 msgid "" "The primary must evaluate to an object that supports subscription (lists or " "dictionaries for example). User-defined objects can support subscription by " "defining a :meth:`__getitem__` method." msgstr "" #: ../Doc/reference/expressions.rst:726 msgid "" "For built-in objects, there are two types of objects that support " "subscription:" msgstr "" #: ../Doc/reference/expressions.rst:728 msgid "" "If the primary is a mapping, the expression list must evaluate to an object " "whose value is one of the keys of the mapping, and the subscription selects " "the value in the mapping that corresponds to that key. (The expression list " "is a tuple except if it has exactly one item.)" msgstr "" #: ../Doc/reference/expressions.rst:733 msgid "" "If the primary is a sequence, the expression (list) must evaluate to an " "integer or a slice (as discussed in the following section)." msgstr "" #: ../Doc/reference/expressions.rst:736 msgid "" "The formal syntax makes no special provision for negative indices in " "sequences; however, built-in sequences all provide a :meth:`__getitem__` " "method that interprets negative indices by adding the length of the sequence " "to the index (so that ``x[-1]`` selects the last item of ``x``). The " "resulting value must be a nonnegative integer less than the number of items " "in the sequence, and the subscription selects the item whose index is that " "value (counting from zero). Since the support for negative indices and " "slicing occurs in the object's :meth:`__getitem__` method, subclasses " "overriding this method will need to explicitly add that support." msgstr "" #: ../Doc/reference/expressions.rst:750 msgid "" "A string's items are characters. A character is not a separate data type " "but a string of exactly one character." msgstr "" #: ../Doc/reference/expressions.rst:757 msgid "Slicings" msgstr "" #: ../Doc/reference/expressions.rst:769 msgid "" "A slicing selects a range of items in a sequence object (e.g., a string, " "tuple or list). Slicings may be used as expressions or as targets in " "assignment or :keyword:`del` statements. The syntax for a slicing:" msgstr "" #: ../Doc/reference/expressions.rst:782 msgid "" "There is ambiguity in the formal syntax here: anything that looks like an " "expression list also looks like a slice list, so any subscription can be " "interpreted as a slicing. Rather than further complicating the syntax, this " "is disambiguated by defining that in this case the interpretation as a " "subscription takes priority over the interpretation as a slicing (this is " "the case if the slice list contains no proper slice)." msgstr "" #: ../Doc/reference/expressions.rst:794 msgid "" "The semantics for a slicing are as follows. The primary is indexed (using " "the same :meth:`__getitem__` method as normal subscription) with a key that " "is constructed from the slice list, as follows. If the slice list contains " "at least one comma, the key is a tuple containing the conversion of the " "slice items; otherwise, the conversion of the lone slice item is the key. " "The conversion of a slice item that is an expression is that expression. " "The conversion of a proper slice is a slice object (see section :ref:" "`types`) whose :attr:`~slice.start`, :attr:`~slice.stop` and :attr:`~slice." "step` attributes are the values of the expressions given as lower bound, " "upper bound and stride, respectively, substituting ``None`` for missing " "expressions." msgstr "" #: ../Doc/reference/expressions.rst:815 msgid "Calls" msgstr "Appels" #: ../Doc/reference/expressions.rst:817 msgid "" "A call calls a callable object (e.g., a :term:`function`) with a possibly " "empty series of :term:`arguments `:" msgstr "" #: ../Doc/reference/expressions.rst:833 msgid "" "An optional trailing comma may be present after the positional and keyword " "arguments but does not affect the semantics." msgstr "" #: ../Doc/reference/expressions.rst:839 msgid "" "The primary must evaluate to a callable object (user-defined functions, " "built-in functions, methods of built-in objects, class objects, methods of " "class instances, and all objects having a :meth:`__call__` method are " "callable). All argument expressions are evaluated before the call is " "attempted. Please refer to section :ref:`function` for the syntax of " "formal :term:`parameter` lists." msgstr "" #: ../Doc/reference/expressions.rst:847 msgid "" "If keyword arguments are present, they are first converted to positional " "arguments, as follows. First, a list of unfilled slots is created for the " "formal parameters. If there are N positional arguments, they are placed in " "the first N slots. Next, for each keyword argument, the identifier is used " "to determine the corresponding slot (if the identifier is the same as the " "first formal parameter name, the first slot is used, and so on). If the " "slot is already filled, a :exc:`TypeError` exception is raised. Otherwise, " "the value of the argument is placed in the slot, filling it (even if the " "expression is ``None``, it fills the slot). When all arguments have been " "processed, the slots that are still unfilled are filled with the " "corresponding default value from the function definition. (Default values " "are calculated, once, when the function is defined; thus, a mutable object " "such as a list or dictionary used as default value will be shared by all " "calls that don't specify an argument value for the corresponding slot; this " "should usually be avoided.) If there are any unfilled slots for which no " "default value is specified, a :exc:`TypeError` exception is raised. " "Otherwise, the list of filled slots is used as the argument list for the " "call." msgstr "" #: ../Doc/reference/expressions.rst:867 msgid "" "An implementation may provide built-in functions whose positional parameters " "do not have names, even if they are 'named' for the purpose of " "documentation, and which therefore cannot be supplied by keyword. In " "CPython, this is the case for functions implemented in C that use :c:func:" "`PyArg_ParseTuple` to parse their arguments." msgstr "" #: ../Doc/reference/expressions.rst:873 msgid "" "If there are more positional arguments than there are formal parameter " "slots, a :exc:`TypeError` exception is raised, unless a formal parameter " "using the syntax ``*identifier`` is present; in this case, that formal " "parameter receives a tuple containing the excess positional arguments (or an " "empty tuple if there were no excess positional arguments)." msgstr "" #: ../Doc/reference/expressions.rst:879 msgid "" "If any keyword argument does not correspond to a formal parameter name, a :" "exc:`TypeError` exception is raised, unless a formal parameter using the " "syntax ``**identifier`` is present; in this case, that formal parameter " "receives a dictionary containing the excess keyword arguments (using the " "keywords as keys and the argument values as corresponding values), or a " "(new) empty dictionary if there were no excess keyword arguments." msgstr "" #: ../Doc/reference/expressions.rst:890 msgid "" "If the syntax ``*expression`` appears in the function call, ``expression`` " "must evaluate to an :term:`iterable`. Elements from these iterables are " "treated as if they were additional positional arguments. For the call " "``f(x1, x2, *y, x3, x4)``, if *y* evaluates to a sequence *y1*, ..., *yM*, " "this is equivalent to a call with M+4 positional arguments *x1*, *x2*, " "*y1*, ..., *yM*, *x3*, *x4*." msgstr "" #: ../Doc/reference/expressions.rst:897 msgid "" "A consequence of this is that although the ``*expression`` syntax may appear " "*after* explicit keyword arguments, it is processed *before* the keyword " "arguments (and any ``**expression`` arguments -- see below). So::" msgstr "" #: ../Doc/reference/expressions.rst:913 msgid "" "It is unusual for both keyword arguments and the ``*expression`` syntax to " "be used in the same call, so in practice this confusion does not arise." msgstr "" #: ../Doc/reference/expressions.rst:919 msgid "" "If the syntax ``**expression`` appears in the function call, ``expression`` " "must evaluate to a :term:`mapping`, the contents of which are treated as " "additional keyword arguments. If a keyword is already present (as an " "explicit keyword argument, or from another unpacking), a :exc:`TypeError` " "exception is raised." msgstr "" #: ../Doc/reference/expressions.rst:925 msgid "" "Formal parameters using the syntax ``*identifier`` or ``**identifier`` " "cannot be used as positional argument slots or as keyword argument names." msgstr "" #: ../Doc/reference/expressions.rst:928 msgid "" "Function calls accept any number of ``*`` and ``**`` unpackings, positional " "arguments may follow iterable unpackings (``*``), and keyword arguments may " "follow dictionary unpackings (``**``). Originally proposed by :pep:`448`." msgstr "" #: ../Doc/reference/expressions.rst:934 msgid "" "A call always returns some value, possibly ``None``, unless it raises an " "exception. How this value is computed depends on the type of the callable " "object." msgstr "" #: ../Doc/reference/expressions.rst:938 msgid "If it is---" msgstr "" #: ../Doc/reference/expressions.rst:951 msgid "a user-defined function:" msgstr "" #: ../Doc/reference/expressions.rst:947 msgid "" "The code block for the function is executed, passing it the argument list. " "The first thing the code block will do is bind the formal parameters to the " "arguments; this is described in section :ref:`function`. When the code " "block executes a :keyword:`return` statement, this specifies the return " "value of the function call." msgstr "" #: ../Doc/reference/expressions.rst:965 msgid "a built-in function or method:" msgstr "" #: ../Doc/reference/expressions.rst:964 msgid "" "The result is up to the interpreter; see :ref:`built-in-funcs` for the " "descriptions of built-in functions and methods." msgstr "" #: ../Doc/reference/expressions.rst:972 msgid "a class object:" msgstr "" #: ../Doc/reference/expressions.rst:972 msgid "A new instance of that class is returned." msgstr "" #: ../Doc/reference/expressions.rst:982 msgid "a class instance method:" msgstr "" #: ../Doc/reference/expressions.rst:980 msgid "" "The corresponding user-defined function is called, with an argument list " "that is one longer than the argument list of the call: the instance becomes " "the first argument." msgstr "" #: ../Doc/reference/expressions.rst:991 msgid "a class instance:" msgstr "" #: ../Doc/reference/expressions.rst:989 msgid "" "The class must define a :meth:`__call__` method; the effect is then the same " "as if that method was called." msgstr "" #: ../Doc/reference/expressions.rst:996 ../Doc/reference/expressions.rst:1702 msgid "Await expression" msgstr "" #: ../Doc/reference/expressions.rst:998 msgid "" "Suspend the execution of :term:`coroutine` on an :term:`awaitable` object. " "Can only be used inside a :term:`coroutine function`." msgstr "" #: ../Doc/reference/expressions.rst:1010 msgid "The power operator" msgstr "" #: ../Doc/reference/expressions.rst:1012 msgid "" "The power operator binds more tightly than unary operators on its left; it " "binds less tightly than unary operators on its right. The syntax is:" msgstr "" #: ../Doc/reference/expressions.rst:1018 msgid "" "Thus, in an unparenthesized sequence of power and unary operators, the " "operators are evaluated from right to left (this does not constrain the " "evaluation order for the operands): ``-1**2`` results in ``-1``." msgstr "" #: ../Doc/reference/expressions.rst:1022 msgid "" "The power operator has the same semantics as the built-in :func:`pow` " "function, when called with two arguments: it yields its left argument raised " "to the power of its right argument. The numeric arguments are first " "converted to a common type, and the result is of that type." msgstr "" #: ../Doc/reference/expressions.rst:1027 msgid "" "For int operands, the result has the same type as the operands unless the " "second argument is negative; in that case, all arguments are converted to " "float and a float result is delivered. For example, ``10**2`` returns " "``100``, but ``10**-2`` returns ``0.01``." msgstr "" #: ../Doc/reference/expressions.rst:1032 msgid "" "Raising ``0.0`` to a negative power results in a :exc:`ZeroDivisionError`. " "Raising a negative number to a fractional power results in a :class:" "`complex` number. (In earlier versions it raised a :exc:`ValueError`.)" msgstr "" #: ../Doc/reference/expressions.rst:1040 msgid "Unary arithmetic and bitwise operations" msgstr "" #: ../Doc/reference/expressions.rst:1046 msgid "All unary arithmetic and bitwise operations have the same priority:" msgstr "" #: ../Doc/reference/expressions.rst:1055 msgid "" "The unary ``-`` (minus) operator yields the negation of its numeric argument." msgstr "" #: ../Doc/reference/expressions.rst:1059 msgid "The unary ``+`` (plus) operator yields its numeric argument unchanged." msgstr "" #: ../Doc/reference/expressions.rst:1064 msgid "" "The unary ``~`` (invert) operator yields the bitwise inversion of its " "integer argument. The bitwise inversion of ``x`` is defined as ``-(x+1)``. " "It only applies to integral numbers." msgstr "" #: ../Doc/reference/expressions.rst:1070 msgid "" "In all three cases, if the argument does not have the proper type, a :exc:" "`TypeError` exception is raised." msgstr "" #: ../Doc/reference/expressions.rst:1077 msgid "Binary arithmetic operations" msgstr "" #: ../Doc/reference/expressions.rst:1081 msgid "" "The binary arithmetic operations have the conventional priority levels. " "Note that some of these operations also apply to certain non-numeric types. " "Apart from the power operator, there are only two levels, one for " "multiplicative operators and one for additive operators:" msgstr "" #: ../Doc/reference/expressions.rst:1094 msgid "" "The ``*`` (multiplication) operator yields the product of its arguments. " "The arguments must either both be numbers, or one argument must be an " "integer and the other must be a sequence. In the former case, the numbers " "are converted to a common type and then multiplied together. In the latter " "case, sequence repetition is performed; a negative repetition factor yields " "an empty sequence." msgstr "" #: ../Doc/reference/expressions.rst:1102 msgid "" "The ``@`` (at) operator is intended to be used for matrix multiplication. " "No builtin Python types implement this operator." msgstr "" #: ../Doc/reference/expressions.rst:1111 msgid "" "The ``/`` (division) and ``//`` (floor division) operators yield the " "quotient of their arguments. The numeric arguments are first converted to a " "common type. Division of integers yields a float, while floor division of " "integers results in an integer; the result is that of mathematical division " "with the 'floor' function applied to the result. Division by zero raises " "the :exc:`ZeroDivisionError` exception." msgstr "" #: ../Doc/reference/expressions.rst:1120 msgid "" "The ``%`` (modulo) operator yields the remainder from the division of the " "first argument by the second. The numeric arguments are first converted to " "a common type. A zero right argument raises the :exc:`ZeroDivisionError` " "exception. The arguments may be floating point numbers, e.g., ``3.14%0.7`` " "equals ``0.34`` (since ``3.14`` equals ``4*0.7 + 0.34``.) The modulo " "operator always yields a result with the same sign as its second operand (or " "zero); the absolute value of the result is strictly smaller than the " "absolute value of the second operand [#]_." msgstr "" #: ../Doc/reference/expressions.rst:1129 msgid "" "The floor division and modulo operators are connected by the following " "identity: ``x == (x//y)*y + (x%y)``. Floor division and modulo are also " "connected with the built-in function :func:`divmod`: ``divmod(x, y) == (x//" "y, x%y)``. [#]_." msgstr "" #: ../Doc/reference/expressions.rst:1134 msgid "" "In addition to performing the modulo operation on numbers, the ``%`` " "operator is also overloaded by string objects to perform old-style string " "formatting (also known as interpolation). The syntax for string formatting " "is described in the Python Library Reference, section :ref:`old-string-" "formatting`." msgstr "" #: ../Doc/reference/expressions.rst:1139 msgid "" "The floor division operator, the modulo operator, and the :func:`divmod` " "function are not defined for complex numbers. Instead, convert to a " "floating point number using the :func:`abs` function if appropriate." msgstr "" #: ../Doc/reference/expressions.rst:1145 msgid "" "The ``+`` (addition) operator yields the sum of its arguments. The " "arguments must either both be numbers or both be sequences of the same " "type. In the former case, the numbers are converted to a common type and " "then added together. In the latter case, the sequences are concatenated." msgstr "" #: ../Doc/reference/expressions.rst:1152 msgid "" "The ``-`` (subtraction) operator yields the difference of its arguments. " "The numeric arguments are first converted to a common type." msgstr "" #: ../Doc/reference/expressions.rst:1159 msgid "Shifting operations" msgstr "" #: ../Doc/reference/expressions.rst:1163 msgid "" "The shifting operations have lower priority than the arithmetic operations:" msgstr "" #: ../Doc/reference/expressions.rst:1168 msgid "" "These operators accept integers as arguments. They shift the first argument " "to the left or right by the number of bits given by the second argument." msgstr "" #: ../Doc/reference/expressions.rst:1173 msgid "" "A right shift by *n* bits is defined as floor division by ``pow(2,n)``. A " "left shift by *n* bits is defined as multiplication with ``pow(2,n)``." msgstr "" #: ../Doc/reference/expressions.rst:1178 msgid "" "In the current implementation, the right-hand operand is required to be at " "most :attr:`sys.maxsize`. If the right-hand operand is larger than :attr:" "`sys.maxsize` an :exc:`OverflowError` exception is raised." msgstr "" #: ../Doc/reference/expressions.rst:1185 msgid "Binary bitwise operations" msgstr "" #: ../Doc/reference/expressions.rst:1189 msgid "Each of the three bitwise operations has a different priority level:" msgstr "" #: ../Doc/reference/expressions.rst:1198 msgid "" "The ``&`` operator yields the bitwise AND of its arguments, which must be " "integers." msgstr "" #: ../Doc/reference/expressions.rst:1205 msgid "" "The ``^`` operator yields the bitwise XOR (exclusive OR) of its arguments, " "which must be integers." msgstr "" #: ../Doc/reference/expressions.rst:1212 msgid "" "The ``|`` operator yields the bitwise (inclusive) OR of its arguments, which " "must be integers." msgstr "" #: ../Doc/reference/expressions.rst:1219 msgid "Comparisons" msgstr "Comparaisons" #: ../Doc/reference/expressions.rst:1225 msgid "" "Unlike C, all comparison operations in Python have the same priority, which " "is lower than that of any arithmetic, shifting or bitwise operation. Also " "unlike C, expressions like ``a < b < c`` have the interpretation that is " "conventional in mathematics:" msgstr "" #: ../Doc/reference/expressions.rst:1235 msgid "Comparisons yield boolean values: ``True`` or ``False``." msgstr "" #: ../Doc/reference/expressions.rst:1239 msgid "" "Comparisons can be chained arbitrarily, e.g., ``x < y <= z`` is equivalent " "to ``x < y and y <= z``, except that ``y`` is evaluated only once (but in " "both cases ``z`` is not evaluated at all when ``x < y`` is found to be " "false)." msgstr "" #: ../Doc/reference/expressions.rst:1243 msgid "" "Formally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and *op1*, " "*op2*, ..., *opN* are comparison operators, then ``a op1 b op2 c ... y opN " "z`` is equivalent to ``a op1 b and b op2 c and ... y opN z``, except that " "each expression is evaluated at most once." msgstr "" #: ../Doc/reference/expressions.rst:1248 msgid "" "Note that ``a op1 b op2 c`` doesn't imply any kind of comparison between *a* " "and *c*, so that, e.g., ``x < y > z`` is perfectly legal (though perhaps not " "pretty)." msgstr "" #: ../Doc/reference/expressions.rst:1253 msgid "Value comparisons" msgstr "" #: ../Doc/reference/expressions.rst:1255 msgid "" "The operators ``<``, ``>``, ``==``, ``>=``, ``<=``, and ``!=`` compare the " "values of two objects. The objects do not need to have the same type." msgstr "" #: ../Doc/reference/expressions.rst:1258 msgid "" "Chapter :ref:`objects` states that objects have a value (in addition to type " "and identity). The value of an object is a rather abstract notion in " "Python: For example, there is no canonical access method for an object's " "value. Also, there is no requirement that the value of an object should be " "constructed in a particular way, e.g. comprised of all its data attributes. " "Comparison operators implement a particular notion of what the value of an " "object is. One can think of them as defining the value of an object " "indirectly, by means of their comparison implementation." msgstr "" #: ../Doc/reference/expressions.rst:1267 msgid "" "Because all types are (direct or indirect) subtypes of :class:`object`, they " "inherit the default comparison behavior from :class:`object`. Types can " "customize their comparison behavior by implementing :dfn:`rich comparison " "methods` like :meth:`__lt__`, described in :ref:`customization`." msgstr "" #: ../Doc/reference/expressions.rst:1273 msgid "" "The default behavior for equality comparison (``==`` and ``!=``) is based on " "the identity of the objects. Hence, equality comparison of instances with " "the same identity results in equality, and equality comparison of instances " "with different identities results in inequality. A motivation for this " "default behavior is the desire that all objects should be reflexive (i.e. " "``x is y`` implies ``x == y``)." msgstr "" #: ../Doc/reference/expressions.rst:1280 msgid "" "A default order comparison (``<``, ``>``, ``<=``, and ``>=``) is not " "provided; an attempt raises :exc:`TypeError`. A motivation for this default " "behavior is the lack of a similar invariant as for equality." msgstr "" #: ../Doc/reference/expressions.rst:1284 msgid "" "The behavior of the default equality comparison, that instances with " "different identities are always unequal, may be in contrast to what types " "will need that have a sensible definition of object value and value-based " "equality. Such types will need to customize their comparison behavior, and " "in fact, a number of built-in types have done that." msgstr "" #: ../Doc/reference/expressions.rst:1290 msgid "" "The following list describes the comparison behavior of the most important " "built-in types." msgstr "" #: ../Doc/reference/expressions.rst:1293 msgid "" "Numbers of built-in numeric types (:ref:`typesnumeric`) and of the standard " "library types :class:`fractions.Fraction` and :class:`decimal.Decimal` can " "be compared within and across their types, with the restriction that complex " "numbers do not support order comparison. Within the limits of the types " "involved, they compare mathematically (algorithmically) correct without loss " "of precision." msgstr "" #: ../Doc/reference/expressions.rst:1300 msgid "" "The not-a-number values :const:`float('NaN')` and :const:`Decimal('NaN')` " "are special. They are identical to themselves (``x is x`` is true) but are " "not equal to themselves (``x == x`` is false). Additionally, comparing any " "number to a not-a-number value will return ``False``. For example, both ``3 " "< float('NaN')`` and ``float('NaN') < 3`` will return ``False``." msgstr "" #: ../Doc/reference/expressions.rst:1307 msgid "" "Binary sequences (instances of :class:`bytes` or :class:`bytearray`) can be " "compared within and across their types. They compare lexicographically " "using the numeric values of their elements." msgstr "" #: ../Doc/reference/expressions.rst:1311 msgid "" "Strings (instances of :class:`str`) compare lexicographically using the " "numerical Unicode code points (the result of the built-in function :func:" "`ord`) of their characters. [#]_" msgstr "" #: ../Doc/reference/expressions.rst:1315 msgid "Strings and binary sequences cannot be directly compared." msgstr "" #: ../Doc/reference/expressions.rst:1317 msgid "" "Sequences (instances of :class:`tuple`, :class:`list`, or :class:`range`) " "can be compared only within each of their types, with the restriction that " "ranges do not support order comparison. Equality comparison across these " "types results in inequality, and ordering comparison across these types " "raises :exc:`TypeError`." msgstr "" #: ../Doc/reference/expressions.rst:1323 msgid "" "Sequences compare lexicographically using comparison of corresponding " "elements, whereby reflexivity of the elements is enforced." msgstr "" #: ../Doc/reference/expressions.rst:1326 msgid "" "In enforcing reflexivity of elements, the comparison of collections assumes " "that for a collection element ``x``, ``x == x`` is always true. Based on " "that assumption, element identity is compared first, and element comparison " "is performed only for distinct elements. This approach yields the same " "result as a strict element comparison would, if the compared elements are " "reflexive. For non-reflexive elements, the result is different than for " "strict element comparison, and may be surprising: The non-reflexive not-a-" "number values for example result in the following comparison behavior when " "used in a list::" msgstr "" #: ../Doc/reference/expressions.rst:1344 msgid "" "Lexicographical comparison between built-in collections works as follows:" msgstr "" #: ../Doc/reference/expressions.rst:1346 msgid "" "For two collections to compare equal, they must be of the same type, have " "the same length, and each pair of corresponding elements must compare equal " "(for example, ``[1,2] == (1,2)`` is false because the type is not the same)." msgstr "" #: ../Doc/reference/expressions.rst:1351 msgid "" "Collections that support order comparison are ordered the same as their " "first unequal elements (for example, ``[1,2,x] <= [1,2,y]`` has the same " "value as ``x <= y``). If a corresponding element does not exist, the " "shorter collection is ordered first (for example, ``[1,2] < [1,2,3]`` is " "true)." msgstr "" #: ../Doc/reference/expressions.rst:1357 msgid "" "Mappings (instances of :class:`dict`) compare equal if and only if they have " "equal `(key, value)` pairs. Equality comparison of the keys and values " "enforces reflexivity." msgstr "" #: ../Doc/reference/expressions.rst:1361 msgid "" "Order comparisons (``<``, ``>``, ``<=``, and ``>=``) raise :exc:`TypeError`." msgstr "" #: ../Doc/reference/expressions.rst:1363 msgid "" "Sets (instances of :class:`set` or :class:`frozenset`) can be compared " "within and across their types." msgstr "" #: ../Doc/reference/expressions.rst:1366 msgid "" "They define order comparison operators to mean subset and superset tests. " "Those relations do not define total orderings (for example, the two sets " "``{1,2}`` and ``{2,3}`` are not equal, nor subsets of one another, nor " "supersets of one another). Accordingly, sets are not appropriate arguments " "for functions which depend on total ordering (for example, :func:`min`, :" "func:`max`, and :func:`sorted` produce undefined results given a list of " "sets as inputs)." msgstr "" #: ../Doc/reference/expressions.rst:1374 msgid "Comparison of sets enforces reflexivity of its elements." msgstr "" #: ../Doc/reference/expressions.rst:1376 msgid "" "Most other built-in types have no comparison methods implemented, so they " "inherit the default comparison behavior." msgstr "" #: ../Doc/reference/expressions.rst:1379 msgid "" "User-defined classes that customize their comparison behavior should follow " "some consistency rules, if possible:" msgstr "" #: ../Doc/reference/expressions.rst:1382 msgid "" "Equality comparison should be reflexive. In other words, identical objects " "should compare equal:" msgstr "" #: ../Doc/reference/expressions.rst:1385 msgid "``x is y`` implies ``x == y``" msgstr "``x is y`` implique ``x == y``" #: ../Doc/reference/expressions.rst:1387 msgid "" "Comparison should be symmetric. In other words, the following expressions " "should have the same result:" msgstr "" #: ../Doc/reference/expressions.rst:1390 msgid "``x == y`` and ``y == x``" msgstr "``x == y`` et ``y == x``" #: ../Doc/reference/expressions.rst:1392 msgid "``x != y`` and ``y != x``" msgstr "``x != y`` et ``y != x``" #: ../Doc/reference/expressions.rst:1394 msgid "``x < y`` and ``y > x``" msgstr "``x < y`` et ``y > x``" #: ../Doc/reference/expressions.rst:1396 msgid "``x <= y`` and ``y >= x``" msgstr "``x <= y`` et ``y >= x``" #: ../Doc/reference/expressions.rst:1398 msgid "" "Comparison should be transitive. The following (non-exhaustive) examples " "illustrate that:" msgstr "" #: ../Doc/reference/expressions.rst:1401 msgid "``x > y and y > z`` implies ``x > z``" msgstr "``x > y et y > z`` implique ``x > z``" #: ../Doc/reference/expressions.rst:1403 msgid "``x < y and y <= z`` implies ``x < z``" msgstr "``x < y et y <= z`` implique ``x < z``" #: ../Doc/reference/expressions.rst:1405 msgid "" "Inverse comparison should result in the boolean negation. In other words, " "the following expressions should have the same result:" msgstr "" #: ../Doc/reference/expressions.rst:1408 msgid "``x == y`` and ``not x != y``" msgstr "``x == y`` et ``not x != y``" #: ../Doc/reference/expressions.rst:1410 msgid "``x < y`` and ``not x >= y`` (for total ordering)" msgstr "" #: ../Doc/reference/expressions.rst:1412 msgid "``x > y`` and ``not x <= y`` (for total ordering)" msgstr "" #: ../Doc/reference/expressions.rst:1414 msgid "" "The last two expressions apply to totally ordered collections (e.g. to " "sequences, but not to sets or mappings). See also the :func:`~functools." "total_ordering` decorator." msgstr "" #: ../Doc/reference/expressions.rst:1418 msgid "" "The :func:`hash` result should be consistent with equality. Objects that are " "equal should either have the same hash value, or be marked as unhashable." msgstr "" #: ../Doc/reference/expressions.rst:1422 msgid "" "Python does not enforce these consistency rules. In fact, the not-a-number " "values are an example for not following these rules." msgstr "" #: ../Doc/reference/expressions.rst:1431 msgid "Membership test operations" msgstr "" #: ../Doc/reference/expressions.rst:1433 msgid "" "The operators :keyword:`in` and :keyword:`not in` test for membership. ``x " "in s`` evaluates to ``True`` if *x* is a member of *s*, and ``False`` " "otherwise. ``x not in s`` returns the negation of ``x in s``. All built-in " "sequences and set types support this as well as dictionary, for which :" "keyword:`in` tests whether the dictionary has a given key. For container " "types such as list, tuple, set, frozenset, dict, or collections.deque, the " "expression ``x in y`` is equivalent to ``any(x is e or x == e for e in y)``." msgstr "" #: ../Doc/reference/expressions.rst:1441 msgid "" "For the string and bytes types, ``x in y`` is ``True`` if and only if *x* is " "a substring of *y*. An equivalent test is ``y.find(x) != -1``. Empty " "strings are always considered to be a substring of any other string, so ``" "\"\" in \"abc\"`` will return ``True``." msgstr "" #: ../Doc/reference/expressions.rst:1446 msgid "" "For user-defined classes which define the :meth:`__contains__` method, ``x " "in y`` returns ``True`` if ``y.__contains__(x)`` returns a true value, and " "``False`` otherwise." msgstr "" #: ../Doc/reference/expressions.rst:1450 msgid "" "For user-defined classes which do not define :meth:`__contains__` but do " "define :meth:`__iter__`, ``x in y`` is ``True`` if some value ``z`` with ``x " "== z`` is produced while iterating over ``y``. If an exception is raised " "during the iteration, it is as if :keyword:`in` raised that exception." msgstr "" #: ../Doc/reference/expressions.rst:1455 msgid "" "Lastly, the old-style iteration protocol is tried: if a class defines :meth:" "`__getitem__`, ``x in y`` is ``True`` if and only if there is a non-negative " "integer index *i* such that ``x == y[i]``, and all lower integer indices do " "not raise :exc:`IndexError` exception. (If any other exception is raised, " "it is as if :keyword:`in` raised that exception)." msgstr "" #: ../Doc/reference/expressions.rst:1467 msgid "" "The operator :keyword:`not in` is defined to have the inverse true value of :" "keyword:`in`." msgstr "" #: ../Doc/reference/expressions.rst:1480 msgid "Identity comparisons" msgstr "" #: ../Doc/reference/expressions.rst:1482 msgid "" "The operators :keyword:`is` and :keyword:`is not` test for object identity: " "``x is y`` is true if and only if *x* and *y* are the same object. Object " "identity is determined using the :meth:`id` function. ``x is not y`` yields " "the inverse truth value. [#]_" msgstr "" #: ../Doc/reference/expressions.rst:1494 msgid "Boolean operations" msgstr "" #: ../Doc/reference/expressions.rst:1505 msgid "" "In the context of Boolean operations, and also when expressions are used by " "control flow statements, the following values are interpreted as false: " "``False``, ``None``, numeric zero of all types, and empty strings and " "containers (including strings, tuples, lists, dictionaries, sets and " "frozensets). All other values are interpreted as true. User-defined " "objects can customize their truth value by providing a :meth:`__bool__` " "method." msgstr "" #: ../Doc/reference/expressions.rst:1514 msgid "" "The operator :keyword:`not` yields ``True`` if its argument is false, " "``False`` otherwise." msgstr "" #: ../Doc/reference/expressions.rst:1519 msgid "" "The expression ``x and y`` first evaluates *x*; if *x* is false, its value " "is returned; otherwise, *y* is evaluated and the resulting value is returned." msgstr "" #: ../Doc/reference/expressions.rst:1524 msgid "" "The expression ``x or y`` first evaluates *x*; if *x* is true, its value is " "returned; otherwise, *y* is evaluated and the resulting value is returned." msgstr "" #: ../Doc/reference/expressions.rst:1527 msgid "" "(Note that neither :keyword:`and` nor :keyword:`or` restrict the value and " "type they return to ``False`` and ``True``, but rather return the last " "evaluated argument. This is sometimes useful, e.g., if ``s`` is a string " "that should be replaced by a default value if it is empty, the expression " "``s or 'foo'`` yields the desired value. Because :keyword:`not` has to " "create a new value, it returns a boolean value regardless of the type of its " "argument (for example, ``not 'foo'`` produces ``False`` rather than ``''``.)" msgstr "" #: ../Doc/reference/expressions.rst:1537 msgid "Conditional expressions" msgstr "" #: ../Doc/reference/expressions.rst:1548 msgid "" "Conditional expressions (sometimes called a \"ternary operator\") have the " "lowest priority of all Python operations." msgstr "" #: ../Doc/reference/expressions.rst:1551 msgid "" "The expression ``x if C else y`` first evaluates the condition, *C* rather " "than *x*. If *C* is true, *x* is evaluated and its value is returned; " "otherwise, *y* is evaluated and its value is returned." msgstr "" #: ../Doc/reference/expressions.rst:1555 msgid "See :pep:`308` for more details about conditional expressions." msgstr "" #: ../Doc/reference/expressions.rst:1562 msgid "Lambdas" msgstr "" #: ../Doc/reference/expressions.rst:1573 msgid "" "Lambda expressions (sometimes called lambda forms) are used to create " "anonymous functions. The expression ``lambda arguments: expression`` yields " "a function object. The unnamed object behaves like a function object " "defined with:" msgstr "" #: ../Doc/reference/expressions.rst:1582 msgid "" "See section :ref:`function` for the syntax of parameter lists. Note that " "functions created with lambda expressions cannot contain statements or " "annotations." msgstr "" #: ../Doc/reference/expressions.rst:1590 msgid "Expression lists" msgstr "" #: ../Doc/reference/expressions.rst:1602 msgid "" "Except when part of a list or set display, an expression list containing at " "least one comma yields a tuple. The length of the tuple is the number of " "expressions in the list. The expressions are evaluated from left to right." msgstr "" #: ../Doc/reference/expressions.rst:1611 msgid "" "An asterisk ``*`` denotes :dfn:`iterable unpacking`. Its operand must be " "an :term:`iterable`. The iterable is expanded into a sequence of items, " "which are included in the new tuple, list, or set, at the site of the " "unpacking." msgstr "" #: ../Doc/reference/expressions.rst:1616 msgid "" "Iterable unpacking in expression lists, originally proposed by :pep:`448`." msgstr "" #: ../Doc/reference/expressions.rst:1621 msgid "" "The trailing comma is required only to create a single tuple (a.k.a. a " "*singleton*); it is optional in all other cases. A single expression " "without a trailing comma doesn't create a tuple, but rather yields the value " "of that expression. (To create an empty tuple, use an empty pair of " "parentheses: ``()``.)" msgstr "" #: ../Doc/reference/expressions.rst:1631 msgid "Evaluation order" msgstr "" #: ../Doc/reference/expressions.rst:1635 msgid "" "Python evaluates expressions from left to right. Notice that while " "evaluating an assignment, the right-hand side is evaluated before the left-" "hand side." msgstr "" #: ../Doc/reference/expressions.rst:1638 msgid "" "In the following lines, expressions will be evaluated in the arithmetic " "order of their suffixes::" msgstr "" #: ../Doc/reference/expressions.rst:1652 msgid "Operator precedence" msgstr "" #: ../Doc/reference/expressions.rst:1656 msgid "" "The following table summarizes the operator precedence in Python, from " "lowest precedence (least binding) to highest precedence (most binding). " "Operators in the same box have the same precedence. Unless the syntax is " "explicitly given, operators are binary. Operators in the same box group " "left to right (except for exponentiation, which groups from right to left)." msgstr "" #: ../Doc/reference/expressions.rst:1662 msgid "" "Note that comparisons, membership tests, and identity tests, all have the " "same precedence and have a left-to-right chaining feature as described in " "the :ref:`comparisons` section." msgstr "" #: ../Doc/reference/expressions.rst:1668 msgid "Operator" msgstr "" #: ../Doc/reference/expressions.rst:1668 msgid "Description" msgstr "Description" #: ../Doc/reference/expressions.rst:1670 msgid ":keyword:`lambda`" msgstr "" #: ../Doc/reference/expressions.rst:1670 msgid "Lambda expression" msgstr "Expression lambda" #: ../Doc/reference/expressions.rst:1672 msgid ":keyword:`if` -- :keyword:`else`" msgstr "" #: ../Doc/reference/expressions.rst:1672 msgid "Conditional expression" msgstr "" #: ../Doc/reference/expressions.rst:1674 msgid ":keyword:`or`" msgstr "" #: ../Doc/reference/expressions.rst:1674 msgid "Boolean OR" msgstr "" #: ../Doc/reference/expressions.rst:1676 msgid ":keyword:`and`" msgstr "" #: ../Doc/reference/expressions.rst:1676 msgid "Boolean AND" msgstr "" #: ../Doc/reference/expressions.rst:1678 msgid ":keyword:`not` ``x``" msgstr "" #: ../Doc/reference/expressions.rst:1678 msgid "Boolean NOT" msgstr "" #: ../Doc/reference/expressions.rst:1680 msgid "" ":keyword:`in`, :keyword:`not in`, :keyword:`is`, :keyword:`is not`, ``<``, " "``<=``, ``>``, ``>=``, ``!=``, ``==``" msgstr "" #: ../Doc/reference/expressions.rst:1680 msgid "Comparisons, including membership tests and identity tests" msgstr "" #: ../Doc/reference/expressions.rst:1684 msgid "``|``" msgstr "" #: ../Doc/reference/expressions.rst:1684 msgid "Bitwise OR" msgstr "" #: ../Doc/reference/expressions.rst:1686 msgid "``^``" msgstr "" #: ../Doc/reference/expressions.rst:1686 msgid "Bitwise XOR" msgstr "" #: ../Doc/reference/expressions.rst:1688 msgid "``&``" msgstr "" #: ../Doc/reference/expressions.rst:1688 msgid "Bitwise AND" msgstr "" #: ../Doc/reference/expressions.rst:1690 msgid "``<<``, ``>>``" msgstr "``<<``, ``>>``" #: ../Doc/reference/expressions.rst:1690 msgid "Shifts" msgstr "" #: ../Doc/reference/expressions.rst:1692 msgid "``+``, ``-``" msgstr "``+``, ``-``" #: ../Doc/reference/expressions.rst:1692 msgid "Addition and subtraction" msgstr "" #: ../Doc/reference/expressions.rst:1694 msgid "``*``, ``@``, ``/``, ``//``, ``%``" msgstr "``*``, ``@``, ``/``, ``//``, ``%``" #: ../Doc/reference/expressions.rst:1694 msgid "Multiplication, matrix multiplication division, remainder [#]_" msgstr "" #: ../Doc/reference/expressions.rst:1698 msgid "``+x``, ``-x``, ``~x``" msgstr "``+x``, ``-x``, ``~x``" #: ../Doc/reference/expressions.rst:1698 msgid "Positive, negative, bitwise NOT" msgstr "" #: ../Doc/reference/expressions.rst:1700 msgid "``**``" msgstr "" #: ../Doc/reference/expressions.rst:1700 msgid "Exponentiation [#]_" msgstr "" #: ../Doc/reference/expressions.rst:1702 msgid "``await`` ``x``" msgstr "``await`` ``x``" #: ../Doc/reference/expressions.rst:1704 msgid "``x[index]``, ``x[index:index]``, ``x(arguments...)``, ``x.attribute``" msgstr "" #: ../Doc/reference/expressions.rst:1704 msgid "Subscription, slicing, call, attribute reference" msgstr "" #: ../Doc/reference/expressions.rst:1707 msgid "" "``(expressions...)``, ``[expressions...]``, ``{key: value...}``, " "``{expressions...}``" msgstr "" #: ../Doc/reference/expressions.rst:1707 msgid "Binding or tuple display, list display, dictionary display, set display" msgstr "" #: ../Doc/reference/expressions.rst:1715 msgid "Footnotes" msgstr "Notes" #: ../Doc/reference/expressions.rst:1716 msgid "" "While ``abs(x%y) < abs(y)`` is true mathematically, for floats it may not be " "true numerically due to roundoff. For example, and assuming a platform on " "which a Python float is an IEEE 754 double-precision number, in order that " "``-1e-100 % 1e100`` have the same sign as ``1e100``, the computed result is " "``-1e-100 + 1e100``, which is numerically exactly equal to ``1e100``. The " "function :func:`math.fmod` returns a result whose sign matches the sign of " "the first argument instead, and so returns ``-1e-100`` in this case. Which " "approach is more appropriate depends on the application." msgstr "" #: ../Doc/reference/expressions.rst:1725 msgid "" "If x is very close to an exact integer multiple of y, it's possible for ``x//" "y`` to be one larger than ``(x-x%y)//y`` due to rounding. In such cases, " "Python returns the latter result, in order to preserve that ``divmod(x,y)[0] " "* y + x % y`` be very close to ``x``." msgstr "" #: ../Doc/reference/expressions.rst:1730 msgid "" "The Unicode standard distinguishes between :dfn:`code points` (e.g. U+0041) " "and :dfn:`abstract characters` (e.g. \"LATIN CAPITAL LETTER A\"). While most " "abstract characters in Unicode are only represented using one code point, " "there is a number of abstract characters that can in addition be represented " "using a sequence of more than one code point. For example, the abstract " "character \"LATIN CAPITAL LETTER C WITH CEDILLA\" can be represented as a " "single :dfn:`precomposed character` at code position U+00C7, or as a " "sequence of a :dfn:`base character` at code position U+0043 (LATIN CAPITAL " "LETTER C), followed by a :dfn:`combining character` at code position U+0327 " "(COMBINING CEDILLA)." msgstr "" #: ../Doc/reference/expressions.rst:1741 msgid "" "The comparison operators on strings compare at the level of Unicode code " "points. This may be counter-intuitive to humans. For example, ``\"\\u00C7\" " "== \"\\u0043\\u0327\"`` is ``False``, even though both strings represent the " "same abstract character \"LATIN CAPITAL LETTER C WITH CEDILLA\"." msgstr "" #: ../Doc/reference/expressions.rst:1746 msgid "" "To compare strings at the level of abstract characters (that is, in a way " "intuitive to humans), use :func:`unicodedata.normalize`." msgstr "" #: ../Doc/reference/expressions.rst:1749 msgid "" "Due to automatic garbage-collection, free lists, and the dynamic nature of " "descriptors, you may notice seemingly unusual behaviour in certain uses of " "the :keyword:`is` operator, like those involving comparisons between " "instance methods, or constants. Check their documentation for more info." msgstr "" #: ../Doc/reference/expressions.rst:1754 msgid "" "The ``%`` operator is also used for string formatting; the same precedence " "applies." msgstr "" #: ../Doc/reference/expressions.rst:1757 msgid "" "The power operator ``**`` binds less tightly than an arithmetic or bitwise " "unary operator on its right, that is, ``2**-1`` is ``0.5``." msgstr ""