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] ")"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

generator_expression ::=  "(" expression comp_for ")"

Генерирующее выражение приводит к созданию нового генерирующего объекта. Его синтаксис такой же, как и у comprehensions, за исключением того, что оно заключено в круглые скобки, а не в фигурные скобки.

Переменные, используемые в генераторном выражении, вычисляются лениво, когда для объекта generator вызывается метод __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_from       ::=  "yield" "from" expression
yield_expression ::=  "yield" expression_list | yield_from

Выражение 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 не разрешены как часть неявно определенных областей, используемых для реализации интерпретаций и генераторных выражений.

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

Когда вызывается функция-генератор, она возвращает итератор, известный как generator. Этот генератор затем управляет выполнением функции-генератора. Выполнение начинается при вызове одного из методов генератора. В это время выполнение переходит к первому выражению 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 является единственным выражением в правой части оператора присваивания.

>>> 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

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

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

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

6.3.2. Подписки¶

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

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

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

Первичный объект должен соответствовать объекту, поддерживающему подписку. Объект может поддерживать подписку путем определения одного или обоих из __getitem__() и __class_getitem__(). Когда первичное значение подписано, результат вычисления списка выражений будет передан одному из этих методов. Более подробную информацию о том, когда вместо __getitem__ вызывается __class_getitem__, смотрите в разделе __класс_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__(), что и обычная подписка) с помощью ключа, который создается из списка фрагментов следующим образом. Если список фрагментов содержит хотя бы одну запятую, ключом является кортеж, содержащий преобразование элементов фрагмента; в противном случае ключом является преобразование отдельного элемента фрагмента. Преобразование элемента фрагмента, который является выражением, является этим выражением. Преобразованием соответствующего фрагмента является объект slice (см. раздел Иерархия стандартных типов), атрибуты которого start, stop и step являются значениями выражений, заданных в виде нижней границы, верхней границы и шаг, соответственно, заменяя пропущенные выражения 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.

Когда используется **expression, каждый ключ в этом сопоставлении должен быть строкой. Каждое значение из сопоставления присваивается первому формальному параметру, подходящему для присвоения ключевого слова, имя которого равно ключу. Ключ не обязательно должен быть идентификатором Python (например, "max-temp °F" допустимо, хотя он не будет соответствовать ни одному формальному параметру, который можно было бы объявить). Если нет совпадения с формальным параметром, пара ключ-значение собирается с помощью параметра **, если он есть, или если его нет, генерируется исключение 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 все значения false, а x != x - true. Такое поведение соответствует стандарту IEEE 754.

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

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

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

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

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

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

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

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

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

• Сопоставления (экземпляры 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. Все встроенные последовательности и типы наборов поддерживают это, а также dictionary, для которого in проверяет, имеет ли словарь заданный ключ. Для таких типов контейнеров, как list, tuple, set, frozenset, dict или collections.например, выражение x in y эквивалентно any(x is e or x == e for e in y).

Для типов string и 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, если некоторое значение 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]