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

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, встречающимся в других языках.

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

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

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

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

# 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, как и в 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 оператора 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. Определение функций

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

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

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

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

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

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.8. Интермедия: Стиль кодирования

Теперь, когда вы собираетесь писать более длинные и сложные фрагменты кода 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

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