Выражения

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

Идентификатор, используемый в качестве атома, является именем. Лексическое определение см. в разделе Идентификаторы и ключевые слова, а описание присваивания имён и связывания — в разделе Присваивание имён и связывание.

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

6.2.2. Литералы

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

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

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

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

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

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

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

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

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

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

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

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

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

Общие синтаксические элементы генераторов:

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" or_test [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 или другие асинхронные генераторы в любом месте, кроме выражения-итератора в самой левой части for, он называется асинхронным генератором. Асинхронный генератор может приостанавливать выполнение сопрограммы, в которой он находится. См. также PEP 530.

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

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

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

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

6.2.6. Отображения множеств

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

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

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

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

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

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

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

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

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

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

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

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

6.2.8. Генераторные выражения

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

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

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():  # defines a generator function
    yield 123

async def agen(): # defines an asynchronous generator function
    yield 123

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

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

>>> 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.

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

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

attributeref ::= primary "." identifier

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

Это поведение можно настроить, переопределив метод __getattribute__() или метод __getattr__(). Сначала вызывается метод __getattribute__(), который либо возвращает значение, либо вызывает исключение AttributeError, если атрибут недоступен.

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

6.3.2. Индексация

Индексация экземпляра класса-контейнера обычно выбирает элемент из контейнера. Индексация обобщённого класса обычно возвращает объект GenericAlias.

subscription ::= primary "[" flexible_expression_list "]"

При индексации объекта интерпретатор вычисляет первичное выражение и список выражений.

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

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

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

1. Отображения. Если первичное выражение — это отображение, список выражений должен вычисляться в объект, значение которого является одним из ключей отображения, а индексация выбирает значение отображения, соответствующее этому ключу. Пример встроенного класса отображения — класс dict.
2. Последовательности. Если первичное выражение — это последовательность, список выражений должен вычисляться в int или slice (как описано в следующем разделе). Примеры встроенных классов последовательностей: str, list и tuple.

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

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

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

Если позиционных аргументов больше, чем слотов формальных параметров, вызывается исключение 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 нельзя использовать в качестве слотов для позиционных аргументов или имён именованных аргументов.

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

Если это —

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

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

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

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

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

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

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

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

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

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

6.10.1. Сравнения значений

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

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

Поскольку все типы являются (прямыми или косвенными) подтипами object, они наследуют стандартное поведение сравнения от object. Типы могут настраивать поведение сравнения, реализуя методы расширенного сравнения, такие как __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] истинно).

• Отображения (экземпляры dict) равны тогда и только тогда, когда у них одинаковы пары (key, value). Сравнение ключей и значений на равенство обеспечивает рефлексивность.

  Сравнения на упорядоченность (<, >, <= и >=) приводят к исключению 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

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

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

Для типов string и 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 истинно. Если во время перебора возникает исключение, это равносильно тому, что 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]