8. Составные операторы

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

if, while и for инструкции осуществляют традиционные конструкции потока контроля. try определяет укладчиков исключения и/или очистку код для группы заявлений, в то время как with оператор позволяет выполнение инициализации и завершения код вокруг блока код. Функция и определения класс - также синтаксически составной инструкция.

Составной оператор состоит из одного или нескольких „пунктов“. Пункт состоит из заголовка и „номера серия“. Заголовки пункта особого составного оператор - все на том же уровне углубления. Каждый заголовок пункта начинается с однозначного определения ключевой и заканчивается двоеточием. Номер серия - группа операторы, которыми управляет пункт. Номер серия может быть одним или несколькими отделенными от точки с запятой простыми операторы на той же линии как заголовок, после двоеточия заголовка, или это может быть, один или несколько заказал операторы на последующих линиях. Только последняя форма номера серия может содержать вложенные составные операторы; следующее незаконно, главным образом потому что это не было бы ясно, которому пункту if будет принадлежать следующий пункт else:

if test1: if test2: print(x)

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

if x < y < z: print(x); print(y); print(z)

Суммируя:

compound_stmt ::=  if_stmt
                   | while_stmt
                   | for_stmt
                   | try_stmt
                   | with_stmt
                   | funcdef
                   | classdef
                   | async_with_stmt
                   | async_for_stmt
                   | async_funcdef
suite         ::=  stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
statement     ::=  stmt_list NEWLINE | compound_stmt
stmt_list     ::=  simple_stmt (";" simple_stmt)* [";"]

Обратите внимание, что инструкции всегда заканчивается на NEWLINE, за которым может следовать DEDENT. Также обратите внимание, что дополнительные пункты продолжения всегда начинаются с ключевой, который не может начать Оператор, таким образом нет никаких двусмысленностей („свисание, else“ проблема решен в Python, требуя, чтобы вложенный if операторы был заказан).

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

8.1. Оператор if

if оператор - используемый для условного исполнения:

if_stmt ::=  "if" assignment_expression ":" suite
             ("elif" assignment_expression ":" suite)*
             ["else" ":" suite]

Он выбирает только один из наборов, вычисляя выражения один за другим до тех пор, пока один из них не будет найден истинным (определение истинного и ложного см. в разделе Логические операции); тогда тот номер серия выполнен (и никакая другая часть if оператор не выполнена или оценена). Если все выражения имеют значение false, выполняется набор предложения else, если он присутствует.

8.2. Оператор while

while оператор - используемый для повторного выполнения, пока выражение - true:

while_stmt ::=  "while" assignment_expression ":" suite
                ["else" ":" suite]

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

break оператор, выполненный в первом номере серия, заканчивает петлю, не выполняя номер серия пункта else. continue оператор, выполненный в первом номере серия, пропускает остальную часть номера серия и возвращается к тестированию выражения.

8.3. Оператор for

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

for_stmt ::=  "for" target_list "in" expression_list ":" suite
              ["else" ":" suite]

Список выражений вычисляется один раз; он должен давать итабельный объект. Для результата expression_list создается итератор. Затем набор выполняется один раз для каждого элемента, предоставленного итератором, в порядке, возвращенном итератором. Каждый элемент в свою очередь присваивается целевому списку с использованием стандартных правил присвоения (см. Инструкции присваивания), и затем выполняется набор. Когда элементы исчерпаны (что происходит сразу же, когда последовательность пуста или итератор вызывает исключение StopIteration), выполняется набор в предложении else, если он присутствует, и цикл завершается.

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

Для цикла делает назначения на переменные в целевом списке. Это переписывает все предыдущие назначения на те переменные включая сделанных в номере серия для цикла:

for i in range(10):
    print(i)
    i = 5             # this will not affect the for-loop
                      # because i will be overwritten with the next
                      # index in the range

Имена в целевом списке не удаляются после завершения цикла, но если последовательность пуста, они не будут назначены циклом. Подсказка: встроенная функция range() возвращает итератор целых чисел, пригодный для эмуляции эффекта for i := a to b do паскаля; например, list(range(3)) возвращает список [0, 1, 2].

Примечание

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

for x in a[:]:
    if x < 0: a.remove(x)

8.4. Оператор try

В try оператор указаны обработчики исключений и/или код очистки для группы операторов:

try_stmt  ::=  try1_stmt | try2_stmt
try1_stmt ::=  "try" ":" suite
               ("except" [expression ["as" identifier]] ":" suite)+
               ["else" ":" suite]
               ["finally" ":" suite]
try2_stmt ::=  "try" ":" suite
               "finally" ":" suite

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

Если не кроме пункта соответствует исключению, поиск обработчика исключения продолжает в окружении код и на стопке просьбы. [1]

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

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

Если исключение было назначено с помощью as target, оно очищается в конце предложения except. Это как будто:

except E as N:
    foo

был переведен к:

except E as N:
    try:
        foo
    finally:
        del N

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

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

Дополнительный пункт else подписан, если поток контроля покидает try suite, никакое исключение не было поднято, и не return, continue, или break оператор был выполнен. Исключения в предложении else не обрабатываются предыдущими предложениями except.

Если finally присутствует, он определяет обработчика „очистки“. Пункт try подписан, включая любой except и пункты else. Если исключение происходит в каком-либо из пунктов и не обработано, исключение временно спасено. Пункт finally подписан. Если есть спасенное исключение, оно повторно поднято в конце пункта finally. Если пункт finally поднимает другое исключение, спасенное исключение установлено как контекст нового исключения. Если пункт finally выполняет return, break или Оператор continue, от спасенного исключения отказываются:

>>> def f():
...     try:
...         1/0
...     finally:
...         return 42
...
>>> f()
42

Информация об исключении не доступна программе во время подписания пункта finally.

Когда return, break или continue оператор выполняется в наборе try инструкции tryfinally, предложение finally также выполняется на выходе

Возвращаемое значение функции определено последним выполненным return оператор. Так как предложение finally всегда выполняется, предложение return оператор, выполненное в предложении finally, всегда будет последним выполненным:

>>> def foo():
...     try:
...         return 'try'
...     finally:
...         return 'finally'
...
>>> foo()
'finally'

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

Изменено в версии 3.8: До Python 3.8 continue оператор был незаконным в пункте finally из-за проблемы с реализацией.

8.5. Оператор with

with оператор - используемый, чтобы обернуть выполнение блока с методы, определенным менеджером контекст (см. раздел Оператор with контекстных менеджеров). Это позволяет инкапсулировать общие шаблоны использования H67651628 …:keyword:exceptfinally для удобного повторного использования.

with_stmt ::=  "with" with_item ("," with_item)* ":" suite
with_item ::=  expression ["as" target]

Выполнение with оператор с одним «товаром» происходит следующим образом

  1. Выражение контекст (выражение, приведенное в with_item) вычисляется для получения менеджера контекст.

  2. __enter__() менеджера контекст загружен для более позднего использования.

  3. __exit__() менеджера контекст загружен для более позднего использования.

  4. __enter__() метод менеджера контекст призван.

  5. Если целевой объект был включен в инструкцию with, ему присваивается возвращаемое значение из __enter__().

    Примечание

    with оператор гарантирует, что если __enter__() метод возвращается без ошибки, то __exit__() всегда будет вызываться. Таким образом, если ошибка возникает во время назначения целевому списку, она будет обрабатываться так же, как и ошибка, возникающая в наборе. См. шаг 6 ниже.

  6. Серия выполнена.

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

    Если из номера серия вышли из-за исключения, и возвращаемое значение от __exit__() метод было ложным, исключение повторно поднято. Если возвращаемое значение было верно, исключение подавлено, и выполнение продолжает оператор после with оператор.

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

Следующий код:

with EXPRESSION as TARGET:
    SUITE

семантически эквивалентно:

manager = (EXPRESSION)
enter = type(manager).__enter__
exit = type(manager).__exit__
value = enter(manager)
hit_except = False

try:
    TARGET = value
    SUITE
except:
    hit_except = True
    if not exit(manager, *sys.exc_info()):
        raise
finally:
    if not hit_except:
        exit(manager, None, None, None)

Больше чем с одним предметом обработаны менеджеры контекст, как будто несколько with операторы были вложены:

with A() as a, B() as b:
    SUITE

семантически эквивалентно:

with A() as a:
    with B() as b:
        SUITE

Изменено в версии 3.1: Поддержка нескольких выражений контекст.

См.также

PEP 343 - «с» оператор спецификация, фон и примеры для Python with оператор.

8.6. Определения функции

Определение функции определяет определяемый пользователем объект функции (см. раздел Стандартная иерархия типов):

funcdef                   ::=  [decorators] "def" funcname "(" [parameter_list] ")"
                               ["->" expression] ":" suite
decorators                ::=  decorator+
decorator                 ::=  "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE
dotted_name               ::=  identifier ("." identifier)*
parameter_list            ::=  defparameter ("," defparameter)* "," "/" ["," [parameter_list_no_posonly]]
                                 | parameter_list_no_posonly
parameter_list_no_posonly ::=  defparameter ("," defparameter)* ["," [parameter_list_starargs]]
                               | parameter_list_starargs
parameter_list_starargs   ::=  "*" [parameter] ("," defparameter)* ["," ["**" parameter [","]]]
                               | "**" parameter [","]
parameter                 ::=  identifier [":" expression]
defparameter              ::=  parameter ["=" expression]
funcname                  ::=  identifier

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

Определение функции не выполняет тело функции; это выполнено только, когда функция вызвана. [2]

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

@f1(arg)
@f2
def func(): pass

примерно эквивалентно:

def func(): pass
func = f1(arg)(f2(func))

за исключением того, что исходная функция временно не связана с именем func.

Когда один или несколько параметров имеют форму параметр = выражение, говорят, что функция имеет «значения параметров по умолчанию». Для параметра со значением по умолчанию соответствующий аргумент может быть опущен от требования, в этом случае значением по умолчанию параметра заменяют. Если параметр имеет значение по умолчанию, все последующие параметры вплоть до «*» также должны иметь значение по умолчанию — это синтаксическое ограничение, которое не выражается грамматикой.

Значения параметров по умолчанию оцениваются слева направо при выполнении определения функции. это означает, что выражение вычисляется один раз, когда его функция определена, и что одно и то же «предварительно вычисленное» значение является используемый для каждого из всех. Это особенно важно для понимания, когда параметр по умолчанию является объектом utable, таким как список или словарь: если функция изменяет объект (например, добавляя элемент в список), значение по умолчанию фактически изменяется. Это, как правило, не то, что предполагалось. Способ - использовать «Нет» в качестве значения по умолчанию и явно проверить его в теле функции, например:

def whats_on_the_telly(penguin=None):
    if penguin is None:
        penguin = []
    penguin.append("property of the zoo")
    return penguin

Семантика вызова функции более подробно описана в разделе Вызовы. Вызов функции всегда назначает значения всем параметрам, упомянутым в списке параметров, либо из аргументов позиции, либо из аргументов ключевой, либо из значений по умолчанию. Если форма «*identifier» присутствует, она инициализируется для кортежа, принимающего любые избыточные позиционные параметры, по умолчанию задавая пустой кортеж. Если форма «**identifier» присутствует, она инициализируется для нового упорядоченного сопоставления, получающего любые избыточные аргументы ключевой, по умолчанию устанавливая новое пустое сопоставление того же типа. Параметры после «*» или «*identifier» - параметры только для ключевого слова и могут только быть переданными аргументами используемый ключевой.

У параметров может быть аннотации формы «: expression» после названия параметра. Любой параметр может иметь аннотацию, даже в форме *identifier или **identifier. Функции могут иметь аннотацию «return» формы «-> expression» после списка параметров. Эти аннотации могут быть любым допустимым выражением Python. Наличие аннотаций не меняет семантику функции. Значения аннотаций доступны как значения словаря, задаваемые именами параметров в атрибуте __annotations__ объекта функции. Если используется импорт annotations из __future__, аннотации сохраняются как строки во время выполнения, что позволяет отложить анализ. В противном случае они вычисляются при выполнении определения функции. В этом случае аннотации могут вычисляться в порядке, отличном от того, в котором они отображаются в исходном код.

Также можно создавать анонимные функции (функции, не связанные с именем) для немедленного использования в выражениях. При этом используются лямбда-выражения, описанные в разделе Лямбды. Заметим, что лямбда-выражение является просто кратким для упрощенного определения функции; функция, определенная в «def» оператор, может передаваться или назначаться другому имени так же, как функция, определенная лямбда-выражением. Форма «def» на самом деле более мощна, так как позволяет выполнять несколько операторы и аннотаций.

Примечание программиста: функции являются первый-класс объектами. «def» оператор xecuted в определении функции определяет функцию локальная, которая может быть eturned или розданный. Свободные переменные используемый во вложенной функции могут получить доступ к переменным локальная функции, содержащей значение def. См. раздел Именование и биндинги.

См.также

PEP 3107 - аннотации к функциям исходная спецификация для аннотаций к функциям.

PEP 484 - подсказки типа определение стандартного значения для аннотаций: подсказки типа.

PEP 526 - синтаксис для аннотаций к переменным возможность ввода объявлений подсказок к переменным, включая переменные класс и переменные сущность

PEP 563 - отложенная оценка аннотаций поддержка прямых ссылок в аннотациях путем сохранения аннотаций в строка форме во время выполнения, а не жаждущей оценки.

8.7. Определения класса

Определение класс определяет объект класс (см. раздел Стандартная иерархия типов):

classdef    ::=  [decorators] "class" classname [inheritance] ":" suite
inheritance ::=  "(" [argument_list] ")"
classname   ::=  identifier

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

class Foo:
    pass

эквивалентно:

class Foo(object):
    pass

Номер серия класса тогда выполнен в новой структуре выполнения (см. Именование и биндинги), используя недавно созданное пространство имен локальная и оригинальное глобальное пространство имен. (Обычно, номер серия содержит главным образом определения функции.), когда выполнение концов номера серия класса, от его структуры выполнения отказываются, но его пространство имен локальная спасено. [#] _ объект класс тогда создан, используя список наследования для основного классы и спасенное пространство имен локальная для словаря признака. Имя класс связано с этим объектом класс в оригинальном пространстве имен локальная.

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

Создание класса может быть сильно настроено с помощью метаклассы.

Занятия тоже можно оформить: так же, как при оформлении функций,:

@f1(arg)
@f2
class Foo: pass

примерно эквивалентно:

class Foo: pass
Foo = f1(arg)(f2(Foo))

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

Примечание программиста: переменные, определенные в определении класс, являются класс ttributes; их разделяют сущности. Атрибуты экземпляра можно задать в методе с помощью self.name = value. Атрибуты класс и сущность доступны через нотацию «self.name,», а атрибут сущность скрывает атрибут класс с одинаковым именем при обращении таким образом. Дань класса может быть используемый как дефолтами для признаков сущность, но использование изменчивых галерей там может привести к неожиданным результатам. Дескрипторы быть используемый для создания переменных сущность с различными деталями реализации.

См.также

PEP 3115 - метаклассы в Python 3000 предложение, которое изменило декларацию метаклассов к текущему синтаксису и семантику для того, как построены классы с метаклассами.

PEP 3129 - декораторы класса предложение, которое добавило декораторов класс. Функция и декораторы метод были представлены в PEP 318.

8.8. Корутины

Добавлено в версии 3.5.

8.8.1. Определение функции корутины

async_funcdef ::=  [decorators] "async" "def" funcname "(" [parameter_list] ")"
                   ["->" expression] ":" suite

Выполнение сопрограмм Python может быть приостановлено и возобновлено во многих точках (см. корутина). Внутри тела функции корутины идентификаторы await и async становятся зарезервированными ключевыми словами; выражения await, async for и async with могут только быть используемый в телах функции корутины.

Функции, определенные с синтаксисом async def, всегда являются функциями корутины, даже если они не содержат await или ключевые слова async.

Это SyntaxError использовать выражение yield from внутри тела функции корутины.

Пример функции корутины:

async def func(param1, param2):
    do_stuff()
    await some_coroutine()

8.8.2. Оператор async for

async_for_stmt ::=  "async" for_stmt

Асинхронный итерабельный в состоянии вызвать асинхронный код в своем внедрении iter, и асинхронный итератор может назвать асинхронный код в своем next метод.

async for оператор позволяет удобное повторение по асинхронному итераторы.

Следующий код:

async for TARGET in ITER:
    SUITE
else:
    SUITE2

Семантически эквивалентен:

iter = (ITER)
iter = type(iter).__aiter__(iter)
running = True

while running:
    try:
        TARGET = await type(iter).__anext__(iter)
    except StopAsyncIteration:
        running = False
    else:
        SUITE
else:
    SUITE2

Более подробную информацию см. также в разделах __aiter__() и __anext__().

Это SyntaxError использовать async for оператор вне тела функции корутины.

8.8.3. Оператор async with

async_with_stmt ::=  "async" with_stmt

асинхронный контекстный менеджер - это контекстный менеджер, который может приостановить выполнение в своих enter и exit методов.

Следующий код:

async with EXPRESSION as TARGET:
    SUITE

семантически эквивалентно:

manager = (EXPRESSION)
aexit = type(manager).__aexit__
aenter = type(manager).__aenter__
value = await aenter(manager)
hit_except = False

try:
    TARGET = value
    SUITE
except:
    hit_except = True
    if not await aexit(manager, *sys.exc_info()):
        raise
finally:
    if not hit_except:
        await aexit(manager, None, None, None)

Более подробную информацию см. также в разделах __aenter__() и __aexit__().

Это SyntaxError использовать async with оператор вне тела функции корутины.

См.также

PEP 492 - корутины с async и синтаксисом await предложение, которое сделало корутины надлежащим автономным понятием в пайтоне и добавило синтаксис поддержки.

Сноски

[1]Исключение распространяется в стек вызовов, если только существует предложение finally, которое вызывает другое исключение. Это новое исключение приводит к потере старого.
[2]Строковый литерал, появляющийся в качестве первого оператора в теле функции преобразованный в признак __doc__ функции и поэтому докстринг функции.
[3]Строковый литерал, появляющийся в качестве первого оператора в теле класса преобразованный в предмет пространства имен __doc__ и поэтому класс докстринг.