Более сложные инструменты управления потоком

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(), ведет себя так, как будто это список, но на самом деле это не так. Это объект, который возвращает последующие элементы нужной последовательности при итерации, но не создаёт список, тем самым экономя память.

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

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

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

4.4. break и continue операторы и else блоки в циклах

Оператор break прерывает выполнение ближайшего вложенного цикла for или while.

Цикл for или while может содержать else блок.

В цикле for блок else выполняется после завершения последней итерации.

В цикле while он выполняется после того, как условие цикла станет ложным.

В обоих типах циклов блок else не выполняется, если цикл был прерван оператором break.

Это проиллюстрировано в следующем цикле for, который ищет простые числа:

>>> 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 оператора try выполняется, когда не происходит исключения, а блок 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:
    def __init__(self, x, y):
        self.x = x
        self.y = y

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")

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

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

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

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

class Point:
    __match_args__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

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. (Подробнее о docstring см. в разделе Строки документации.) Существуют инструменты, которые используют docstring для автоматического создания онлайн-или печатной документации или для интерактивного просмотра кода; хорошая практика включать 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 !

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

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