6. Выражения

Глава объясняет значение элементов выражений в Python.

Синтаксические заметки: в этом и следующих главах, расширенное примечание BNF будет e
используемый, чтобы описать синтаксис, не лексический анализ. Когда (один из вариантов) правило yntax имеет вид
name ::=  othername

и семантики не дано, семантика этой формы name такая же, как для othername.

6.1. Арифметические преобразования

Когда в описании арифметического оператора ниже используется фраза «числовые аргументы преобразуются в общий тип», это означает, что реализация оператора для встроенных типов работает следующим образом:

  • Если любой аргумент является комплексным числом, другой преобразуется в комплексный;
  • в противном случае, если любой аргумент является числом с плавающей запятой, другой преобразуется в число с плавающей запятой;
  • иначе оба должны быть целыми числами, и никакое преобразование не необходимо.

Некоторые дополнительные правила применяются к определенным операторам (например, строка в качестве левого аргумента для оператора «%»). Расширения должны определять собственное поведение преобразования.

6.2. Атомы

Атомы - наиболее основные элементы выражений. Самые простые атомы - идентификаторы или опечатки. Формы, приложенные в круглых скобках, скобках или фигурных скобках, также категоризированы синтаксически как атомы. Синтаксис для атомов is:

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display
               | generator_expression | yield_atom

6.2.1. Идентификаторы (Имена)

Идентификатор, происходящий как атом, является именем. Посмотрите раздел Идентификаторы и ключевые слова для лексического определения и раздел Именование и биндинги для документации обозначения и биндинг.

Когда имя привязано к объекту, оценка атома дает этот объект. Если имя не привязано, попытка его вычисления вызывает исключение NameError.

Искажение приватного имени:, когда идентификатор, который дословно происходит в класс определение, начинается два или больше, подчеркивают знаки, и не заканчивается в двух r, больше подчеркивает, это считают private name этого класс. имена приватные преобразованы к более длинной форме, прежде чем код будет произведен для кромки. Преобразование вставляет имя класс, с продвижением подчеркивает, что emoved и сингл подчеркивают вставленный перед именем. Например, он идентификатор __spam, происходящий в класс по имени Ham, будет преобразованным o _Ham__spam. Это преобразование независимо от синтаксического ontext, в котором идентификатор - используемый. Если преобразованное имя чрезвычайно ong (дольше, чем 255 знаков), определенное усечение внедрения может произойти. f имя класс состоит только из, подчеркивает, никакое преобразование не сделано.

6.2.2. Литералы

Python поддерживает строка и опечатки байтов и различный числовой literals:

literal ::=  stringliteral | bytesliteral
             | integer | floatnumber | imagnumber

Оценка опечатки урожаи объект данного типа (последовательность, байты, целое число, число с плавающей запятой, комплексное число) с данной стоимостью. Стоимость может быть приближена в случае плавающей запятой и воображаемых (сложных) опечаток. Посмотрите раздел Литералы для деталей.

Все опечатки соответствуют неизменным типам данных, и следовательно идентичность объекта менее важна, чем ее стоимость. Несколько оценок опечаток с той же стоимостью (или то же возникновение в тексте программы или различное возникновение) могут получить тот же объект или различный объект с той же стоимостью.

6.2.3. Формы в скобках

Форма в скобках представляет собой необязательный список выражений, заключенный в круглые скобки:

parenth_form ::=  "(" [starred_expression] ")"

Список выражений в скобках дает все, что дает список выражений: если список содержит хотя бы одну запятую, он дает кортеж; в противном случае оно дает единственное выражение, которое составляет список выражений.

Пустая пара круглых скобок приводит к пустому объекту кортежа. Так как кортежи неизменны, те же правила что касается опечаток применяются (т.е. два случаев пустого кортежа могут или могут не привести к тому же объекту).

Обратите внимание, что кортежи формируются не круглыми скобками, а с помощью оператора запятой. Исключение - пустой кортеж, для которых круглых скобок are потребовал —, позволяющего невведенный, «ничто» в выражениях не вызовет двусмысленности и позволит общим опечаткам проходить непойманный.

6.2.4. Отображение списков, наборов и словарей

Для построения списка набор или словарь Python предоставляет специальный синтаксис, называемый «дисплеями», каждый из которых в двух типах:

  • или контейнерное содержание перечислено явно, или
  • они вычисляются с помощью набора команд закольцовывания и фильтрации, называемых comprehension.

Общими синтаксическими элементами для понимания являются:

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" expression_nocond [comp_iter]

Понимание состоит из единственного выражения, сопровождаемого по крайней мере одним пунктом for и нолем или большим количеством for или пунктами if. В этом случае элементы нового контейнера - те, которые были бы произведены, считая каждый из for или пунктов if блоком, вложение слева направо, и оценивая выражение, чтобы произвести элемент каждый раз, когда самый внутренний блок достигнут.

Однако кроме повторяемого выражения в крайнем левом пункте for, понимание выполнено в отдельном, неявно вложил область видимости. Это гарантирует, чтобы имена, назначенные на в целевом списке, не «пропускали» в приложение область видимости.

Повторяемое выражение в крайнем левом пункте for оценено непосредственно в приложении область видимости и затем передано как аргумент неявно вложенному область видимости. Последующие пункты for и любое условие фильтра в крайнем левом пункте for не могут быть оценены в приложении область видимости, поскольку они могут зависеть от ценностей, полученных из крайнего левого повторяемого. Например: [x*y for x in range(10) for y in range(x, x+10)].

Для обеспечения понимания всегда приводит к образованию контейнера соответствующего типа, выражения yield и yield from запрещены в неявно вложенных область видимости.

Начиная с Python 3.6, в функции async def, пункт async for может быть используемый, чтобы повторить по асинхронный итератор. Понимание в функции async def может состоять или из for или из пункта async for после ведущего выражения, может содержать дополнительный for или пункты async for, и может также использовать выражения await. Если понимание содержит или пункты async for или выражения await, это называют asynchronous comprehension. Асинхронное понимание может приостановить выполнение функции сопрограммы, в которой это появляется. См. также PEP 530.

Добавлено в версии 3.6: Были введены асинхронные понимания.

Изменено в версии 3.8: yield и yield from, запрещенные в неявно вложенных область видимости.

6.2.5. Отображение списка

Отображение списка - это, возможно, пустая серия выражений, заключенная в квадратные скобки:

list_display ::=  "[" [starred_list | comprehension] "]"

Отображение списка дает новый объект списка, содержимое которого определяется списком выражений или пониманием. Когда предоставляется список выражений, разделенный запятыми, его элементы вычисляются слева направо и помещаются в объект списка в таком порядке. При предоставлении представления список формируется из элементов, полученных в результате понимания.

6.2.6. Дисплеи набора

Отображение набора обозначается фигурными скобками и отличается от отображения словаря отсутствием двоеточий, разделяющих клавиши и значения:

set_display ::=  "{" (starred_list | comprehension) "}"

Отображение набора дает новый изменяемый объект набора, содержимое которого определяется либо последовательностью выражений, либо пониманием. При предоставлении списка выражений, разделенных запятыми, его элементы вычисляются слева направо и добавляются к объекту набора. Когда обеспечивается понимание, набор строится из элементов, полученных в результате понимания.

Пустой набор нельзя создать с помощью {}; этот литерал создает пустой словарь.

6.2.7. Отображение словаря

Отображение словаря - это, возможно, пустая серия пар ключ/опорный элемент, заключенная в фигурные фигурные скобки:

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for

Дисплей словаря приводит к новому объекту словаря.

Если отделенная от запятой последовательность пар ключа/данной величины дана, они оценены от левого, чтобы исправиться, чтобы определить записи словаря: каждый ключевой объект - используемый как ключ в словарь, чтобы сохранить соответствующую данную величину. Это означает, что в списке ключей/опорных элементов можно указать один и тот же ключ несколько раз, и последнее значение словаря для этого ключа будет последним.

Двойная звёздочка ** обозначает dictionary unpacking. Его операнд должен быть отображение. Каждый элемент сопоставления добавляется в новый словарь. Более поздние значения заменяют значения, уже заданные более ранними парами ключ/опорный элемент и более ранними распаковками словаря.

Добавлено в версии 3.5: Распаковка в словарные дисплеи, первоначально предложенная PEP 448.

Диктное понимание, в отличие от списка и набора понятий, требует двух выражений, разделённых двоеточием, за которым следуют обычные предложения «for» и «if». При выполнении понимания результирующие элементы ключа и значения вставляются в новый словарь в порядке их создания.

Ограничения на типы ключевых значений перечислены выше в разделе Стандартная иерархия типов. (Таким образом, тип ключа должен быть хэшируемым, что исключает все изменяемые объекты.) конфликты между повторяющимися ключами не обнаружены; последний опорный элемент (самый правый в текстуальном представлении), сохраненный для заданного ключевого значения, преобладает.

Изменено в версии 3.8: До Python 3.8 в определениях порядок оценки ключа и ценности не был четко определен. В CPython значение оценивалось перед ключом. Начиная с 3.8, ключ оценивается перед значением, как предложено PEP 572.

6.2.8. Выражения генератора

Выражение генератор - компактное примечание генератор в parentheses:

generator_expression ::=  "(" expression comp_for ")"

Выражение генератор приводит к новому объекту генератор. Его синтаксис совпадает с для пониманий, за исключением того, что это приложено в круглых скобках вместо скобок или фигурных скобок.

Переменные используемый в выражении генератор вычисляются лениво, когда __next__() метод вызывается для объекта генератор (аналогично нормальным генераторам). Однако сразу же вычисляется итабельное выражение в крайнем левом предложении for, так что ошибка, создаваемая им, будет выдана в точке, где определено выражение генератор, а не в точке, где извлечено первое значение. Последующие пункты for и любое условие фильтра в крайнем левом пункте for не могут быть оценены в приложении область видимости, поскольку они могут зависеть от ценностей, полученных из крайнего левого повторяемого. Например: (x*y for x in range(10) for y in range(x, x+10)).

Круглые скобки можно опустить для вызовов, содержащих только один аргумент. Дополнительные сведения см. в разделе Вызовы.

Чтобы избежать вмешательства в ожидаемую работу самого выражения генератор, выражения yield и yield from запрещены в неявно определенном генератор.

Если выражение генератор содержит предложения async for или выражения await, оно называется asynchronous generator expression. Асинхронное выражение генератор возвращает новый асинхронный объект генератор, который является асинхронным итератором (см. Асинхронные итераторы).

Добавлено в версии 3.6: Были введены асинхронные выражения генератор.

Изменено в версии 3.7: До Python 3.7 асинхронные выражения генератор могли появляться только в async def coroutines. Начиная с версии 3.7 любая функция может использовать асинхронные выражения генератор.

Изменено в версии 3.8: yield и yield from, запрещенные в неявно вложенных область видимости.

6.2.9. Выражение Yield

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]

Выражение доходности является используемый при определении функции генератор или функции асинхронный генератор и, таким образом, может быть используемый только в теле определения функции. Используя выражение урожая в причинах тела функции, которые функционируют, чтобы быть генератором, и использование его в теле функции async def заставляет ту функцию сопрограммы быть асинхронным генератор. Например:

def gen():  # определяет функцию генератора
    yield 123

async def agen(): # определяет функцию асинхронного генератора
    yield 123

Из-за их побочных эффектов на содержащую область выражения yield не разрешаются как часть неявно определенных области видимости используемый для реализации понятий и выражений генератор.

Изменено в версии 3.8: Выражение выхода запрещено в неявно вложенных выражениях области видимости используемый для реализации понятий и выражений генератор.

Функции генератора описаны ниже, а асинхронные функции генератор описаны отдельно в разделе Асинхронные генератор функции.

Когда вызывается функция генератор, она возвращает итератор, известный как генератор. Это генератор тогда управляет выполнением функции генератор. Выполнение начинается при вызове одного из методы генератора. В это время выполнение переходит к первому выражению выхода, где оно снова приостанавливается, возвращая значение expression_list вызывающему абоненту генератора. Под приостановкой мы подразумеваем, что сохраняются все локальная состояние, включая текущие привязки переменных локальная, указатель команды, внутренний стек оценки и состояние любой обработки исключений. Когда выполнение возобновляется путем вызова одного из методов генератора, функция может работать точно так же, как если бы выражение выхода было просто другим внешним вызовом. Значение выражения доходности после возобновления зависит от метод, возобновившего выполнение. Если __next__() является используемый (обычно через for или next() builtin), то результат является None. В противном случае, если используется send(), то результатом будет значение, переданное этому метод.

Все это делает функции генератор весьма схожими с сопрограммами; они уступают многократно, у них есть больше чем одна точка входа, и их выполнение может быть приостановлено. Единственная разница - то, что функция генератор не может управлять, где выполнение должно продолжиться после того, как это уступает; контроль всегда передается посетителю генератора.

Выражения урожая позволены где угодно в конструкции try. Если генератор не будет возобновлен, прежде чем он будет завершен (достигая нулевого справочного количества или будучи собранным мусором), close() метод генератора-iterator’s назовут, позволяя любому ожиданию пункты finally, чтобы выполнить.

Когда yield from <expr> используется, он рассматривает поставляемое выражение как subiterator. Все значения, генерируемые этим субитератором, передаются непосредственно вызывающему абоненту методы генератора тока. Любые значения, переданные с помощью send(), и любые исключения, переданные с помощью throw(), передаются в базовый итератор, если он имеет соответствующий методы. Если это не так, то send() поднимет AttributeError или TypeError, тогда как throw() просто поднимет пройденное в исключение сразу.

Когда основной iterator полон, признак value поднятого StopIteration сущность становится ценностью выражения урожая. Он может быть установлен явно при поднятии StopIteration или автоматически, когда субитератор является генератор (путем возврата значения из субгенератора).

Изменено в версии 3.3: Добавлено yield from <expr> для делегирования потока управления субитератору.

Круглые скобки могут быть опущены, если выражение выхода является единственным выражением в правой части присваивания оператор.

См.также

PEP 255 - простые генераторы
Предложение по добавлению генераторов и yield оператор к Python.
PEP 342 - Корутины через усиленные генераторы
предложение по усовершенствованию API и синтаксиса генераторов, делающее их пригодными для использования в качестве простых корутин.
PEP 380 - синтаксис делегирования субгенератору
Предложение ввести синтаксис yield_from, облегчающее делегирование субгенераторам.
PEP 525 - асинхронные генераторы
Предложение, которое расширилось на PEP 492, добавив возможности генератор в функции корутины.

6.2.9.1. Методы генератора-итератора

Этот подраздел описывает методы генератор iterator. Они могут быть используемый, чтобы управлять выполнением функции генератор.

Обратите внимание, что запрос любого генератор методы ниже, когда генератор уже выполняет, поднимает исключение ValueError.

generator.__next__()

Запускает выполнение функции генератор или возобновляет ее в последнем выполненном выражении доходности. Когда функция генератор возобновляется методом __next__(), текущее выражение доходности всегда вычисляется как None. Затем выполнение продолжается до следующего выражения выхода, где генератор снова приостанавливается, и значение expression_list возвращается вызывающему абоненту __next__(). Если генератор выходит, не давая другого значения, возникает исключение StopIteration.

Этот метод обычно называют неявно, например, петлей for, или встроенной функцией next().

generator.send(value)

Возобновляет выполнение и «посылает» стоимость в функцию генератор. Аргумент value становится результатом выражения текущей доходности. send() метод возвращает следующую стоимость, к которой приводит генератор, или поднимает StopIteration, если генератор выходит, не приводя к другой стоимости. Когда send() называют, чтобы начать генератор, это нужно назвать с None как аргумент, потому что нет никакого выражения урожая, которое могло получить стоимость.

generator.throw(type[, value[, traceback]])

Вызывает исключение типа type в точке приостановки генератор и возвращает следующее значение, выданное функцией генератор. Если генератор выходит, не давая другого значения, возникает исключение StopIteration. Если функция генератор не перехватывает переданное исключение или вызывает другое исключение, то это исключение распространяется на вызывающего абонента.

generator.close()

Поднимает GeneratorExit в точке приостановки функции генератор. Если функция генератор после этого выходит изящно, уже закрыта или вызывает GeneratorExit (не перехватывая исключение), то функция close возвращается к вызывающему абоненту. Если генератор приводит к стоимости, RuntimeError поднят. Если генератор вызывает какое-либо другое исключение, оно передается вызывающему абоненту. close() ничего не делает, если генератор уже вышел из-за исключения или обычного выхода.

6.2.9.2. Примеры

Вот простой пример, демонстрирующий поведение генераторов и функций генератор:

>>> def echo(value=None):
...     print("Execution starts when 'next()' is called for the first time.")
...     try:
...         while True:
...             try:
...                 value = (yield value)
...             except Exception as e:
...                 value = e
...     finally:
...         print("Don't forget to clean up when 'close()' is called.")
...
>>> generator = echo(1)
>>> print(next(generator))
Execution starts when 'next()' is called for the first time.
1
>>> print(next(generator))
None
>>> print(generator.send(2))
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.

Для примеров, используя yield from, см. PEP 380: Syntax for Delegating to a Subgenerator в, «Что является новым в Python.

6.2.9.3. Асинхронные генератор функции

Присутствие выражения урожая в функции или метод определило использование, async def далее определяет функцию как функцию асинхронный генератор.

При вызове асинхронной функции генератор возвращается асинхронный итератор, известный как асинхронный объект генератор. Затем этот объект управляет выполнением функции генератор. Асинхронный объект генератор, как правило - используемый в async for оператор в функции сопрограммы аналогично к тому, как объект генератор был бы используемый в for оператор.

Вызов одного из методы асинхронного генератора возвращает объект awaitable, и выполнение начинается, когда этот объект ожидает. В это время исполнение переходит к первому выражению выхода, где оно снова приостанавливается, возвращая значение expression_list ожидающему корутину. Как и в случае с генератором, приостановка означает, что все локальная состояние сохраняются, включая текущие привязки переменных локальная, указатель команды, внутренний оценочный стек и состояние любой обработки исключений. Когда выполнение возобновляется в ожидании следующего объекта, возвращенного методами асинхронного генератора, функция может работать точно так же, как если бы выражение выхода было просто другим внешним вызовом. Значение выражения доходности после возобновления зависит от метод, возобновившего выполнение. Если __anext__() используемый, то результат None. В противном случае, если используется asend(), то результатом будет значение, переданное этому метод.

В асинхронной функции генератор выражения выхода разрешены в любом месте конструкции try. Однако, если асинхронное генератор не возобновляется до его завершения (путем достижения нулевого счетчика ссылок или сбора мусора), то выражение выхода в конструкции try может привести к сбою выполнения ожидающих предложений finally. В этом случае это - ответственность событийный цикл или планировщика, управляющего асинхронным генератор, чтобы назвать асинхронный aclose() метод генератора-iterator’s и управлять получающимся объектом сопрограммы, таким образом позволяя любому ожиданию пункты finally, чтобы выполнить.

Чтобы позаботиться о завершении, событийный цикл должен определить функцию finalizer, которая принимает асинхронный генератор-итератор и, предположительно, вызывает aclose() и выполняет корутину. Эта finalizer может быть зарегистрирована путем вызова метода sys.set_asyncgen_hooks(). При первой итерации асинхронный генератор-итератор сохраняет зарегистрированные finalizer, которые должны быть вызваны при завершении. Поскольку справочный пример finalizer метод видит внедрение asyncio.Loop.shutdown_asyncgens в Lib/asyncio/base_events.py.

Выражение yield from <expr> - синтаксическая ошибка, когда используемый в асинхронном генератор функционируют.

6.2.9.4. Методы асинхронного генератора-итератора

Этот подраздел описывает методы асинхронного генератор итератора, которые являются используемый, чтобы управлять выполнением функции генератор.

coroutine agen.__anext__()

Возвращает ожидаемое значение, которое при запуске начинает выполнять асинхронный генератор или возобновляет его в последнем выполненном выражении доходности. При возобновлении асинхронной функции генератор с помощью метода __anext__() текущее выражение доходности всегда вычисляется как None в возвращаемом ожидаемом выражении, которое при выполнении будет продолжено до следующего выражения доходности. Ценность expression_list выражения урожая - ценность исключения StopIteration, поднятого сопрограммой завершения. Если асинхронные выходы генератор, не приводя к другой стоимости, awaitable вместо этого поднимает исключение StopAsyncIteration, сигнализируя, что асинхронное повторение закончило.

Этот метод обычно называет неявно петля async for.

coroutine agen.asend(value)

Возвращает awaitable который, когда управляется возобновляет выполнение асинхронного генератор. Как с send() метод для генератора, это «посылает» стоимость в асинхронную функцию генератор, и аргумент value становится результатом выражения текущей доходности. awaitable, возвращенное asend() метод, возвратит следующую стоимость, к которой приводит генератор как ценность поднятого StopIteration, или поднимает StopAsyncIteration, если асинхронный генератор выйдет, не приводя к другой стоимости. Когда для запуска асинхронного генератора вызывается метод «asend()», его необходимо вызвать с аргументом «None», поскольку отсутствует выражение выхода, которое могло бы получить значение.

coroutine agen.athrow(type[, value[, traceback]])

Возвращает awaitable, которое поднимает исключение типа type в точке, где асинхронный генератор был сделан паузу и возвращает следующую стоимость, к которой приводит функция генератор как ценность поднятого исключения StopIteration. Если асинхронные выходы генератор, не приводя к другой стоимости, исключение StopAsyncIteration поднято awaitable. Если функция генератор не ловит переданный - в исключении или поднимает различное исключение, то, когда awaitable управляют, что исключение размножается посетителю awaitable.

coroutine agen.aclose()

Возвращает awaitable что, когда управляемый бросит GeneratorExit в асинхронную функцию генератор в точке, где это было сделано паузу. Если асинхронная функция генератор тогда выйдет изящно, будет уже закрыта или поднимет GeneratorExit (не ловя исключение), то возвращенное awaitable поднимет исключение StopIteration. Любые последующие ожидаемые значения, возвращаемые последующими вызовами асинхронного генератор, вызовут исключение StopAsyncIteration. Если асинхронное генератор дает значение, то ожидаемое значение вызывает RuntimeError. Если асинхронный генератор поднимает какое-либо другое исключение, он размножен посетителю awaitable. Если асинхронный генератор уже вышел из-за исключения или обычного выхода, дальнейшие вызовы к aclose() вернут ожидаемый, который ничего не делает.

6.3. Праймериз

Праймериз представляют наиболее плотно связанные операции языка. Их синтаксис is:

primary ::=  atom | attributeref | subscription | slicing | call

6.3.1. Ссылка на атрибут

Ссылка признака - предварительные выборы, сопровождаемые периодом и name:

attributeref ::=  primary "." identifier

Первичный должен вычислять объект типа, поддерживающего ссылки на атрибуты, что и делает большинство объектов. Затем этому объекту предлагается создать атрибут, именем которого является идентификатор. Это производство можно настроить путем переопределения __getattr__() метод. Если этот атрибут недоступен, возникает исключение AttributeError. В противном случае тип и значение создаваемого объекта определяется объектом. Несколько оценок одной и той же ссылки на атрибут могут давать различные объекты.

6.3.2. Подписки

Подписка выбирает элемент объекта последовательности (строка, кортеж или список) или сопоставления (словарь):

subscription ::=  primary "[" expression_list "]"

Предварительные выборы должны оценить к объекту, который поддерживает подписку (списки или словари, например). Определенные пользователями объекты могут поддержать подписку, определив __getitem__() метод.

Для встроенных объектов существует два типа объектов, поддерживающих подписку:

Если основным является сопоставление, список выражений должен вычисляться для объекта, значение которого является одним из ключей сопоставления, и подписка выбирает значение в сопоставлении, которое соответствует этому ключу. (Список выражений является кортежем, за исключением случаев, когда он содержит только один элемент.)

Если основным является последовательность, список выражений должен вычисляться как целое число или фрагмент (как описано в следующем разделе).

Формальный синтаксис не предусматривает особых положений для отрицательных индексов в последовательностях; однако все встроенные последовательности обеспечивают __getitem__() метод, который интерпретирует отрицательные индексы путем добавления длины последовательности к индексу (так что x[-1] выбирает последний элемент из x). Результирующее значение должно быть неотрицательным целым числом, меньшим числа элементов в последовательности, и подписка выбирает элемент, индекс которого равен этому значению (считая от нуля). Начиная с поддержки отрицательных индексов и разрезания происходит в методе объекта __getitem__(), подклассы, отвергающий этот метод, должен будет явно добавить ту поддержку.

Предметы последовательности - знаки. Характер не отдельный тип данных, а строка точно одного характера.

6.3.3. Слайсинг

При разделении выбирается диапазон элементов в объекте последовательности (например, строка, кортеж или список). Срезы могут быть используемый как выражения или как целевые объекты в назначении или del операторы. Синтаксис среза:

slicing      ::=  primary "[" slice_list "]"
slice_list   ::=  slice_item ("," slice_item)* [","]
slice_item   ::=  expression | proper_slice
proper_slice ::=  [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound  ::=  expression
upper_bound  ::=  expression
stride       ::=  expression

Здесь существует неоднозначность формального синтаксиса: всё, что выглядит как список выражений, также выглядит как список фрагментов, поэтому любая подписка может быть интерпретирована как нарезка. Вместо того, чтобы дополнительно усложнять синтаксис, это устраняется определением того, что в этом случае интерпретация как подписка имеет приоритет над интерпретацией как нарезка (это происходит, если список срезов не содержит надлежащего среза).

Семантика для разрезания следующие. Предварительные выборы внесены в указатель (использование того же __getitem__() метод как нормальная подписка) с ключом, который построен из списка части, следующим образом. Если список части содержит по крайней мере одну запятую, ключ - кортеж, содержащий преобразование предметов части; иначе преобразование одинокого предмета части - ключ. Преобразование предмета части, который является выражением, является тем выражением. Преобразование надлежащей части - объект части (см. раздел Стандартная иерархия типов), чей start, stop и признаки step - ценности выражений, данных как ниже связанная, верхняя граница и шаг, соответственно, заменяя None недостающие выражения.

6.3.4. Вызовы

Вызов вызывает вызываемый объект (например, функция) с возможной пустой серией аргументы:

call                 ::=  primary "(" [argument_list [","] | comprehension] ")"
argument_list        ::=  positional_arguments ["," starred_and_keywords]
                            ["," keywords_arguments]
                          | starred_and_keywords ["," keywords_arguments]
                          | keywords_arguments
positional_arguments ::=  positional_item ("," positional_item)*
positional_item      ::=  assignment_expression | "*" expression
starred_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: Реализация может предусматривать встроенные функции, позиционные параметры которых не имеют имен, даже если они «названы» для целей документации и поэтому не могут быть предоставлены ключевой. В CPython это относится к функциям, реализованным в C, которые use:c:func: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 может появиться явные аргументы ключевой after, он обработан before аргументы ключевой (и любые аргументы **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.

Формальные параметры, используя синтаксис *identifier или **identifier не могут быть используемый как позиционными местами аргумента или как имена аргумента ключевой.

Изменено в версии 3.5: Вызовы функций принимают любое количество распаковок * и **, позиционные аргументы могут следовать за итерабельными распаковками (*), а аргументы ключевой могут следовать за распаковками словаря (**). Первоначально предложен PEP 448.

Требование всегда возвращает некоторую стоимость, возможно None, если это не поднимает исключение. То, как эта стоимость вычислена, зависит от типа подлежащего выкупу объекта.

Если это —

определяемая пользователем функция:

Выполняется блок код для функции, передающий ему список аргументов. Первое, что будет делать блок код, это связать формальные параметры с аргументами; это описано в разделе Определения функции. Когда блок код выполняет оператор return, это указывает возвращаемое значение вызова функции.

встроенная функция или метод:

Результат зависит от переводчика; см. Встроенные функции для описаний встроенных функций и методы.

объект класса:

Возвращается новое сущность этого класс.

метод класс сущность:

Вызывается соответствующая определяемая пользователем функция со списком аргументов, который длиннее списка аргументов вызова: сущность становится первым аргументом.

сущность класса:

В класс должен быть определен метод __call__(); тогда эффект будет таким же, как если бы этот метод был вызван.

6.4. Выражения Await

Приостановка выполнения корутины для объекта awaitable. Может только использоваться в функции корутины.

await_expr ::=  "await" primary

Добавлено в версии 3.5.

6.5. Оператор возведения в степень

Силовой оператор связывается более плотно, чем унарные операторы слева; он связывается менее плотно, чем унарные операторы справа. Синтаксис:

power ::=  (await_expr | primary) ["**" u_expr]

Таким образом, в непарентезированной последовательности степенных и унарных операторов операторы оцениваются справа налево (это не ограничивает порядок оценки операндов): -1**2 приводит к -1.

У степенного оператора та же семантика, что и у встроенной pow() функции, при вызове с двумя аргументами: он приводит свой левый аргумент, поднятый в силу своего правого аргумента. Числовые аргументы сначала преобразуются в общий тип, а результат - в этот тип.

Для операндов int результат имеет тот же тип, что и операнды, если второй аргумент не является отрицательным; в этом случае все аргументы преобразуются в float и доставляется результат float. Например, 10**2 возвращает 100, а 10**-2 возвращает 0.01.

Подъем 0.0 к отрицательной власти приводит к ZeroDivisionError. Увеличивание отрицательного числа к фракционной власти приводит к числу complex. (В более ранних версиях это подняло ValueError.)

6.6. Унарные арифметические и побитовые операции

У всех одноместных арифметических и битовых операций есть тот же priority:

u_expr ::=  power | "-" u_expr | "+" u_expr | "~" u_expr

Одноместный - (минус) оператор приводит к отрицанию своего числового аргумента.

Унарный оператор + (плюс) дает свой числовой аргумент без изменений.

Одноместный ~ (обратный свод) оператор приводит к bitwise инверсии своего целочисленного аргумента. Побитовая инверсия x определяется как -(x+1). Это относится только к интегральным числам.

Во всех трех случаях, если аргумент не имеет правильного типа, возникает исключение 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_expr
a_expr ::=  m_expr | a_expr "+" m_expr | a_expr "-" m_expr

Оператор * (умножения) дает произведение своих аргументов. Аргументы должны быть числами, или один аргумент должен быть целым числом, а другой - последовательностью. В первом случае числа преобразуются в общий тип и затем умножаются вместе. В последнем случае выполняют повторение последовательности; отрицательный коэффициент повторения дает пустую последовательность.

@ (в) операторе предназначен, чтобы быть используемый для матричного умножения. Никакие встроенные типы Python не осуществляют этого оператора.

Добавлено в версии 3.5.

Операторы / (division) и // (floor division) дают частное число своих аргументов. Числовые аргументы сначала преобразуются в общий тип. Деление целых чисел даёт поплавковое деление, в то время как половое деление целых чисел приводит к целому числу; результатом является математическое деление с функцией «floor», применяемой к результату. Деление на ноль вызывает исключение ZeroDivisionError.

Оператор % (по модулю) дает остаток от деления первого аргумента на второй. Числовые аргументы сначала преобразуются в общий тип. Аргумент с нулевым правом вызывает исключение ZeroDivisionError. Аргументы могут быть числами с плавающей запятой, например, 3.14%0.7 равно 0.34 (поскольку 3.14 равно 4*0.7 + 0.34.) оператор по модулю всегда дает результат с тем же знаком, что и его второй операнд (или ноль); абсолютное значение результата строго меньше абсолютного значения второго операнда [1].

Деление пола и операторы по модулю соединены следующим идентификатором: x == (x//y)*y + (x%y). Разделение пола и по модулю также связаны со встроенной функцией divmod(): divmod(x, y) == (x//y, x%y). [2].

В дополнение к выполнению операции по модулю на числах оператор % также перегружен объектами строка выполнить форматирование строка в старинном стиле (также известный как интерполяция). Синтаксис для форматирования строка описан в ссылке библиотеки Python, разделе printf-стиль форматирования строк.

Оператор разделения пола, оператор по модулю и функция divmod() не определены для комплексных чисел. Вместо этого преобразуйте в число с плавающей запятой с помощью функции abs(), если это необходимо.

Оператор + (сложение) дает сумму своих аргументов. Аргументы должны быть числами или последовательностями одного типа. В первом случае номера преобразуются в общий тип и затем добавляются вместе. В последнем случае последовательности конкатенируются.

Оператор - (вычитания) дает разницу своих аргументов. Числовые аргументы сначала преобразуются в общий тип.

6.8. Здвиговые операции

Операции сдвига имеют меньший приоритет, чем арифметические операции:

shift_expr ::=  a_expr | shift_expr ("<<" | ">>") a_expr

Эти операторы принимают целые числа как аргументы. Они перемещают первый аргумент налево или направо числом битов, данных вторым аргументом.

Сдвиг вправо на n бит определяется как разделение пола на pow(2,n). Сдвиг влево на n бит определяется как умножение на pow(2,n).

6.9. Бинарные битовые операции

Каждая из трех побитовых операций имеет различный уровень приоритета:

and_expr ::=  shift_expr | and_expr "&" shift_expr
xor_expr ::=  and_expr | xor_expr "^" and_expr
or_expr  ::=  xor_expr | or_expr "|" xor_expr

Оператор & выдает побитовое значение AND своих аргументов, которые должны быть целыми числами.

Оператор ^ выдает побитовое значение XOR (исключающее иЛИ) своих аргументов, которые должны быть целыми числами.

Оператор | выдает побитовое (включительно) иЛИ своих аргументов, которые должны быть целыми числами.

6.10. Сравнения

В отличие от C, все операции сравнения в Python имеют одинаковый приоритет, который ниже, чем у любой арифметической, сдвиговой или побитовой операции. Также в отличие от C, выражения как a < b < c имеют толкование, которое является обычным в математике:

comparison    ::=  or_expr (comp_operator or_expr)*
comp_operator ::=  "<" | ">" | "==" | ">=" | "<=" | "!="
                   | "is" ["not"] | ["not"] "in"

Сравнения дают логические значения: True или False.

Сравнения могут быть связаны произвольно, например, 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. Сравнение значений

Операторы <, >, ==, >=, <= и != сравнивают ценности двух объектов. Объекты не обязательно должны иметь одинаковый тип.

Глава Объекты, значения и типы указывает, что у объектов есть стоимость (кроме того, чтобы напечатать и идентичность). Ценность объекта - довольно абстрактное понятие в пайтоне: например, нет никакого канонического доступа метод для стоимости объекта. Кроме того, нет никакого требования, чтобы ценность объекта была построена особым способом, например, состояться из всех своих признаков данных. Операторы Comparison осуществляют особое понятие того, какова ценность объекта. Можно думать о них как об определении ценности объекта косвенно посредством их внедрения сравнения.

Поскольку все типы (прямые или косвенные) подтипы object, они наследуют поведение сравнения по умолчанию от object. Типы могут настроить свое поведение сравнения, осуществив rich comparison methods как __lt__(), описанный в Основная настройка.

Поведение по умолчанию для сравнения равенства (== и !=) основано на идентификаторе объектов. Следовательно, сравнение равенства сущности с одинаковой идентичностью приводит к равенству, а сравнение равенства сущности с различной идентичностью приводит к неравенству. Мотивацией для такого поведения по умолчанию является желание, чтобы все объекты были рефлексивными (т.е. x is y подразумевает x == y).

Сравнение заказов по умолчанию (<, >, <= и >=) не предусмотрено; попытка вызывает TypeError. Мотивацией для такого поведения по умолчанию является отсутствие такого инварианта, как для равенства.

Поведение сравнения равенства по умолчанию, которое сущности с различными тождествами всегда неодинаково, может отличаться от того, какие типы потребуются для определения значения объекта и равенства на основе значений. Такие типы должны будут настраивать свое поведение сравнения, и фактически это сделал ряд встроенных типов.

В следующем списке описывается поведение сравнения наиболее важных встроенных типов.

  • Количество встроенных числовых типов (Числовые типы — 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) сравнивают лексикографически использование числовых точек Unicode код (результат встроенной функции ord()) их характеров. [3]

    Напрямую сравнивать строки и бинарные последовательности нельзя.

  • Последовательности (сущности tuple, list или range) можно сравнивать только в пределах каждого из их типов, с тем ограничением, что диапазоны не поддерживают сравнение порядка. Сравнение равенства через эти результаты типов в неравенстве и сравнение заказа через эти типы поднимают TypeError.

    Последовательности сравниваются лексикографически с использованием сравнения соответствующих элементов. Встроенные контейнеры обычно предполагают, что одинаковые объекты равны самим себе. Это позволяет им обходить тесты на равенство для идентичных объектов для повышения производительности и поддержания внутренних инвариантов.

    Лексикографическое сравнение встроенных коллекций работает следующим образом:

    • Чтобы две коллекции сравнивали равные, они должны быть одного типа, иметь одинаковую длину, и каждая пара соответствующих элементов должна сравнивать равные (например, [1,2] == (1,2) является ложным, потому что тип не является одинаковым).
    • Коллекции, поддерживающие сравнение заказов, упорядочены так же, как и их первые неравные элементы (например, [1,2,x] <= [1,2,y] имеет то же значение, что и x <= y). Если соответствующий элемент не существует, то сначала упорядочивается более короткая коллекция (например, [1,2] < [1,2,3] имеет значение true).
  • Сопоставления (сущности из dict) сравниваются равными тогда и только тогда, когда они имеют равные пары (ключ, значение). Сравнение ключей и значений на основе равенства обеспечивает рефлексивность.

    Сортировка сравнения (<, >, <=, and >=) является TypeError.

  • Наборы (сущности set или frozenset) могут быть сравнены в и через их типы.

    Они определяют операторы сравнения порядка для определения тестов подмножества и суперсета. Эти отношения не определяют тотальных порядков (например, два множества {1,2} и {2,3} не равны, ни подмножества друг друга, ни суперсеты друг друга). Соответственно, наборы не являются подходящими аргументами для функций, которые зависят от общего порядка (например, min(), max() и sorted() дают неопределенные результаты при наличии списка множеств в качестве входных данных).

    Сравнение множеств обеспечивает рефлексивность его элементов.

  • Большинство других встроенных типов не имеют реализованных методы сравнения, поэтому они наследуют поведение сравнения по умолчанию.

Определяемые пользователем классы, которые настраивают свое поведение сравнения, должны следовать некоторым правилам согласованности, по возможности:

  • Сравнение равенства должно быть рефлексивным. Другими словами, одинаковые объекты должны сравнивать равные:

    x is y подразумевает x == y

  • Сравнение должно быть симметричным. Другими словами, следующие выражения должны иметь одинаковый результат:

    x == y и y == x

    x != y и y != x

    x < y и y > x

    x <= y и y >= x

  • Сравнение должно быть переходным. Следующие (неисчерпывающие) примеры иллюстрируют that:

    x > y and y > z подразумевает x > z

    x < y and y <= z подразумевает x < z

  • Обратное сравнение должно привести к логическому отрицанию. Другими словами, следующие выражения должны иметь одинаковый результат:

    x == y и not x != y

    x < y и not x >= y (для общего заказа)

    x > y и not x <= y (для общего заказа)

    Последние два выражения применяются к полностью упорядоченным коллекциям (например, к последовательностям, но не к множествам или отображениям). См. также декоратор 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 проверяет, есть ли у словаря данный ключ. Для контейнерных типов, таких как список, кортеж, набор, frozenset, dict, или collections.deque, выражение x in y эквивалентно any(x is e or x == e for e in y).

Для типов строка и bytes, 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 имеет значение true. Если исключение поднято во время повторения, это - как будто 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 имеет значение true, если и только если x и y являются одинаковыми объектами. Идентификатор объекта определяется с помощью функции id(). x is not y дает обратное значение истины. [4]

6.11. Логические операции

or_test  ::=  and_test | or_test "or" and_test
and_test ::=  not_test | and_test "and" not_test
not_test ::=  comparison | "not" not_test

В контекст логических операций, и также когда выражения - используемый, проверяют утверждения потока, следующие ценности интерпретируются как ложные: False, None, числовой ноль всех типов, и пустой строки и контейнеры (включая последовательности, кортежи, списки, словари, наборы и frozensets). Все другие ценности интерпретируются как верные. Определенные пользователями объекты могут настроить свою стоимость правды, обеспечив __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

Дополнительные сведения о выражениях назначения см. в разделе PEP 572.

6.13. Условные выражения

conditional_expression ::=  or_test ["if" or_test "else" expression]
expression             ::=  conditional_expression | lambda_expr
expression_nocond      ::=  or_test | lambda_expr_nocond

У условных выражений (иногда названный «троичным оператором») есть самый низкий приоритет всех операций Python.

Выражение x if C else y сначала оценивает условие, C, а не x. Если C верен, x оценен, и его стоимость возвращена; иначе y оценен, и его стоимость возвращена.

Дополнительные сведения об условных выражениях см. в разделе PEP 308.

6.14. Лямбды

lambda_expr        ::=  "lambda" [parameter_list] ":" expression
lambda_expr_nocond ::=  "lambda" [parameter_list] ":" expression_nocond

Лямбда-выражения (иногда называемые лямбда-формами) являются используемый для создания анонимных функций. Выражение lambda parameters: expression дает объект функции. Неназванный объект ведет себя как функциональный объект, определенный с помощью:

def <lambda>(parameters):
    return expression

Посмотрите раздел Определения функции для синтаксиса списков параметров. Обратите внимание, что функции, созданные с выражениями лямбды, не могут содержать операторы или аннотации.

6.15. Списки выражений

expression_list    ::=  expression ("," expression)* [","]
starred_list       ::=  starred_item ("," starred_item)* [","]
starred_expression ::=  expression | (starred_item ",")* [starred_item]
starred_item       ::=  assignment_expression | "*" or_expr

За исключением случаев, когда часть списка или набора отображается, список выражений, содержащий хотя бы одну запятую, дает кортеж. Длина кортежа - это количество выражений в списке. Выражения вычисляются слева направо.

Звездочка * обозначает итеративная распаковка. Его операнд должен быть итерируемым. Итабль расширяется в последовательность элементов, которые включаются в новый кортеж, список или набор на месте распаковки.

Добавлено в версии 3.5: Повторяемая распаковка в списках выражения, первоначально предложенных PEP 448.

Конечная запятая необходима только для создания одного кортежа (a.k.a. singleton); он является необязательным во всех других случаях. Единственное выражение без конечной запятой не создает кортеж, а скорее дает значение этого выражения. (Чтобы создать пустой кортеж, используйте пустую пару скобок ().

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: от самого низкого приоритета (наименьшая привязка) до самого высокого приоритета (наибольшая привязка). Операторы в том же окне имеют одинаковый приоритет. Если синтаксис явно не задан, операторы являются двоичными. Операторы в одной группе полей слева направо (за исключением степени, которая группируется справа налево).

Обратите внимание, что сравнения, тесты членства и тесты на идентичность, все имеют то же предшествование и имеют слева направо приковывающую цепью особенность, как описано в разделе Сравнения.

Оператор Описание
:= Assignment expression
lambda Lambda expression
ifelse Conditional expression
or Boolean OR
and Boolean AND
not x Boolean NOT
in, not in, is, is not, <, <=, >, >=, !=, == Comparisons, including membership tests and identity tests
| Bitwise OR
^ Bitwise XOR
& Bitwise AND
<<, >> Shifts
+, - Addition and subtraction
*, @, /, //, % Multiplication, matrix multiplication, division, floor division, remainder [5]
+x, -x, ~x Positive, negative, bitwise NOT
** Exponentiation [6]
await x Await expression
x[index], x[index:index], x(arguments...), x.attribute Subscription, slicing, call, attribute reference

(expressions...),

[expressions...], {key: value...}, {expressions...}

Binding or parenthesized expression, list display, dictionary display, set display

Сноски

[1]Хотя abs(x%y) < abs(y) верно математически, для флоатов этого может не быть true численно из-за округления. Например, и принимая платформу, на которой плавание Python - число IEEE 754 двойной точности, чтобы у -1e-100 % 1e100 был тот же знак как 1e100, вычисленный результат - -1e-100 + 1e100, который численно точно равен 1e100. Функция math.fmod() возвращает результат, знак которого соответствует знаку первого аргумента, и поэтому возвращает -1e-100 в этом случае. Какой подход более подходит, зависит от приложения.
[2]Если x очень близко к точному целому кратному y, это возможно для x//y на единицу больше чем (x-x%y)//y из-за округления. В таких случаях Python возвращает последний результат, чтобы сохранить это divmod(x,y)[0] * y + x % y быть очень близко к x.
[3]

The Unicode standard distinguishes between code points (например, U 0041) и abstract characters (например, «ЛАТИНСКАЯ пРОПИСНАЯ бУКВА а»). Хотя большинство абстрактных символов в юникоде представлены только с помощью одной точки код, существует ряд абстрактных символов, которые в дополнение могут быть представлены с помощью последовательности из нескольких точек код. Например, абстрактный символ «LATIN CAPITAL LETTER C WITH CEDILLA» может быть представлен в виде одного precomposed character в код position U 00C7, или в виде последовательности base character в код position U 0043 (LATIN CAPITAL LETTER C), за которым следует combining character в код position U 0327 (ОБЪЕДИНЕНИЕ CEDILLILLA A).

Операторы сравнения на строки выдерживают сравнение на уровне точек Unicode код. Это может быть контринтуитивно понятным для людей. Например, "\u00C7" == "\u0043\u0327" является False, хотя оба строки представляют один и тот же абстрактный символ «LATIN CAPITAL LETTER C WITH CEDILLA».

Сравнить строки на уровне абстрактных знаков (то есть, в некотором роде интуитивный людям), unicodedata.normalize() использования.

[4]Благодаря автоматическому сбору мусора, свободным спискам и динамическому характеру описатели, вы можете заметить на вид необычное поведение в определенном использовании оператора is, как те, которые включают сравнения между методами сущность или константы. Проверьте их документацию на большее количество информации.
[5]Оператор % также используемый для форматирования строка; то же самое предшествование применяется.
[6]Оператор степени ** связывается менее плотно, чем арифметика или битовый унарный оператор справа, то есть 2**-1 0.5.