Выражения¶Expressions

Идентификаторы (имена)¶Identifiers (Names)

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

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

Искажение закрытых имён: Когда идентификатор, текстуально встречающийся в определении класса, начинается с двух или более символов подчёркивания и не заканчивается двумя или более подчёркиваниями, он считается закрытым именем этого класса. Закрытые имена преобразуются в более длинную форму перед генерацией кода для них. Преобразование вставляет имя класса перед именем, удаляя ведущие подчёркивания, и вставляет одно подчёркивание перед именем класса. Например, идентификатор __spam, встречающийся в классе с именем Ham, будет преобразован в _Ham__spam. Это преобразование не зависит от синтаксического контекста, в котором используется идентификатор. Если преобразованное имя слишком длинное (длиннее 255 символов), может произойти усечение, определяемое реализацией. Если имя класса состоит только из подчёркиваний, преобразование не выполняется.

Литералы¶Literals

Python поддерживает строковые литералы, литералы bytes и различные числовые литералы:

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

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

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

Формы в скобках¶Parenthesized forms

Выражение в скобках – это необязательный список выражений, заключённый в круглые скобки:

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

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

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

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

Отображения для списков, множеств и словарей¶Displays for lists, sets and dictionaries

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

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

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

comprehension ::=  expression comp_for
comp_for      ::=  "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 как блока, вложенных слева направо, и вычислении выражения для получения элемента каждый раз, когда достигается самый внутренний блок.

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

Отображения списков¶List displays

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

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

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

Отображения множеств¶Set displays

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

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

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

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

Отображения словарей¶Dictionary displays

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

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

Словарное отображение возвращает новый объект словаря.

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

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

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

Выражения-генераторы¶Generator expressions

Генераторное выражение – это компактная запись генератора в круглых скобках:

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

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

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

Круглые скобки можно опускать при вызовах с единственным аргументом. Подробнее см. раздел Calls.

Выражения yield¶Yield expressions

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list]

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

Когда вызывается генераторная функция, она возвращает итератор, называемый генератором. Этот генератор затем управляет выполнением генераторной функции. Выполнение начинается, когда вызывается один из методов генератора. В этот момент выполнение доходит до первого выражения yield, где оно снова приостанавливается, возвращая значение expression_list вызывающему коду генератора. Под «приостановлено» подразумевается, что всё локальное состояние сохраняется, включая текущие привязки локальных переменных, указатель инструкций и внутренний стек вычислений. Когда выполнение возобновляется вызовом одного из методов генератора, функция продолжается так, как если бы выражение yield было просто ещё одним внешним вызовом. Значение выражения yield после возобновления зависит от метода, который возобновил выполнение.

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

Инструкция yield разрешена в блоке try конструкции try ... finally. Если генератор не будет возобновлён до его финализации (достижение нулевого счётчика ссылок или сборка мусора), будет вызван метод close() итератора генератора, что позволит выполнить незавершённые блоки finally.

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

generator.__next__()¶

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

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

generator.send(value)¶

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

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

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

generator.close()¶

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

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

>>> def echo(value=None):
...     print("Execution starts when 'next()' is called for the first time.")
...     try:
...         while True:
...             try:
...                 value = (yield value)
...             except Exception, 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.

Ссылки на атрибуты¶Attribute references

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

attributeref ::=  primary "." identifier

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

Индексация¶Subscriptions

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

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

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

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

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

Если первичное выражение – последовательность, выражение (список) должно вычисляться в целое число. Если это значение отрицательно, к нему прибавляется длина последовательности (так, например, x[-1] выбирает последний элемент x). Полученное значение должно быть неотрицательным целым, меньшим количества элементов в последовательности, и операция индексации выбирает элемент, чей индекс равен этому значению (счёт с нуля).

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

Срезы¶Slicings

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

Вызовы¶Calls

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

call                 ::=  primary "(" [argument_list [","] | comprehension] ")"
argument_list        ::=  positional_arguments ["," keyword_arguments]
                            ["," "*" expression] ["," keyword_arguments]
                            ["," "**" expression]
                          | keyword_arguments ["," "*" expression]
                            ["," keyword_arguments] ["," "**" expression]
                          | "*" expression ["," keyword_arguments] ["," "**" expression]
                          | "**" expression
positional_arguments ::=  expression ("," expression)*
keyword_arguments    ::=  keyword_item ("," keyword_item)*
keyword_item         ::=  identifier "=" expression

Замыкающая запятая может присутствовать после позиционных и именованных аргументов, но не влияет на семантику.

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

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

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

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

Если в вызове функции встречается синтаксис *expression, то expression должно вычисляться в последовательность. Элементы этой последовательности обрабатываются так, будто они являются дополнительными позиционными аргументами; если есть позиционные аргументы x1, ..., xN, и expression вычисляется в последовательность y1, ..., yM, то это эквивалентно вызову с M+N позиционными аргументами x1, ..., xN, y1, ..., yM.

Следствием этого является то, что хотя синтаксис *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 ?
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

Необычно использовать одновременно именованные аргументы и синтаксис *expression в одном вызове, поэтому на практике такая путаница не возникает.

Если в вызове функции присутствует синтаксис **expression, то expression должно быть отображением, содержимое которого обрабатывается как дополнительные именованные аргументы. Если имя аргумента встречается как в expression, так и в явном именованном аргументе, вызывается исключение TypeError.

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

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

Если это–

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

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

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

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

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

Возвращается новый экземпляр этого класса.

метод экземпляра класса:

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

экземпляр класса:

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