Python-4 函数
一、函数作用
代码出现大量重复操作时，考虑将操作重构为函数(Functions)。
例如，我们想做一个记账本，记录日期、地点和消费内容及金额。
不用函数时，我们要这样写：
print("5月10号")
print("去水果店")
print("买苹果，花费5.2元")
print("5月11号")
print("去水果店")
print("买橘子，花费6元")
print("5月12号")
print("去超市")
print("买牛奶，花费60元")
看起来很多重复的地方，我们把核心内容抽象出来，然后封装成函数。
记录日期、地点和消费内容及金额，这些内容会改变，我们把它们作为参数传递给函数（(date, place, item, price)作为参数传入函数）。
def record_consume(date, place, item, price):
定义函数后，我们只需要用函数名(参数)方式调用
record_consume("5月10日", "水果店", "苹果", 5.2)
二、函数定义
2.1 函数的定义和调用
def record_consume(date, place, item, price):
"""记账函数，传入参数日期，地点，物品，价格"""
print(date)
print(f"去{place}")
print(f"买{item}，花费{price}元")
record_consume("5月10日", "水果店", "苹果", 5.2)
可以看出函数定义的语法：
定义 函数使用关键字 def，后跟函数名与括号内的形参列表。函数语句从下一行开始，并且有4空格缩进。
def 函数名(参数列表):
函数内容
函数内的第一条语句是字符串时，该字符串就是文档字符串，也称为 docstring，利用文档字符串可以自动生成文档，还可以让开发者在浏览代码时直接查阅文档；最好养成在代码中加入文档字符串的好习惯。
函数执行的过程：
有实际值的实参 传递给 函数中形式上占位的参数（形参)
具体细节：（初次阅读时可跳过）
函数在 执行 时使用函数局部变量符号表，所有函数变量赋值都存在局部符号表中。
引用变量的查找顺序从从内到外的。首先，在局部符号表里查找变量，然后是外层函数局部符号表，再是全局符号表，最后是内置名称符号表。因此，尽管可以引用全局变量和外层函数的变量，但最好不要在函数内直接赋值（除非是 global 语句定义的全局变量，或 nonlocal 语句定义的外层函数变量）。
在调用函数时会将实际参数（实参）引入到被调用函数的局部符号表中；因此，实参是使用 按值调用 来传递的（该值 是对象的 引用 而不是对象的值）。当一个函数调用另外一个函数时，会为该调用创建一个新的局部符号表。
上面我们定义了一个没有返回值的函数，
下面来看一个有返回值的函数,该函数使用return 返回一个列表。
def distance_to_avg(scores):
"""计算到平均值的差值"""
avg = sum(scores) / len(scores)
return [x - avg for x in scores]
scores = [90, 80, 70, 80, 90]
distances = distance_to_avg(scores) # 将返回的列表赋值给distances变量
print(distances)
2.2 函数参数
2.2.1 默认值参数
如果参数中某些值通常固定，可以为它设置默认值。
语法：
def 函数名(必选参数，默认值参数=默认值):
例如：我们有一个计算列表均值或总和的函数，我们通常使用均值功能，因此将mood设置默认值为‘avg’。
def calculate_list_sta(list_a, mood='avg'):
if mood == 'avg':
return sum(list_a) / len(list_a)
elif mood == 'sum':
return sum(list_a)
else:
return -1
调用时默认模式就是'avg'，只有模式不是'avg'的时候需要传mood参数。
scores = [90, 80, 70, 80, 90]
avg = calculate_list_sta(scores)
s = calculate_list_sta(scores,"sum")
print(avg,s)
关于默认值的细节:
默认值在定义作用域里的函数定义中求值：
i = 5
def f(arg=i):
print(arg)
i = 6
f() # 5
默认值只计算一次，使用列表、字典等可变对象时，会产生累积效果。
def f(a, L=[]):
L.append(a)
return L
print(f(1)) #[1]
print(f(2)) #[1, 2]
print(f(3)) #[1, 2, 3]
调用f(2)的时候，L不再赋值为[],而是使用已有的L=[1]。
如果不想在后续调用之间共享默认值，应该使用下面方法：
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
默认值为None，在函数内赋值[]。
2.2.2 关键字参数
可用key=value 形式关键字参数调用函数。
例如：
print(calculate_list_sta(scores, 'sum'))
print(calculate_list_sta(list_a=scores, mood='sum'))
print(calculate_list_sta(mood='sum', list_a=scores))
print(calculate_list_sta(mood='sum',scores)) # 错误，位置参数必须在关键字参数前
2.2.3 *name 和 **name形式参数
*name 接收一个元组，该元组包含形参列表之外的参数。
**name接收一个字典。
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")
"Limburger"传给kind，剩下的被传给arguments，下面三行的key=value形式被当成字典，传给*keywords。
2.2.4 特殊参数
通常，参数传递有上面的两种方式，位置参数，关键字参数。
通过/和*标记，可以限制传参方式。
/前面仅限位置参数，
*后面仅限关键字参数
def standard_arg(arg):
print(arg)
standard_arg(2)
standard_arg(arg=2)
def pos_only_arg(arg, /):
print(arg)
pos_only_arg(1)
pos_only_arg(arg=1) #报错，只能通过位置传参，不能用关键字传参
def kwd_only_arg(*, arg):
print(arg)
kwd_only_arg(3) #报错，只能关键字传参
kwd_only_arg(arg=3)
# /前面仅位置传参，*后面仅关键字，standard不受约束
def combined_example(pos_only, /, standard, *, kwd_only):
print(pos_only, standard, kwd_only)
combined_example(1, 2, kwd_only=3)
combined_example(1, standard=2, kwd_only=3)
限制传参方式可以避免潜在的传参冲突问题：
def foo(name, **kwds):
return 'name' in kwds
foo(1, **{'name': 2}) # 冲突，1会先传递给name,{'name':2}会以关键字方式再传递给name
使用位置限定就可以避免，现在name只能从通过位置参数传递。
def foo(name, /, **kwds):
return 'name' in kwds
print(foo(1, **{'name': 2}))
2.2.5 任意实参列表
*arg可以传递可变数量的实参。
def write_multiple_items(file, separator, *args):
file.write(separator.join(args))
通常，可变参数arg放在最后。因为它会把剩余的参数全部读入。arg后面的只能是关键字参数。
def concat(*args, sep="/"):
return sep.join(args)
concat("earth", "mars", "venus")
concat("earth", "mars", "venus", sep=".")
2.3 解包实参列表
使用*解包(unpack)，将参数从列表中取出：
list(range(3, 6)) # 正常调用，使用两个参数
args = [3, 6]
list(range(*args)) # 使用解包(unpack)，两个参数从列表中取出
同样，字典可以用 ** 操作符传递关键字参数：
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)
2.4 Lambda 表达式
lambda 关键字用于创建小巧的匿名函数。例如：lambda a, b: a+b 函数返回两个参数的和。在语法上，它只能是单个表达式。在语义上，它只是常规函数的语法糖。
最常见的用法是用在排序中，将其作为排序的关键字函数。
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs.sort(key=lambda pair: pair[1])
pairs
三、提升函数可读性
3.1 文档字符串
文档字符串用来说明对象用途。
第一行为摘要。大写字母开头，句号结尾。
第二行空白。
后面可以包含若干段落，描述对象的使用等。
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.
3.2 函数注解
注解（annotations）用来说明数据类型。以字典形式存放在函数的annotations属性中，不会影响函数的其他部分。
语法：形参后跟:标注参数类型，参数列表后用 -> 返回值类型。
def 函数名(形参: 参数类型, 关键字参数: 参数类型 = '默认值') -> 返回值类型:
def f(ham: str, eggs: str = 'eggs') -> str:
print("Annotations:", f.__annotations__)
print("Arguments:", ham, eggs)
return ham + ' and ' + eggs
3.3 编码风格
当代码变长、变复杂时，统一、可读性高的编码风格非常重要。
PEP 8 （Python Enhancement Proposal,python增强建议）是Python风格指南。内容比较多，可以去官网查看：https://peps.python.org/pep-0008/ 后面我也会整理一部分常用的。
另外补充一个技巧，如果你用的是PyCharm，可以通过Reformat（快捷键：ctrl+alt+enter）进行格式化代码，优化代码排版。
本文思维导图：
关注公众号一只大鸽子，Python从入门到进阶。
