Выражения

6.2.1. Встроенные константы

Ключевые слова True, False и None обозначают встроенные константы. Токен ... обозначает константу Ellipsis.

Вычисление этих атомов даёт соответствующее значение.

>>> False = 123
  File "<input>", line 1
   False = 123
   ^^^^^
SyntaxError: cannot assign to False

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

Идентификатор, встречающийся в качестве атома, является именем. Лексическое определение приведено в разделе Имена (идентификаторы и ключевые слова), а описание присваивания имён и связывания — в разделе Именование и связывание.

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

6.2.3. Литералы

Литерал — это текстовое представление значения. Python поддерживает числовые, строковые и байтовые литералы. Форматируемые строки и шаблонные строки рассматриваются как строковые литералы.

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

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

Обратите внимание, что отрицательные и комплексные числа, например -3 или 3+4.2j, синтаксически не являются литералами, а представляют собой унарные или бинарные арифметические операции с оператором - или +.

Вычисление литерала даёт объект соответствующего типа (int, float, complex, str, bytes или Template) с заданным значением. В случае литералов с плавающей запятой и мнимых чисел значение может быть приближённым.

Формальная грамматика литералов:

literal: strings | NUMBER

>>> x = 7
>>> y = 7
>>> x is y
True

>>> x = 123456789
>>> y = 123456789
>>> x is y
False

>>> x = 7
>>> x is 7
<input>:1: SyntaxWarning: "is" with 'int' literal. Did you mean "=="?
True

>>> "hello" 'world'
"helloworld"

>>> greeting = "Hello"
>>> space = " "
>>> name = "Blaise"
>>> print(greeting + space + name)   # not: print(greeting space name)
Hello Blaise

>>> "Hello" r', ' f"{name}!"
"Hello, Blaise!"

re.compile("[A-Za-z_]"       # letter or underscore
           "[A-Za-z0-9_]*"   # letter, digit or underscore
          )

>>> t"Hello" t"{name}!"
Template(strings=('Hello', '!'), interpolations=(...))

strings: (STRING | fstring)+ | tstring+

6.2.4. Формы в скобках

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

parenth_form: "(" [starred_expression] ")"

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

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

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

6.2.5. Литералы списков, множеств и словарей

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

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

Общие синтаксические элементы генераторных выражений:

comprehension: assignment_expression comp_for
comp_for:      ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter:     comp_for | comp_if
comp_if:       "if" or_test [comp_iter]

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

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

Итерируемое выражение в самой левой конструкции for вычисляется непосредственно во внешней области видимости, а затем передаётся в качестве аргумента неявно вложенной области видимости. Последующие конструкции for и любые условия фильтрации в самой левой конструкции for нельзя вычислить во внешней области видимости, поскольку они могут зависеть от значений, полученных из самой левой итерируемой конструкции. Например: [x*y for x in range(10) for y in range(x, x+10)].

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

Начиная с Python 3.6, в функции async def конструкцию async for можно использовать для перебора асинхронного итератора. Генераторное выражение в функции async def может содержать после начального выражения конструкцию for или async for, дополнительные конструкции for или async for, а также выражения await.

Если генераторное выражение содержит конструкции async for или выражения await либо другие асинхронные генераторные выражения где-либо, кроме итерируемого выражения в самой левой конструкции for, оно называется асинхронным генераторным выражением. Асинхронное генераторное выражение может приостанавливать выполнение функции-корутины, в которой оно находится. См. также PEP 530.

6.2.6. Литералы списков

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

list_display: "[" [flexible_expression_list | comprehension] "]"

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

6.2.7. Литералы множеств

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

set_display: "{" (flexible_expression_list | comprehension) "}"

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

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

6.2.8. Литералы словарей

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

dict_display:       "{" [dict_item_list | dict_comprehension] "}"
dict_item_list:     dict_item ("," dict_item)* [","]
dict_item:          expression ":" expression | "**" or_expr
dict_comprehension: expression ":" expression comp_for

Литерал словаря создаёт новый объект-словарь.

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

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

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

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

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

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

>>> iterator = (x ** 2 for x in range(10))
>>> iterator
<generator object <genexpr> at ...>

Во время выполнения генераторное выражение вычисляется в итератор-генератор, который выдаёт те же значения, что и соответствующее генераторное выражение для списка:

>>> list(iterator)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Таким образом, приведённый выше пример примерно эквивалентен определению и вызову следующей функции-генератора:

def make_generator_of_squares(iterator):
    for x in iterator:
        yield x ** 2

make_generator_of_squares(iter(range(10)))

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

# The parentheses after `sum` are part of the call syntax:
>>> sum(x ** 2 for x in range(10))
285

# The generator needs its own parentheses if it's not the only argument:
>>> sum((x ** 2 for x in range(10)), start=1000)
1285

Итерируемое выражение в самой левой конструкции for вычисляется немедленно, поэтому ошибка, вызванная этим выражением, возникает в момент определения генераторного выражения, а не тогда, когда извлекается первое значение:

>>> (x ** 2 for x in nonexistent_iterable)
Traceback (most recent call last):
  ...
NameError: name 'nonexistent_iterable' is not defined

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

>>> (x ** 2 for x in None)
Traceback (most recent call last):
  ...
TypeError: 'NoneType' object is not iterable

Все остальные выражения вычисляются лениво, как и в обычных генераторах (то есть когда итератор запрашивают выдать значение):

>>> iterator = (nonexistent_value for x in range(10))
>>> iterator
<generator object <genexpr> at ...>
>>> list(iterator)
Traceback (most recent call last):
  ...
NameError: name 'nonexistent_value' is not defined

>>> iterator = (x * y for x in range(10) for y in nonexistent_iterable)
>>> iterator
<generator object <genexpr> at ...>
>>> list(iterator)
Traceback (most recent call last):
  ...
NameError: name 'nonexistent_iterable' is not defined

Чтобы не нарушать ожидаемую работу самого генераторного выражения, выражения yield и yield from запрещены во вложенной неявной области видимости.

Если генераторное выражение содержит конструкции async for или выражения await, оно называется асинхронным генераторным выражением. Асинхронное генераторное выражение возвращает новый объект асинхронного генератора, являющийся асинхронным итератором (см. раздел Асинхронные итераторы).

Формальная грамматика генераторных выражений:

generator_expression: "(" expression comp_for ")"

6.2.10. Выражения yield

yield_atom:       "(" yield_expression ")"
yield_from:       "yield" "from" expression
yield_expression: "yield" yield_list | yield_from

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

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

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

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

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

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

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

>>> digits_by_name = {'one': 1, 'two': 2}
>>> digits_by_name['two']  # Subscripting a dictionary using the key 'two'
2

В синтаксисе индексации за объектом, к которому применяется индексация, — первичным выражением — следует индекс в квадратных скобках. В простейшем случае индекс представляет собой одно выражение.

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

>>> colors = ['red', 'blue', 'green', 'black']
>>> colors[3]  # Subscripting a list using the index 3
'black'

>>> list[str]  # Parameterizing the list type using the type argument str
list[str]

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

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

>>> class SubscriptionDemo:
...     def __getitem__(self, key):
...         print(f'subscripted with: {key!r}')
...
>>> demo = SubscriptionDemo()
>>> demo[1]
subscripted with: 1
>>> demo['a' * 3]
subscripted with: 'aaa'

О том, как встроенные типы обрабатывают индексацию, см. документацию __getitem__().

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

>>> colors = ['red', 'blue', 'green', 'black']
>>> colors[3] = 'white'  # Setting item at index
>>> colors
['red', 'blue', 'green', 'white']
>>> del colors[3]  # Deleting item at index 3
>>> colors
['red', 'blue', 'green']

Все расширенные формы индекса, описанные в следующих разделах, также можно использовать для присваивания и удаления.

>>> number_names = ['zero', 'one', 'two', 'three', 'four', 'five']
>>> number_names[1:3]
['one', 'two']
>>> number_names[1:]
['one', 'two', 'three', 'four', 'five']
>>> number_names[:3]
['zero', 'one', 'two']
>>> number_names[:]
['zero', 'one', 'two', 'three', 'four', 'five']
>>> number_names[::2]
['zero', 'two', 'four']
>>> number_names[:-3]
['zero', 'one', 'two']
>>> del number_names[4:]
>>> number_names
['zero', 'one', 'two', 'three']

# continuing with the SubscriptionDemo instance defined above:
>>> demo[2:3]
subscripted with: slice(2, 3, None)
>>> demo[::'spam']
subscripted with: slice(None, None, 'spam')

# continuing with the SubscriptionDemo instance defined above:
>>> demo[1, 2, 3]
subscripted with: (1, 2, 3)
>>> demo[1:2, 3]
subscripted with: (slice(1, 2, None), 3)

>>> demo['spam',]
subscripted with: ('spam',)

# continuing with the SubscriptionDemo instance defined above:
>>> demo[*range(10)]
subscripted with: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

>>> demo['a', 'b', *range(3), 'c']
subscripted with: ('a', 'b', 0, 1, 2, 'c')

subscription:     primary '[' subscript ']'
subscript:        single_subscript | tuple_subscript
single_subscript: proper_slice | assignment_expression
proper_slice:     [expression] ":" [expression] [ ":" [expression] ]
tuple_subscript:  ','.(single_subscript | starred_expression)+ [',']

6.3.3. Вызовы

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

call:                 primary "(" [argument_list [","] | comprehension] ")"
argument_list:        positional_arguments ["," starred_and_keywords]
                        ["," keywords_arguments]
                      | starred_and_keywords ["," keywords_arguments]
                      | keywords_arguments
positional_arguments: positional_item ("," positional_item)*
positional_item:      assignment_expression | "*" expression
starred_and_keywords: ("*" expression | keyword_item)
                      ("," "*" expression | "," keyword_item)*
keywords_arguments:   (keyword_item | "**" expression)
                      ("," keyword_item | "," "**" expression)*
keyword_item:         identifier "=" expression

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

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

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

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

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

Если в вызове функции используется синтаксис *expression, выражение expression должно вычисляться в итерируемый объект. Элементы этих итерируемых объектов рассматриваются как дополнительные позиционные аргументы. Для вызова f(x1, x2, *y, x3, x4), если y вычисляется в последовательность y1, …, yM, это эквивалентно вызову с M+4 позиционными аргументами x1, x2, y1, …, yM, x3, x4.

Из этого следует, что хотя синтаксис *expression может встречаться после явных именованных аргументов, он обрабатывается до именованных аргументов (и любых аргументов **expression — см. ниже). Поэтому:

>>> def f(a, b):
...     print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

Одновременное использование именованных аргументов и синтаксиса *expression в одном вызове встречается редко, поэтому на практике такая неоднозначность возникает нечасто.

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

При использовании **expression каждый ключ в этом отображении должен быть строкой. Каждое значение из отображения присваивается первому формальному параметру, которому можно присвоить значение по имени и имя которого совпадает с ключом. Ключ не обязан быть идентификатором Python (например, "max-temp °F" допустимо, хотя оно не совпадёт ни с одним формальным параметром, который можно объявить). Если соответствующего формального параметра нет, пара «ключ-значение» добавляется в параметр **, если он имеется; в противном случае возбуждается исключение TypeError.

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

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

Если это —

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

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

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

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

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

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

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

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

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

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

6.10.1. Сравнение значений

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

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

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

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

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

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

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

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

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

• None и NotImplemented — синглтоны. PEP 8 рекомендует всегда сравнивать синглтоны с помощью is или is not, а не операторов равенства.
• Бинарные последовательности (экземпляры bytes или bytearray) можно сравнивать как в пределах одного типа, так и между типами. Сравнение выполняется лексикографически с использованием числовых значений элементов.

• Строки (экземпляры str) сравниваются лексикографически с использованием числовых кодовых точек 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) равны тогда и только тогда, когда у них совпадают пары (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 (для полного порядка)

  Два последних выражения применимы к коллекциям с полным порядком (например, к последовательностям, но не к множествам и отображениям). См. также декоратор @~functools.total_ordering.

• Результат функции hash() должен быть согласован с равенством. Равные объекты должны иметь одинаковое хеш-значение либо быть помечены как нехешируемые.

Python не обеспечивает соблюдение этих правил согласованности. На самом деле значения «не число» служат примером нарушения этих правил.

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

Операторы in и not in проверяют принадлежность. Выражение x in s даёт значение True, если x является элементом s, и False в противном случае. x not in s возвращает логическое отрицание x in s. Все встроенные последовательности и типы множеств поддерживают эту операцию, как и словарь, для которого in проверяет, содержит ли словарь заданный ключ. Для контейнерных типов, таких как 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, если при переборе y выдаётся некоторое значение z, для которого выражение x is z or x == z истинно. Если во время перебора возникает исключение, это равносильно тому, что исключение возникло при выполнении in.

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

Оператор not in определён так, чтобы возвращать значение, обратное логическому значению in.

6.10.3. Проверка идентичности

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