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

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

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

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

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

6.2.2. Литература¶

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

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

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

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

6.2.3. Парентезные формы¶

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

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

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

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

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

6.2.4. Дисплеи для списков, наборов и словарей¶

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

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

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

Общими элементами синтаксиса для понимания являются:

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 может использоваться предложение asynchronous iterator. Понимание в функции async def может состоять из предложения for или async for, следующего за ведущим выражением, может содержать дополнительные предложения for или async for, а также использовать выражения await. Если вычисление содержит либо async for клаузулы, либо await выражения, оно называется asynchronous comprehension. Асинхронное понимание может приостановить выполнение функции coroutine, в которой оно появляется. См. также PEP 530.

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

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

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

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

6.2.6. Установить дисплеи¶

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

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

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

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

6.2.7. Отображения в словаре¶

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

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

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

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

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

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

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

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 выражения, оно называется asynchronous generator expression. Выражение асинхронного генератора возвращает новый объект асинхронного генератора, который является асинхронным итератором (см. Асинхронные итераторы).

6.2.9. Выражения доходности¶

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

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

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

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

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

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

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

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

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

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

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

Изменено в версии 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. Ссылки на атрибуты¶

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

attributeref ::=  primary "." identifier

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

6.3.2. Подписки¶

Подписка на экземпляр container class обычно выбирает элемент из контейнера. Подписка на generic class обычно возвращает объект GenericAlias.

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

Когда объект подзаписывается, интерпретатор оценивает основной объект и список выражений.

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

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

Для встроенных объектов существует два типа объектов, которые поддерживают подписку через __getitem__():

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

2. Последовательности. Если первичным является sequence, список выражений должен оцениваться как int или slice (как обсуждается в следующем разделе). Примерами встроенных классов последовательностей являются классы str, list и tuple.

Формальный синтаксис не предусматривает специальных условий для отрицательных индексов в sequences. Однако все встроенные последовательности предоставляют метод __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 являются значения выражений, заданных в виде нижней границы, верхней границы и stride, соответственно, с заменой None на отсутствующие выражения.

6.3.4. Звонки¶

Вызов вызывает вызываемый объект (например, function) с возможно пустой серией arguments:

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

Если присутствуют аргументы с ключевыми словами, они сначала преобразуются в позиционные аргументы следующим образом. Сначала создается список незаполненных слотов для формальных параметров. Если имеется N позиционных аргументов, они помещаются в первые N слотов. Далее, для каждого аргумента с ключевым словом используется идентификатор для определения соответствующего слота (если идентификатор совпадает с именем первого формального параметра, то используется первый слот и так далее). Если слот уже заполнен, то выдается исключение TypeError. В противном случае значение аргумента помещается в слот, заполняя его (даже если выражение имеет вид None, оно заполняет слот). Когда все аргументы обработаны, оставшиеся незаполненными слоты заполняются соответствующим значением по умолчанию из определения функции. (Значения по умолчанию вычисляются один раз, когда функция определена; таким образом, изменяемый объект, такой как список или словарь, используемый в качестве значения по умолчанию, будет использоваться всеми вызовами, которые не указывают значение аргумента для соответствующего слота; обычно этого следует избегать). Если есть незаполненные слоты, для которых не указано значение по умолчанию, выдается исключение TypeError. В противном случае список заполненных слотов используется в качестве списка аргументов для вызова.

Если позиционных аргументов больше, чем слотов формальных параметров, возникает исключение TypeError, если только не присутствует формальный параметр, использующий синтаксис *identifier; в этом случае этот формальный параметр получает кортеж, содержащий избыточные позиционные аргументы (или пустой кортеж, если избыточных позиционных аргументов не было).

Если какой-либо аргумент ключевого слова не соответствует имени формального параметра, возникает исключение TypeError, если только не присутствует формальный параметр, использующий синтаксис **identifier; в этом случае этот формальный параметр получает словарь, содержащий избыточные аргументы ключевых слов (используя ключевые слова как ключи, а значения аргументов как соответствующие значения), или (новый) пустой словарь, если избыточных аргументов ключевых слов не было.

Если в вызове функции встречается синтаксис *expression, то expression должен оцениваться как iterable. Элементы из этих итераций рассматриваются так, как если бы они были дополнительными позиционными аргументами. Для вызова 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 должен быть оценен в mapping, содержимое которого рассматривается как дополнительные аргументы ключевого слова. Если ключевое слово уже присутствует (как явный аргумент ключевого слова или в результате другой распаковки), то возникает исключение TypeError.

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

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

Если это так…

функция, определяемая пользователем:

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

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

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

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

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

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

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

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

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

6.10.1. Сравнение ценностей¶

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

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

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

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

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

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

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

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

  Нечисловые значения float('NaN') и decimal.Decimal('NaN') являются специальными. Любое упорядоченное сравнение числа с нечисловым значением ложно. Противоположное интуитивное следствие заключается в том, что значения не-чисел не равны самим себе. Например, если x = float('NaN'), 3 < x, x < 3 и x == x все ложны, а x != x истинно. Такое поведение соответствует стандарту IEEE 754.

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

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

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

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

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

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

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

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

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

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

  При сравнении порядков (<, >, <= и >=) возникает ошибка 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 не обеспечивает соблюдение этих правил согласованности. Фактически, значения not-a-number являются примером несоблюдения этих правил.

6.10.2. Операции по проверке членства¶

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

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

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

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