Выражения

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

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

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

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

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

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

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

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

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

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

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

set_display ::=  "{" (starred_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_expression ::=  "yield" [expression_list | "from" expression]

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

def gen():  # defines a generator function
    yield 123

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

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

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

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

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

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

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

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

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

6.3.1. Обращения к атрибутам

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

attributeref ::=  primary "." identifier

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

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

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

6.3.2. Обращения по индексу

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

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

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

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

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

Для встроенных объектов существуют два типа объектов, поддерживающих обращение по индексу через метод __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, это определяет возвращаемое значение вызова функции.

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

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

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

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

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

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

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

Класс должен определить метод __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) сравниваются лексикографически с использованием числовых значений кодовых точек Юникода (результат встроенной функции 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 проверяет, содержит ли словарь заданный ключ. Для контейнерных типов, таких как список, кортеж, множество, неизменяемое множество, словарь или 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