6. Выражения¶Expressions

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

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

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

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

6.2.2. Литералы¶Literals

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

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

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

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

6.2.3. Выражения в скобках¶Parenthesized forms

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

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

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

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

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

6.2.4. Отображения для списков, множеств и словарей¶Displays for lists, sets and dictionaries

Для создания списка, множества или словаря в Python предусмотрен специальный синтаксис, называемый «отображениями» (displays); каждый из них существует в двух вариантах:

• либо содержимое контейнера перечисляется явно, либо

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

Общие синтаксические элементы для включений:

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 displays

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

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

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

6.2.6. Множественные отображения¶Set displays

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

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

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

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

6.2.7. Словарные отображения¶Dictionary displays

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

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for

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

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

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

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

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

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

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

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 expressions

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]

The yield expression is used when defining a generator function or an asynchronous generator function and thus can only be used in the body of a function definition. Using a yield expression in a function’s body causes that function to be a generator function, and using it in an async def function’s body causes that coroutine function to be an asynchronous generator function. For example:

def gen():  # определяет функцию-генератор
    yield 123

async def agen(): # определяет асинхронную функцию-генератор
    yield 123

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

Generator functions are described below, while asynchronous generator functions are described separately in section Asynchronous generator functions.

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

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

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

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

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

Изменено в версии 3.3: Добавлено yield from <expr> для делегирования потока управления под-итератору.

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

>>> def echo(value=None):
...     print("Execution starts when 'next()' is called for the first time.")
...     try:
...         while True:
...             try:
...                 value = (yield value)
...             except Exception as e:
...                 value = e
...     finally:
...         print("Don't forget to clean up when 'close()' is called.")
...
>>> generator = echo(1)
>>> print(next(generator))
Execution starts when 'next()' is called for the first time.
1
>>> print(next(generator))
None
>>> print(generator.send(2))
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.

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

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

attributeref ::=  primary "." identifier

Первичное выражение должно вычисляться в объект типа, который поддерживает ссылки на атрибуты (большинство объектов это делают). Затем у этого объекта запрашивается атрибут, имя которого является идентификатором. Это получение можно настроить, переопределив метод __getattr__(). Если такой атрибут недоступен, возбуждается исключение AttributeError. В противном случае тип и значение полученного объекта определяются объектом. Многократные вычисления одной и той же ссылки на атрибут могут давать разные объекты.

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

Индексирование экземпляра класса-контейнера обычно выбирает элемент из контейнера. Индексирование обобщённого класса обычно возвращает объект 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. Срезы¶Slicings

Срез выбирает диапазон элементов в объекте-последовательности (например, строке, кортеже или списке). Срезы могут использоваться как выражения или как цели в операторах присваивания или 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. Вызовы¶Calls

Вызов – это обращение к вызываемому объекту (например, функции) с возможно пустой последовательностью аргументов:

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.

Формальные параметры с синтаксисом *identifier или **identifier не могут использоваться как слоты позиционных аргументов или как имена именованных аргументов.

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

Если это–

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

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

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

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

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

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

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

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

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

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

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

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

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

Поскольку все типы являются (прямыми или косвенными) подтипами object, они наследуют поведение сравнения по умолчанию от object. Типы могут настраивать своё поведение сравнения, реализуя методы расширенного сравнения, такие как __lt__(), описанные в разделе Базовая настройка.

Поведение по умолчанию для сравнения на равенство (== и !=) основано на идентичности объектов. Следовательно, сравнение на равенство экземпляров с одинаковой идентичностью даёт равенство, а сравнение экземпляров с разной идентичностью – неравенство. Мотивация такого поведения по умолчанию – желание, чтобы все объекты были рефлексивными (т.е. x is y влечёт x == y).

Поведение сравнения порядка по умолчанию (<, >, <= и >=) не предусмотрено; попытка вызывает TypeError. Мотивация такого поведения по умолчанию – отсутствие аналогичного инварианта, как для равенства.

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

Следующий список описывает поведение сравнения наиболее важных встроенных типов.

• Числа встроенных числовых типов (Числовые типы – int, float, complex) и типов стандартной библиотеки fractions.Fraction и decimal.Decimal можно сравнивать как внутри своих типов, так и между ними, с ограничением, что комплексные числа не поддерживают сравнение порядка. В пределах задействованных типов они сравниваются математически (алгоритмически) корректно без потери точности.

  Значения «не число» (NaN) float('NaN') и decimal.Decimal('NaN') являются особыми. Любое упорядоченное сравнение числа со значением «не число» даёт ложь. Контринтуитивное следствие: значения «не число» не равны сами себе. Например, если x = float('NaN'), 3 < x, x < 3 и x == x – все ложны, а x != x истинно. Это поведение соответствует стандарту IEEE 754.

• None и NotImplemented – это синглтоны. PEP 8 рекомендует всегда выполнять сравнения синглтонов с помощью is или is not, а не операторов равенства.

• Бинарные последовательности (экземпляры bytes или bytearray) можно сравнивать как внутри своих типов, так и между ними. Они сравниваются лексикографически по числовым значениям своих элементов.

• Строки (экземпляры str) сравниваются лексикографически по числовым кодовым точкам Unicode (результат встроенной функции ord()) своих символов. 3

  Строки и двоичные последовательности нельзя сравнивать напрямую.

• Последовательности (экземпляры tuple, list или range) можно сравнивать только внутри каждого из своих типов, с ограничением, что диапазоны не поддерживают сравнение порядка. Сравнение на равенство между этими типами даёт неравенство, а сравнение порядка между этими типами вызывает TypeError.

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

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

  • Чтобы две коллекции были равны при сравнении, они должны быть одного типа, иметь одинаковую длину, и каждая пара соответствующих элементов должна быть равной (например, [1,2] == (1,2) – ложь, так как типы разные).

  • Коллекции, поддерживающие сравнение порядка, упорядочиваются так же, как и их первые неравные элементы (например, [1,2,x] <= [1,2,y] имеет то же значение, что и x <= y). Если соответствующего элемента не существует, более короткая коллекция считается меньшей (например, [1,2] < [1,2,3] – истина).

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

  Сравнения порядка (<, >, <= и >=) вызывают 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 не требует соблюдения этих правил согласованности. Фактически, значения «не число» (NaN) являются примером их нарушения.

6.10.2. Операции проверки принадлежности¶Membership test operations

Операторы in и not in проверяют принадлежность. x in s вычисляется в True, если x является элементом s, и False в противном случае. x not in s возвращает отрицание x in s. Все встроенные последовательности и множества поддерживают это, а также словари, для которых in проверяет, содержит ли словарь заданный ключ. Для контейнерных типов, таких как list, tuple, set, frozenset, dict или collections.deque, выражение x in y эквивалентно any(x is e or x == e for e in y).

Для типов str и bytes x in y равно True тогда и только тогда, когда x является подстрокой y. Эквивалентная проверка: y.find(x) != -1. Пустые строки всегда считаются подстрокой любой другой строки, поэтому "" in "abc" вернёт True.

Для пользовательских классов, которые определяют метод __contains__(), x in y возвращает True, если y.__contains__(x) возвращает истинное значение, и False в противном случае.

Для пользовательских классов, которые не определяют __contains__(), но определяют __iter__(), x in y равно True, если при итерации по y встречается некоторое значение z, для которого выражение x is z or x == z истинно. Если во время итерации возникает исключение, это равносильно тому, что in вызвало это исключение.

Наконец, используется протокол итерации старого стиля: если класс определяет __getitem__(), x in y равно True тогда и только тогда, когда существует неотрицательный целочисленный индекс i, такой что x is y[i] or x == y[i], и ни один меньший индекс не вызывает исключение IndexError. (Если возникает любое другое исключение, это равносильно тому, что in вызвало это исключение).

Оператор not in определён так, что его истинностное значение противоположно in.

6.10.3. Сравнение идентичности¶Identity comparisons

Операторы is и is not проверяют идентичность объектов: x is y истинно тогда и только тогда, когда x и y являются одним и тем же объектом. Идентичность объекта определяется с помощью функции id(). x is not y возвращает противоположное логическое значение. 4