Произвольные списки аргументов.

Наконец, реже используется возможность вызова функции с произвольным числом аргументов. Эти аргументы будут обернуты в кортеж Перед переменным числом аргументов могут быть обычные аргументы или не быть ни одного.

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("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!

Lambda-выражения.

С помощью ключевого слова 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

Пример выше использует lambda-выражения для возврата функции. Другое использование - это передать небольшую функцию в качестве аргумента:

>>> 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')]

Строки документации.

Здесь несколько соглашений о содержании и форматировании строк документации.

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

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

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

Вот пример многострочной строки документации:

>>> def my_function():...      """Do nothing, but document it.......     No, really, it doesn't do anything....     """...      pass...>>> print(my_function.__doc__)Do nothing, but document it.     No, really, it doesn 't do anything.

Аннотации функций.

Function annotations являются полностью необязательными метаданными о типах, используемых пользовательскими.

Аннотации хранятся в атрибуте __annotations__ функции как словарь и не имеют никакого эффекта на любую другую часть функции. Параметры аннотаций определяются двоеточием после имени параметра, за которым следует выражение, оценивающее значение аннотации. Возвращения аннотации определяются литералом ->, следующим выражению, между списком параметра и двоеточием, обозначая конец оператора def. Следующий пример имеет позиционный аргумент, аргумент с ключевым словом и аннотированное возвращаемое значение:

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

 

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

 

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

Списковый тип данных имеет несколько больше методов. Здесь все методы списковых объектов:

list. append (x)
Добавляет элемент в конец списка. Эквивалентно a[len(a):] = [x].

list. extend (iterable)
Расширяет список добавлением всех элементов из итерации. Эквивалентно a[len(a):] = iterable.

list. insert (i, x)
Вставляет элемент в заданную позицию. Первый аргумент - это индекс элемента, перед которым происходит вставка, так a.insert(0, x) вставляет впереди списка, а a.insert(len(a), x) эквивалентно a.append(x).

list. remove (x)
Удаляет первый элемент из списка, чье значение равно x. Возникает ошибка, если такого элемента нет.

list. pop ([ i ])
Удаляет элемент в заданной позиции в списке и возвращает его. Если индекс не указан, a.pop() удаляет и возвращает последний элемент в списке. (Квадратные скобки вокруг i в сигнатуре метода означают, что параметр необязательный)

list. clear ()
Удаляет все элементы из списка. Эквивалентно del a[:].

list. index (x [, start [, end ]])
Возвращает индекс (отсчет с нуля) первого элемента в списке, чье значение равно x. Возникает ValueError, если такого элемента нет.

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

list. count (x)
Возвращает какое число раз x добавлен в список.

list. sort (key=None, reverse=False)
Сортирует элементы списка на месте (аргументы могут быть использованы для настройки сортировки).

list. reverse ()
Выполняет реверс (обратное построение) элементов списка на месте.

list. copy ()
Возвращает поверхностную копию списка. Эквивалентно a[:].

Пример, в котором используется большинство методов списка:

>>> fruits = [ 'orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana' ]>>> fruits.count('apple')2>>> fruits.count('tangerine')0>>> fruits.index('banana')3>>> fruits.index('banana', 4) # Находит следующий banana, начиная с позиции 4 6>>> fruits.reverse()>>> fruits[ 'banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange' ]>>> fruits.append('grape')>>> fruits[ 'banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape' ]>>> fruits.sort()>>> fruits[ 'apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear' ]>>> fruits.pop() 'pear'

Вы могли заметить, что такие методы как insert, remove и sort, которые только изменяют список, не возвращают значения, которое может быть выведено, по умолчанию они возвращают None. Это принцип работы всех изменяемых структур данных в Python.