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

6.2.1. Встроенные константы¶Built-in constants

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

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

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

Формально синтаксис встроенных констант:

builtin_constant: 'True' | 'False' | 'None' | '...'

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

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

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

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

Литерал – это текстовое представление значения. 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)   # не: print(greeting space name)
Hello Blaise

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

re.compile("[A-Za-z_]"       # буква или подчёркивание
           "[A-Za-z0-9_]*"   # буква, цифра или подчёркивание
          )

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

strings: (STRING | fstring)+ | tstring+

6.2.4. Группы в круглых скобках¶Parenthesized groups

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

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

>>> 3 << 2 | 4
12
>>> 3 << (2 | 4)   # Переопределяет приоритет оператора | (побитовое ИЛИ)
192
>>> (3 << 2) | 4   # То же, что и без скобок (но более понятно)
12

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

Формально синтаксис групп:

group: '(' assignment_expression ')'

6.2.5. Отображения контейнеров¶Container displays

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

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

>>> ["one", "two", "three"]
['one', 'two', 'three']
>>> [1 + 2, 2 + 3]
[3, 5]

В отображениях списка, кортежа и словаря (но не множества) последовательность может быть пустой:

>>> []  # пустой список
[]
>>> ()  # пустой кортеж
()
>>> {}  # пустой словарь
{}

Если последовательность не пуста, после элементов может стоять дополнительная запятая, которая ни на что не влияет:

>>> ["one", "two", "three",]  # обратите внимание на запятую после "three"
['one', 'two', 'three']

>>> [
...     'one',
...     'two',
...     'three',
... ]
['one', 'two', 'three']

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

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

>>> numbers = (1, 2)
>>> [*numbers, 'word', *numbers]
[1, 2, 'word', 1, 2]

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

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

>>> ["one", "two", "three"]
['one', 'two', 'three']
>>> ["one"]  # список из одного элемента
['one']
>>> []       # пустой список
[]

list: '[' [flexible_expression_list] ']'

>>> {"one", "two", "three"}
{'one', 'three', 'two'}
>>> {"one"}  # множество из одного элемента
{'one'}

set: '{' flexible_expression_list '}'

>>> (1, 2)
(1, 2)
>>> ()  # пустой кортеж
()

>>> ('single',)  # кортеж из одного элемента
('single',)
>>> ('single')   # без запятой: одна строка
'single'

tuple:
   | '(' flexible_expression (',' flexible_expression)+ [','] ')'
   | '(' flexible_expression ',' ')'
   | '(' ')'

>>> {1: 'one', 2: 'two'}
{1: 'one', 2: 'two'}

>>> {
...     1: 'this will be overridden',
...     2: 'two',
...     1: 'also overridden',
...     1: 'one',
... }
{1: 'one', 2: 'two'}

>>> defaults = {'color': 'blue', 'count': 8}
>>> overrides = {'color': 'yellow'}
>>> {**defaults, **overrides}
{'color': 'yellow', 'count': 8}

dict:                   '{' [double_starred_kvpairs] '}'
double_starred_kvpairs: ','.double_starred_kvpair+ [',']
double_starred_kvpair:  '**' or_expr | kvpair
kvpair:                 expression ':' expression

6.2.6. Включения¶Comprehensions

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

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

Например, список первых десяти квадратов:

>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

def make_list_of_squares(iterable):
    result = []
    for x in iterable:
        result.append(x**2)
    return result

make_list_of_squares(range(10))

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

>>> {x.lower() for x in ['a', 'A', 'b', 'C']}
{'c', 'a', 'b'}

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

def make_lowercase_set(iterable):
    result = set(iterable)
    for x in iterable:
        result.append(x.lower())
    return result

make_lowercase_set(['a', 'A', 'b', 'C'])

Включения словарей начинаются с разделённой двоеточием пары «ключ-значение» вместо выражения. Например:

>>> {func.__name__: func for func in [print, hex, any]}
{'print': <built-in function print>,
 'hex': <built-in function hex>,
 'any': <built-in function any>}

Во время выполнения это примерно соответствует:

def make_dict_mapping_names_to_functions(iterable):
    result = {}
    for func in iterable:
        result[func.__name__] = func
    return result

iterable([print, hex, any])

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

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

>>> tuple(x**2 for x in range(10))
(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

>>> [name for name in vars(math) if name.startswith('f')]
['fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum']

def get_math_f_names(iterable):
    result = []
    for name in iterable:
        if name.startswith('f'):
           result.append(name)
    return result

get_math_f_names(vars(math))

>>> import array
>>> import math
>>> [
...     name
...     for module in [array, math]
...     for name in vars(module)
...     if name.startswith('a')
... ]
['array', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh']

def get_a_names(iterable):
    result = []
    for module in iterable:
        for name in vars(module):
            if name.startswith('a'):
                result.append(name)
    return result

get_a_names([array, math])

>>> x = 'old value'
>>> [x**2 for x in range(10)]  # этот `x` является локальным для включения
>>> x
'old value'

>>> students = ['Petr', 'Blaise', 'Jarka']
>>> teachers = ['Salim', 'Bartosz']
>>> lists_of_people = [students, teachers]
>>> [*people for people in lists_of_people]
['Petr', 'Blaise', 'Jarka', 'Salim', 'Bartosz']

def flatten_names(lists_of_people):
    result = []
    for people in lists_of_people:
        result.extend(people)
    return result

>>> system_defaults = {'color': 'blue', 'count': 8}
>>> user_defaults = {'color': 'yellow'}
>>> overrides = {'count': 5}

>>> configuration_sets = [system_defaults, user_defaults, overrides]

>>> {**d for d in configuration_sets}
{'color': 'yellow', 'count': 5}

listcomp:      '[' comprehension ']'
setcomp:       '{' comprehension '}'
comprehension: flexible_expression for_if_clause+

dictcomp:
    | '{' kvpair for_if_clause+ '}'
    | '{' '**' expression for_if_clause+ '}'

for_if_clause:
    | ['async'] 'for' target_list 'in' or_test ('if' or_test)*

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

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

>>> 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 enclosing parentheses can be omitted in calls when the generator expression is the only positional argument and there are no keyword arguments. See the Calls section for details. For example:

# Круглые скобки после `sum` являются частью синтаксиса вызова:
>>> sum(x ** 2 for x in range(10))
285

# Генератор требует собственных круглых скобок, если он не единственный аргумент:
>>> sum((x ** 2 for x in range(10)), start=1000)
1285

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

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

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

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

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

generator_expression: "(" comprehension ")"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

attributeref: primary "." identifier

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

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

Если возбуждено AttributeError и у объекта есть метод __getattr__(), этот метод вызывается как запасной вариант.

6.3.2. Извлечение элементов и срезы¶Subscriptions and slicings

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

>>> digits_by_name = {'one': 1, 'two': 2}
>>> digits_by_name['two']  # Индексирование словаря по ключу 'two'
2

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

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

>>> colors = ['red', 'blue', 'green', 'black']
>>> colors[3]  # Индексирование списка по индексу 3
'black'

>>> list[str]  # Параметризация типа списка с помощью аргумента типа 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'  # Установка элемента по индексу
>>> colors
['red', 'blue', 'green', 'white']
>>> del colors[3]  # Удаление элемента по индексу 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']

# продолжение с экземпляром SubscriptionDemo, определённым выше:
>>> demo[2:3]
subscripted with: slice(2, 3, None)
>>> demo[::'spam']
subscripted with: slice(None, None, 'spam')

# продолжение с экземпляром SubscriptionDemo, определённым выше:
>>> 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',)

# продолжение с экземпляром SubscriptionDemo, определённым выше:
>>> 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. Вызовы¶Calls

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Если это–

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

6.15.1. Распаковка итерируемых объектов¶Iterable unpacking

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

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