Введение
Функции — это основа структурного программирования и краеугольный камень повторного использования кода. В Python def используется для определения функций. В этой статье мы углубимся в секреты функций в Python.
встроенная функция
В дополнение к пользовательским функциям Python создал несколько очень полезных функций:
пользовательская функция
Python использует def для определения функций и return для возврата определенного значения.
См. пример простой функции:
def my_function(x, y, z):
if z > 1:
return z * (x + y)
else:
return z / (x + y)
Чтобы переопределить пример последовательности Фибоначчи, о котором мы говорили ранее, как функцию, его можно записать следующим образом:
def fib(n):
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
# 调用函数
fib(1000)
Содержимое функции должно иметь отступ с пробелами или табуляцией.
значение параметра по умолчанию
В Python мы можем установить значения по умолчанию для параметров, так что, если во время вызова функции не будут переданы никакие параметры, в качестве параметра будет использоваться значение по умолчанию.
В функции my_function, которую мы определили ранее, мы можем установить значение по умолчанию для z:
def my_function(x, y, z=10):
if z > 1:
return z * (x + y)
else:
return z / (x + y)
Таким образом, мы можем передать только два параметра при вызове my_function, а последний z может использовать значение параметра по умолчанию.
Обратите внимание, что значение по умолчанию будет выполнено только один раз, если параметр, который вы передаете, является изменяемым объектом (список, словарь и экземпляр класса), нам нужно обратить внимание на эту проблему:
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 my_function(x, y, z=10):
if z > 1:
return z * (x + y)
else:
return z / (x + y)
Мы можем назвать это так:
my_function(1,y=3,z=5)
my_function(1,y=3)
Но его нельзя использовать так:
my_function(y=3,1)
Аргументы ключевых слов должны быть помещены после аргументов, не являющихся ключевыми словами. Также невозможно назначить несколько значений параметрам:
>>> 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 keyword argument 'a'
Из приведенного выше обсуждения мы видим, что в функциях Python есть два типа параметров: один — это параметр со значением по умолчанию, а другой — параметр без значения по умолчанию.
Обратите внимание, что параметр без значения по умолчанию должен быть в аргументах перед значениями по умолчанию.
Посмотрите неправильный пример:
In [69]: def fa(a=100,b,c=200):
...: pass
File "<ipython-input-69-d5678b64f352>", line 1
def fa(a=100,b,c=200):
^
SyntaxError: non-default argument follows default argument
Есть также два способа передать параметры в функцию: один — передать без ключевых слов, а другой — передать с ключевыми словами.
Обратите внимание, что аргументы, не являющиеся ключевыми словами, должны передаваться перед аргументами ключевых слов.
Вот пример ошибки:
In [70]: def fa(a,b=100,c=200):
...: pass
...:
In [71]: fa(a=100,30)
File "<ipython-input-71-5a229b8e420e>", line 1
fa(a=100,30)
^
SyntaxError: positional argument follows keyword argument
Итак, вопрос в том, если есть несколько параметров ключевых слов и несколько параметров, не являющихся ключевыми словами, есть ли простой способ определить такую функцию?
да, это*argumentsи**keywords
*argumentsОн используется для получения всех ненужных параметров, не являющихся ключевыми словами. и**keywordsИспользуется для получения всех дополнительных аргументов ключевого слова.
Уведомление,
*argumentsдолжен появиться в**keywordsспереди.
Например:
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):
----------- ---------- ----------
| | |
| 按位置或者关键词 |
| - 只允许按关键词传递
-- 只允许按位置传递
Обратите внимание, что параметры отмечены символами / и *.
Возьмем пример:
>>> 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)
Вышеуказанное определяет функции 4 способа прохождения параметров.
Первая функция является стандартной формой, которая может быть передана по положению или по ключевому слову.
Вторую функцию можно передавать только по положению.
Третью функцию можно передавать только по ключевому слову.
Четвертая функция — это режим наложения.
распаковка параметра
Иногда нам нужно преобразовать значения списка или словаря в параметры функции. Затем нужно воспользоваться функцией распаковки параметров.
*Оператор может использоваться для распаковки списков и кортежей.
>>> 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)
Lambda
Друзья, знакомые с Java, могут знать, что в JDK8 в Java представлены лямбда-выражения. В том же Питоне есть и лямбда.
Вы можете думать о Lambdas как об анонимных функциях. Лямбда-выражения можно использовать везде, где требуется функция.
Взгляните на пример лямбды:
>>> def make_incrementor(n):
... return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43
Вы также можете взять возвращаемое значение лямбды в качестве параметра:
>>> 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')]
аннотация функции
Простую форму пользовательской функции мы уже обсуждали ранее. Мы не знаем тип параметра и тип возвращаемого значения функции. На самом деле функцию можно написать более подробно, что требует использования аннотации функции.
Так называемая метка функции представляет собой необязательную информацию метаданных типа в определяемой пользователем функции.
Аннотации функций хранятся в виде словаря в__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'
На самом деле программы, написанные с использованием аннотаций функций, более понятны и читабельны.
Эта статья была включена вWoohoo. Флойд press.com/05-Python-post…
Самая популярная интерпретация, самая глубокая галантерея, самые краткие уроки и множество трюков, о которых вы не знаете, ждут вас!
Добро пожаловать, чтобы обратить внимание на мой официальный аккаунт: «Программируйте эти вещи», разбирайтесь в технологиях, лучше поймите себя!