forked from AFPy/python-docs-fr
1808 lines
65 KiB
Plaintext
1808 lines
65 KiB
Plaintext
|
# SOME DESCRIPTIVE TITLE.
|
||
|
# Copyright (C) 2001-2016, Python Software Foundation
|
||
|
# This file is distributed under the same license as the Python package.
|
||
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
|
#
|
||
|
#, fuzzy
|
||
|
msgid ""
|
||
|
msgstr ""
|
||
|
"Project-Id-Version: Python 3.6\n"
|
||
|
"Report-Msgid-Bugs-To: \n"
|
||
|
"POT-Creation-Date: 2016-10-30 10:40+0100\n"
|
||
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
|
"Language-Team: LANGUAGE <LL@li.org>\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:193
|
||
|
msgid "List displays"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:201
|
||
|
msgid ""
|
||
|
"A list display is a possibly empty series of expressions enclosed in square "
|
||
|
"brackets:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:207
|
||
|
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:217
|
||
|
msgid "Set displays"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:222
|
||
|
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:228
|
||
|
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:234
|
||
|
msgid ""
|
||
|
"An empty set cannot be constructed with ``{}``; this literal constructs an "
|
||
|
"empty dictionary."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:241
|
||
|
msgid "Dictionary displays"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:247
|
||
|
msgid ""
|
||
|
"A dictionary display is a possibly empty series of key/datum pairs enclosed "
|
||
|
"in curly braces:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:256
|
||
|
msgid "A dictionary display yields a new dictionary object."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:258
|
||
|
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:266
|
||
|
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:271
|
||
|
msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:274
|
||
|
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:282
|
||
|
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:292
|
||
|
msgid "Generator expressions"
|
||
|
msgstr "Générateurs (expressions)"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:297
|
||
|
msgid "A generator expression is a compact generator notation in parentheses:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:302
|
||
|
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:306
|
||
|
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:315
|
||
|
msgid ""
|
||
|
"The parentheses can be omitted on calls with only one argument. See "
|
||
|
"section :ref:`calls` for details."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:322
|
||
|
msgid "Yield expressions"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:333
|
||
|
msgid ""
|
||
|
"The yield expression is only used when defining a :term:`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."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:337
|
||
|
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:356
|
||
|
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:362
|
||
|
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:368
|
||
|
msgid ""
|
||
|
"When ``yield from <expr>`` 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:377
|
||
|
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:383
|
||
|
msgid "Added ``yield from <expr>`` to delegate control flow to a subiterator."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:386
|
||
|
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:392
|
||
|
msgid ":pep:`255` - Simple Generators"
|
||
|
msgstr ":pep:`255`: Générateurs simples"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:392
|
||
|
msgid ""
|
||
|
"The proposal for adding generators and the :keyword:`yield` statement to "
|
||
|
"Python."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:396
|
||
|
msgid ":pep:`342` - Coroutines via Enhanced Generators"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:395
|
||
|
msgid ""
|
||
|
"The proposal to enhance the API and syntax of generators, making them usable "
|
||
|
"as simple coroutines."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:399
|
||
|
msgid ":pep:`380` - Syntax for Delegating to a Subgenerator"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:399
|
||
|
msgid ""
|
||
|
"The proposal to introduce the :token:`yield_from` syntax, making delegation "
|
||
|
"to sub-generators easy."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:406
|
||
|
msgid "Generator-iterator methods"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:408
|
||
|
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:411
|
||
|
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:419
|
||
|
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:428
|
||
|
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:434
|
||
|
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:445
|
||
|
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:456
|
||
|
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:467
|
||
|
msgid "Examples"
|
||
|
msgstr "Exemples"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:469
|
||
|
msgid ""
|
||
|
"Here is a simple example that demonstrates the behavior of generators and "
|
||
|
"generator functions::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:496
|
||
|
msgid ""
|
||
|
"For examples using ``yield from``, see :ref:`pep-380` in \"What's New in "
|
||
|
"Python.\""
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:503
|
||
|
msgid "Primaries"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:507
|
||
|
msgid ""
|
||
|
"Primaries represent the most tightly bound operations of the language. Their "
|
||
|
"syntax is:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:517
|
||
|
msgid "Attribute references"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:521
|
||
|
msgid "An attribute reference is a primary followed by a period and a name:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:531
|
||
|
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:543
|
||
|
msgid "Subscriptions"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:556
|
||
|
msgid ""
|
||
|
"A subscription selects an item of a sequence (string, tuple or list) or "
|
||
|
"mapping (dictionary) object:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:562
|
||
|
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:566
|
||
|
msgid ""
|
||
|
"For built-in objects, there are two types of objects that support "
|
||
|
"subscription:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:568
|
||
|
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:573
|
||
|
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:576
|
||
|
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:590
|
||
|
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:597
|
||
|
msgid "Slicings"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:609
|
||
|
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:622
|
||
|
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:634
|
||
|
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:655
|
||
|
msgid "Calls"
|
||
|
msgstr "Appels"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:657
|
||
|
msgid ""
|
||
|
"A call calls a callable object (e.g., a :term:`function`) with a possibly "
|
||
|
"empty series of :term:`arguments <argument>`:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:673
|
||
|
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:679
|
||
|
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:687
|
||
|
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:707
|
||
|
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:713
|
||
|
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:719
|
||
|
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:730
|
||
|
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:737
|
||
|
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:753
|
||
|
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:759
|
||
|
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:765
|
||
|
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:768
|
||
|
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:774
|
||
|
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:778
|
||
|
msgid "If it is---"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:791
|
||
|
msgid "a user-defined function:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:787
|
||
|
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:805
|
||
|
msgid "a built-in function or method:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:804
|
||
|
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:812
|
||
|
msgid "a class object:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:812
|
||
|
msgid "A new instance of that class is returned."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:822
|
||
|
msgid "a class instance method:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:820
|
||
|
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:831
|
||
|
msgid "a class instance:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:829
|
||
|
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:836 ../Doc/reference/expressions.rst:1537
|
||
|
msgid "Await expression"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:838
|
||
|
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:850
|
||
|
msgid "The power operator"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:852
|
||
|
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:858
|
||
|
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:862
|
||
|
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:867
|
||
|
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:872
|
||
|
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:880
|
||
|
msgid "Unary arithmetic and bitwise operations"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:886
|
||
|
msgid "All unary arithmetic and bitwise operations have the same priority:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:895
|
||
|
msgid ""
|
||
|
"The unary ``-`` (minus) operator yields the negation of its numeric argument."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:899
|
||
|
msgid "The unary ``+`` (plus) operator yields its numeric argument unchanged."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:904
|
||
|
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:910
|
||
|
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:917
|
||
|
msgid "Binary arithmetic operations"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:921
|
||
|
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:934
|
||
|
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:942
|
||
|
msgid ""
|
||
|
"The ``@`` (at) operator is intended to be used for matrix multiplication. "
|
||
|
"No builtin Python types implement this operator."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:951
|
||
|
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:960
|
||
|
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:969
|
||
|
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:974
|
||
|
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:979
|
||
|
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:985
|
||
|
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:992
|
||
|
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:999
|
||
|
msgid "Shifting operations"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1003
|
||
|
msgid ""
|
||
|
"The shifting operations have lower priority than the arithmetic operations:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1008
|
||
|
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:1013
|
||
|
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:1018
|
||
|
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:1025
|
||
|
msgid "Binary bitwise operations"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1029
|
||
|
msgid "Each of the three bitwise operations has a different priority level:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1038
|
||
|
msgid ""
|
||
|
"The ``&`` operator yields the bitwise AND of its arguments, which must be "
|
||
|
"integers."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1045
|
||
|
msgid ""
|
||
|
"The ``^`` operator yields the bitwise XOR (exclusive OR) of its arguments, "
|
||
|
"which must be integers."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1052
|
||
|
msgid ""
|
||
|
"The ``|`` operator yields the bitwise (inclusive) OR of its arguments, which "
|
||
|
"must be integers."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1059
|
||
|
msgid "Comparisons"
|
||
|
msgstr "Comparaisons"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1065
|
||
|
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:1075
|
||
|
msgid "Comparisons yield boolean values: ``True`` or ``False``."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1079
|
||
|
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:1083
|
||
|
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:1088
|
||
|
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:1093
|
||
|
msgid "Value comparisons"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1095
|
||
|
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:1098
|
||
|
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:1107
|
||
|
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:1113
|
||
|
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:1120
|
||
|
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:1124
|
||
|
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:1130
|
||
|
msgid ""
|
||
|
"The following list describes the comparison behavior of the most important "
|
||
|
"built-in types."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1133
|
||
|
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:1140
|
||
|
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:1147
|
||
|
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:1151
|
||
|
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:1155
|
||
|
msgid "Strings and binary sequences cannot be directly compared."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1157
|
||
|
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 unequality, and ordering comparison across these types "
|
||
|
"raises :exc:`TypeError`."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1163
|
||
|
msgid ""
|
||
|
"Sequences compare lexicographically using comparison of corresponding "
|
||
|
"elements, whereby reflexivity of the elements is enforced."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1166
|
||
|
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:1184
|
||
|
msgid ""
|
||
|
"Lexicographical comparison between built-in collections works as follows:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1186
|
||
|
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:1191
|
||
|
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:1197
|
||
|
msgid ""
|
||
|
"Mappings (instances of :class:`dict`) compare equal if and only if they have "
|
||
|
"equal `(key, value)` pairs. Equality comparison of the keys and elements "
|
||
|
"enforces reflexivity."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1201
|
||
|
msgid ""
|
||
|
"Order comparisons (``<``, ``>``, ``<=``, and ``>=``) raise :exc:`TypeError`."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1203
|
||
|
msgid ""
|
||
|
"Sets (instances of :class:`set` or :class:`frozenset`) can be compared "
|
||
|
"within and across their types."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1206
|
||
|
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:1214
|
||
|
msgid "Comparison of sets enforces reflexivity of its elements."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1216
|
||
|
msgid ""
|
||
|
"Most other built-in types have no comparison methods implemented, so they "
|
||
|
"inherit the default comparison behavior."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1219
|
||
|
msgid ""
|
||
|
"User-defined classes that customize their comparison behavior should follow "
|
||
|
"some consistency rules, if possible:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1222
|
||
|
msgid ""
|
||
|
"Equality comparison should be reflexive. In other words, identical objects "
|
||
|
"should compare equal:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1225
|
||
|
msgid "``x is y`` implies ``x == y``"
|
||
|
msgstr "``x is y`` implique ``x == y``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1227
|
||
|
msgid ""
|
||
|
"Comparison should be symmetric. In other words, the following expressions "
|
||
|
"should have the same result:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1230
|
||
|
msgid "``x == y`` and ``y == x``"
|
||
|
msgstr "``x == y`` et ``y == x``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1232
|
||
|
msgid "``x != y`` and ``y != x``"
|
||
|
msgstr "``x != y`` et ``y != x``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1234
|
||
|
msgid "``x < y`` and ``y > x``"
|
||
|
msgstr "``x < y`` et ``y > x``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1236
|
||
|
msgid "``x <= y`` and ``y >= x``"
|
||
|
msgstr "``x <= y`` et ``y >= x``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1238
|
||
|
msgid ""
|
||
|
"Comparison should be transitive. The following (non-exhaustive) examples "
|
||
|
"illustrate that:"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1241
|
||
|
msgid "``x > y and y > z`` implies ``x > z``"
|
||
|
msgstr "``x > y et y > z`` implique ``x > z``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1243
|
||
|
msgid "``x < y and y <= z`` implies ``x < z``"
|
||
|
msgstr "``x < y et y <= z`` implique ``x < z``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1245
|
||
|
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:1248
|
||
|
msgid "``x == y`` and ``not x != y``"
|
||
|
msgstr "``x == y`` et ``not x != y``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1250
|
||
|
msgid "``x < y`` and ``not x >= y`` (for total ordering)"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1252
|
||
|
msgid "``x > y`` and ``not x <= y`` (for total ordering)"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1254
|
||
|
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:1258
|
||
|
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:1267
|
||
|
msgid "Membership test operations"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1269
|
||
|
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:1277
|
||
|
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:1282
|
||
|
msgid ""
|
||
|
"For user-defined classes which define the :meth:`__contains__` method, ``x "
|
||
|
"in y`` is true if and only if ``y.__contains__(x)`` is true."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1285
|
||
|
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:1290
|
||
|
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:1302
|
||
|
msgid ""
|
||
|
"The operator :keyword:`not in` is defined to have the inverse true value of :"
|
||
|
"keyword:`in`."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1315
|
||
|
msgid "Identity comparisons"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1317
|
||
|
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:1329
|
||
|
msgid "Boolean operations"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1340
|
||
|
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:1349
|
||
|
msgid ""
|
||
|
"The operator :keyword:`not` yields ``True`` if its argument is false, "
|
||
|
"``False`` otherwise."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1354
|
||
|
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:1359
|
||
|
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:1362
|
||
|
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:1372
|
||
|
msgid "Conditional expressions"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1383
|
||
|
msgid ""
|
||
|
"Conditional expressions (sometimes called a \"ternary operator\") have the "
|
||
|
"lowest priority of all Python operations."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1386
|
||
|
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:1390
|
||
|
msgid "See :pep:`308` for more details about conditional expressions."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1397
|
||
|
msgid "Lambdas"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1408
|
||
|
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:1417
|
||
|
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:1425
|
||
|
msgid "Expression lists"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1437
|
||
|
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:1446
|
||
|
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:1451
|
||
|
msgid ""
|
||
|
"Iterable unpacking in expression lists, originally proposed by :pep:`448`."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1456
|
||
|
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:1466
|
||
|
msgid "Evaluation order"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1470
|
||
|
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:1473
|
||
|
msgid ""
|
||
|
"In the following lines, expressions will be evaluated in the arithmetic "
|
||
|
"order of their suffixes::"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1487
|
||
|
msgid "Operator precedence"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1491
|
||
|
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:1497
|
||
|
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:1503
|
||
|
msgid "Operator"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1503
|
||
|
msgid "Description"
|
||
|
msgstr "Description"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1505
|
||
|
msgid ":keyword:`lambda`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1505
|
||
|
msgid "Lambda expression"
|
||
|
msgstr "Expression lambda"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1507
|
||
|
msgid ":keyword:`if` -- :keyword:`else`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1507
|
||
|
msgid "Conditional expression"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1509
|
||
|
msgid ":keyword:`or`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1509
|
||
|
msgid "Boolean OR"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1511
|
||
|
msgid ":keyword:`and`"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1511
|
||
|
msgid "Boolean AND"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1513
|
||
|
msgid ":keyword:`not` ``x``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1513
|
||
|
msgid "Boolean NOT"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1515
|
||
|
msgid ""
|
||
|
":keyword:`in`, :keyword:`not in`, :keyword:`is`, :keyword:`is not`, ``<``, "
|
||
|
"``<=``, ``>``, ``>=``, ``!=``, ``==``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1515
|
||
|
msgid "Comparisons, including membership tests and identity tests"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1519
|
||
|
msgid "``|``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1519
|
||
|
msgid "Bitwise OR"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1521
|
||
|
msgid "``^``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1521
|
||
|
msgid "Bitwise XOR"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1523
|
||
|
msgid "``&``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1523
|
||
|
msgid "Bitwise AND"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1525
|
||
|
msgid "``<<``, ``>>``"
|
||
|
msgstr "``<<``, ``>>``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1525
|
||
|
msgid "Shifts"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1527
|
||
|
msgid "``+``, ``-``"
|
||
|
msgstr "``+``, ``-``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1527
|
||
|
msgid "Addition and subtraction"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1529
|
||
|
msgid "``*``, ``@``, ``/``, ``//``, ``%``"
|
||
|
msgstr "``*``, ``@``, ``/``, ``//``, ``%``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1529
|
||
|
msgid "Multiplication, matrix multiplication division, remainder [#]_"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1533
|
||
|
msgid "``+x``, ``-x``, ``~x``"
|
||
|
msgstr "``+x``, ``-x``, ``~x``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1533
|
||
|
msgid "Positive, negative, bitwise NOT"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1535
|
||
|
msgid "``**``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1535
|
||
|
msgid "Exponentiation [#]_"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1537
|
||
|
msgid "``await`` ``x``"
|
||
|
msgstr "``await`` ``x``"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1539
|
||
|
msgid "``x[index]``, ``x[index:index]``, ``x(arguments...)``, ``x.attribute``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1539
|
||
|
msgid "Subscription, slicing, call, attribute reference"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1542
|
||
|
msgid ""
|
||
|
"``(expressions...)``, ``[expressions...]``, ``{key: value...}``, "
|
||
|
"``{expressions...}``"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1542
|
||
|
msgid "Binding or tuple display, list display, dictionary display, set display"
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1550
|
||
|
msgid "Footnotes"
|
||
|
msgstr "Notes"
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1551
|
||
|
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:1560
|
||
|
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:1565
|
||
|
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:1576
|
||
|
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:1581
|
||
|
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:1584
|
||
|
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:1589
|
||
|
msgid ""
|
||
|
"The ``%`` operator is also used for string formatting; the same precedence "
|
||
|
"applies."
|
||
|
msgstr ""
|
||
|
|
||
|
#: ../Doc/reference/expressions.rst:1592
|
||
|
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 ""
|