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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5.2.4. Списковые отображения¶List displays

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

list_display        ::=  "[" [expression_list | list_comprehension] "]"
list_comprehension  ::=  expression list_for
list_for            ::=  "for" target_list "in" old_expression_list [list_iter]
old_expression_list ::=  old_expression [("," old_expression)+ [","]]
old_expression      ::=  or_test | old_lambda_expr
list_iter           ::=  list_for | list_if
list_if             ::=  "if" old_expression [list_iter]

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

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

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

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

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

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

comprehension ::=  expression comp_for
comp_for      ::=  "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" expression_nocond [comp_iter]

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

Обратите внимание, что включение выполняется в отдельной области видимости, так что имена, присвоенные в списке целей, не «просачиваются» в окружающую область.

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

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

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

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

Переменные, используемые в генераторном выражении, вычисляются лениво при вызове метода __next__() для объекта-генератора (так же, как у обычных генераторов). Однако самое левое предложение for вычисляется немедленно, чтобы ошибка, возникшая в нём, была видна до любых других возможных ошибок в коде, обрабатывающем генераторное выражение. Последующие предложения for не могут быть вычислены немедленно, поскольку они могут зависеть от предыдущего цикла for. Например: (x*y for x in range(10) for y in bar(x)).

Круглые скобки можно опускать при вызовах с единственным аргументом. Подробнее см. раздел Calls.

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

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

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

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

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

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

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

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

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

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

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

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

5.2.9. Преобразования строк¶String conversions

Преобразование строки – это список выражений, заключённый в обратные (также называемые зеркальными) кавычки:

string_conversion ::=  "`" expression_list "`"

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

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

(В частности, преобразование строки добавляет кавычки вокруг неё и преобразует «необычные» символы в управляющие последовательности, которые безопасно печатать.)

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

Встроенная функция repr() выполняет точно такое же преобразование своего аргумента, как и заключение его в круглые скобки и обратные кавычки. Встроенная функция str() выполняет аналогичное, но более удобное для пользователя преобразование.

5.2.10. Выражения yield¶Yield expressions

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list]

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

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

Всё это делает функции-генераторы очень похожими на корутины: они порождают значения многократно, у них более чем одна точка входа, и их выполнение может быть приостановлено. Единственное отличие в том, что функция-генератор не может управлять тем, где должно продолжиться выполнение после 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, e:
...                 value = e
...     finally:
...         print "Don't forget to clean up when 'close()' is called."
...
>>> generator = echo(1)
>>> print generator.next()
Execution starts when 'next()' is called for the first time.
1
>>> print generator.next()
None
>>> print generator.send(2)
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.

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

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

attributeref ::=  primary "." identifier

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

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

Индексация выбирает элемент последовательности (строки, кортежа или списка) или отображения (словаря):

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

Первичное выражение должно вычисляться в объект типа последовательности или отображения.

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

Если первичное выражение является последовательностью, список выражений должен вычисляться в обычное целое число. Если это значение отрицательное, к нему прибавляется длина последовательности (так, например, x[-1] выбирает последний элемент x). Результирующее значение должно быть неотрицательным целым числом, меньшим количества элементов в последовательности, и индексация выбирает элемент, индекс которого равен этому значению (счёт с нуля).

Элементами строки являются символы. Символ не является отдельным типом данных, а представляет собой строку ровно из одного символа.

5.3.3. Срезы¶Slicings

Срез выбирает диапазон элементов в объекте-последовательности (например, строке, кортеже или списке). Срезы могут использоваться как выражения или как цели в операторах присваивания или del. Синтаксис среза:

slicing          ::=  simple_slicing | extended_slicing
simple_slicing   ::=  primary "[" short_slice "]"
extended_slicing ::=  primary "[" slice_list "]"
slice_list       ::=  slice_item ("," slice_item)* [","]
slice_item       ::=  expression | proper_slice | ellipsis
proper_slice     ::=  short_slice | long_slice
short_slice      ::=  [lower_bound] ":" [upper_bound]
long_slice       ::=  short_slice ":" [stride]
lower_bound      ::=  expression
upper_bound      ::=  expression
stride           ::=  expression
ellipsis         ::=  "..."

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

Семантика простого среза следующая. Первичное выражение должно вычисляться в объект последовательности. Выражения нижней и верхней границы, если присутствуют, должны вычисляться в обычные целые числа; значения по умолчанию – ноль и sys.maxint соответственно. Если любая из границ отрицательна, к ней прибавляется длина последовательности. Срез теперь выбирает все элементы с индексом k, таким что i <= k < j, где i и j – указанные нижняя и верхняя границы. Это может быть пустая последовательность. Не является ошибкой, если i или j выходят за диапазон допустимых индексов (такие элементы не существуют, поэтому они не выбираются).

Семантика расширенного среза следующая. Первичное выражение должно вычисляться в объект отображения, и оно индексируется ключом, который строится из списка срезов следующим образом. Если список срезов содержит хотя бы одну запятую, ключом является кортеж, содержащий преобразования элементов среза; в противном случае ключом является преобразование единственного элемента среза. Преобразованием элемента среза, являющегося выражением, является само это выражение. Преобразованием элемента-многоточия является встроенный объект Ellipsis. Преобразованием обычного среза является объект среза (см. раздел Стандартная иерархия типов), чьи атрибуты start, stop и step являются значениями выражений, заданных как нижняя граница, верхняя граница и шаг соответственно, с подстановкой None для отсутствующих выражений.

5.3.4. Вызовы¶Calls

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

call                 ::=  primary "(" [argument_list [","]
                          | expression genexpr_for] ")"
argument_list        ::=  positional_arguments ["," keyword_arguments]
                            ["," "*" expression] ["," keyword_arguments]
                            ["," "**" expression]
                          | keyword_arguments ["," "*" expression]
                            ["," "**" expression]
                          | "*" expression ["," keyword_arguments] ["," "**" expression]
                          | "**" expression
positional_arguments ::=  expression ("," expression)*
keyword_arguments    ::=  keyword_item ("," keyword_item)*
keyword_item         ::=  identifier "=" expression

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

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

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

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

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

Если в вызове функции встречается синтаксис *expression, то expression должно вычисляться в итерируемый объект. Элементы из этого итерируемого объекта рассматриваются как дополнительные позиционные аргументы; если есть позиционные аргументы x1, …, xN, а expression вычисляется в последовательность y1, …, yM, это эквивалентно вызову с M+N позиционными аргументами x1, …, xN, y1, …, yM.

Из этого следует, что хотя синтаксис *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), содержимое которого рассматривается как дополнительные именованные аргументы. В случае, когда один и тот же ключ встречается как в expression, так и в явном именованном аргументе, возбуждается исключение TypeError.

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

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

Если это–

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Упорядочивающие сравнения по умолчанию (<, >, <= и >=) дают согласованный, но произвольный порядок.

(Это необычное определение сравнения использовалось для упрощения определения таких операций, как сортировка и операторов in и not in. В будущем правила сравнения для объектов разных типов, вероятно, изменятся.)

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

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

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

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

• Экземпляры tuple или list можно сравнивать только внутри каждого из своих типов. Сравнение на равенство между этими типами даёт результат «не равно», а упорядочивающее сравнение между этими типами даёт произвольный порядок.

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

  Обеспечивая рефлексивность элементов, сравнение коллекций исходит из того, что для элемента коллекции x выражение x == x всегда истинно. Исходя из этого предположения, сначала сравнивается идентичность элементов, а сравнение элементов выполняется только для различных элементов. Этот подход даёт тот же результат, что и строгое сравнение элементов, если сравниваемые элементы рефлексивны. Для нерефлексивных элементов результат отличается от строгого сравнения элементов.

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

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

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

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

  Результаты, отличные от равенства, разрешаются согласованно, но в остальном не определены. 5

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

Пользовательские классы, которые настраивают своё поведение сравнения, должны по возможности следовать некоторым правилам согласованности:

• Сравнение на равенство должно быть рефлексивным. Другими словами, идентичные объекты должны быть равны:

  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 не принуждает к соблюдению этих правил согласованности.

5.9.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 == z. Если во время итерации возбуждается исключение, то это равносильно тому, что in возбудило это исключение.

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

Оператор not in определён как имеющий обратное истинностное значение оператора in.

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

Операторы is и is not проверяют тождественность объектов: x is y истинно тогда и только тогда, когда x и y являются одним и тем же объектом. x is not y даёт обратное значение истинности. 6