[ Россум, Дрейк, Откидач ] Язык программирования Python

>>>f = fib

>>>f(100)

1 1 2 3 5 8 13 21 34 55 89

Вы можете возразить, что fib является процедурой, а не функцией. В языке Python, как и в C, процедура — всего лишь функция, которая не возвращает никакого значения. Строго говоря, процедуры все же возвращают значение, которое, скорее, не представляет большого интереса. Это значение — None (встроенное имя). Значение None обычно не выводится интерпретатором, но Вы можете его увидеть, если действительно хотите этого:

>>> print fib(0) None

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

>>> def fib2(n):

>>># чЩЪЩЧБЕН ФПМШЛП ЮФП ПРТЕДЕМЕООХА ЖХОЛГЙА

... f100 = fib2(100)

>>># чЩЧПДЙН ТЕЪХМШФБФ

... f100

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

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

Инструкция return выходит из функции и возвращает значение. Без аргументов return используется для выхода из середины процедуры (иначе выход происходит при достижении конца процедуры), в этом случае возвращается значение None.

Инструкция result.append(b) вызывает метод объекта-списка result. Метод — это функция, “принадлежащая” объекту, вызывается как obj.methodname, где obj — объект (или выражение его определяющее) и methodname — имя метода, определенного для данного типа объектов. Различные типы имеют различные наборы методов. Методы различных типов могут иметь одинаковые имена, не приводя к неопределенности. (Вы можете определить собственные типы объектов —

классы — и методы работы с ними.) Метод append(), используемый в примере, определен для объектов-списков. Он добавляет элемент в конец списка. В приведенном примере его использование эквивалентно записи ‘result = result + [b]’, но более эффективно.

4.7 Дополнительные возможности в определении функций

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

4.7.1Значения аргументов по умолчанию

Наиболее полезный способ — установить значения по умолчанию для одного или нескольких аргументов. Таким образом, получается функция, которую можно вызывать с меньшим количеством аргументов, чем в определении, например:

def ask_ok(prompt, retries=4,

complaint=’дБ ЙМЙ ОЕФ, РПЦБМХКУФБ!’): while 1:

ok = raw_input(prompt)

if ok in (’Ä’, ’ÄÁ’): return 1

if ok in (’Î’, ’ÎÅ’, ’ÎÅÔ’): return 0 retries = retries - 1

if retries < 0: raise IOError(

’рПМШЪПЧБФЕМШ ПФЛБЪЩЧБЕФУС ПФЧЕЮБФШ’) print complaint

Эта функция может быть вызвана так: ‘ask_ok(’чЩ ДЕКУФЧЙФЕМШОП ИПФЙФЕ ЧЩКФЙ?’)’, или так: ‘ask_ok(’рЕТЕЪБРЙУБФШ ЖБКМ?’, 2)’.

Значения по умолчанию вычисляются в месте определения функции в области видимости определения, так что

i = 5

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

f()

выведет 5.

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

допускающим изменения, таким как список или словарь. Например, следующая функция накапливает передаваемые аргументы (то есть переменная l является статической)3:

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

4.7.2Произвольный набор аргументов

Наконец, не так часто используемый вариант — определить функцию таким образом, чтобы ее можно было вызвать с произвольным числом аргументов. В этом случае аргументы будут переданы в виде кортежа4. Перед переменным числом аргументов может присутствовать произвольное число обычных аргументов:

def fprintf(file, format, *args): file.write(format % args)

4.7.3Именованные аргументы

Функция может быть вызвана с использованием именованных аргументов (keyword arguments) в виде ‘keyword = value’. Например, функция ask_ok() (раздел 4.7.1) может быть вызвана следующими способами:

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

4Кортеж — своего рода последовательность объектов, в которую Вы не можете вносить изменения.

ask_ok(’чЩ ДЕКУФЧЙФЕМШОП ИПФЙФЕ ЧЩКФЙ?’) ask_ok(retries = 2, prompt = ’рЕТЕЪБРЙУБФШ ЖБКМ?’) ask_ok(’рТПДПМЦЙН?’, complaint =

’б ФЕРЕТШ ФП ЦЕ УБНПЕ, ФПМШЛП РП-ТХУУЛЙ!’) ask_ok(’хДБМЙФШ ЧУЕ ЖБКМЩ ЙЪ ЛПТОЕЧПЗП ТБЪДЕМБ?’, 100,

’б НПЦЕФ ЧУЕ-ФБЛЙ ХДБМЙФШ?’)

Однако следующие вызовы ошибочны:

#ПФУХФУФЧХЕФ ПВСЪБФЕМШОЩК БТЗХНЕОФ ask_ok()

#ОЕЙНЕОПЧБООЩК БТЗХНЕОФ УМЕДХЕФ ЪБ ЙНЕОПЧБООЩН ask_ok(prompt = ’рЕТЕЪБРЙУБФШ ЖБКМ?’, 2)

#ДЧБ ЪОБЮЕОЙС ДМС ПДОПЗП БТЗХНЕОФБ

ask_ok(’рТПДПМЦЙН?’, prompt = ’дБ/ОЕФ’)

# ОЕЙЪЧЕУФОПЕ ЙНС БТЗХНЕОФБ ask_ok(actor = ’оЙЛХМЙО’)

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

>>>def function(a):

... pass

...

>>>function(0, a=0) Traceback (innermost last):

File "<stdin>", line 1, in ? TypeError: keyword parameter redefined

Если в определении функции присутствует формальный параметр в виде **name, то его значением становится словарь, содержащий все именованные аргументы, чьи имена не соответствуют формальным параметрам. Такой способ можно комбинировать с формой *name, позволяющей получить кортеж (tuple), содержащий позиционные аргументы, не входящие в список формальных параметров. (Запись **name должна следовать после записи *name.) Например, определим функцию:

def example(formal, *arguments, **keywords): print "лПМЙЮЕУФЧП РПМШЪПЧБФЕМЕК:", formal print ’-’*40

for arg in arguments: print arg print ’-’*40

for kw in keywords.keys(): print kw, ’:’, keywords[kw]

строкой. Первая строка часто используется интегрированными средами разработки (например, IDLE) в качестве подсказки при использовании объекта. Большинство встроенных объектов и объектов, определенных в стандартной библиотеке, снабжены строками документации — используйте их в качестве примеров оформления. Например:

>>> print map.__doc__

map(function, sequence[, sequence, ...]) -> list

Return a list of the results of applying the function to the items of the argument sequence(s). If more than one sequence is given, the function is called with an argument list consisting of the corresponding item of each sequence, substituting None for missing values when not all sequences have the same length. If the function is None, return a list of the items of the sequence (or a list of tuples if more than one sequence).

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

4.7.6Вызов функций

Помимо описанного (func(arg . . . )), язык Python предоставляет еще несколько способов вызова функций. Начиная с версии 1.6, Вы можете указать кортеж позиционных и словарь именованных аргументов, например:

args = (’ьФП ПЮЕОШ НОПЗП’,

’ьФП ДЕКУФЧЙФЕМШОП ПЮЕОШ НОПЗП’) kwds = {’language’: ’Python’,

’author’: ’Guido van Rossum’) example(1000000, *args, **kwds)

Такой же эффект можно получить используя встроенную функцию apply():

apply(example, (1000000,)+args, kwds)

С помощью средств функционального программирования Вы можете применить функцию к элементам последовательности (см. раздел 5.2).

47

Глава 5

Структуры данных

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

5.1Подробнее о списках

Ранее мы уже говорили, что метод append() позволяет добавить элемент в конец списка:

>>>a = [66.6, 333, 333, 1, 1234.5]

>>>a.append(333)

>>>a

[66.6, 333, 333, 1, 1234.5, 333]

Однако иногда необходимо вставить элемент в начало или другую позицию списка. Это позволяет сделать метод insert — Вы указываете индекс элемента, перед которым новый элемент будет добавлен:

>>> a.insert(2, -1)

[66.6, 333, -1, 333, 1, 1234.5, 333]

Кроме того, для списков определены методы, позволяющие анализировать его содержимое: найти, в каком положении находится (первый) элемент с определенным значением (метод index), или подсчитать количество таких элементов (метод count):

>>>a.index(333)

1

>>>print a.count(333), a.count(66.6), a.count(’x’) 3 1 0

Метод remove() позволяет удалить из списка (первый) элемент, имеющий заданное значение:

>>>a.remove(333)

>>>a

[66.6, -1, 333, 1, 1234.5, 333]

Элементы списка можно отсортировать (метод sort()) и изменить порядок следования элементов на противоположный (метод reverse()):

>>>a.sort() # УПТФЙТХЕН РП ЧПЪТБУФБОЙА

>>>a

[-1, 1, 66.6, 333, 333, 1234.5]

>>>a.reverse()

>>>a

[1234.5, 333, 333, 66.6, 1, -1]

Более подробно эти и другие операции над списками описаны в разделе 11.2.6. Приведем лишь несколько примеров, показывающих насколько широка область их применения.

5.1.1 Стеки

Методы, определенные для списков, позволяют использовать список в качестве стека, где последний добавленный элемент извлекается первым (LIFO, “last-in, first-out”). Для добавления элемента в стек, используйте метод append(), для извлечения элемента с вершины стека — метод pop() без явного указания индекса:

>>>stack = [3, 4, 5]

>>>stack.append(6)

>>>stack.append(7)

>>>stack

[3, 4, 5, 6, 7]

>>>stack.pop()

7

>>>stack

[3, 4, 5, 6]

>>>stack.pop()

6

>>>stack.pop()

5

>>>stack

[3, 4]

5.1.2Очереди

Еще одно применение списков — очереди, где элементы извлекаются в том же порядке, в котором они добавлялись (FIFO, “first-in, first-out”). Для добавления элемента в стек, используйте метод append(), для извлечения “очередного” элемента — метод pop() с индексом 0:

>>>queue.append("Graham") # Graham ДПВБЧМЕО Ч ПЮЕТЕДШ

>>>queue.pop(0)

’Eric’

>>>queue.pop(0)

’John’

>>>queue

[’Michael’, ’Terry’, ’Graham’]

5.2 Средства функционального программирования

Существуют три встроенные функции, которые могут быть полезны при работе с последовательностями: filter(), map(), zip() и reduce().

filter(function, sequence) возвращает последовательность (по возможности того же типа, что и sequence), состоящую из тех элементов последовательности sequence, для которых function(item) является истиной. Например, выделим простые числа из списка:

map(function, sequence [. . . ]) возвращает список значений, полученных применением функции function к элементам одной или нескольких последовательностей. Например, создадим список кубов натуральных чисел:

>>>def cube(x): return x*x*x

...

>>>map(cube, xrange(1, 11))

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

Функция function должна воспринимать столько аргументов, сколько последовательностей передается. Она вызывается с соответствующими элементами из каждой последовательности или None, если какая-нибудь последовательность оказалась короче других. Если function равно None, то используется функция, возвращающая свои аргументы.

Учитывая эти две особенности, мы видим, что ‘map(None, list1, list2)’ является удобным способом превращения пары списков в список пар:

>>>seq = xrange(8)

>>>def square(x): return x*x

...

>>>map(None, seq, map(square, seq))

[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

Таким образом Вы можете перебирать элементы одновременно несколько последовательностей одинаковой длины:

>>>seq1 = [’cat’, ’mouse’, ’bird’]

>>>seq2 = [’ЛПФ’, ’НЩЫШ’, ’РФЙГБ’]

>>>for x, y in map(None, seq1, seq2):

... print x, y

...

cat ЛПФ mouse НЩЫШ bird РФЙГБ

Как мы уже говорили, если какая-либо последовательность оказывается короче других, функция map() дополняет ее элементами, равными None. Такое поведение не всегда желательно. Поэтому в версии 2.0 была добавлена функция zip(). zip(sequence [. . . ]) возвращает список кортежей, каждый из которых состоит из соответствующих элементов аргументов-последовательностей. При этом длина полученной последовательности будет равна длине самой короткой последовательности среди аргументов. Например:

>>>a = (1, 2, 3, 4)

>>>b = (5, 6, 7, 8)

>>>c = (9, 10, 11)

>>>d = (12, 13)

>>>zip(a, b)

[(1, 5), (2, 6), (3, 7), (4, 8)]

>>>zip(a, d) [(1, 12), (2, 13)]

>>>zip(a, b, c, d)

[(1, 5, 9, 12), (2, 6, 10, 13)]

Если последовательности имеют одинаковую длину, поведение функции zip() полностью аналогично поведению map() с None в качестве первого аргумента. Кроме того, в этом случае действие функций zip() и map() обратимо:

>>>a = (1, 2, 3)

>>>b = (4, 5, 6)

>>>x = zip(a, b)

>>>y = zip(*x) # ÉÌÉ apply(zip, x)