10.函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
语法
Python 定义函数使用 def 关键字，一般格式如下：
def 函数名（参数列表）:
函数体
默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
# 定义无参函数 def myprint(): print("hello") myprint() # 定义有参函数 def funcWithArgs(arg1, arg2): print(arg1, arg2) funcWithArgs("hello", "world") #定义有返回值函数 def getMax(num1, num2): if num1 > num2: return num1 elif num1 < num2: return num2 else: return "一样大" res= getMax(3, 3) print(res)
参数
以下是调用函数时可使用的正式参数类型：
- 必需参数
- 关键字参数
- 默认参数
- 不定长参数
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：
#可写函数说明 def printme( str ): "打印任何传入的字符串" print (str) return # 调用 printme 函数，不加参数会报错 printme()#TypeError: printme() missing 1 required positional argument: 'str'
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
# 以下实例中演示了函数关键字参数的使用不需要使用指定顺序： def meanArgFunc(name,age): print(name,age) meanArgFunc(18,"tom")#18 tom meanArgFunc(age=18,name="tom")#tom 18
声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 *，则星号 * 后的参数必须用关键字传入，例如:
def f(a,b,*,c,d): print(a,b,c,d) f(1,2,3,4)#TypeError: f() takes 2 positional arguments but 4 were given f(1,2,c=3,d=4)
强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
以下使用方法是正确的:
f(10, 20, 30, d=40, e=50, f=60)
以下使用方法会发生错误:
f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
def defaultParramFunc(age=18,name="tom"): print(name,age) defaultParramFunc(age=88,name="tom")#tom 88
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
还有一种就是参数带两个星号 **基本语法如下：
使用 **kwargs 表示接收任意数量的额外关键字参数，这些参数会被封装成一个字典。
def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def longParamFunc(name,*argTuple): print(name,',',end='') i=1 for arg in argTuple: if i<len(argTuple): print(arg,",",end="") i+=1 else: print(arg,end="") longParamFunc("tom",18,"男","180cm")#tom ,18 ,男 ,180cm
如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：
def longParamFunc(name,*argTuple): i=1 if len(argTuple)>1: for arg in argTuple: if i<len(argTuple): print(arg,",",end="") i+=1 else: print(arg,end="") else: print(name,end="") longParamFunc("tom")#Tom
还有一种就是参数带两个星号 **，加了两个星号 ** 的参数其实就是不定长的关键字参数，会以字典的形式导入。
def dictParamFunc(name,**argDicts): print(name,argDicts) dictParamFunc("Tom",one=1,tow=2)#Tom {'one': 1, 'tow': 2}
匿名函数
Python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
- lambda 只是一个表达式，函数体比 def 简单很多。
- lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
- lambda 函数是一种小型、匿名的、内联函数，它可以具有任意数量的参数，但只能有一个表达式。
- lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用，例如在 map()、filter()、reduce() 等函数中。
- 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。
lambda 函数特点：
- lambda 函数是匿名的，它们没有函数名称，只能通过赋值给变量或作为参数传递给其他函数来使用。
- lambda 函数通常只包含一行代码，这使得它们适用于编写简单的函数。
语法
lambda 函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
lambda arguments: expression
lambda是 Python 的关键字，用于定义 lambda 函数。arguments是参数列表，可以包含零个或多个参数，但必须在冒号(:)前指定。expression是一个表达式，用于计算并返回函数的结果。
以下的 lambda 函数没有参数：
f = lambda: "Hello, world!" print(f()) # 输出: Hello, world!
设置参数 a 加上 10:
f=lambda a:a+10 print(f(10))
以下实例匿名函数设置两个参数：
f2=lambda a,b:a+b print(f2(10,20))#30
lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作。例如：
numbers = [1, 2, 3, 4, 5] squared = list(map(lambda x: x**2, numbers)) print(squared) # 输出: [1, 4, 9, 16, 25]
使用 lambda 函数与 filter() 一起，筛选偶数：
numbers = [1, 2, 3, 4, 5, 6, 7, 8] even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) print(even_numbers) # 输出：[2, 4, 6, 8]
下面是一个使用 reduce() 和 lambda 表达式演示如何计算一个序列的累积乘积：
from functools import reduce numbers = [1, 2, 3, 4, 5] # 使用 reduce() 和 lambda 函数计算乘积 product = reduce(lambda x, y: x * y, numbers) print(product) # 输出：120
在上面的实例中，reduce() 函数通过遍历 numbers 列表，并使用 lambda 函数将累积的结果不断更新，最终得到了 1 * 2 * 3 * 4 * 5 = 120 的结果。
我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。
以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：
def myfunc(n): return lambda a : a * n mydoubler = myfunc(2) mytripler = myfunc(3) print(mydoubler(11)) print(mytripler(11))
函数传参技巧
传参后解包
def fun(args): # 解包参数：args=(0, [], True) num,list,flag = args if flag: list.append(num) list=[] # 将多个参数打包成元组 argslists=[(num,list,num<5) for num in range(10) if num<5 ] print(argslists)#[(0, [], True), (1, [], True), (2, [], True), (3, [], True), (4, [], True)] for args in argslists: fun(args) print(list)#[0, 1, 2, 3, 4]
传参前解包
def fun(num,list,flag): if flag: list.append(num) list=[] # 将多个参数打包成元组 argslists=[(num,list,num<5) for num in range(10) if num<5 ] print(argslists)#[(0, [], True), (1, [], True), (2, [], True), (3, [], True), (4, [], True)] for args in argslists: # 使用“*”添加到元组之前，解包参数：将(0, [], True)解包为三个参数：0, [], True fun(*args) print(list)#[0, 1, 2, 3, 4]
def add(a, b, c): return a + b + c numbers = [1, 2, 3] # 正确写法：解包列表为独立参数 result = add(*numbers) # 等价于 add(1, 2, 3) print(result) # 输出 6 # 错误写法：直接传递列表 result = add(numbers) # 等价于 add([1,2,3])，参数数量不匹配 # 报错：TypeError: add() missing 2 required positional arguments: 'b' and 'c'
浙公网安备 33010602011771号