8. 函数进阶 - 2
函数参数的高级用法
缺省参数
引入
缺省参数也叫做默认参数，是指定义函数时形参变量有默认值，如果调用函数时没有传递参数，那么函数就用默认值，如果传递了参数就用传递的那个数据。
示例：
def print_info(name, age=35):
print(f'name: {name}')
print(f'age: {age}')
print_info('顾安')
print_info('顾安', 18)
缺省参数的作用
当调用函数时，有些参数不必传递，而是用默认值，这样的场景往往都用缺省参数
例如，一个学校现在开始检查每个学生的信息，学生说：报告老师我是xxx学校xxx系xxx年级xxx班学生，名字叫xxxx，大家想只要是这学校的学生那么“xxx学校”就可以省略不用说了，因为大家都知道。所以就可以认为默认的学校就是xxx，而当其他学校的学生介绍时yyy学校名字案例说就一定要说清楚，否则让人弄混了。
示例：
def print_info(name, class_name, grade, department_name, school_name="图灵学院"):
print("老师好：我是来自 %s(大学) %s系 %s年级 %s班级 的学生，我叫%s" % (
school_name,
department_name,
grade,
class_name,
name
))
print_info("顾安", "爬虫", "二", "软件工程")
print_info("顾安", "爬虫", "二", "软件工程", "图灵python")
注意点
- 缺省参数只能在形参的最后（即最后侧）
- 缺省参数全挨在一起（在右侧），不是缺省参数挨在一起（在左侧）
>>> def printinfo(name, age=35, sex):
... print name
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument
命名参数
引入
命名参数是指：在调用函数时，传递的实参带有名字，这样的参数叫做命名参数
示例：
def test(a, b):
print('-----')
print(f'a={a}')
print(f'b={b}')
test(11, 22)
test(a=11, b=22)
test(a=22, b=11) # 根据名称将值传入到指定的变量中
命名参数的作用
命名参数能够在调用函数的时候，不受位置的影响，可以给需要的参数指定传递数据
注意点
- 命名参数的名字要与形参中的名字相同，不能出现命名参数名字叫做
num，而形参中没有变量num - 如果形参左侧有普通的形参，调用函数时传递的参数一定要先满足这些形参，然后再根据需要编写命名参数
def test(a, b, c=100, d=200):
print("a=%d, b=%d, c=%d, d=%d" % (a, b, c, d))
# 下面的方式都成功
test(11, 22)
test(11, 22, 33)
test(11, 22, 33, 44)
test(11, 22, d=33, c=44)
# 下面的方式都失败
test(c=1, d=2) # 缺少a、b的值
test(c=1, d=2, 11, 22) # 11, 22应该在左侧
不定长参数
引入
不定长参数：定义函数的时候形参可以不确定到底多少个，这样的参数就叫做不定长参数
不定长参数有2种方式表示
*args：表示调用函数时多余的未命名参数都会以元组的方式存储到args中**kwargs：表示调用函数时多余的命名参数都会以键值对的方式存储到kwargs中
注意：
*和**是必须要写的，否则就变成了普通的形参了- 当我们说不定长参数的时候，就是指
*args和**kwargs
示例：
def test(a, b, *args, **kwargs):
print(a, type(a))
print(b, type(b))
print(args, type(args))
print(kwargs, type(kwargs))
test(11, 22, 33, 44, 55, 66, name='顾安', address='长沙')
不定长参数的作用
通过不定长参数，能够实现调用函数时传递实参个数可以随意变换的需求
注意点
- 加了星号
*的变量args会存放所有未命名的变量参数，args为元组 - 而加
**的变量kwargs会存放命名参数，即形如key=value的参数，kwargs为字典 - 一般情况下
*args、**kwargs会在形参的最右侧 args与kwargs的名字可以变，例如叫*aa，**bb都是可以，但一般为了能够让其他的开发者快速读懂我们的代码最好还是不改
特殊情况
缺省参数在*args的后面
def sum_nums_3(a, *args, b=22, c=33, **kwargs):
print(a)
print(b)
print(c)
print(args)
print(kwargs)
sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)
说明：
*args后可以有缺省参数，想要给这些缺省参数在调用时传递参数，需要用命名参数传递，否则多余的未命名参数都会给args- 如果有
**kwargs的话，**kwargs必须是最后的
输出结果：
100
1
2
(200, 300, 400, 500, 600, 700)
{'mm': 800, 'nn': 900}
函数返回值拆包
什么是函数返回值拆包
函数返回值拆包：如果一个函数通过return返回了一个元组、列表、集合，可以通过拆包的方式将返回值进行拆分到每个变量中，这就是返回值拆包。
示例：
def test():
return 11, 22, 33
a, b, c = test()
print(a, b, c)
返回值拆包的作用
通过函数返回值拆包，可以快速的将具体的数据用变量进行存储，这样对数据的处理会更加方便
示例：
def test():
return 11, 22, 33
# 通过返回值拆包，快速使用每个数据
a, b, c = test()
print(a + b + c)
# 没有通过返回值拆包，这样用数据时稍微复杂
ret = test()
print(ret[0] + ret[1] + ret[2])
拆包的使用
def get_my_info():
high = 178
weight = 100
age = 18
return high, weight, age
# result = get_my_info()
# print(result)
# 通过返回值拆包，能够更加方便的对每个数据使用
my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)
使用拆包时的注意点
- 拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
通过星号拆包
通过普通方式拆包
假如有以下函数：
def test(a, b, c):
print(a + b + c)
现在自己拥有的数据：
nums = [11, 22, 33]
怎样才能在调用test函数的时候，将nums给传递过去呢?
def test(a, b, c):
print(a + b + c)
nums = [11, 22, 33]
test(nums[0], nums[1], nums[2])
上述代码用的方式虽然能行，但不是很简洁
为了能够用更加简洁的方式实现上述场景需求，Python可以通过*、**将数据拆包后传递
使用*拆包
有时在调用函数时，这个函数需要的是多个参数，而自己拥有的是一个列表或者集合这样的数据，此时就用可以用*拆包
使用方式：
*列表
*元组
*集合
用*拆包的方式实现上述功能：
def test(a, b, c):
print(a + b + c)
nums = [11, 22, 33]
test(*nums) # 此时的*的作用就是拆包，此时*nums相当于11, 22, 33 即test(11, 22, 33)
如果为数据元组时使用方式与上述代码一致：
def test(a, b, c):
print(a + b + c)
nums = (11, 22, 33)
test(*nums)
集合类型同上：
def test(a, b, c):
print(a + b + c)
nums = {11, 22, 33}
test(*nums)
注意：
*对列表、元组、集合可以拆包，但一般都是在调用函数时用
使用**拆包
使用**可以对字典进行拆包，拆包的结果是命名参数
示例：
def test(name, age, address):
print(name)
print(age)
print(address)
info = {
"name": "顾安",
"age": 18,
"address": "长沙"
}
test(**info)
'''
当前**info相当于以下代码：
name='顾安'
age=18
address='长沙'
** 主要对字典进行拆包
'''
难点
学习不定长参数时，掌握了*args、**kwargs
现在学习拆包时，也用到了*、**
那它们之间有什么关系呢？
答：没有任何关系，只是长得像罢了
示例一：
def test1(*args, **kwargs):
print("----在test1函数中----")
print("args:", args)
print("kwargs", kwargs)
def test2(*args, **kwargs):
print("----在test2函数中----")
print("args:", args)
print("kwargs", kwargs)
test1(args, kwargs) # 在函数test1传递参数时没有进行拆包
test2(11, 22, 33, name="顾安", age=18)
运行结果：
----在test2函数中----
args: (11, 22, 33)
kwargs {'name': '顾安', 'age': 18}
----在test1函数中----
args: ((11, 22, 33), {'name': '顾安', 'age': 18})
kwargs {}
示例二：
def test1(*args, **kwargs):
print("----在test1函数中----")
print("args:", args)
print("kwargs", kwargs)
def test2(*args, **kwargs):
print("----在test2函数中----")
print("args:", args)
print("kwargs", kwargs)
test1(*args, **kwargs) # 对参数进行了拆包
test2(11, 22, 33, name="顾安", age=18)
运行结果：
----在test2函数中----
args: (11, 22, 33)
kwargs {'name': '顾安', 'age': 18}
----在test1函数中----
args: (11, 22, 33)
kwargs {'name': '顾安', 'age': 18}
Python语言中的引用
引入
如下代码中，最后b的值为多少？
>>> a = 1
>>> b = a
>>> b
1
>>> a = 2
>>> a
2
如下代码中，最后b的值为多少？
>>> a = [1, 2]
>>> b = a
>>> b
[1, 2]
>>> a.append(3)
>>> a
[1, 2, 3]
什么是引用
引用：就是地址
那地址是什么呢？可以理解为存放数据的空间在内存中的编号
例如：
a = 100
怎样知道它的地址呢？
id(a)
可以直接将上述的结果打印：
print(id(a))
运行结果（在不同机器上输出的地址可能不相同）：
4347271232
当我们知道了原来引用就是地址之后，再来看如下代码：
a = [1, 2]
我们可以用id(a)取它的地址：
a = [1, 2]
print(id(a)) # 获取变量存储的引用（地址）是多少
接下来定义变量b并且赋值：
a = [1, 2]
print(id(a)) # 获取变量存储的引用（地址）是多少
b = a
此时输出变量b的引用：
a = [1, 2]
print(id(a))
b = a
print(id(b))
运行结果（不同机器上的内存地址可能不相同）：
4558971360
4558971360
这说明，此时变量a、b存储的引用都是相同的
由此我们可以得出一个结论：Python中的变量并不是真正存储数据，而是存储的数据所在内存中的地址，我们一般称之为引用
既然变量a、b都指向同一个列表，那么接下来
a.append(3)
此时变量a、b指向的同一个列表中多了一个数据，即此时列表为[1, 2, 3]
所以a、b此时用print输出相同的结果
补充内容
大家自己试试看a=257, b=257时它们的id还是否会相等。事实上Python 为了优化速度，使用了小整数对象池，避免为整数频繁申请和销毁内存空间。而Python 对小整数的定义是 [-5, 257)，只有数字在-5到256之间它们的id才会相等，超过了这个范围就不行了，同样的道理，字符串对象也有一个类似的缓冲池，超过区间范围内自然不会相等了。**
总的来说，只有数值型和字符串型，并且在通用对象池中的情况下，a is b才为True，否则当a和b是int，str，tuple，list，dict或set型时，a is b均为False。
赋值运算符=
赋值运算符=，之前为了更好的理解变量，把a=100理解为变量a中存放了100，事实上变量a存储是100的引用
也就是说：在Python中只要用=那么就表示=左边的变量存储了一个新的引用
大白话讲：就是=左边的变量指向了右边的数据
想想下面的代码运行的结果是什么？
a = [1, 2]
b = a
b.append(3)
b = [100, 200, 300]
print(b)
运行结果：
[100, 200, 300]
而不是：
[1, 2, 3]
引用当做实参
Python中调用函数时，传递实参实际上都是是引用，即传递的都是地址
只要是传递的引用，那么也就是说在函数中是可以直接对指向的数据进行修改
def test(p):
# 此时变量p也指向nums指向的列表
p.append(44)
print("在函数test中，p=", p)
nums = [11, 22, 33]
print("调用test函数之前，nums=", nums)
test(nums) # 此时将列表的引用当做了实参进行传递
print("调用test函数之后，nums=", nums)
运行结果：
调用test函数之前，nums= [11, 22, 33]
在函数test中，p= [11, 22, 33, 44]
调用test函数之后，nums= [11, 22, 33, 44]
函数名也是引用
引入
阅读如下代码，思考会输出什么结果
def test1():
print("我是test1函数哦。。。。")
def test2():
print("我是test2函数哦。。。。")
test1()
test1 = test2
test1()
运行结果如下：
我是test1函数哦。。。。
我是test2函数哦。。。。
你可能会惊讶，为什么第9行调用test1函数输出的是我是test1函数哦。。。。，反而到了第12行再次调用test1函数时变成了我是test2函数哦。。。。
上述问题的原因核心点是：在Python中即使是函数名也是一个变量名，只不过这个变量没有指向普通的数据，而是指向了一段代码；也就是说如果定义了一个函数名字叫做test1就好比是一个变量名test1指向了那个代码块而已，所以当上述代码第11行test1 = test2时，就相当于让test1变量不在指向原本的代码块，而是指向新的代码块即test2指向的代码块，所以当第12行执行test1函数时，会输出我是test2函数哦。。。。
引用的作用
看完上述的引入知识后，相信你会对什么是函数的引入有一个大体的认知了
在此简单总结：所谓函数名当做引用，其实是指在Python中所有的函数名实际上是一个变量名，只不过这个变量名指向的不是常见的数据，而是一段代码，当我们用函数名()是实际上就是让指向的这块代码开始执行，当我们只用函数名时其实就是这个函数的引用
记住：既然函数名也是变量名，那么就可以给它赋值获取它的引用给别的变量
总结：
- 使用
def定义的函数名，实际就是个变量名它存储了函数的引用 - 如果将另外一个变量，例如
b保存了函数的引用，即也指向了同一个函数，那么b()就是调用函数
匿名函数
什么是匿名函数
没有名字的函数，在Python中用lambda定义
示例：
lambda x, y: x + y # 定义了一个匿名函数 1.没有名字 2.完成2个数的加法操作
匿名函数的作用
- 可以用一行代码完成简单的函数定义
- 可以当做实参快速传递到函数中去
使用方式
用lambda关键词能创建匿名函数。这种函数得名于省略了用def声明函数的标准步骤
lambda函数的语法只包含一个语句，如下：
lambda 形参1, 形参2, 形参3: 表达式
注意点：lambda函数能接收任何数量的参数但只能返回一个表达式的值，其默认就是返回的，不用写return
既然我们已经知道def定义函数时的变量存储的是函数的引用，所以只要有了这个函数的引用，也就可以通过变量名()的方式调用函数
而函数分为def定义的普通函数，和用lambda定义的匿名函数，所以无论一个变量例如b保存的是普通函数的引用，还是匿名函数的引用，都可以用b()方式调用b指向的函数
一般情况下对匿名函数的使用有2种方式
- 通过
lambda定义匿名函数，然后用一个变量指向这个匿名函数，然后通过变量名()调用这个匿名函数 - 直接在调用其它函数实参的位置通过
lambda定义匿名函数，会将这个匿名函数的引用当做实参进行传递
方式一：
# 定义了一个匿名函数，然后让变量add_2_nums指向它
add_2_nums = lambda x, y: x + y
# 调用add_2_nums指向的匿名函数
print("10+20=" % add_2_nums(10, 20))
输出结果：
10+20=30
方式二：
def fun(a, b, opt):
print("a = %d" % a)
print("b = %d" % b)
print("result = %d" % opt(a, b)) # 此时opt指向了第7行定义的匿名函数，所以opt(a, b)就相当于调用匿名函数
fun(1, 2, lambda x, y: x + y) # 定义一个匿名函数，且将它的引用当做实参进行传递
代码案例
想一想，下面的数据如何指定按age或name排序？
stus = [
{"name": "顾安", "age": 18},
{"name": "夏洛", "age": 19},
{"name": "木木", "age": 17}
]
按照name排序：
stus = [
{"name": "顾安", "age": 18},
{"name": "夏洛", "age": 19},
{"name": "木木", "age": 17}
]
print("排序前，stus=", stus)
stus.sort(key=lambda x: x['name'])
print("排序后，stus=", stus)
按照age排序：
stus = [
{"name": "顾安", "age": 18},
{"name": "夏洛", "age": 19},
{"name": "木木", "age": 17}
]
print("排序前，stus=", stus)
stus.sort(key=lambda x: x['age'])
print("排序后，stus=", stus)