函数
数学定义
y=f(x), y是x的函数，x是自变量。y=f(x0,x1,…xn)

Python函数
由诺干语句组成的语句块、函数名、参数列表构成，它是组织代码的最小单元
能完成一定的功能
是一个可调用对象，可以使用callable(函数名)判断该名称是否是一个可调用对象

函数的作用
结构化编程对代码的最基本封装，一般按照功能组织一段代码
封装的目的为了复用，减少冗余代码
代码更加简洁美观、可读易懂

函数的分类
内建函数，如：max()、reversed()等
库函数，如math.ceil()
自定义函数，使用def等关键字定义

函数定义

def 函数名（参数列表）:函数体（代码块）return 返回

函数名就是标识符。命名要求和标识符命名要求一样。
语句块必须缩进，约定4个空格
Python的函数如果没有return语句，那么默认会返回None值
定义中的参数列表成为形式参数，只是一种符号表达（标识符），简称形参

函数调用
函数定义，只是在内存中声明了一个函数。需要调用才能执行该函数
调用方法：函数名加上小括号，如果有必要参数，需要在括号内写上参数
调用时写的参数是实际参数，是实实在在传入的值，简称实参

def add(x,y):     #函数定义result = x + y   #函数体return result   #返回值out = add(4,5)    #函数调用，可能有返回值，让变量接收这个值
print(out)       #print函数加上括号也是调用，out是实参

上面代码解释：

定义一个函数add,函数名是add，只能接受2个参数
该函数计算的结果，通过返回值返回，需要return语句
调用时，通过函数名add后加2个参数，通过返回值可使用变量接收
函数名也是标识符
返回值也是值
定义需要在调用之前，就是说调用时，已经被定义过了，否则抛出NameError异常
函数是可调用对象，Callable(add)返回True

函数参数

参数是调用函数时传入的。参数要和函数定义的形参想匹配(可变参数例外)

位置参数:
定义时def f(x,y,z)，调用使用f(1,3,5)，按照参数定义顺序传入实参

关键字参数：
定义时def f(x,y,z)，调用使用f(x=1, y=3, z= 5)，使用形参的名字来传入实参的方式，如果使用了形参名字，那么传参顺序就可和定义顺序不同
要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的

def f(x, y, z):passf(z=None, y=10, x=[1])
f((1,), z=6, y=4.1)
f(y=5, z=6, 2) #错误传参

参数缺省值：
缺省值也称为默认值，可以在函数定义时，为形参增加一个缺省值。其作用：

参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值
参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用
可在定义缺省值时，将不常修改的缺省值放在其他缺省值后

def add(x=4, y=5):return x+y

测试调用:

#用print()测一下输出结果是多少
add()			9
add(x=5)		10
add(y=7)		11
add(6, 10)		16
(add(6, y=7)	13
add(x=5, y=6)	11
add(y=5, x=6)	11
add(x=5, 6)		#SyntaxError
add(y=8, 4)		#SyntaxError
add(8, x=4)		#TypeError

总结：def add(x, y=5)，这样可以定义
def add(x=4, y)，这样定义会报错SyntaxError

实例 定义一个函数login，参数名称为lost、port、username、password

def login(host='192.168.1.1', port='8080', username='luqx',password='luqx'):print('{}:{}@{}/{}'.format(host, port, username, password))login()
login('127,0,0,1', 80, 'tom', 'tom')
login('127.0.0.1', port=80, password='com')
login('localhost', port=80, password='com')
login(port=80, password='magedu', host='www')

输出结果

192.168.1.1:8080@luqx/luqx
127,0,0,1:80@tom/tom
127.0.0.1:80@luqx/com
localhost:80@luqx/com
www:80@luqx/magedu

作用

参数的默认值可以在未传入足够的实参时，对没有给定的参数赋值即为默认值
参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用

混合调用

如果使用位置参数和关键字参数混合调用。那么位置参数必须要在关键字参数之前传入，参数不能重复
例：

def add(x,y,z):return x+y+z
#使用位置参数调用
add(1,2,3) #此时形参x=1,y=2,z=3的方式按照顺序获取实参
#使用关键字参数调用
add(z=1,y=3,x=5) #直接指定形参的值调用函数
#形参和实参混合调用
add(4,z=5,y=3) ##正确， #错误写法add(4,x=3,z=8)

函数的可变参数

可变位置参数

一个形参可以匹配任意个参数。会收集多个实参组成一个tuple
注意：
可变位置参数必须要在位置参数后面
可变位置参数不能使用关键字传参

def sum(*args):sum = 0for x in args：sum += 1return sum
print(sum(1,3,5))

可变关键字参数

表示方法：【 ** 变量名】
形参前使用 ** 符号，表示可以接收多个关键字参数
收集的实参名称和值组成一个字典
注意：
可变关键字参数，必须要在所有参数最后面（即，参数，可变参数，可变位置参数）

##可变关键字传参定义
def showname(**kwargs):for k,v in kwargs.items():print("{}:{}".format(k,v))
##调用
showname(a=1,b=2,c=3)

混合使用

混合使用参数的时候，可变关键字参数要放到参数列表的最后，普通参数需要放到参数列表的前面，关键字参数 要放在可变位置参数和可变关键字参数之间
混合定义参数顺序：普通参数，缺省值参数，可变位置参数，关键字参数(keyword-only)(可带缺省值)，可变关键字参数
混合定义参数传参顺序：位置参数在关键字参数前面
注意：混合传参时，可变关键字参数名称不能与普通参数名称相同。
例：

def showname(name,sex=6,*args,b=15,c,**kwargs):print("name={}\nsex={}\nargs={}\nb={}\nc={}\nkwargs={}".format(name,sex,args,b,c,kwargs))
##调用
showname(1,5,4,5,b=23,c=34,hh=23)

keyword-only参数
在python3之后，新增keyword-only参数
keyword-only参数：在形参定义时，在一个*星号之后，或一个可变位置参数之后，出现的普通参数，就已经不是普通的参数了，称为keyword-only参数。
keyword-only参数，就是这个参数必须采用关键字传参

def fn(*args,x):print(x,args)
fn(3,5,x=7)def fn(*,x):print(x,args)
fn(3,5,x=7)

参数的混合使用

def fn(x,y,z=3,*args,m=4,n,**kwargs)print(x,y,z,m,n)print(args)print(kwargs)
fn(1,2,3,4,5,6,m=7,n=8,a=‘b’,b=‘abc’)

参数列表参数一般顺序是:普通参数、缺省参数、可变位置参数、keyword-only(可带缺省值)、
可变关键字参数。
注意：
代码应该是易读易懂，而不是为难别人
请按照书写习惯定义函数参数

定义最常用参数为普通参数，可不提供缺省值，必须由用户提供。注意这些参数的顺序，最常用的先定义
将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参
如果函数有很多参数，无法逐一定义，可使用可变参数。如果需要知道这些参数的意义，则使用可变关键字参数收集

参数解构

在集合类型前使用 * 或者**，把集合类型的解构解开，提取所有元素作为函数的实参
非字典类型使用*解构成位置参数
字典类型使用**解构成关键字参数
提取出来的元素数目要和参数的要求匹配，也要和参数的类型匹配
例：

def add(x,y):return x+y
add(*[4,5]) #相当于add(4,5)
add(*{'x':4,'y':5}) #相当于add("a","b")
add(**{"x":4,"y":5}) #等价于add(x=4,y=5),其中两个星号表示两层解构

总结
有位置可变参数和关键字可变参数
位置可变参数在形参前使用一个星号*，关键字可变参数使用两个星号**
位置可变参数和关键字可变参数都可以手机若干个实参，位置可变参数收集形成一个tuple,关键字可变参数收集成一个dict
混合使用参数的时候，可变关键字参数要放到参数列表的最后，普通参数需要放到参数列表的前面，关键字参数 要放在可变位置参数和可变关键字参数之间
混合定义参数传参顺序：位置参数在关键字参数前面

函数返回值
例
1.return语句之后可以执行吗?

def showplus(x):print(x)return x + 1print('-'*30)  # return语句之后会执行吗showplus(5) # 5，输出结果#return之后print('-'*30)并没有执行
5 # 输出结果,return之后print('-'*30)并没有执行

2.多条return语句都会执行吗

def showplus(x):print(x)return x + 1return x + 2showplus(5) #， 输出结果 # return之后return x + 2并没有执行

3.下例多个return可以执行吗?

def guess(x):if x > 3:return "> 3"else:return "<= 3"print(guess(4)) # >3, 输出结果
print(guess(2)) # <=3,输出结果

4.观察下例函数执行的结果

def fn(x):for i in range(x):if i > 3:return ielse:print("{} is not greater than 3".format(x))print(fn(5)) #4 输出结果
print(fn(2)) # 2 is not greater than 3 ；None 输出结果

总结
Python函数使用return语句返回“返回值”
所有函数都有返回值，如果没有return语句，隐式调用retuen None
return语句并不一定是函数的语句块的最后一条语句
一个函数可以存在多个return语句，但是只有一条可以被执行。如果没有一条return语句被执行到，隐式调用return None
如果有必要，可以显示调用return None，可以简写为return
如果函数执行了return语句，函数就会返回，当前被执行的reutrn语句之后的其他语句就不会被执行了
返回值的作用：结束函数调用、返回“返回值”

def showvalues():return 1, 3, 5
print(showvalues()) #输出结果(1, 3, 5)

函数不能同时返回多个值
return 1, 3, 5看似返回多个值，隐式的被python封装成了一个元祖
x, ,y, z =showlist() 使用结构提取返回值更为方便

函数作用域

作用域
一个标识符的课件范围，这就是标识符的作用域。一般常说的是变量的作用域

def foo():x = 100
print(x) # 可以访问到吗

上例中x不可以访问，会抛出异常（NameError:name ‘x’ is not defined）,原因在于函数是一个封装，它会开辟一个作用域，x变量被限制在这个作用域中，所以在函数外部x变量不可见
注意：每一个函数都会开辟一个作用域
作用域分类
全局作用域
在整个程序运行环境中都可见
全局作用域中的变量称为全局变量
局部作用域
在函数、类等内部课件
局部作用域中的变量称为局部变量，其使用范围不能超过其所在局部作用域
局部变量

def fn1():x = 1 #局部作用域,x为局部变量,使用范围在fn1内def fn2():print(x) # x 能打印吗? 可见吗? 为什么?print(x) #x能打印吗?可见吗?为什么?

全局变量

x = 5 # 全局变量，也在函数外定义
def foo():print(x) #可见吗？为什么？foo()

一般来讲外部作用域变量在函数内部可见，可以使用
反过来，函数内部的局部变量，不能在函数外部看到
函数嵌套
在一个函数中定义了另外一个函数

def outer():def inner():print("inner")print("outer")inner()outer() # 可以调用吗
inner() # 可以调用吗

内部函数inner不能在外部直接使用，会抛出NameError异常，因为它在函数外部不可见
其实，inner不过就是一个标识符，就是一个函数outer内部定义的变量而已
嵌套结构的作用域
对比下面嵌套结构，代码执行的效果

def outer():o = 65def inner():print("inner {}".format(o))print(chr(0))inner()print("outer {}".format(o))outer() #输出结果 inner 65  ； outer 65

def outer2():o = 65def inner():o = 97print("inner {}".format(o))print(chr(0))inner()print("outer {}".format(o))outer2() #输出结果 inner 97  ； outer 65

从执行的结果来看：
外层变量在内部作用域课件
内部作用域inner中，如果定义了 o = 97，相当于在当前函数inner作用域中重新定义了一个新的变量o，但是，这个o并不能覆盖掉外部作用域outer2中的变量o，只不过对于inner函数来说，其只能可见自己作用域中定义的变量o
一个赋值语句的问题

x = 5
def foo():x += 1
foo() #报错如下
#UnboundLocalError: local variable 'x' referenced before assignment

原因分析：
x += 1其实是 x = x+1
相当于在foo内部定义一个局部变量 x，那么foo内部所有x都是这个局部变量x了
x = x +1 相当于使用了局部变量x，但是这个x还没有完成赋值，就被右边拿来做加1操作了
如果解决这个常见问题？
global语句

x = 5
def foo():global x #全局变量x +=1print(x)
foo()

使用global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x
全局作用域中必须有x的定义
使用了global，foo中的x不再是局部变量，它是全局变量
总结
x += 1 这种是特殊形式产生的错误的原因？先引用后赋值，而python动态语言是赋值才算定义，才能被引用。解决办法，在这条与语句前增加x=0之类的赋值语句，或者使用global告诉内部作用域，去全局作用域查找变量定义
内部作用域使用 x= 10 之类的赋值语句会重新定义局部作用域使用的变量x，但是，一旦这个作用域中使用global声明x为全局的，那么x=5相当于在未全局作用域的变量x赋值
global使用原则
外部作用域变量会在内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的就是为了封装，列表玉外界隔离
如果函数需要使用外部全局变量，请尽量使用函数的形参定义，并在调用传实参解决
闭包
自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量
闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。很多语言都有这个概念，最熟悉就是JaveSceipt

def counter():c = [0]def inc():c[0] += 1return c[0]return inc
foo = counter()
print(foo(), foo())
c = 100
print(foo())

代码分析
第7行会执行counter函数并返回inc对应的函数对象，注意这个函数对象并不释放，因为有foo记着
第4行不会报错，c已经在counter函数中定义过了。而且inc中的使用方式是为c的元素修改值，而不是重新定义c变量
第8行打印 1 2
第10行打印 3
第9行的c和counter中的不一样，而inc引用的是自变量真是counter中的变量c
这就是Python2中实现闭包的方式，Python3还可以使用nonlocal关键字
nonlocal语句
nonlocal：将变量标记为不在本地作用域定义，而是在上级的某一级局部作用域中定义，但不能是全局作用域中定义。

def counter():count =0def inc():nonlocal count #声明变量count不是本地变量count += 1return countreturn incfoo = counter()
print(foo(),foo()) # 打印结果 1  2

count 是外层函数的局部变量，被内部函数引用
内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义
代码中内层函数引用外部局部作用域中的自由变量，形成闭包

默认值的作用域

def foo(xyz=1):print(xyz)foo() #打印 1
foo() #打印 1
print(xyz) #错误传参 xyz是foo函数的本地变量，不可再函数范围外直接调用

def foo (xyz=[]):xyz.append(1)print(xyz)foo() #打印 [1]
foo() #打印[1, 1]
print(xyz) #同上

第二次调用foo函数打印的是[1, 1]
因为函数也是对象，每个函数定义被执行后，就生成了一个函数对象和函数名这个标识符关联
python把函数的默认值放在了函数对象的属性中，这个属性就伴随着这个函数对象的整个生命周期
通过查看foo._defaults_属性,它是个元祖

def foo (xyz=[], m=123, n='abc'):xyz.append(1)print(xyz)print(id(foo),foo.__defaults__)	# 打印结果 35535864 ([], 123, 'abc')
foo()							# 打印结果 [1]
print(id(foo),foo.__defaults__)	#打印结果 35535864 ([1], 123, 'abc')
foo()							#打印结果[1, 1]
print(id(foo),foo.__defaults__) #打印结果 35535864 ([1, 1], 123, 'abc')

函数地址并没有变，就是说foo这个函数对象没有变过，调用它，它的属性__defaults__中使用元祖保存默认值xyz默认值是引用类型，引用类型的元素变动，并不是元祖的变化

非引用类型缺省值

def foo (xyz, m=123, n='abc'):m = 456n = 'def'print(xyz)print(foo.__defaults__)	#结果 (123, 'abc')
foo('hello')			#结果 hello
print(foo.__defaults__)	#结果 (123, 'abc')

属性__defaults__中使用元祖保存所有位置参数默认值，它不会因为在函数体内改变了局部变量（形参）的值而发生改变

keyword-only参数的缺省值

def foo(xyz, m=123, *,n='abc',t =[1, 2]):m = 456n = 'def't.append(30)print(xyz, m, n, t)print(foo.__defaults__,foo.__kwdefaults__)	# 结果 (123,) {'n': 'abc', 't': [1, 2]}
foo('hello')								# 结果 hello 456 def [1, 2, 30]
print(foo.__defaults__,foo.__kwdefaults__)	# 结果 {'n': 'abc', 't': [1, 2, 30]}

属性__defaults__中使用元祖保存所有位置参数默认值
属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值
+和+=的区别：
+表示两个列表合并并返回一个全新的列表
+=表示，就地修改前一个列表，在其后追加一个列表。就是extend方法
变量名解析原则LEGB
Local，本地作用域、局部作用域的local命名空间。函数调用时穿件，调用结束消亡
Enclosing，Python2.2时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间
Global，全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡
Build-in，内置模块的命名空间，生命周期从python解释器启动时创建到解释器退出时消亡。例如print(open)，print和open都是内置的变量

函数的销毁
定义一个函数就是生产一个函数对象，函数名指向的就是函数对象
可以使用del语句删除函数，使用引用计数减1
可以使用同名标识符覆盖原有定义，本质上也是使其应用计数减1
Python程序结束时，所有对象销毁
函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0

内建函数

内建函数众多,这里讨论几个比较重要的(带★ 的),其他的需要了解的推荐参考Python的菜鸟教程,里面有详细的讲解.
● isinstance(obj, class_or_tuple)
判断对象obj是否属于某种类型或者元组中列出的某个类型

isinstance(True, int)# 这里的是object,可以是任何一个对象,True只是等效为数字一,所以是在int里.也可以输入 十进制数字,字符串,列表等等,对应的后面也要更改.

issubclass(class, class_or_tuple)
>>>True

判断类型cls是否是某种类型的子类或元组中列出的某个类型的子类

issubclass(bool, int) #函数的class表示必须是classs的参数,如 int bool str

sum(iterable[, start])
>>>True 

从 start 开始，从左到右对 iterable 中的元素求和。 start 默认是 0，迭代的 item 通常是数字，并且不允许 start 的值为字符串。
对于有些情况，有比 sum() 更好的选择，
比如：连接字符串应该用 ‘’.join(sequence)。
浮点数求和用 math.fsum() 。
要连接一系列 iterable，请考虑使用 itertools.chain()。
sum 可以对迭代对象求和,或者加上求和的初始值

sum (iterable,start)
sum(range(10),10)
>>>55

● sorted(iterable[, key][, reverse])
从 iterable 中的 item 中返回一个新的排序列表。
有两个可选参数，必须将其指定为关键字参数。
key 指定一个带有一个参数的函数，用于从每个列表元素中提取比较键：key=str.lower。默认值是 None（直接比较元素）。
reverse 是一个布尔值。如果设置为 True，那么列表元素按照每个比较被颠倒的s顺序进行排序。
内置的 sorted() 函数排序是稳定的。如果确保不会更改比较相等的元素的相对顺序，则排序是稳定的 。
举例:

sorted([1, 3, 5])  
sorted([1, 3, 5,'6'], key=int,reverse=True)  #字符串先转化成int格式进行排序
sorted({'c':1, 'b':2, 'a':1})  # 默认按照字典的key进行排序
注意与列表的sort比较
ls=[1,2,'3']
ls.sort(key=int,reverse =True)   #直接用sort将报错,因为内部格式不一致
>>>['3',2,1]#将字符串先转化成int格式进行排序

● reversed(seq)
返回一个反向迭代器。seq 必须是具有 reversed() 方法或支持序列协议（ len() 方法和整数参数从 0 开始的 getitem() 方法）的对象。

返回迭代器,每需要一个元素就返回一个元素

list(reversed(“13579”))
{ reversed((2, 4)) } # 有几个元素？
for x in reversed([‘c’,‘b’,‘a’]):
print(x)
reversed(sorted({1, 5, 9}))

reversed(set(range(10)))# set是无序结构,所以不能反转.

● enumerate(iterable, start=0)
返回一个枚举对象。 iterable 必须是一个序列，一个迭代器或其他支持迭代的对象。由 enumerate() 返回的迭代器的 next() 方法返回一个元组，该元组包含一个计数（从 start 开始，默认值为 0）以及遍历迭代获得的值。

for x in enumerate([2,4,6,8]):print(x)   
(0, 2)
(1, 4)
(2, 6)
(3, 8)返回一个有起始值的计数元组

● iter(iterable)
迭代器和取元素iter(iterable)、next(iterator[, default])
iter将一个可迭代对象封装成一个迭代器
next对一个迭代器取下一个元素。如果全部元素都取过了，再次next会抛StopIteration异常

it = iter(range(5))
next(it)
it = reversed([1,3,5])
next(it)

可迭代对象
● 能够通过迭代一次次返回不同的元素的对象。
所谓相同，不是指值是否相同，而是元素在容器中是否是同一个，例如列表中值可以重复的，[‘a’, ‘a’]，虽然这个列表有2个元素，值一样，但是两个’a’是不同的元素，因为有不同的索引
● 可以迭代，但是未必有序，未必可索引
● 可迭代对象有：list、tuple、string、bytes、bytearray、range对象、set、dict、生成器、迭代器等
● 可以使用成员操作符in、not in，in本质上对于线性结构就是在遍历对象，非线性结构求hash

迭代器
● 特殊的对象，一定是可迭代对象，具备可迭代对象的特征
● 通过iter方法把一个可迭代对象封装成迭代器
● 通过next方法，迭代迭代器对象
● 生成器对象，就是迭代器对象

● zip(*iterables)
制作一个迭代器，用于聚合来自每个迭代器的元素。

返回元组的迭代器，其中第 i 个元组包含来自每个参数序列或迭代的第 i 个元素。当最短的输入迭代耗尽时，迭代器停止。使用单个迭代参数，它将返回 1 元组的迭代器。没有参数，它返回一个空的迭代器。
举例:

list(zip(range(10),range(10)))# 返回的列表里都是含两个元素的元组
list(zip(range(10),range(10),range(5),range(10)))# 列表里含4个元素的元组
dict(zip(range(10),range(10)))# 构建字典
{str(x):y for x,y in zip(range(10),range(10))}# 构建字典
1

与 * 操作符一起使用 zip() 可用于解构列表：

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)

● all & any

all()#任何元素都等效等于True,空的可迭代对象返回True
any()#其中任一元素等效于True,空的可迭代对象返回False
举例:

lst = [True, {1}, [2, 3], 5.1, 'abc']
print(all(lst), any(lst))
print(all([]), any([]))
print(all(lst + [0]), any(lst + [0]))

匿名函数Lambda表达式

Python中，使用Lambda表达式构建匿名函数

lambda x: x ** 2 #定义
(lambda x: x ** 2)(4) #调用foo = lambda x,y:(x+y) ** 2 #定义函数,不推荐,不如直接定义
foo(1,2)
#等价于
def foo(x,y):return (x+y) ** 2

使用lambda关键字定义匿名函数,格式为 lambda [参数列表]: 表达式
参数列表不需要小括号。无参就不写参数
冒号用来分割参数列表和表达式部分
不需要使用rrturn。表达式的值，就是匿名函数的返回值。表达式中不能出现等号
lambda表达式（匿名函数）只能写在一行上，也称为单行函数
匿名函数往往用在未高阶函数传参时，使用lambda表达式，往往能简化代码
将函数对象加入列表中,通过索引访问

[lambda x : x + 1][0](1) # 调用 #返回值 2

比较整数和字符串大小

l1 = [1, 2, 'a', '1']
sorted(l1, key=lambda x: ord(x) if isinstance(x, str) else x)
#返回值 [1, 2, '1', 'a']

返回常量的函数

print((lambda :0)()) #

加法匿名函数，带缺省值

print((lambda x,y=3:x + y)(5)) # 打印结果 8
print((lambda x,y=3:x + y)(5,6)) # 打印结果 11

keyword-only参数

print((lambda x,*,y=3:x + y)(5)) # 打印结果 8
print((lambda x,*,y=3:x + y)(5,y=6)) # 打印结果 11

可变参数

print((lambda *args:[x for x in args])(*range(5))) # 打印结果 [0, 1, 2, 3, 4]
print((lambda *args:{x for x in args})(*range(5)))  # 打印结果  {0, 1, 2, 3, 4}
print((lambda *args:(x for x in args))(*range(5))) # 打印结果 <generator object <lambda>.<locals>.<genexpr> at 0x0000000001DF5E60>

注:print((lambda *args:(x for x in args))(*range(5)))的打印结果为生成器表达式，因为(x for x in args)使用了小括号，而这种表达方式为生成一个惰性的生成器表达式