1、函数 function 简介
函数也是一个对象，对象是内存中专门用来存储数据的一块区域
函数就是用来保存一些可以执行的代码，并且可以在需要的时候，对这些代码进行多次调用
定义函数的语法：
def 函数名([形参1，形参2…]):
代码块
定义一个函数
def fn():
print(‘这是我第一个函数’)
print(fn) <function fn at 0x000001F6D7CF3E18> 这是函数保存的内存地址
函数和变量没有区别，都是存放数据的
fn 是函数对象 fn() 是调用函数
函数中保存的代码块不会立即执行，需要调用函数代码才会执行
调用函数：函数对象()
2、函数的参数
在定义函数的时候，可以在函数后面的括号定义数量不等的形参，多个形参用“，”号隔开
形参：形式参数，定义形参就相当于在函数内部声明了变量，但不赋值
实参：实际参数，如果指定了形参，那么在调用函数的时候必须传递实际参数，实际参数将会赋值给对应的形参，就是有几个形参就需要传递几个实参。
定义一个函数，求任意两个数的和
def sum():
a = 1
b = 1
print(a + b)
def fn2(a,b):
print(‘a = ‘,a)
print(‘b = ‘,b)
print(a,’+’,b ,’=’ ,a+b)
调用函数：
fn(2,3)
返回值：
a = 1
b = 2
1 + 2 = 3
3、函数的传参方式
3.1默认值
定义形参时，可以给形参指定默认值
制定了默认值之后，如果用户传递了实参，则默认值不会发挥作用
如果用户没有传递实参，则默认值会发挥作用
实参优先
def fn3(a,b,c=20):
print(‘a=’,a)
print(‘b=’,b)
print(‘c=’,c)
fn3(1,2,3)
返回值：
a= 1
b= 2
c= 3
fn3(1,2)
返回值
a= 1
b= 2
c= 20
3.2实参的传递方式
位置传参
位置参数就是将对应位置的实参赋值给对应位置的形参
第一个实参赋值给第一个形参，第二个实参赋值给第二个形参
3.3关键字参数
关键字参数可以不按照形参定义的顺序传递，而根据参数名传递
实参优先
位置参数和关键字参数可以混合使用
混合使用的时候关键字和位置参数时，必须将位置参数写在关键字前面
def fn4(a=10,b=30,c=20):
print(‘a=’,a)
print(‘b=’,b)
print(‘c=’,c)
fn4(1,c=2,b=3)
返回值：
a= 1
b= 3
c= 2
4、实参的类型：可以传递任意类型的对象
def fn5(a):
print(‘a=’,a)
b = 123
fn5(b)
返回值：a=123
fn5(‘python’)
返回值：a=python
fn5(None)
返回值：a=None
fn5(False)
返回值：a=False
4.1 函数作为参数传递
def fn4(a = 20):
print(‘a=’,a)
def fn5(a):
print(‘a=’,a)
fn5(fn4)
返回值：a= <function fn4 at 0x000001F6DA2197B8>
def fn6(a,b):
print(a + b)
fn6(123,‘456’)
返回错误：整形与字符串不能相加
Traceback (most recent call last):
File “”, line 1, in
fn6(123,‘456’)
File “”, line 2, in fn6
print(a + b)
TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’
4.2 在函数中对形参进行重新赋值，不会影响其他的变量
def fn7(a):
print('a = ',a)
c = 10
fn7©
print('c = ’ ,c)
返回值：
a = 10
c=10
在函数中对形参进行重新赋值，不会影响其他的变量
def fn8(a):
a = 20
print(‘a=’,a)
c = 10
fn8©
print('c = ', c)
返回值：
a = 20
c = 10
4.3 如果你在传递的是一个可变对象的时候，而你又不希望我在函数内部的操作影响到函数外部的时候，那么你就可以考虑传递一个副本
def fn9(a):
a[0] = 50
print(‘a =’,a,id(a))
c = [1,2,3]
fn9©
print('c = ',c,id©)
返回值：
a = [50, 2, 3] 2159733275336
c = [50, 2, 3] 2159733275336
def fn9(a):
a[0] = 50
print(‘a =’,a,id(a))
c = [1,2,3]
print('c = ',c,id©)
fn9(c.copy()) 或者 fn9(c[:])
返回值：
c = [1, 2, 3] 1676896758280
a = [50, 2, 3] 1676896758408
5、不定长参数
在定义函数时，可以在形参前面加上一个*,这样做的好处是这个形参可以获取到所有的实参
他将把所有的实参保存到一个元祖中
定义一个函数，求任意个数的和
5.1 *参数
def sum(a,b,c):
print(a + b + c)
def fn(*a):
print('a = ',a,type(a))
fn(1,2,3,4,5)
返回值：a = (1, 2, 3, 4, 5) <class ‘tuple’>
这是一个装包的过程
5.2 *参数解包
def fn(*a):
#定义一个变量，用来保存结果
result = 0
#a以元祖形式接收全部参数，遍历元祖，并将元祖中的数解包进行计算
for n in a:
result = result + n
print(result)
fn(1,3,4,5,7)
返回值：20
5.3 *不定长参数也可以和其他参数配合使用
不定长参数不是必须写在最后，但是要注意，带 * 号的参数后面的所有参数，必须以关键字的参数形式传递
def fn2(a,b,*c):
print('a = ',a)
print('b = ',b)
print('c = ',c)
fn2(1,2,3,4,5)
返回值：
a = 1
b = 2
c = (3, 4, 5)
def fn2(a,*b,c):
print('a = ',a)
print('b = ',b)
print('c = ',c)
fn2(1,2,3,4,c=5)
返回值：
a = 1
b = (2, 3, 4)
c = 5
如果在形参的开头直接写*,则要求我们所有的参数要以关键字传递
如果只有一个不定长参数，那么这个不定长参数只能接受位置参数，不能接受关键字参数
例如：
def fn3(*a):
print('a = ',a)
fn3(b=1,d=2,c=3) 报错
Traceback (most recent call last):
File “”, line 1, in
fn3(b=1,d=2,c=3)
TypeError: fn3() got an unexpected keyword argument ‘b’
5.4 **形参
**形参可以接受其他的关键字参数，他会将这些参数统一保存到一个字典中，自定义的key就是关键字的名字，字典的value就是参数的值
**形参只能有一个并且必须写在所有参数后面
def fn3(**a):
print('a = ',a)
fn3(b=1,d=2,c=3)
返回值
a = {‘b’: 1, ‘d’: 2, ‘c’: 3}
def fn4(b,c,**a):
print(‘a =’,a)
print(‘b =’,b)
print(‘c =’,c)
fn4(b=1,d=2,c=3,e=5,f=20)
返回值
a = {‘d’: 2, ‘e’: 5, ‘f’: 20}
b = 1
c = 3
（*a处理位置参数，**a处理的是关键字参数）
6、* 和 **作为参数解包
def fn4(a,b,c):
print(‘a =’,a)
print(‘b =’,b)
print(‘c =’,c)
创建一个元祖
t = (10,20,30)
fn4(t[0],t[1],t[2])
返回值：
a = 10
b = 20
c = 30
传递参数，也可以在序列类型的参数添加*，这样他会自动将序列中的元素依次解包，当作参数来传递
这里要求序列中的元素个数必须和形参的个数保持一致
fn4(*t)
返回值
a = 10
b = 20
c = 30
创建一个字典
d = {‘a’:1,‘b’:2,‘c’:3}
fn4(**d)
返回值
a = 1
b = 2
c = 3
7、练习:* 和 ** 参数混合使用
def fn2(a,*b,**c):
print('a = ',a)
print('b = ',b)
print('c = ',c)
fn2(2,4,1,d=3,e=4)
返回值:
a = 2
b = (4, 1)
c = {‘d’: 3, ‘e’: 4}
