The Python Language Reference / Справочник по языку Python: 5. Expressions

Срез выделяет диапазон элементов в объекте-последовательности (например в строке, в кортеже) . Срезы могут использоваться и как выражения (дающие в результате значение) и как цель для назначения или инструкции «<code>del</code>» . Синтаксис следующий :

Hittih 21.06.11 в 03:40

<code>slicing      ::= primary "[" slice_list "]"
slice_list   ::= slice_item ("," slice_item)* [","]
slice_item   ::= expression | proper_slice
proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound  ::= expression
upper_bound  ::= expression
stride       ::= expression</code>

Hittih 22.04.11 в 12:52

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

Hittih 21.06.11 в 04:05

Смысл среза следующий. Значением выражения «<code>primary</code>» должен быть объект-отображение, у которого берётся элемент по индексу (с помощью обычного метода «<code>__getitem__()</code>» ) со значением индекса, вычисляемым из «<code>slice_list</code>» – как показано далее. Если «<code>slice_list</code>» содержит хотя-бы одну запятую, то ключом является кортеж срезов, иначе ключом является один срез. .........

Hittih 22.06.11 в 07:25

5.3.4. Вызовы

Hittih 22.06.11 в 07:26

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

Hittih 22.06.11 в 07:35

<code>call                 ::= primary "(" [argument_list [","] | comprehension] ")"
argument_list        ::= positional_arguments ["," keyword_arguments]
                           ["," "*" expression] ["," keyword_arguments]
                           ["," "**" expression]
                         | keyword_arguments ["," "*" expression]
                           ["," keyword_arguments] ["," "**" expression]
                         | "*" expression ["," keyword_arguments] ["," "**" expression]
                         | "**" expression
positional_arguments ::= expression ("," expression)*
keyword_arguments    ::= keyword_item ("," keyword_item)*
keyword_item         ::= identifier "=" expression</code>

Hittih 22.04.11 в 13:03

После позиционных и именованных аргументов может стоять конечная (лишняя) запятая – она не имеет никакого значения и на смысл не влияет.

Hittih 22.06.11 в 08:03

Значением «<code>primary</code>» должен быть вызываемый объект (определяемая пользователем или встроенная функция, метод встроенного объекта, объект-класс, метод экземпляра класса или любой объект с методом «<code>__call__()</code>» ) . Все выражения-аргументы вычисляются прежде, чем делается попытка вызова. Синтаксис списка “формальных” параметров в определении функции смотрите в разделе «Функции» .

Hittih 22.06.11 в 08:30

Если даны именованные аргументы, то они сначала преобразуются в позиционные следующим образом. Сначала для “формальных” параметров создаётся список незаполненных мест. Если дано N позиционных аргументов, то они помещаются в N первых из этих мест. Далее для каждого именованного аргумента определяется, каким по счёту он идёт в формальных параметрах определения функции – и в такое же по счёту место помещается его значение (даже если это значение «<code>None</code>» ) . Если это место оказывается уже́ занятым, то вызывается исключение «<code>TypeError</code>» . Когда все аргументы обработаны – места, оставшиеся необработанными заполняются соответствующими значениями по-умолчанию из определения функции. (Значения по-умолчанию вычисляются один раз – когда выполняется определение функции – таким образом, изменяемый объект, например список или словарь, использованный как значение по-умолчанию, будет сохраняться между вызовами функции, и его предыдущее значение будет доступно, если в него не будет передано значение в соответствующем аргументе при вызове. ) Если останутся незаполненными места, для которых нет значений по-умолчанию, то вызывается исключение «<code>TypeError</code>» . Заполненный таким образом список используется как список аргументов функции.

Hittih 23.06.11 в 10:37

Особенности реализации “CPython” : В какой-либо реализации могут быть встроенные функции, чьи позиционные параметры не имеют имён (несмотря на то, что в ихней документации для удобства используются некие “имена” ) и, таким образом, эти параметры не могут быть переданы как именованные аргументы. Как пример – функции, реализованные на “C” с использованием «<code>PyArg_ParseTuple()</code>» для разбора аргументов .

Hittih 23.06.11 в 11:28

Если дано больше аргументов, чем параметров в определении, то вызывается исключение «<code>TypeError</code>» , если только в определении не присутствует параметр с синтаксисом с «<code>*</code>» – в этом случае этот параметр получает кортеж, содержащий лишние аргументы (или пустой кортеж, если нет таковых) .

Hittih 23.06.11 в 11:46

Если какой-либо именованный аргумент не соответствует имени параметра в определении, то вызывается исключение «<code>TypeError</code>» , если только в определении не присутствует параметр с синтаксисом с «<code>**</code>» – в этом случае этот параметр получает словарь (или пустой словарь, если нет лишних), содержащий лишние именованные аргументы, чьи имена становятся ключами – и они получают соответствующие значения.

Hittih 24.06.11 в 15:47

Если в вызове функции встречается синтаксис «<code>*expression</code>» , то значением «<code>expression</code>» должна быть последовательность. Элементы из этой последовательности извлекаются и воспринимаются как дополнительные позиционные аргументы – тоесть, если в вызове даны позиционные аргументы x1,..., xN и «<code>expression</code>» даёт элементы y1, ..., yM , то это эквивалентно вызову с M+N штуками аргументов x1, ..., xN, y1, ..., yM .

Hittih 25.06.11 в 04:32

Следствием из этого является то, что, хотя «<code>*expression</code>» может идти после некоторых именованных аргументов, «<code>*expression</code>» обрабатывается раньше них (и раньше аргумента «<code>**expression</code>» ) . Таким образом :

Hittih 25.06.11 в 04:43

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

Hittih 22.04.11 в 13:14

-

Hittih 22.04.11 в 13:36

-

Hittih 22.04.11 в 13:37

Использование в вызове одновременно именованных аргументов и синтаксиса «<code>*expression</code>» является редким – только поэтому на практике редко возникают и соответствующие недоразумения.

Hittih 25.06.11 в 04:54

Если в вызове функции встречается синтаксис «<code>**expression</code>» , то значением «<code>expression</code>» должно быть отображение (словарь) . Элементы из этого отображения извлекаются и воспринимаются как дополнительные именованные аргументы. Если некий ключ (имя) присутствует и в «<code>expression</code>» и как явный именованный аргумент, то вызывается исключение «<code>TypeError</code>» .

Hittih 25.06.11 в 05:14

Параметры в определении, использующие синтаксис «<code>*identifier</code>» или «<code>**identifier</code>» , не могут быть использованы как позиционные получатели (места́) или как имена именованных аргументов.

Hittih 25.06.11 в 06:53

Вызов всегда возвращает какое-либо значение (в частности «<code>None</code>» ) – если только этот вызов не привёл к исключению. То, каким способом это значение вычисляется – зависит от типа вызываемого объекта.

Hittih 20.06.11 в 07:38

-

Hittih 20.06.11 в 07:47

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

Hittih 20.06.11 в 07:41

Функции передаётся список аргументов, и её блок кода исполняется. Первое, что происходит в блоке кода – это связывание имён “формальных” параметров с предоставленными аргументами (подробнее в разделе «Определение функций» ) . Если в блоке кода исполняется инструкция «<code>return</code>» , то она задаёт возвращаемое функцией значение – иначе, по-умолчанию, – возвращается «<code>None</code>» .

Hittih 20.06.11 в 08:44

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

Hittih 20.06.11 в 07:42

Результат зависит от интерпретатора. Смотрите “Встроенные функции” .

Hittih 20.06.11 в 08:48

Если это объект-класс :

Hittih 20.06.11 в 07:43

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

Hittih 20.06.11 в 08:49

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

Hittih 20.06.11 в 07:45

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

Hittih 20.06.11 в 08:57

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

Hittih 20.06.11 в 07:46

В классе должен быть определён метод «<code>__call__()</code>» (одноимённый метод определённый в самом экземпляре – игнорируется при простом вызове экземпляра ) , в остальном – аналогично вызову метода экземпляра класса.

Hittih 20.06.11 в 09:35

5.4. Оператор возведения в степень

Hittih 20.06.11 в 09:37

Оператор степени имеет бо́льший приоритет, чем однооперандные операторы непосредственно слева, но меньший, чем однооперандные операторы непосредственно справа. Его синтаксис :

Hittih 20.06.11 в 09:43

<code>power ::= primary ["**" u_expr]</code>

Hittih 20.06.11 в 07:20

Таким образом в последовательности без кавычек из степени и однооперандных операторов вычисление выполняется с права налево (это не влияет на порядок действий вутри выражений операндов) : «<code>-1**2</code>» даёт результат «<code>-1</code>» .

Hittih 25.06.11 в 07:15

Оператор степени имеет тот же смысл, что и встроенная функция «<code>pow()</code>» – если вызывается с двумя аргументами : левый аргумент возводится в степень правого. Числовые аргументы сначала преобразуются к общему типу, и результат будет этого же типа.

Hittih 25.06.11 в 07:29

Для целочисленных операндов результат тоже будет целым, если только второй операнд не негативный – в таком случае все аргументы преобразуются в дробные, и результат тоже будет дробный. Например : «<code>10**2</code>» даёт «<code>100</code>» , но «<code>10**-2</code>» даёт «<code>0.01</code>» .

Hittih 25.06.11 в 07:40

Возведение «<code>0.0</code>» в негативную степень вызывает исключение «<code>ZeroDivisionError</code>» . Возведение негативного числа в дробную степень даёт комплексное число (в прошлых версиях вызывалось исключение «<code>ValueError</code>» ) .

Hittih 25.06.11 в 07:46

5.5. Однооперандные арифметические и побитовые операци

Hittih 25.06.11 в 07:52

Все однооперандные арифметические и побитовые операци имеют одинаковый приоритет :

Hittih 25.06.11 в 07:54

<code>u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr</code>

Hittih 20.06.11 в 07:16

«-» (минус) негативирует (умножает на «-1» ) свой числовой аргумент.

Hittih 25.06.11 в 07:58

«+» (плюс) не изменяет свой числовой аргумент.

Hittih 25.06.11 в 07:59

Оператор «~» побитово инвертирует свой целочисленный аргумент, и для аргумента «x» определяется как «-(x+1)» .

Hittih 25.06.11 в 08:08

Во всех трёх случаях – если аргумент не требуемого типа, то вызывается исключение «<code>TypeError</code>» .

Hittih 25.06.11 в 08:12

5.6. Двухоперандные арифметические операции

Hittih 25.06.11 в 08:13

У двухоперандных арифметических операций уровни приоритета соответствуют общепринятым. Заметьте, что некоторые из них также применяются для нечисловых типов. Кроме операции степени – среди них есть только два уровня приоритета : выше – для произведения и деления (одинаковый) , и ниже – для суммы и вычитания (одинаковый) .

Hittih 25.06.11 в 10:18

<code>m_expr ::= u_expr | m_expr "*" u_expr | m_expr "//" u_expr | m_expr "/" u_expr
            | m_expr "%" u_expr
a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr</code>

Hittih 20.06.11 в 07:12