Выражения

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 ::=  "[" [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_from       ::=  "yield" "from" expression
yield_expression ::=  "yield" expression_list | yield_from

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

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

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

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

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

Когда вызывается функция-генератор, она возвращает итератор, известный как генератор. Затем этот генератор управляет выполнением функции-генератора. Выполнение начинается, когда вызывается один из методов генератора. В этот момент выполнение продолжается до первого выражения yield, где оно приостанавливается, возвращая значение expression_list вызывающей функции-генератора, или None если expression_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 "[" 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, это указывает возвращаемое значение вызова функции.

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

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

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

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

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

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

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

Класс должен определить метод __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]