函数
将常用的代码以固定的格式封装（包装）成一个独立的模块，只要知道这个模块的名字就可以重复使用它，这个模块就叫做函数（Function）。
1. 函数的定义和调用
1.1 函数定义
定义一个函数,也叫声明一个函数，其语法格式如下：
def 函数名(参数列表):
# 实现特定功能的多行代码
[return [返回值]]
其中，用 [] 括起来的为可选择部分，可写可不写。
注意：
- 函数形参不需要声明类型，也不需要指定函数返回值类型
- 即使该函数不需要接收任何参数，也必须保留一对空的圆括号
- 括号后面的冒号必不可少
- 函数体相对于def关键字必须保持一定的空格缩进
- Python允许嵌套定义函数
- 另外，如果想定义一个没有任何功能的空函数，可以使用 pass 语句作为占位符。
1.2 函数调用
函数必须先定义然后才能调用
调用一个函数的方法非常简单，函数名后面加一个() ，
() 是一个运算符，表示执行一个函数。
执行函数:
函数名()
一旦调用了函数，函数内部的语句就会执行。
2. 函数的参数
2. 1 参数的了解
在使用函数时，经常会用到形式参数（简称“形参”）和实际参数（简称“实参”），二者都叫参数，之间的区别是：
- 形式参数：在定义函数时，函数名后面括号中的参数就是形式参数。
# 定义函数时，这里的函数参数 obj 就是形式参数
def func(obj)
print(obj)
- 实际参数：在调用函数时，函数名后面括号中的参数称为实际参数，也就是函数的调用者给函数的参数。
a = "hello world!"
# 调用已经定义好的 func 函数，此时传入的函数参数 a 就是实际参数
func(a)
实参和形参的区别，就如同剧本选主角，剧本中的角色相当于形参，而演角色的演员就相当于实参。
形式参数就像占位置,先把位置站好,等你来赋值
2.2参数传递
Python中，根据实际参数的类型不同，函数参数的传递方式可分为 2 种，分别为值传递和引用（地址）传递：
- 值传递：适用于实参类型为不可变类型（字符串、数字、元组）；
- 引用（地址）传递：适用于实参类型为可变类型（列表，字典）；
值传递和引用传递的区别是，函数参数进行值传递后，若形参的值发生改变，不会影响实参的值；而函数参数继续引用传递后，改变形参的值，实参的值也会一同改变。
def demo(obj) :
obj += obj
print("形参值为：",obj)
# 值传递
a = "hello"
print("a的值为：",a) # out:hello
demo(a) # out:hellohello
print("实参值为：",a) # out:hello
# 引用传递
a = [1,2,3]
print("a的值为：",a) # out:[1, 2, 3]
demo(a) # out:[1, 2, 3, 1, 2, 3]
print("实参值为：",a) # out:[1, 2, 3, 1, 2, 3]
在执行值传递时，改变形式参数的值，实际参数并不会发生改变；而在进行引用传递时，改变形式参数的值，实际参数也会发生同样的改变。
2. 3 参数的分类
1.位置参数（调用函数时根据函数定义的参数位置来传递参数）
位置参数(有时也称必备参数)，指的是必须按照正确的顺序将实际参数传到函数中，换句话说，调用函数时传入实际参数的<b style="color:red;">数量和位置</b>都必须和定义函数时保持一致。
简单一点的理解其实就是“一个萝卜一个坑”，调用函数时，传入的参数和定义参数时的形参相比，不能多，不能少，不能交换顺序，一定要保证<span style="color:red;">一一对应</span>。
def login(name, password):
if name == "jack" and password == 110:
print("登录系统成功")
else:
print("用户名或密码错误")
login("tony", "120") # out: 用户名或密码错误
比如上面的login函数，入参为name和password，要求使用这在调用时传入用户和密码，明显name在前，password在后，那么我们调用login时，实参一定要先写name后写password如果位置顺序填反或者少输入一个参数，执行代码就会报错！
2.关键字参数（调用函数传入参数时在参数前面加上形参名称和等于号来区分填入的是哪个参数）
关键字参数是指使用形式参数的名字来确定输入的参数值。通过此方式指定函数实参时，不再需要与形参的位置完全一致，<span style="color:red;">只要将参数名写正确即可</span>。
例如：
def login(name, password):
if name == "jack" and password == 110:
print("登录系统成功")
else:
print("用户名或密码错误")
login(password=110, name="jack") # out: 登录系统成功
login(name="jack", 110) # out: 报错SyntaxError: positional argument follows keyword argument
最后一行我们调用login函数时，login(password=120, name="tony")，在实际参数前面分别添加了“password=”和“name=”,这样，我们可以清楚的看出，120和tony代表的是啥，而且我们并未按照函数定义时的参数顺序进行传值。
其实，直白的讲，关键字参数就像贴标签。用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。但是，这里我们要注意的一点是，<b style="color:orangered;">关键字参数必须在位置参数的后面使用！</b>
3.默认参数（定义函数时直接给形参给定一个值，如果调用时未给值，就用定义函数时给定的默认值）
默认值参数语法格式：
def 函数名(..., 形参名, 形参名=默认值)：
代码块
示例：
def login(name, password=110):
if name == "jack" and password == 110:
print("登录系统成功")
else:
print("用户名或密码错误")
login("jack") # out: 登录系统成功
login("jack", 120) # out: 用户名或密码错误
y由上述代码可知，默认函数用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
4.可变长参数（当参数个数不定时使用，很是灵活）
(1) *args(一个星号的可变长参数)
顾名思义，可变长参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。主要用于一个函数不能确定入参个数的情况。就以一个数学题目举例：“将用户输入的所有数字相乘之后对20取余数用户输入的数字个数不确定”，针对这个题目，我们并不知道入参是多少个，所以按照常规思路，我们可以在圆括号内传入列表，列表中放入要进行计算的所有的数，代码如下：
def get_remainder(list):
product = 1
for item in range(len(list)):
product = list[item] * product
return product % 20
my_list = [1, 2, 3, 4]
print(get_remainder(my_list))
在这里，我们调用此函数时，必须把要参与计算的所有数据封装成一个列表才能进行计算，那么，如果不进行封装呢？下面就是可变长参数的Show Time:
def get_remainder(*args):
"""
获取输入值的乘积对20的余数
:param args: 输入的所有值
:return: 乘积对20的余数
"""
product = 1
for arg in args:
product *= int(arg)
return product % 20
result = get_remainder(1, 2, 3, 4)
print(result)
从代码表示上，我们可以看到，在定义函数的时候，我们在圆括号内的参数表示为“args”,重点在于号，args只是一般习惯性写法，当然我们也可以写成“_any”、“_haha”。在参数前面加*号，就表示这是一个可变长参数，在代码调用result = get_remainder(1, 2, 3, 4)，我们无需封装列表，只需要将参与计算的数据传入方法中，并且用逗号隔开即可，这样是不是很方便呢？
另外，如果已经有一个list或者tuple，要调用一个可变参数怎么办？其实也很方便，看下方代码：
def get_remainder(*args):
"""
获取输入值的乘积对20的余数
:param args: 输入的所有值
:return: 乘积对20的余数
"""
product = 1
for arg in args:
product *= int(arg)
return product % 20
my_list = [1, 2, 3, 4]
result = get_remainder(*my_list)
print(result)
我们可以看到，在最后三行调用代码中，我们有一个my_list的列表，要作为入参调用get_remainder方法，那么我们在调用时，在my_list前加一个_号即可，即result = get_remainder(_my_list)，这样列表也能使用可变长参数的函数。这一过程，在python中我们叫做“解包”。
(2)**kwargs(两个星号的可变长参数)
说完了args的情况，我们来说下两个星号的可变长参数情况*kwargs。他们两个的区别在于， 两个星表示接受键值对的动态参数，数量任意。调用的时候会将实际参数打包成字典。详细还是看例子，这次我们的题目为“输入键盘数字键(0~9)，返回数字键上方字符”，看相应代码：
def get_symbol(**kwargs):
for people in kwargs:
print(kwargs[people], end=" ")
print()
num_str_dic = {'1': '!', '2': '@', '3': '#', '4': '$', '5': '%', '6': '^', '7': '&', '8': '*', '9': '(', '0': ')'}
get_symbol(**num_str_dic)
在get_symbol函数中，我们传入参数为“kwargs”,在调用函数时，直接加上，如get_symbol(__num_str_dic)即可调用。
要注意的是list或者tuple的时候用args,而dict的时候用的是*kwargs。
3.返回值return
return的作用：
- 返回数据给函数的调用者。
- 结束（打断）函数执行
函数可以通过参数来接收东西，更可以通过return的语句来返回值，“吐出”东西。
def sum(a, b):
return a + b # 现在这个函数的返回值就是a+b的和
print(sum(5, 4)) # out: 9
函数只能有唯一的return，有if语句除外,因为if是分支语句
程序遇到了return，将立即返回结果，返回调用它的地方，而函数内return后面的语句将不在执行。
def fun():
print(1)
print(2)
return # 返回一个空值
print(3) # 这行语句不执行，因为函数已经return了,所以不会输出3
fun() # out: 1, 2
4. 变量作用域
所谓作用域（Scope），就是变量的有效范围，就是变量可以在哪个范围以内使用。有些变量可以在整段代码的任意位置使用，有些变量只能在函数内部使用，有些变量只能在 for 循环内部使用。
4.1 局部变量
在函数内部定义的变量，它的作用域也仅限于函数内部，出了函数就不能使用了，将这样的变量称为局部变量（Local Variable）。
要知道，当函数被执行时，Python 会为其分配一块临时的存储空间，所有在函数内部定义的变量，都会存储在这块空间中。而在函数执行完毕后，这块临时存储空间随即会被释放并回收，该空间中存储的变量自然也就无法再被使用。
def demo():
num = 2
print("函数内部 num =", num) # out: 函数内部 num = 2
demo()
print("函数外部 num =", num) # 报错
函数的参数也属于局部变量，只能在函数内部使用
def demo(a, b):
sum = a + b
print(sum) # out: 5
demo(2, 3)
print(a, b) # 报错
4.2 全局变量
除了在函数内部定义变量，Python 还允许在所有函数的外部定义变量，这样的变量称为全局变量（Global Variable）。
和局部变量不同，全局变量的默认作用域是整个程序，即全局变量既可以在各个函数的外部使用，也可以在各函数内部使用。
全局变量定义方式有2种：
- (比较常用)在函数体外定义的变量，一定是全局变量，例如：
a = 3
def demo():
print("函数内访问：", a) # out: 3
demo()
print('函数外访问：', a) # out: 3
- 在函数体内定义全局变量。即使用 global 关键字对变量进行修饰后，该变量就会变为全局变量。例如：
def demo():
global b
b = 5
print("函数内访问：", b) # out: 5
demo()
print('函数外访问：', b) # out: 5
5. 闭包
闭包，又称闭包函数或者闭合函数，其实和前面讲的嵌套函数类似，不同之处在于，闭包中外部函数返回的不是一个具体的值，而是一个函数。一般情况下，返回的函数会赋值给一个变量，这个变量可以在后面被继续执行调用。
示例：使用闭包计算一个数的 n 次幂
# 闭包函数，其中 exponent 称为自由变量
def nth_power(exponent):
def exponent_of(base):
return base ** exponent
return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方
print(square(2)) # 计算2的平方 输出：4
print(cube(2)) # 计算2的立方 输出：8
其实上述代码完全可以写成下方代码
def nth_power_rewrite(base, exponent):
return base ** exponent
result = nth_power_rewrite(2, 3)
print(result) # out: 8
上面的程序可以实现相同的功能，不过使用闭包肯定有它的好处，它可以让程序变得更简洁易读。如果要计算很多个数的平方，那么你觉得用那种方法好呢?
# 不使用闭包
res1 = nth_power_rewrite(base1, 2)
res2 = nth_power_rewrite(base2, 2)
res3 = nth_power_rewrite(base3, 2)
# 使用闭包
square = nth_power(2)
res1 = square(base1)
res2 = square(base2)
res3 = square(base3)
显然第二种方式表达更为简洁，在每次调用函数时，都可以少输入一个参数。
其次，和缩减嵌套函数的优点类似，函数开头需要做一些额外工作，当需要多次调用该函数时，如果将那些额外工作的代码放在外部函数，就可以减少多次调用导致的不必要开销，提高程序的运行效率。
Python闭包的__closure__属性
闭包比普通的函数多了一个 __closure__属性，该属性记录着自由变量的地址。当闭包被调用时，系统就会根据该地址找到对应的自由变量，完成整体的函数调用。
以 nth_power() 为例，当其被调用时，可以通过__closure__ 属性获取自由变量（也就是程序中的 exponent 参数）存储的地址，例如：
def nth_power(exponent):
def exponent_of(base):
return base ** exponent
return exponent_of
square = nth_power(2)
#查看 __closure__ 的值
print(square.__closure__) # out: (<cell at 0x000001FCB51C7490: int object at 0x00007FF96E5CC6C0>,)
可以看到，显示的内容是一个 int 整数类型，这就是 square 中自由变量 exponent 的初始值。还可以看到，__closure__ 属性的类型是一个元组，这表明闭包可以支持多个自由变量的形式。
6.lambda表达式 ( 匿名函数 )
lambda 表达式，又称匿名函数，常用来表示内部仅包含 1 行表达式的函数。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。
lambda 表达式的语法格式如下：
定义 lambda 表达式，必须使用 lambda 关键字；
[list] 作为可选参数，等同于定义函数是指定的参数列表；
value 为该表达式的名称。
name = lambda [list] : 表达式
将上述lambda表达式转化为普通函数：
def name(list):
return 表达式
name(list)
显然，使用普通方法定义此函数，需要 3 行代码，而使用 lambda 表达式仅需 1 行。
示例：求两数之和
# def普通函数写法
def sum(x, y):
return x+ y
print(sum(3,4)) # out: 7
# 使用lambda表达式
sum = lambda x, y : x + y
print(sum(3, 4)) # out: 7
可以这样理解 lambda 表达式，其就是简单函数（函数体仅是单行的表达式）的简写版本。相比函数，lamba 表达式具有以下 2 个优势：
- 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁；
- 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能
