Выражения

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 в теле функции делает эту функцию функцией-генератором, а использование его в теле функции-корутины делает эту корутинную функцию функцией-асинхронного генератора. Например:

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 является единственным выражением в правой части оператора присваивания.

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