4. Дополнительные инструменты управления потоком¶More Control Flow Tools

4.1. if Операторы¶if Statements

Пожалуй, наиболее известным типом оператора является оператор 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, встречающихся в других языках.

4.2. for Операторы¶for Statements

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

>>> # Измеряем некоторые строки:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

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

>>> for w in words[:]:  # Выполнить итерацию по копии среза всего списка.
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

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

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

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

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

range(5, 10)
   5 through 9

range(0, 10, 3)
   0, 3, 6, 9

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:

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

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

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

>>> list(range(5))
[0, 1, 2, 3, 4]

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

4.4. Операторы break и continue, а также предложения else в циклах¶break and continue Statements, and else Clauses on Loops

Оператор 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:
...         # цикл завершился без нахождения множителя
...         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: предложение else оператора 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 a number", num)
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9

4.5. Оператор pass¶pass Statements

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

>>> while True:
...     pass  # Активное ожидание прерывания с клавиатуры (Ctrl+C)
...

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

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

Ещё одно место, где можно использовать pass – в качестве заполнителя для тела функции или условного оператора при работе над новым кодом, позволяя сохранять более абстрактный уровень мышления. pass молча игнорируется:

>>> def initlog(*args):
...     pass   # Не забудьте реализовать это!
...

4.6. Определение функций¶Defining Functions

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

>>> def fib(n):    # вывести ряд Фибоначчи до n
...     """Вывести ряд Фибоначчи до n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # Теперь вызовите только что определённую функцию:
... 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), хотя на них можно ссылаться.

Фактические параметры (аргументы) вызова функции вносятся в локальную таблицу символов вызываемой функции при её вызове; таким образом, аргументы передаются с использованием передачи по значению (где значение всегда является ссылкой на объект, а не значением объекта). [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):  # возвращает ряд Фибоначчи до n
...     """Возвращает список, содержащий ряд Фибоначчи до n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # см. ниже
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # вызов
>>> f100                # вывод результата
[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.7. Подробнее об определении функций¶More on Defining Functions

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

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 позиционный аргумент
parrot(voltage=1000)                                  # 1 именованный аргумент
parrot(voltage=1000000, action='VOOOOOM')             # 2 именованных аргумента
parrot(action='VOOOOOM', voltage=1000000)             # 2 именованных аргумента
parrot('a million', 'bereft of life', 'jump')         # 3 позиционных аргумента
parrot('a thousand', state='pushing up the daisies')  # 1 позиционный, 1 именованный

parrot()                     # отсутствует обязательный аргумент
parrot(voltage=5.0, 'dead')  # неименованный аргумент после именованного
parrot(110, voltage=220)     # дублирование значения для одного и того же аргумента
parrot(actor='John Cleese')  # неизвестный именованный аргумент

>>> 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 keyword 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)
    keys = sorted(keywords.keys())
    for kw in keys:
        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.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

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))            # обычный вызов с отдельными аргументами
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # вызов с аргументами, распакованными из списка
[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():
...     """Ничего не делает, но документирует.
...
...     Нет, правда, он ничего не делает.
...     """
...     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.8. Интермеццо: стиль кодирования¶Intermezzo: Coding Style

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

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

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

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

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

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

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

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

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

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

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

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

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

Сноски