Выражения

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

Для строк и байтовых последовательностей 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]