6. Выражения¶
Эта глава объясняет значение элементов выражений в Python.
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
name ::= othername
и никакая семантика не задана, то семантика этой формы name такая же, как у othername.
6.1. Арифметические преобразования¶
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:
If either argument is a complex number, the other is converted to complex;
otherwise, if either argument is a floating-point number, the other is converted to floating point;
otherwise, both must be integers and no conversion is necessary.
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.
6.2. Элементарные выражения¶
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:
atom ::=identifier|literal|enclosureenclosure ::=parenth_form|list_display|dict_display|set_display|generator_expression|yield_atom
6.2.1. Идентификаторы (имена)¶
Идентификатор, встречающийся в роли элементарного выражения, является именем. Лексическое определение см. в разделе Identifiers and keywords, а описание именования и связывания — в разделе Именование и связывание.
Когда имя связано с объектом, вычисление элементарного выражения даёт этот объект. Если имя не связано, попытка его вычислить возбуждает исключение NameError.
6.2.1.1. Искажение закрытых имён¶
Если идентификатор, который в тексте встречается внутри определения класса, начинается с двух и более символов подчёркивания и не заканчивается двумя и более подчёркиваниями, он считается закрытым именем этого класса.
См. также
Точнее, перед генерацией кода закрытые имена преобразуются в более длинную форму. Если преобразованное имя длиннее 255 символов, может произойти усечение, определяемое реализацией.
Преобразование не зависит от синтаксического контекста, в котором используется идентификатор, но искажаются только следующие закрытые идентификаторы:
Любое имя, используемое как имя переменной, в которую записывают или из которой читают, а также любое имя атрибута, к которому обращаются.
Атрибут
__name__вложенных функций, классов и псевдонимов типов при этом не искажается.Имя импортируемого модуля, например
__spamвimport __spam. Если модуль входит в пакет (то есть его имя содержит точку), имя не искажается, например__fooвimport __foo.barне искажается.Имя импортируемого члена, например
__fвfrom spam import __f.
Правило преобразования определено следующим образом:
Перед идентификатором вставляется имя класса, у которого сперва удалены все ведущие подчёркивания, а затем добавлено одно. Например, идентификатор
__spamв классе с именемFoo,_Fooили__Fooпреобразуется в_Foo__spam.Если имя класса состоит только из подчёркиваний, преобразование никак не изменяет идентификатор. Например, идентификатор
__spamв классе с именем_или__остаётся без изменений.
6.2.2. Литералы¶
Python supports string and bytes literals and various numeric literals:
literal ::=stringliteral|bytesliteral|integer|floatnumber|imagnumber
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 Литералы for details.
Все литералы соответствуют неизменяемым типам данных, поэтому идентичность объекта менее важна, чем его значение. Многократные вычисления литералов с одним и тем же значением (будь то одно и то же вхождение в тексте программы или разные) могут давать один и тот же объект или разные объекты с одинаковым значением.
6.2.3. Parenthesized forms¶
A parenthesized form is an optional expression list enclosed in parentheses:
parenth_form ::= "(" [starred_expression] ")"
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.
An empty pair of parentheses yields an empty tuple object. Since tuples are immutable, the same rules as for literals apply (i.e., two occurrences of the empty tuple may or may not yield the same object).
Note that tuples are not formed by the parentheses, but rather by use of the comma. 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.
6.2.4. Displays for lists, sets and dictionaries¶
For constructing a list, a set or a dictionary Python provides special syntax called «displays», each of them in two flavors:
either the container contents are listed explicitly, or
they are computed via a set of looping and filtering instructions, called a comprehension.
Common syntax elements for comprehensions are:
comprehension ::=assignment_expressioncomp_forcomp_for ::= ["async"] "for"target_list"in"or_test[comp_iter] comp_iter ::=comp_for|comp_ifcomp_if ::= "if"or_test[comp_iter]
The comprehension consists of a single expression followed by at least one
for clause and zero or more for or if clauses.
In this case, the elements of the new container are those that would be produced
by considering each of the for or if clauses a block,
nesting from left to right, and evaluating the expression to produce an element
each time the innermost block is reached.
However, aside from the iterable expression in the leftmost for clause,
the comprehension is executed in a separate implicitly nested scope. This ensures
that names assigned to in the target list don’t «leak» into the enclosing scope.
The iterable expression in the leftmost for clause is evaluated
directly in the enclosing scope and then passed as an argument to the implicitly
nested scope. Subsequent for clauses and any filter condition in the
leftmost for clause cannot be evaluated in the enclosing scope as
they may depend on the values obtained from the leftmost iterable. For example:
[x*y for x in range(10) for y in range(x, x+10)].
Чтобы включение всегда давало контейнер соответствующего типа, выражения yield и yield from запрещены в неявно вложенной области видимости.
Since Python 3.6, in an async def function, an async for
clause may be used to iterate over a asynchronous iterator.
A comprehension in an async def function may consist of either a
for or async for clause following the leading
expression, may contain additional for or async for
clauses, and may also use await expressions.
If a comprehension contains async for clauses, or if it contains
await expressions or other asynchronous comprehensions anywhere except
the iterable expression in the leftmost for clause, it is called an
asynchronous comprehension. An asynchronous comprehension may suspend the
execution of the coroutine function in which it appears.
See also PEP 530.
Добавлено в версии 3.6: Asynchronous comprehensions were introduced.
Изменено в версии 3.8: Теперь yield и yield from запрещены в неявно вложенной области видимости.
Изменено в версии 3.11: Теперь асинхронные включения разрешены внутри включений в асинхронных функциях. Внешние включения неявно становятся асинхронными.
6.2.5. Явные представления списков¶
A list display is a possibly empty series of expressions enclosed in square brackets:
list_display ::= "[" [flexible_expression_list|comprehension] "]"
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.
6.2.6. Явные представления множеств¶
A set display is denoted by curly braces and distinguishable from dictionary displays by the lack of colons separating keys and values:
set_display ::= "{" (flexible_expression_list | comprehension) "}"
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.
An empty set cannot be constructed with {}; this literal constructs an empty
dictionary.
6.2.7. Явные представления словарей¶
A dictionary display is a possibly empty series of dict items (key/value pairs) enclosed in curly braces:
dict_display ::= "{" [dict_item_list | dict_comprehension] "}"
dict_item_list ::= dict_item ("," dict_item)* [","]
dict_item ::= expression ":" expression | "**" or_expr
dict_comprehension ::= expression ":" expression comp_for
A dictionary display yields a new dictionary object.
If a comma-separated sequence of dict items 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 value. This means that you can specify the same key multiple times in the dict item list, and the final dictionary’s value for that key will be the last one given.
A double asterisk ** denotes dictionary unpacking.
Its operand must be a mapping. Each mapping item is added
to the new dictionary. Later values replace values already set by
earlier dict items and earlier dictionary unpackings.
Добавлено в версии 3.5: Распаковка в явные представления словарей, изначально предложенная в PEP 448.
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.
Restrictions on the types of the key values are listed earlier in section Иерархия стандартных типов. (To summarize, the key type should be hashable, which excludes all mutable objects.) Clashes between duplicate keys are not detected; the last value (textually rightmost in the display) stored for a given key value prevails.
Изменено в версии 3.8: До Python 3.8 порядок вычисления ключа и значения во включениях словарей не был строго определён. В CPython значение вычислялось раньше ключа. Начиная с версии 3.8 ключ вычисляется раньше значения, как предложено в PEP 572.
6.2.8. Генераторные выражения¶
A generator expression is a compact generator notation in parentheses:
generator_expression ::= "(" expression comp_for ")"
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.
Variables used in the generator expression are evaluated lazily when the
__next__() method is called for the generator object (in the same
fashion as normal generators). However, the iterable expression in the
leftmost for clause is immediately evaluated, and the
iterator is immediately created for that iterable, so that an error
produced while creating the iterator will be emitted at the point where the generator expression
is defined, rather than at the point where the first value is retrieved.
Subsequent for clauses and any filter condition in the leftmost
for clause cannot be evaluated in the enclosing scope as they may
depend on the values obtained from the leftmost iterable. For example:
(x*y for x in range(10) for y in range(x, x+10)).
The parentheses can be omitted on calls with only one argument. See section Вызовы for details.
To avoid interfering with the expected operation of the generator expression
itself, yield and yield from expressions are prohibited in the
implicitly defined generator.
If a generator expression contains either async for
clauses or await expressions it is called an
asynchronous generator expression. An asynchronous generator
expression returns a new asynchronous generator object,
which is an asynchronous iterator (see Асинхронные итераторы).
Добавлено в версии 3.6: Были представлены асинхронные генераторные выражения.
Изменено в версии 3.7: До Python 3.7 асинхронные генераторные выражения могли появляться только в сопрограммах async def. Начиная с версии 3.7 асинхронные генераторные выражения могут использоваться в любой функции.
Изменено в версии 3.8: Теперь yield и yield from запрещены в неявно вложенной области видимости.
6.2.9. Выражения yield¶
yield_atom ::= "(" yield_expression ")"
yield_from ::= "yield" "from" expression
yield_expression ::= "yield" yield_list | yield_from
Выражение yield используется при определении генераторной функции или асинхронной генераторной функции, и поэтому его можно использовать только в теле определения функции. Использование выражения yield в теле функции делает эту функцию генераторной, а его использование в теле функции async def делает эту сопрограммную функцию асинхронной генераторной функцией. Например:
def gen(): # определяет генераторную функцию
yield 123
async def agen(): # определяет асинхронную генераторную функцию
yield 123
Из-за побочных эффектов, оказываемых на содержащую их область видимости, выражения yield не допускаются в неявно определяемых областях видимости, которые используются для реализации включений и генераторных выражений.
Изменено в версии 3.8: Теперь выражения yield запрещены в неявно вложенных областях видимости, используемых для реализации включений и генераторных выражений.
Генераторные функции описаны ниже, в то время как асинхронные генераторные функции описаны отдельно в разделе Асинхронные генераторные функции.
При вызове генераторной функции она возвращает итератор, называемый генератором. Этот генератор затем управляет выполнением генераторной функции. Выполнение начинается при вызове одного из методов генератора. В этот момент выполнение доходит до первого выражения yield, где снова приостанавливается, возвращая вызывающей стороне генератора значение yield_list или None, если yield_list опущен. Под приостановкой понимается, что сохраняется всё локальное состояние: текущие привязки локальных переменных, указатель инструкций, внутренний стек вычислений и состояние обработки любых исключений. Когда выполнение возобновляется вызовом одного из методов генератора, функция может продолжить работу точно так, как если бы выражение yield было обычным внешним вызовом. Значение выражения yield после возобновления зависит от метода, который возобновил выполнение. Если используется __next__() (обычно через for или встроенную функцию next()), результат равен None. В противном случае, если используется send(), результатом будет значение, переданное в этот метод.
Всё это делает генераторные функции очень похожими на сопрограммы: они выдают значения несколько раз, у них больше одной точки входа, и их выполнение можно приостанавливать. Единственное отличие в том, что генераторная функция не может управлять тем, где должно продолжиться выполнение после выдачи значения: управление всегда передаётся вызывающей стороне генератора.
Выражения yield разрешены в любом месте конструкции try. Если генератор не возобновляется до его финализации (при достижении нулевого счётчика ссылок или при сборке мусора), вызывается метод close() генераторного итератора, что позволяет выполниться всем ожидающим частям finally.
При использовании yield from <expr> переданное выражение должно быть итерируемым объектом. Значения, получаемые при переборе этого итерируемого объекта, передаются напрямую тому, кто вызывает методы текущего генератора. Любые значения, переданные с помощью send(), и любые исключения, переданные с помощью throw(), передаются вложенному итератору, если у него есть соответствующие методы. В противном случае send() возбудит AttributeError или TypeError, а throw() просто немедленно возбудит переданное исключение.
Когда вложенный итератор завершается, атрибут value возбуждённого экземпляра StopIteration становится значением выражения yield. Это значение можно задать явно при возбуждении StopIteration или автоматически, если подитератор является генератором (возвратом значения из подгенератора).
Изменено в версии 3.3: Добавлено выражение yield from <expr>, которое делегирует поток управления подитератору.
Теперь скобки можно опустить, если выражение yield — единственное выражение в правой части инструкции присваивания.
См. также
- PEP 255 — Простые генераторы
Предложение о добавлении в Python генераторов и инструкции
yield.- PEP 342 — Сопрограммы через расширенные генераторы
Предложение расширить API и синтаксис генераторов, чтобы их можно было использовать как простые сопрограммы.
- PEP 380 — Синтаксис делегирования подгенератору
Предложение добавить синтаксис
yield_from, упрощающий делегирование подгенераторам.- PEP 525 — Асинхронные генераторы
Предложение, которое расширило PEP 492, добавив возможности генераторов в сопрограммные функции.
6.2.9.1. Generator-iterator methods¶
This subsection describes the methods of a generator iterator. They can be used to control the execution of a generator function.
Note that calling any of the generator methods below when the generator
is already executing raises a ValueError exception.
- generator.__next__()¶
Starts the execution of a generator function or resumes it at the last executed yield expression. When a generator function is resumed with a
__next__()method, the current yield expression always evaluates toNone. The execution then continues to the next yield expression, where the generator is suspended again, and the value of theyield_listis returned to__next__()“s caller. If the generator exits without yielding another value, aStopIterationexception is raised.This method is normally called implicitly, e.g. by a
forloop, or by the built-innext()function.
- generator.send(value)¶
Resumes the execution and «sends» a value into the generator function. The value argument becomes the result of the current yield expression. The
send()method returns the next value yielded by the generator, or raisesStopIterationif the generator exits without yielding another value. Whensend()is called to start the generator, it must be called withNoneas the argument, because there is no yield expression that could receive the value.
- generator.throw(value)¶
- generator.throw(type[, value[, traceback]])
Raises an exception 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
StopIterationexception 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.In typical use, this is called with a single exception instance similar to the way the
raisekeyword is used.For backwards compatibility, however, the second signature is supported, following a convention from older versions of Python. The type argument should be an exception class, and value should be an exception instance. If the value is not provided, the type constructor is called to get an instance. If traceback is provided, it is set on the exception, otherwise any existing
__traceback__attribute stored in value may be cleared.Изменено в версии 3.12: The second signature (type[, value[, traceback]]) is deprecated and may be removed in a future version of Python.
- generator.close()¶
Raises a
GeneratorExitexception at the point where the generator function was paused (equivalent to callingthrow(GeneratorExit)). The exception is raised by the yield expression where the generator was paused. If the generator function catches the exception and returns a value, this value is returned fromclose(). If the generator function is already closed, or raisesGeneratorExit(by not catching the exception),close()returnsNone. If the generator yields a value, aRuntimeErroris raised. If the generator raises any other exception, it is propagated to the caller. If the generator has already exited due to an exception or normal exit,close()returnsNoneand has no other effect.Изменено в версии 3.13: If a generator returns a value upon being closed, the value is returned by
close().
6.2.9.2. Примеры¶
Вот простой пример, демонстрирующий поведение генераторов и генераторных функций:
>>> def echo(value=None):
... print("Выполнение начинается, когда 'next()' вызывается в первый раз.")
... try:
... while True:
... try:
... value = (yield value)
... except Exception as e:
... value = e
... finally:
... print("Не забудьте выполнить очистку при вызове 'close()'.")
...
>>> generator = echo(1)
>>> print(next(generator))
Выполнение начинается, когда 'next()' вызывается в первый раз.
1
>>> print(next(generator))
None
>>> print(generator.send(2))
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Не забудьте выполнить очистку при вызове 'close()'.
Примеры использования yield from см. в PEP 380: Syntax for Delegating to a Subgenerator в разделе «Что нового в Python».
6.2.9.3. Асинхронные генераторные функции¶
Наличие выражения yield в функции или методе, определённых с помощью async def, делает эту функцию асинхронной генераторной.
При вызове асинхронной генераторной функции она возвращает асинхронный итератор, называемый объектом асинхронного генератора. Этот объект затем управляет выполнением генераторной функции. Объект асинхронного генератора обычно используется в циклической инструкции async for в сопрограммной функции аналогично тому, как объект генератора используется в инструкции for.
Вызов одного из методов асинхронного генератора возвращает ожидаемый объект, и выполнение начинается, когда этот объект ожидается с помощью await. В этот момент выполнение доходит до первого выражения yield, где снова приостанавливается, возвращая значение yield_list ожидающей сопрограмме. Как и в случае генератора, приостановка означает, что сохраняется всё локальное состояние: текущие привязки локальных переменных, указатель инструкций, внутренний стек вычислений и состояние обработки любых исключений. Когда выполнение возобновляется ожиданием следующего объекта, возвращённого методами асинхронного генератора, функция может продолжить работу точно так, как если бы выражение yield было обычным внешним вызовом. Значение выражения yield после возобновления зависит от метода, который возобновил выполнение. Если используется __anext__(), результат равен None. В противном случае, если используется asend(), результатом будет значение, переданное в этот метод.
If an asynchronous generator happens to exit early by break, the caller
task being cancelled, or other exceptions, the generator’s async cleanup code
will run and possibly raise exceptions or access context variables in an
unexpected context–perhaps after the lifetime of tasks it depends, or
during the event loop shutdown when the async-generator garbage collection hook
is called.
To prevent this, the caller must explicitly close the async generator by calling
aclose() method to finalize the generator and ultimately detach it
from the event loop.
In an asynchronous generator function, yield expressions are allowed anywhere
in a 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 try
construct could result in a failure to execute pending 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 aclose() method and run the resulting
coroutine object, thus allowing any pending finally clauses
to execute.
To take care of finalization upon event loop termination, an event loop should
define a finalizer function which takes an asynchronous generator-iterator and
presumably calls aclose() and executes the coroutine.
This finalizer may be registered by calling 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 Lib/asyncio/base_events.py.
Выражение yield from <expr> является синтаксической ошибкой при использовании в асинхронной генераторной функции.
6.2.9.4. Asynchronous generator-iterator methods¶
This subsection describes the methods of an asynchronous generator iterator, which are used to control the execution of a generator function.
- async agen.__anext__()¶
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 an
__anext__()method, the current yield expression always evaluates toNonein the returned awaitable, which when run will continue to the next yield expression. The value of theyield_listof the yield expression is the value of theStopIterationexception raised by the completing coroutine. If the asynchronous generator exits without yielding another value, the awaitable instead raises aStopAsyncIterationexception, signalling that the asynchronous iteration has completed.This method is normally called implicitly by a
async forloop.
- async agen.asend(value)¶
Returns an awaitable which when run resumes the execution of the asynchronous generator. As with the
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 theasend()method will return the next value yielded by the generator as the value of the raisedStopIteration, or raisesStopAsyncIterationif the asynchronous generator exits without yielding another value. Whenasend()is called to start the asynchronous generator, it must be called withNoneas the argument, because there is no yield expression that could receive the value.
- async agen.athrow(value)¶
- async agen.athrow(type[, value[, traceback]])
Returns an awaitable that raises an exception of type
typeat the point where the asynchronous generator was paused, and returns the next value yielded by the generator function as the value of the raisedStopIterationexception. If the asynchronous generator exits without yielding another value, aStopAsyncIterationexception is raised by the awaitable. If the generator function does not catch the passed-in exception, or raises a different exception, then when the awaitable is run that exception propagates to the caller of the awaitable.Изменено в версии 3.12: The second signature (type[, value[, traceback]]) is deprecated and may be removed in a future version of Python.
- async agen.aclose()¶
Returns an awaitable that when run will throw a
GeneratorExitinto the asynchronous generator function at the point where it was paused. If the asynchronous generator function then exits gracefully, is already closed, or raisesGeneratorExit(by not catching the exception), then the returned awaitable will raise aStopIterationexception. Any further awaitables returned by subsequent calls to the asynchronous generator will raise aStopAsyncIterationexception. If the asynchronous generator yields a value, aRuntimeErroris 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 toaclose()will return an awaitable that does nothing.
6.3. Первичные выражения¶
Первичные выражения представляют операции языка с самым высоким приоритетом. Их синтаксис:
primary ::=atom|attributeref|subscription|slicing|call
6.3.1. Обращения к атрибутам¶
Обращение к атрибуту — это первичное выражение, за которым следуют точка и имя:
attributeref ::=primary"."identifier
Первичное выражение должно вычисляться в объект типа, поддерживающего обращения к атрибутам, что и делает большинство объектов. Затем у этого объекта запрашивается атрибут, имя которого задано идентификатором. Тип и значение результата определяет сам объект. Многократные вычисления одного и того же обращения к атрибуту могут давать разные объекты.
Поведение такого обращения можно настроить, переопределив метод __getattribute__() или метод __getattr__(). Сначала вызывается метод __getattribute__(), который либо возвращает значение, либо возбуждает AttributeError, если атрибут недоступен.
Если возникает AttributeError и у объекта есть метод __getattr__(), то он вызывается как запасной вариант.
6.3.2. Subscriptions¶
The subscription of an instance of a container class will generally select an element from the container. The subscription of a generic class will generally return a GenericAlias object.
subscription ::=primary"["flexible_expression_list"]"
When an object is subscripted, the interpreter will evaluate the primary and the expression list.
The primary must evaluate to an object that supports subscription. An object
may support subscription through defining one or both of
__getitem__() and __class_getitem__(). When the
primary is subscripted, the evaluated result of the expression list will be
passed to one of these methods. For more details on when __class_getitem__
is called instead of __getitem__, see __class_getitem__ против __getitem__.
If the expression list contains at least one comma, or if any of the expressions
are starred, the expression list will evaluate to a tuple containing
the items of the expression list. Otherwise, the expression list will evaluate
to the value of the list’s sole member.
Изменено в версии 3.11: Expressions in an expression list may be starred. See PEP 646.
For built-in objects, there are two types of objects that support subscription
via __getitem__():
Mappings. 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. An example of a builtin mapping class is the
dictclass.Sequences. If the primary is a sequence, the expression list must evaluate to an
intor aslice(as discussed in the following section). Examples of builtin sequence classes include thestr,listandtupleclasses.
The formal syntax makes no special provision for negative indices in
sequences. However, built-in sequences all provide a __getitem__()
method that interprets negative indices by adding the length of the sequence
to the index so that, for example, 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 __getitem__() method, subclasses overriding
this method will need to explicitly add that support.
A string is a special kind of sequence whose items are
characters. A character is not a separate data type but a
string of exactly one character.
6.3.3. Срезы¶
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
del statements. The syntax for a slicing:
slicing ::=primary"["slice_list"]" slice_list ::=slice_item(","slice_item)* [","] slice_item ::=expression|proper_sliceproper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ] lower_bound ::=expressionupper_bound ::=expressionstride ::=expression
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).
The semantics for a slicing are as follows. The primary is indexed (using the
same __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 Иерархия стандартных типов) whose start,
stop and step attributes are the values of the
expressions given as lower bound, upper bound and stride, respectively,
substituting None for missing expressions.
6.3.4. Вызовы¶
Вызов запускает вызываемый объект (например, функцию), передавая ему, возможно, пустой набор аргументов:
call ::=primary"(" [argument_list[","] |comprehension] ")" argument_list ::=positional_arguments[","starred_and_keywords] [","keywords_arguments] |starred_and_keywords[","keywords_arguments] |keywords_argumentspositional_arguments ::=positional_item(","positional_item)* positional_item ::=assignment_expression| "*"expressionstarred_and_keywords ::= ("*"expression|keyword_item) ("," "*"expression| ","keyword_item)* keywords_arguments ::= (keyword_item| "**"expression) (","keyword_item| "," "**"expression)* keyword_item ::=identifier"="expression
После позиционных и именованных аргументов может стоять необязательная завершающая запятая, которая не влияет на семантику.
Первичное выражение должно вычисляться в вызываемый объект (вызываемыми являются пользовательские функции, встроенные функции, методы встроенных объектов, объекты классов, методы экземпляров классов и все объекты, имеющие метод __call__()). Все выражения аргументов вычисляются до попытки вызова. Синтаксис списков формальных параметров см. в разделе Определения функций.
Если есть именованные аргументы, они сначала преобразуются в позиционные следующим образом. Сначала для формальных параметров создаётся список незаполненных слотов. Если позиционных аргументов N, они помещаются в первые N слотов. Затем для каждого именованного аргумента по идентификатору определяется соответствующий слот (если идентификатор совпадает с именем первого формального параметра, используется первый слот, и так далее). Если слот уже заполнен, возбуждается исключение TypeError. В противном случае аргумент помещается в слот и заполняет его (даже если выражение равно None, оно заполняет слот). Когда все аргументы обработаны, слоты, оставшиеся незаполненными, заполняются соответствующими значениями по умолчанию из определения функции. (Значения по умолчанию вычисляются один раз, при определении функции; поэтому изменяемый объект, например список или словарь, используемый в качестве значения по умолчанию, будет общим для всех вызовов, в которых не указано значение аргумента для соответствующего слота; этого обычно следует избегать.) Если остались незаполненные слоты, для которых значение по умолчанию не задано, возбуждается исключение TypeError. В противном случае список заполненных слотов используется в качестве списка аргументов вызова.
Реализация может предоставлять встроенные функции, у позиционных параметров которых нет имён, даже если для целей документации они «названы», и которые поэтому нельзя передать как именованные аргументы. В CPython так обстоит дело с функциями, написанными на C, которые используют PyArg_ParseTuple() для разбора своих аргументов.
Если позиционных аргументов больше, чем слотов формальных параметров, возбуждается исключение TypeError, если только нет формального параметра, использующего синтаксис *identifier. В этом случае данный формальный параметр получает кортеж, содержащий лишние позиционные аргументы (или пустой кортеж, если лишних позиционных аргументов не было).
Если какой-либо именованный аргумент не соответствует имени формального параметра, возбуждается исключение TypeError, если только нет формального параметра, использующего синтаксис **identifier. В этом случае данный формальный параметр получает словарь, содержащий лишние именованные аргументы (ключами служат имена аргументов, а значениями — переданные значения), или (новый) пустой словарь, если лишних именованных аргументов не было.
Если в вызове функции встречается синтаксис *expression, то expression должно вычисляться в итерируемый объект. Элементы этих итерируемых объектов рассматриваются так, как если бы они были дополнительными позиционными аргументами. Для вызова f(x1, x2, *y, x3, x4), если y вычисляется в последовательность y1, …, yM, это будет эквивалентно вызову с M+4 позиционными аргументами x1, x2, y1, …, yM, x3, x4.
Следствием этого является то, что, хотя синтаксис *expression может стоять после явных именованных аргументов, он обрабатывается до именованных аргументов (и любых аргументов **expression — см. ниже). Так:
>>> def f(a, b):
... print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2
Редко случается, что в одном вызове используются и именованные аргументы, и синтаксис *expression, поэтому на практике такая путаница возникает нечасто.
Если в вызове функции встречается синтаксис **expression, то expression должно вычисляться в отображение, содержимое которого рассматривается как дополнительные именованные аргументы. Если параметр, соответствующий какому-либо ключу, уже получил значение (через явный именованный аргумент или из другой распаковки), возбуждается исключение TypeError.
Когда используется **expression, каждый ключ в этом отображении должен быть строкой. Каждое значение из отображения присваивается первому формальному параметру, допускающему передачу по имени, имя которого равно ключу. Ключ не обязан быть идентификатором Python (например, "max-temp °F" допустим, хотя и не совпадёт ни с одним формальным параметром, который можно объявить). Если ни один формальный параметр не подходит, пара «ключ — значение» собирается параметром **, если он есть, а если его нет, возбуждается исключение TypeError.
Формальные параметры, использующие синтаксис *identifier или **identifier, нельзя использовать как слоты для позиционных аргументов или как имена именованных аргументов.
Изменено в версии 3.5: Вызовы функций принимают любое число распаковок * и **, позиционные аргументы могут следовать за распаковками итерируемых объектов (*), а именованные аргументы — за распаковками словарей (**). Первоначально предложено в PEP 448.
Вызов всегда возвращает некоторое значение, возможно None, если только он не возбуждает исключение. Как это значение вычисляется, зависит от типа вызываемого объекта.
Если это —
- пользовательская функция:
Выполняется блок кода функции, которому передаётся список аргументов. Первое, что сделает блок кода, — свяжет формальные параметры с аргументами; это описано в разделе Определения функций. Когда блок кода выполняет инструкцию
return, она задаёт возвращаемое значение вызова функции. Если выполнение доходит до конца блока кода, не выполнив инструкциюreturn, возвращаемое значение равноNone.- встроенная функция или метод:
Результат определяется интерпретатором; описания встроенных функций и методов см. в разделе Встроенные функции.
- объект класса:
Возвращается новый экземпляр этого класса.
- метод экземпляра класса:
Вызывается соответствующая пользовательская функция со списком аргументов, который на единицу длиннее списка аргументов вызова: экземпляр становится первым аргументом.
- экземпляр класса:
Класс должен определять метод
__call__(); тогда эффект такой же, как если бы был вызван этот метод.
6.4. Выражение await¶
Приостанавливает выполнение сопрограммы на ожидаемом объекте. Может использоваться только внутри сопрограммной функции.
await_expr ::= "await" primary
Добавлено в версии 3.5.
6.5. Оператор возведения в степень¶
Оператор возведения в степень связывает сильнее, чем унарные операторы слева от него, и слабее, чем унарные операторы справа от него. Синтаксис такой:
power ::= (await_expr|primary) ["**"u_expr]
Таким образом, в последовательности степенных и унарных операторов без скобок операторы вычисляются справа налево (это не ограничивает порядок вычисления операндов): -1**2 даёт -1.
The power operator has the same semantics as the built-in 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.
Для операндов типа int результат имеет тот же тип, что и операнды, если только второй аргумент не отрицателен. В этом случае все аргументы преобразуются во float и возвращается результат типа float. Например, 10**2 возвращает 100, а 10**-2 возвращает 0.01.
Возведение 0.0 в отрицательную степень приводит к ZeroDivisionError. Возведение отрицательного числа в дробную степень даёт число типа complex. (В более ранних версиях возбуждалось ValueError.)
Эту операцию можно настроить с помощью специальных методов __pow__() и __rpow__().
6.6. Унарные арифметические и побитовые операции¶
Все унарные арифметические и побитовые операции имеют одинаковый приоритет:
u_expr ::=power| "-"u_expr| "+"u_expr| "~"u_expr
Унарный оператор - (минус) возвращает значение, противоположное своему числовому аргументу. Операцию можно переопределить с помощью специального метода __neg__().
Унарный оператор + (плюс) возвращает свой числовой аргумент без изменений. Операцию можно переопределить с помощью специального метода __pos__().
Унарный оператор ~ (инверсия) возвращает побитовую инверсию своего целочисленного аргумента. Побитовая инверсия x определяется как -(x+1). Оператор применим только к целым числам и к пользовательским объектам, переопределяющим специальный метод __invert__().
Во всех трёх случаях, если аргумент имеет неподходящий тип, возбуждается исключение TypeError.
6.7. Бинарные арифметические операции¶
Бинарные арифметические операции имеют привычные уровни приоритета. Обратите внимание, что некоторые из этих операций применимы и к нечисловым типам. Помимо оператора возведения в степень, есть только два уровня: один для мультипликативных операторов и один для аддитивных:
m_expr ::=u_expr|m_expr"*"u_expr|m_expr"@"m_expr|m_expr"//"u_expr|m_expr"/"u_expr|m_expr"%"u_expra_expr ::=m_expr|a_expr"+"m_expr|a_expr"-"m_expr
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.
Эту операцию можно настроить с помощью специальных методов __mul__() и __rmul__().
Оператор @ (собака) предназначен для умножения матриц. Ни один встроенный тип Python не реализует этот оператор.
Эту операцию можно настроить с помощью специальных методов __matmul__() и __rmatmul__().
Добавлено в версии 3.5.
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 ZeroDivisionError
exception.
Операцию деления можно настроить с помощью специальных методов __truediv__() и __rtruediv__(). Операцию целочисленного деления можно настроить с помощью специальных методов __floordiv__() и __rfloordiv__().
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 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
[1].
Операторы целочисленного деления и взятия остатка от деления связаны следующим тождеством: x == (x//y)*y + (x%y). Целочисленное деление и взятия остатка от деления также связаны со встроенной функцией divmod(): divmod(x, y) == (x//y, x%y). [2].
Помимо выполнения операции взятия остатка над числами, оператор % также перегружен строковыми объектами для форматирования строк в старом стиле (оно же интерполяция). Синтаксис форматирования строк описан в справочнике по библиотеке Python, в разделе printf-style String Formatting.
Операцию остатка можно настроить с помощью специальных методов __mod__() и __rmod__().
Оператор целочисленного деления, оператор взятия остатка от деления и функция divmod() не определены для комплексных чисел. Вместо этого, если это уместно, преобразуйте такие числа в числа с плавающей точкой с помощью функции abs().
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.
Эту операцию можно настроить с помощью специальных методов __add__() и __radd__().
The - (subtraction) operator yields the difference of its arguments. The
numeric arguments are first converted to a common type.
Эту операцию можно настроить с помощью специальных методов __sub__() и __rsub__().
6.8. Операции сдвига¶
Операции сдвига имеют более низкий приоритет, чем арифметические операции:
shift_expr ::=a_expr|shift_expr("<<" | ">>")a_expr
Эти операторы принимают в качестве аргументов целые числа. Они сдвигают первый аргумент влево или вправо на число битов, заданное вторым аргументом.
Операцию сдвига влево можно настроить с помощью специальных методов __lshift__() и __rlshift__(). Операцию сдвига вправо можно настроить с помощью специальных методов __rshift__() и __rrshift__().
Сдвиг вправо на n битов определяется как целочисленное деление на pow(2,n). Сдвиг влево на n битов определяется как умножение на pow(2,n).
6.9. Бинарные побитовые операции¶
Каждая из трёх побитовых операций имеет свой уровень приоритета:
and_expr ::=shift_expr|and_expr"&"shift_exprxor_expr ::=and_expr|xor_expr"^"and_expror_expr ::=xor_expr|or_expr"|"xor_expr
Оператор & возвращает побитовое И своих аргументов, которые должны быть целыми числами, либо один из них должен быть пользовательским объектом, переопределяющим специальные методы __and__() или __rand__().
Оператор ^ возвращает побитовое XOR (исключающее ИЛИ) своих аргументов, которые должны быть целыми числами, либо один из них должен быть пользовательским объектом, переопределяющим специальные методы __xor__() или __rxor__().
Оператор | возвращает побитовое (включающее) ИЛИ своих аргументов, которые должны быть целыми числами, либо один из них должен быть пользовательским объектом, переопределяющим специальные методы __or__() или __ror__().
6.10. Сравнения¶
В отличие от C, все операции сравнения в Python имеют одинаковый приоритет, более низкий, чем у любых арифметических операций, операций сдвига и побитовых операций. Кроме того, в отличие от C, выражения вида a < b < c интерпретируются так, как принято в математике:
comparison ::=or_expr(comp_operatoror_expr)* comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!=" | "is" ["not"] | ["not"] "in"
Сравнения возвращают логические значения: True или False. Пользовательские методы расширенного сравнения могут возвращать значения других типов. В этом случае в логическом контексте Python вызывает для такого значения bool().
Сравнения можно произвольно объединять в цепочки, например, x < y <= z эквивалентно x < y and y <= z, за исключением того, что y вычисляется только один раз (но в обоих случаях z вообще не вычисляется, если обнаружено, что x < y ложно).
Формально, если a, b, c, …, y, z — выражения, а op1, op2, …, opN — операторы сравнения, то a op1 b op2 c ... y opN z эквивалентно a op1 b and b op2 c and ... y opN z, за исключением того, что каждое выражение вычисляется не более одного раза.
Обратите внимание, что a op1 b op2 c не подразумевает никакого сравнения между a и c, так что, например, x < y > z вполне допустимо (хотя, возможно, и некрасиво).
6.10.1. Сравнение значений¶
Операторы <, >, ==, >=, <= и != сравнивают значения двух объектов. Объекты не обязаны иметь один и тот же тип.
В главе Объекты, значения и типы данных говорится, что у объектов есть значение (помимо типа и идентификатора). Значение объекта — довольно абстрактное понятие в Python: например, не существует канонического метода доступа к значению объекта. Кроме того, нет требования, чтобы значение объекта строилось каким-то определённым образом, например, состояло из всех его атрибутов данных. Операторы сравнения реализуют определённое представление о том, что такое значение объекта. Можно считать, что они определяют значение объекта косвенно, через свою реализацию сравнения.
Поскольку все типы являются (прямыми или косвенными) подтипами object, они наследуют от object поведение сравнения по умолчанию. Типы могут настроить своё поведение при сравнении, реализовав методы расширенного сравнения, такие как __lt__(), описанные в разделе Базовая настройка поведения.
Поведение по умолчанию при сравнении на равенство (== и !=) основано на идентификаторах объектов. Следовательно, сравнение на равенство экземпляров с одинаковыми идентификаторами даёт равенство, а сравнение на равенство экземпляров с разными идентификаторами даёт неравенство. Мотивация такого поведения по умолчанию — желание, чтобы все объекты были рефлексивными (т. е. из x is y следовало x == y).
По умолчанию упорядочивающие сравнения (<, >, <= и >=) не поддерживаются: попытка выполнить такое сравнение возбуждает TypeError. Причина такого поведения — отсутствие инварианта, аналогичного тому, что есть для равенства.
Поведение сравнения на равенство по умолчанию, при котором экземпляры с разными идентификаторами всегда неравны, может расходиться с потребностями типов, у которых есть разумное определение значения объекта и равенства, основанного на значении. Таким типам необходимо настраивать своё поведение при сравнении, и некоторые встроенные типы так и делают.
Следующий список описывает поведение при сравнении наиболее важных встроенных типов.
Числа встроенных числовых типов (Numeric Types — int, float, complex) и типов стандартной библиотеки
fractions.Fractionиdecimal.Decimalможно сравнивать как внутри своих типов, так и между ними, с тем ограничением, что комплексные числа не поддерживают упорядочивающие сравнения. В пределах возможностей задействованных типов они сравниваются математически (алгоритмически) правильно, без потери точности.Значения «не число»
float('NaN')иdecimal.Decimal('NaN')особые. Любое упорядочивающее сравнение числа со значением «не число» ложно. Нелогичное на первый взгляд следствие — значения «не число» не равны сами себе. Например, еслиx = float('NaN'), то3 < x,x < 3иx == xложны, аx != xистинно. Такое поведение соответствует IEEE 754.NoneиNotImplemented— синглтоны. В PEP 8 рекомендуется всегда сравнивать синглтоны с помощьюisилиis not, а не операторов равенства.Двоичные последовательности (экземпляры
bytesилиbytearray) можно сравнивать как внутри своих типов, так и между ними. Они сравниваются лексикографически по числовым значениям своих элементов.Строки (экземпляры
str) сравниваются лексикографически по числовым кодовым позициям Юникода своих символов (результату встроенной функцииord()). [3]Строки и двоичные последовательности нельзя сравнивать напрямую.
Последовательности (экземпляры
tuple,listилиrange) можно сравнивать только внутри каждого из своих типов, причём объекты range не поддерживают упорядочивающие сравнения. Сравнение на равенство между этими типами даёт неравенство, а упорядочивающее сравнение между этими типами возбуждаетTypeError.Последовательности сравниваются лексикографически с помощью сравнения соответствующих элементов. Встроенные контейнеры, как правило, считают, что идентичные объекты равны самим себе. Это позволяет им пропускать проверки на равенство для идентичных объектов, чтобы повысить производительность и сохранить свои внутренние инварианты.
Лексикографическое сравнение встроенных коллекций работает следующим образом:
Чтобы две коллекции были равны, они должны быть одного типа, иметь одинаковую длину, а каждая пара соответствующих элементов должна быть равна (например,
[1,2] == (1,2)ложно, потому что типы различны).Коллекции, поддерживающие упорядочивающие сравнения, упорядочиваются так же, как их первые неравные элементы (например,
[1,2,x] <= [1,2,y]имеет то же значение, что иx <= y). Если соответствующего элемента не существует, первой упорядочивается более короткая коллекция (например,[1,2] < [1,2,3]истинно).
Отображения (экземпляры
dict) равны тогда и только тогда, когда у них равные пары(key, value). Сравнение на равенство ключей и значений обеспечивает рефлексивность.Упорядочивающие сравнения (
<,>,<=и>=) возбуждаютTypeError.Множества (экземпляры
setилиfrozenset) можно сравнивать как внутри своих типов, так и между ними.Для них операторы упорядочивающего сравнения определены как проверки на подмножество и надмножество. Эти отношения не определяют полный порядок (например, множества
{1,2}и{2,3}не равны, и ни одно из них не является подмножеством или надмножеством другого). Соответственно, множества не подходят в качестве аргументов функций, которые зависят от полного порядка (например,min(),max()иsorted()дают неопределённые результаты, если на вход подан список множеств).Сравнение множеств обеспечивает рефлексивность их элементов.
У большинства других встроенных типов методы сравнения не реализованы, поэтому они наследуют поведение сравнения по умолчанию.
Пользовательские классы, настраивающие своё поведение при сравнении, по возможности должны следовать некоторым правилам согласованности:
Сравнение на равенство должно быть рефлексивным. Другими словами, идентичные объекты должны быть равны:
из
x is yследуетx == yСравнение должно быть симметричным. Другими словами, следующие выражения должны давать один и тот же результат:
x == yиy == xx != yиy != xx < yиy > xx <= yиy >= xСравнение должно быть транзитивным. Это иллюстрируют следующие (неисчерпывающие) примеры:
из
x > y and y > zследуетx > zиз
x < y and y <= zследуетx < zОбратное сравнение должно давать логическое отрицание. Другими словами, следующие выражения должны давать один и тот же результат:
x == yиnot x != yx < yиnot x >= y(для полного порядка)x > yиnot x <= y(для полного порядка)Последние два выражения применимы к коллекциям с полным порядком (например, к последовательностям, но не к множествам и не к отображениям). См. также декоратор
@~functools.total_ordering.Результат
hash()должен быть согласован с равенством. Равные объекты должны либо иметь одинаковое хеш-значение, либо быть помечены как нехешируемые.
Python не принуждает к соблюдению этих правил согласованности. На самом деле значения «не число» — пример того, что эти правила не соблюдаются.
6.10.2. Операции проверки принадлежности¶
Операторы in и not in проверяют принадлежность. x in s вычисляется в True, если x является элементом s, и в False в противном случае. x not in s возвращает отрицание x in s. Это поддерживают все встроенные последовательности и типы множеств, а также словари, для которых in проверяет, есть ли в словаре заданный ключ. Для контейнерных типов, таких как list, tuple, set, frozenset, dict или collections.deque, выражение x in y эквивалентно any(x is e or x == e for e in y).
Для строковых и байтовых типов x in y равно True тогда и только тогда, когда x является подстрокой y. Эквивалентная проверка — y.find(x) != -1. Пустая строка всегда считается подстрокой любой другой строки, поэтому "" in "abc" вернёт True.
Для пользовательских классов, определяющих метод __contains__(), x in y возвращает True, если y.__contains__(x) возвращает истинное значение, и False в противном случае.
Для пользовательских классов, которые не определяют __contains__(), но определяют __iter__(), x in y равно True, если при итерации по y порождается некоторое значение z, для которого выражение x is z or x == z истинно. Если во время итерации возбуждается исключение, это равносильно тому, что исключение возбудил in.
Наконец, пробуется старый протокол итерации: если класс определяет __getitem__(), x in y равно True тогда и только тогда, когда существует неотрицательный целочисленный индекс i, для которого x is y[i] or x == y[i], и ни один меньший целочисленный индекс не возбуждает исключение IndexError. (Если возбуждается любое другое исключение, это равносильно тому, что исключение возбудил in).
Оператор not in определён так, чтобы его значение истинности было обратным значению in.
6.10.3. Сравнение идентичности¶
Операторы is и is not проверяют идентификаторы объектов: x is y истинно тогда и только тогда, когда x и y — один и тот же объект. Идентификатор объекта определяется с помощью функции id(). x is not y даёт обратное значение истинности. [4]
6.11. Логические операции¶
or_test ::=and_test|or_test"or"and_testand_test ::=not_test|and_test"and"not_testnot_test ::=comparison| "not"not_test
В контексте логических операций, а также когда выражения используются в инструкциях управления потоком выполнения, следующие значения интерпретируются как ложные: False, None, числовой нуль всех типов, а также пустые строки и контейнеры (включая строки, кортежи, списки, словари, множества и frozenset). Все остальные значения интерпретируются как истинные. Пользовательские объекты могут настроить своё значение истинности, предоставив метод __bool__().
Оператор not возвращает True, если его аргумент ложен, и False в противном случае.
Выражение x and y сначала вычисляет x. Если x ложно, возвращается его значение, в противном случае вычисляется y и возвращается полученное значение.
Выражение x or y сначала вычисляет x. Если x истинно, возвращается его значение, в противном случае вычисляется y и возвращается полученное значение.
Обратите внимание, что ни and, ни or не ограничивают возвращаемое значение и его тип значениями False и True, а возвращают последний вычисленный аргумент. Иногда это полезно: например, если s — строка, которую нужно заменить значением по умолчанию, когда она пуста, то выражение s or 'foo' даёт нужное значение. Поскольку not должен создать новое значение, он возвращает логическое значение независимо от типа своего аргумента (например, not 'foo' даёт False, а не ''.)
6.12. Выражения присваивания¶
assignment_expression ::= [identifier":="]expression
Выражение присваивания (иногда его также называют «именованным выражением» или «моржом») присваивает значение expression идентификатору identifier и одновременно возвращает значение expression.
Один из распространённых случаев применения — обработка найденных совпадений регулярных выражений:
if matching := pattern.search(data):
do_something(matching)
Или обработка файлового потока по частям:
while chunk := file.read(9000):
process(chunk)
Выражения присваивания должны быть заключены в круглые скобки, если они используются как инструкции-выражения или как подвыражения в срезах, условных выражениях, лямбдах, именованных аргументов и условиях во включениях, а также в инструкциях assert, with и assignment. Во всех остальных местах, где их можно использовать, скобки не требуются, в том числе в инструкциях if и while.
Добавлено в версии 3.8: Подробнее о выражениях присваивания см. в PEP 572.
6.13. Условные выражения¶
conditional_expression ::=or_test["if"or_test"else"expression] expression ::=conditional_expression|lambda_expr
Условное выражение (иногда его называют «тернарным оператором») — это альтернатива инструкции if-else. Поскольку это выражение, оно возвращает значение и может использоваться как подвыражение.
Выражение x if C else y сначала вычисляет условие C, а не x. Если C истинно, вычисляется x и возвращается его значение, в противном случае вычисляется y и возвращается его значение.
Подробнее об условных выражениях см. в PEP 308.
6.14. Лямбды¶
lambda_expr ::= "lambda" [parameter_list] ":"expression
Лямбда-выражения (иногда их называют лямбда-формами) используются для создания анонимных функций. Выражение lambda parameters: expression возвращает объект функции. Этот безымянный объект ведёт себя как объект функции, определённый так:
def <lambda>(parameters):
return expression
Синтаксис списков параметров см. в разделе Определения функций. Обратите внимание, что функции, созданные с помощью лямбда-выражений, не могут содержать инструкции и аннотации.
6.15. Списки выражений¶
starred_expression ::= ["*"]or_exprflexible_expression ::=assignment_expression|starred_expressionflexible_expression_list ::=flexible_expression(","flexible_expression)* [","] starred_expression_list ::=starred_expression(","starred_expression)* [","] expression_list ::=expression(","expression)* [","] yield_list ::=expression_list|starred_expression"," [starred_expression_list]
Если список выражений не является частью явного представления списка или множества, то список, содержащий хотя бы одну запятую, даёт кортеж. Длина кортежа равна числу выражений в списке. Выражения вычисляются слева направо.
An asterisk * denotes iterable unpacking. Its operand must be
an 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.
Добавлено в версии 3.5: Первоначально распаковка итерируемых объектов в списках выражений предложена в PEP 448.
Добавлено в версии 3.11: Любой элемент списка выражений может быть помечен звёздочкой. См. PEP 646.
Завершающая запятая нужна только для создания кортежа из одного элемента, например 1,, а во всех остальных случаях она необязательна. Одиночное выражение без завершающей запятой не создаёт кортеж, а даёт значение этого выражения. (Чтобы создать пустой кортеж, используйте пустую пару круглых скобок: ().)
6.16. Порядок вычислений¶
Python вычисляет выражения слева направо. Обратите внимание, что при вычислении присваивания правая часть вычисляется раньше левой.
В следующих строках выражения вычисляются в порядке возрастания их числовых суффиксов:
expr1, expr2, expr3, expr4
(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2
6.17. Приоритет операторов¶
В следующей таблице приведены приоритеты операторов в Python: от наивысшего (операторы, связывающие сильнее всего) до низшего (операторы, связывающие слабее всего). Операторы в одной строке таблицы имеют одинаковый приоритет. Если синтаксис не указан явно, операторы бинарные. Операторы в одной строке группируются слева направо (кроме возведения в степень и условных выражений, которые группируются справа налево).
Обратите внимание, что сравнения, проверки принадлежности и проверки идентичности имеют одинаковый приоритет и допускают объединение в цепочки слева направо, как описано в разделе Сравнения.
Оператор |
Описание |
|---|---|
|
Связывание или выражение в скобках, явное представление списка, явное представление словаря, явное представление множества |
|
Subscription, slicing, call, attribute reference |
Выражение await |
|
|
Возведение в степень [5] |
|
Плюс, минус, побитовое НЕ |
|
Умножение, матричное умножение, деление, целочисленное деление, остаток [6] |
|
Сложение и вычитание |
|
Сдвиги |
|
Побитовое И |
|
Побитовое XOR |
|
Побитовое ИЛИ |
Сравнения, включая проверки принадлежности и проверки идентичности |
|
Логическое НЕ |
|
Логическое И |
|
Логическое ИЛИ |
|
|
Условное выражение |
Лямбда-выражение |
|
|
Выражение присваивания |
Примечания