4. Другие инструменты управления потоком управления¶

4.1. if Заявления¶

Пожалуй, самым известным типом оператора является оператор if. Например:

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print('Negative changed to zero')
... elif x == 0:
...     print('Zero')
... elif x == 1:
...     print('Single')
... else:
...     print('More')
...
More

Может быть ноль или более частей elif, а часть else является необязательной. Ключевое слово „elif“ является сокращением от „else if“ и полезно для того, чтобы избежать чрезмерного отступа. Ключевое слово if … elif … <<<последовательность elif … является заменой утверждений switch или case, встречающихся в других языках.

Если вы сравниваете одно и то же значение с несколькими константами или проверяете наличие определенных типов или атрибутов, вам также может пригодиться оператор match. Для получения более подробной информации смотрите match Заявления.

4.2. for Заявления¶

Оператор for в Python несколько отличается от того, к которому вы привыкли в C или Pascal. Вместо того чтобы всегда выполнять итерацию по арифметической прогрессии чисел (как в Pascal) или давать пользователю возможность определить шаг итерации и условие остановки (как в C), оператор for в Python выполняет итерацию по элементам любой последовательности (списка или строки) в том порядке, в котором они появляются в последовательности. Например (без каламбура):

>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

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

# Create a sample collection
users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}

# Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

4.3. Функция range()¶

Если вам необходимо выполнить итерацию по последовательности чисел, вам пригодится встроенная функция range(). Она генерирует арифметические прогрессии:

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

Заданная конечная точка никогда не является частью генерируемой последовательности; range(10) генерирует 10 значений, законные индексы для элементов последовательности длины 10. Можно задать, чтобы диапазон начинался с другого числа, или указать другое приращение (даже отрицательное; иногда это называется «шагом»):

>>> list(range(5, 10))
[5, 6, 7, 8, 9]

>>> list(range(0, 10, 3))
[0, 3, 6, 9]

>>> list(range(-10, -100, -30))
[-10, -40, -70]

Для итерации по индексам последовательности можно комбинировать range() и len() следующим образом:

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

Однако в большинстве таких случаев удобно использовать функцию enumerate(), см. Техники петлеобразования.

Странная вещь происходит, если вы просто печатаете диапазон:

>>> range(10)
range(0, 10)

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

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

>>> sum(range(4))  # 0 + 1 + 2 + 3
6

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

4.4. break и continue утверждения, а также else клаузулы в циклах¶

Оператор break, как и в C, вырывается из самого внутреннего замкнутого цикла for или while.

В операторах цикла может быть оговорка else; она выполняется, когда цикл завершается из-за исчерпания итерабельной части (при for) или когда условие становится ложным (при while), но не когда цикл завершается оператором break. Примером может служить следующий цикл, который ищет простые числа:

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

(Да, это правильный код. Посмотрите внимательно: предложение else принадлежит циклу for, не оператору if).

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

Оператор continue, также заимствованный из языка C, продолжает следующую итерацию цикла:

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found an odd number", num)
...
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9

4.5. pass Заявления¶

Оператор pass ничего не делает. Его можно использовать, когда утверждение требуется синтаксически, но программа не требует никаких действий. Например:

>>> while True:
...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
...

Это обычно используется для создания минимальных классов:

>>> class MyEmptyClass:
...     pass
...

Еще одно место, где можно использовать pass - это место для функции или условного тела, когда вы работаете над новым кодом, что позволяет вам продолжать мыслить на более абстрактном уровне. Символ pass молча игнорируется:

>>> def initlog(*args):
...     pass   # Remember to implement this!
...

4.6. match Заявления¶

Оператор match берет выражение и сравнивает его значение с последовательными шаблонами, заданными в виде одного или нескольких блоков case. Внешне это похоже на оператор switch в C, Java или JavaScript (и многих других языках), но больше похоже на сопоставление шаблонов в таких языках, как Rust или Haskell. Выполняется только первый совпавший шаблон, и он также может извлекать компоненты (элементы последовательности или атрибуты объекта) из значения в переменные.

Простейшая форма сравнивает значение предмета с одним или несколькими литералами:

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

Обратите внимание на последний блок: «имя переменной» _ действует как волшебный знак и никогда не ошибается. Если ни один случай не совпадает, ни одна из ветвей не выполняется.

Вы можете объединить несколько литералов в один шаблон с помощью | («или»):

case 401 | 403 | 404:
    return "Not allowed"

Шаблоны могут выглядеть как задания распаковки, и могут использоваться для связывания переменных:

# point is an (x, y) tuple
match point:
    case (0, 0):
        print("Origin")
    case (0, y):
        print(f"Y={y}")
    case (x, 0):
        print(f"X={x}")
    case (x, y):
        print(f"X={x}, Y={y}")
    case _:
        raise ValueError("Not a point")

Изучите его внимательно! В первом шаблоне два литерала, и его можно рассматривать как расширение шаблона литералов, показанного выше. Но следующие два шаблона объединяют литерал и переменную, причем переменная связывает значение из субъекта (point). Четвертый паттерн фиксирует два значения, что делает его концептуально похожим на распаковывающее присваивание (x, y) = point.

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

class Point:
    x: int
    y: int

def where_is(point):
    match point:
        case Point(x=0, y=0):
            print("Origin")
        case Point(x=0, y=y):
            print(f"Y={y}")
        case Point(x=x, y=0):
            print(f"X={x}")
        case Point():
            print("Somewhere else")
        case _:
            print("Not a point")

Вы можете использовать позиционные параметры с некоторыми встроенными классами, которые обеспечивают упорядочивание своих атрибутов (например, классы данных). Вы также можете определить определенную позицию для атрибутов в шаблонах, установив специальный атрибут __match_args__ в ваших классах. Если он установлен в («x», «y»), то все следующие шаблоны эквивалентны (и все связывают атрибут y с переменной var):

Point(1, var)
Point(1, y=var)
Point(x=1, y=var)
Point(y=var, x=1)

Рекомендуемый способ чтения паттернов - рассматривать их как расширенную форму того, что вы поместите слева от присваивания, чтобы понять, какие переменные будут установлены на что. Только самостоятельные имена (как var выше) присваиваются оператором соответствия. Точечные имена (такие как foo.bar), имена атрибутов (такие как x= и y= выше) или имена классов (распознаваемые по «(…)» рядом с ними, как Point выше) никогда не присваиваются.

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

match points:
    case []:
        print("No points")
    case [Point(0, 0)]:
        print("The origin")
    case [Point(x, y)]:
        print(f"Single point {x}, {y}")
    case [Point(0, y1), Point(0, y2)]:
        print(f"Two on the Y axis at {y1}, {y2}")
    case _:
        print("Something else")

Мы можем добавить к шаблону условие if, известное как «охрана». Если предохранитель ложен, match переходит к попытке следующего блока case. Обратите внимание, что перехват значения происходит до того, как будет оценена защита:

match point:
    case Point(x, y) if x == y:
        print(f"Y=X at {x}")
    case Point(x, y):
        print(f"Not on the diagonal")

Несколько других ключевых особенностей этого заявления:

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

• Шаблоны последовательностей поддерживают расширенную распаковку: [x, y, *rest] и (x, y, *rest) работают аналогично распаковке назначений. Имя после * может быть также _, поэтому (x, y, *_) соответствует последовательности, состоящей как минимум из двух элементов, не связывая остальные элементы.

• Шаблоны отображения: {"bandwidth": b, "latency": l} захватывает значения "bandwidth" и "latency" из словаря. В отличие от шаблонов последовательности, дополнительные ключи игнорируются. Поддерживается также распаковка типа **rest. (Но **_ будет избыточной, поэтому она не допускается).

• Подшаблоны могут быть захвачены с помощью ключевого слова as:

  case (Point(x1, y1), Point(x2, y2) as p2): ...
  

  примет второй элемент входа как p2 (если вход представляет собой последовательность из двух точек).

• Большинство литералов сравниваются по равенству, однако синглтоны True, False и None сравниваются по тождеству.

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

  from enum import Enum
  class Color(Enum):
      RED = 'red'
      GREEN = 'green'
      BLUE = 'blue'
  
  color = Color(input("Enter your choice of 'red', 'blue' or 'green': "))
  
  match color:
      case Color.RED:
          print("I see red!")
      case Color.GREEN:
          print("Grass is green")
      case Color.BLUE:
          print("I'm feeling the blues :(")
  

Для более подробного объяснения и дополнительных примеров вы можете заглянуть в PEP 636, который написан в формате учебника.

4.7. Определение функций¶

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

>>> def fib(n):    # write Fibonacci series up to n
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

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

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

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

Фактические параметры (аргументы) вызова функции вносятся в локальную таблицу символов вызываемой функции при ее вызове; таким образом, аргументы передаются с помощью вызова по значению (где значение - это всегда объектная ссылка, а не значение объекта). 1 Когда функция вызывает другую функцию или рекурсивно вызывает саму себя, для этого вызова создается новая локальная таблица символов.

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

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

Придя из других языков, вы можете возразить, что fib - это не функция, а процедура, поскольку она не возвращает значение. На самом деле, даже функции без оператора return возвращают значение, хотя и довольно скучное. Это значение называется None (это встроенное имя). Запись значения None обычно подавляется интерпретатором, если это будет единственное записанное значение. Вы можете увидеть его, если очень хотите, используя print():

>>> fib(0)
>>> print(fib(0))
None

Очень просто написать функцию, которая возвращает список чисел ряда Фибоначчи, вместо того, чтобы выводить его на печать:

>>> def fib2(n):  # return Fibonacci series up to n
...     """Return a list containing the Fibonacci series up to n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # see below
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # call it
>>> f100                # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Этот пример, как обычно, демонстрирует некоторые новые возможности Python:

• Оператор return возвращает значение из функции. return без аргумента выражения возвращает None. Падение с конца функции также возвращает None.

• Оператор result.append(a) вызывает метод объекта списка result. Метод - это функция, которая «принадлежит» объекту и имеет имя obj.methodname, где obj - некоторый объект (это может быть выражение), а methodname - имя метода, который определяется типом объекта. Разные типы определяют разные методы. Методы разных типов могут иметь одинаковые имена, не вызывая двусмысленности. (Можно определить собственные типы объектов и методы, используя классы, см. Занятия). Метод append(), показанный в примере, определен для объектов списка; он добавляет новый элемент в конец списка. В данном примере он эквивалентен result = result + [a], но более эффективен.

4.8. Подробнее об определении функций¶

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

def ask_ok(prompt, retries=4, reminder='Please try again!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise ValueError('invalid user response')
        print(reminder)

i = 5

def f(arg=i):
    print(arg)

i = 6
f()

def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

[1]
[1, 2]
[1, 2, 3]

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.")
    print("-- Lovely plumage, the", type)
    print("-- It's", state, "!")

parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

parrot()                     # required argument missing
parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
parrot(110, voltage=220)     # duplicate value for the same argument
parrot(actor='John Cleese')  # unknown keyword argument

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for argument 'a'

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    for kw in keywords:
        print(kw, ":", keywords[kw])

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      -----------    ----------     ----------
        |             |                  |
        |        Positional or keyword   |
        |                                - Keyword only
         -- Positional only

>>> def standard_arg(arg):
...     print(arg)
...
>>> def pos_only_arg(arg, /):
...     print(arg)
...
>>> def kwd_only_arg(*, arg):
...     print(arg)
...
>>> def combined_example(pos_only, /, standard, *, kwd_only):
...     print(pos_only, standard, kwd_only)

>>> standard_arg(2)
2

>>> standard_arg(arg=2)
2

>>> pos_only_arg(1)
1

>>> pos_only_arg(arg=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pos_only_arg() got some positional-only arguments passed as keyword arguments: 'arg'

>>> kwd_only_arg(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: kwd_only_arg() takes 0 positional arguments but 1 was given

>>> kwd_only_arg(arg=3)
3

>>> combined_example(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: combined_example() takes 2 positional arguments but 3 were given

>>> combined_example(1, 2, kwd_only=3)
1 2 3

>>> combined_example(1, standard=2, kwd_only=3)
1 2 3

>>> combined_example(pos_only=1, standard=2, kwd_only=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: combined_example() got some positional-only arguments passed as keyword arguments: 'pos_only'

def foo(name, **kwds):
    return 'name' in kwds

>>> foo(1, **{'name': 2})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
>>>

def foo(name, /, **kwds):
    return 'name' in kwds
>>> foo(1, **{'name': 2})
True

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

>>> list(range(3, 6))            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # call with arguments unpacked from a list
[3, 4, 5]

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

    No, really, it doesn't do anything.

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

4.9. Интермеццо: Стиль кодирования¶

Теперь, когда вы собираетесь писать более длинные и сложные части Python, самое время поговорить о стиле кодирования. Большинство языков могут быть написаны (или, более кратко, форматированы) в разных стилях; некоторые из них более читабельны, чем другие. Сделать так, чтобы другим было легко читать ваш код, всегда хорошая идея, и принятие хорошего стиля кодирования очень помогает в этом.

Для Python, PEP 8 стал руководством по стилю, которого придерживается большинство проектов; он продвигает очень читабельный и приятный для глаз стиль кодирования. Каждый разработчик Python должен прочитать его в какой-то момент; вот наиболее важные моменты, извлеченные для вас:

• Используйте отступ в 4 интервала и никаких табуляций.

  4 пробела - это хороший компромисс между маленьким отступом (позволяет увеличить глубину вложенности) и большим отступом (легче читать). Табуляция вносит путаницу, поэтому ее лучше не использовать.

• Оберните строки так, чтобы они не превышали 79 символов.

  Это помогает пользователям с маленькими дисплеями и позволяет разместить несколько файлов кода рядом на больших дисплеях.

• Используйте пустые строки для разделения функций и классов, а также больших блоков кода внутри функций.

• Когда это возможно, размещайте комментарии на отдельной строке.

• Используйте докстринги.

• Используйте пробелы вокруг операторов и после запятых, но не непосредственно внутри конструкций со скобками: a = f(1, 2) + g(3, 4).

• Называйте свои классы и функции последовательно; принято использовать UpperCamelCase для классов и lowercase_with_underscores для функций и методов. Всегда используйте self в качестве имени первого аргумента метода (подробнее о классах и методах см. в Первый взгляд на классы).

• Не используйте причудливые кодировки, если ваш код предназначен для использования в международной среде. В любом случае лучше использовать кодировку Python по умолчанию, UTF-8 или даже обычный ASCII.

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

Сноски

1

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