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 перебирает элементы любой последовательности (списка или строки) в том порядке, в котором они встречаются. Например (без каламбура):

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

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

>>> for x in a[:]: # создать копию всего списка срезом
...    if len(x) > 6: a.insert(0, x)
...
>>> a
['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.

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

У циклов может быть предложение 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

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, complaint='Yes or no, please!'):
    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 IOError('refusenik user')
        print(complaint)

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)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')

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 ?
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

>>> def my_function():
...     """Ничего не делает, но документирует.
...
...     Нет, правда, он ничего не делает.
...     """
...     pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

    No, really, it doesn't do anything.

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

Сноски