Также есть возможность определять функции с переменным количеством параметров. Для этого существует три формы, которые также можно использовать совместно. Значения аргументов по умолчанию Наиболее полезной формой является задание значений по умолчанию для одного или более параметров. Таким образом создаётся функция, которая может быть вызвана с меньшим количеством параметров, чем в её определении: при этом неуказанные при вызове параметры примут данные в определении функции значения. Например: 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) Эта функция может быть вызвана, например, так: ask_ok('Do you really want to quit?') или так: ask_ok('OK to overwrite the file?', 2). Этот пример также знакомит вас с зарезервированным словом in. Посредством его можно проверить, содержит ли последовательность определённое значение или нет. Значения по умолчанию вычисляются в месте определения функции, в определяющей области, поэтому код i = 5 def f(arg=i): print(arg) i = 6 f() выведет 5. Важное предупреждение: Значение по умолчанию вычисляется лишь единожды. Это особенно важно помнить, когда значением по умолчанию является изменяемый объект, такой как список, словарь (dictionary) или экземпляры большинства классов. Например, следующая функция накапливает переданные ей параметры: 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 Именованные параметры Функции также могут быть вызваны с использованием именованных параметров (keyword arguments) в форме "имя = значение". Например, нижеприведённая функция: 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') # неизвестное имя параметра В общем случае, список параметров должен содержать любое количество позиционных (positional) параметров, за которыми может следовать любое количество именованных, и при этом имена аргументов выбираются из формальных параметров. Неважно, имеет формальный параметр значение по умолчанию или нет. Ни один из аргументов не может получать значение более чем один раз - имена формальных параметров, совпадающие с именами позиционных параметров, не могут использоваться в качестве именующих в одном и том же вызове. Вот пример, завершающийся неудачей по причине описанного ограничения: >>> def function(a): ... pass ... >>> function(0, a=0) Traceback (most recent call last): File "", line 1, in ? TypeError: function() got multiple values for keyword argument 'a' Если в определении функции присутствует завершающий параметр в виде **имя, он получит в качестве значения словарь (подробнее в разделе Справочника - Типы-отображения - словари), содержащий все именованные параметры и их значения, исключая те, которые соответствуют формальным параметрам. Можно совместить эту особенность с поддержкой формального параметра в формате *имя (описывается в следующем подразделе), который получает кортеж (tuple), содержащий все позиционные параметры, следующие за списком формальных параметров. (параметр в формате *имя должен описываться перед параметром в формате **имя.) Например, если мы определим такую функцию: 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.", client="John Cleese", shopkeeper="Michael Palin", 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 Обратите внимание, что список имён (ключей) именованных параметров (keys) создается посредством сортировки содержимого списка ключей keys() словаря keywords; если бы этого не было сделано, порядок вывода параметров был бы произволен. Списки параметров произвольной длины Наконец, наиболее редко используется возможность указания того, что функция может быть вызвана с произвольным числом аргументов. При этом сами параметры будут обёрнуты в кортеж (см. раздел Кортежи). Переменное количество параметров могут предварять ноль или более обычных. def write_multiple_items(file, separator, *args): file.write(separator.join(args)) Обычно параметры неизвестного заранее количества (variadic) указываются последними в списке формальных параметров, поскольку включают в себя все остальные переданные в функцию параметры. Все формальные параметры, которые следуют за параметром *args, должны быть только именованными, то есть, они могут быть заданы только по имени (в отличие от позиционных параметров). >>> def concat(*args, sep="/"): ... return sep.join(args) ... >>> concat("earth", "mars", "venus") 'earth/mars/venus' >>> concat("earth", "mars", "venus", sep=".") 'earth.mars.venus' Распаковка списков параметров Обратная ситуация возникает когда параметры уже содержатся в списке или в кортеже, но должны быть распакованы для вызова функции, требующей отдельных позиционных параметров. Например, встроенная функция range() ожидает отдельные параметры start и stop соответственно. Если они не доступны раздельно, для распаковки аргументов из списка или кортежа в вызове функции используйте *-синтаксис: >>> 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("It'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. It's bleedin' demised ! Модель lambda В связи с неустанными просьбами, в Python были добавлены несколько возможностей, которые были привычны для функциональных языков программирования, таких как Lisp. Используя зарезервированное слово lambda, вы можете создать небольшую безымянную функцию. Например, функцию, которая возвращает сумму двух своих аргументов, можно записать так: lambda a, b: a+b. Формы lambda могут быть использованы в любом месте где требуется объект функции. При этом они синтаксически ограничены одним выражением. Семантически, они лишь 'синтаксический сахар' для обычного определения функции. Как и определения вложенных функций, lambda-формы могут ссылаться на переменные из содержащей их области видимости: >>> def make_incrementor(n): ... return lambda x: x + n ... >>> f = make_incrementor(42) >>> f(0) 42 >>> f(1) 43 Строки документации Перечислим некоторые существующие соглашения по содержимому строк документации и их форматированию. По поводу форматирования строк документации и их содержимого постоянно появляются всё новые соглашения. Первая строка всегда должна быть сжатой, лаконичной сводкой о назначении объекта. Для краткости, в ней не обязательно присутствие имени типа или объекта, поскольку они доступны другими способами (исключая случай, когда имя функции оказывается глаголом, описывающим суть операции). Эта строка должна начинаться с прописной буквы и оканчиваться точкой. Если строке документации (литерале, объекте строки) требуется больше строк (физических), вторая строка должна быть пустой, визуально отделяя сводку от остального описания. Следующие строки могут быть одним или более абзацем, описывающим соглашения по вызову объекта, сторонние эффекты, и т.д. Парсер Python не обрабатывает отступы в много-строковых литералах, поэтому инструментам, которые работают над документацией, предлагается, по желанию, делать это самим. Производится это по следующему соглашению. Первая непустая строка после первой строки литерала определяет величину отступа всего литерала документации. (Мы не можем использовать первую строку, поскольку она обычно выравнивается по открывающим кавычкам и её отступ в литерале не явен). Пробельный 'эквивалент' этого отступа затем отрезается от начала всех строк литерала. Строк с меньшим отступом не должно обнаруживаться, но если они встретились, весь их начальный отступ должен быть обрезан. Эквивалентность пробельных замен может быть протестирована развертыванием табуляции (обычно, к 8 пробелам). Вот пример многострочной документации (док-строки): >>> def my_function(): ... """Не делаем ничего, но документируем. ... ... Нет, правда, эта функция ничего не делает. ... """ ... pass ... >>> print(my_function.__doc__) Не делаем ничего, но документируем. Нет, правда, эта функция ничего не делает. Назад Вперед  8  Комментарии к статье  8 8  Обсудить в чате