Python-函数的参数
一、形参与实参介绍
形参：在定义函数阶段定义的参数称之为形式参数，简称形参，相当于变量名。
def func(x, y):
实参：在调用函数阶段传入的值称之为实际参数，简称实参，相当于变量值。
func(1,2)
形参与实参的关系：
- 在调用阶段，实参（变量值）会绑定给形参（变量名）。
- 这种绑定关系只能在函数体内使用。
- 实参与形参的绑定关系在函数调用时生效，函数调用结束后解除绑定关系。
实参是传入的值，但值可以是以下形式：
-
形式一
func(1,2) -
形式二
a=1 b=2 func(a,b) -
形式三
func(int('1'), 2) func(func1(1, 2, ), func2(2, 3), 333)
二、形参与实参的具体使用
-
位置参数：按照从左到右的顺序依次定义的参数称之为位置参数。
位置形参：在函数定义阶段，按照从左到右的顺序直接定义的“变量名”。
特点：必须被传值，多一个不行少一个也不行
def func(x,y):位置实参：在函数调用阶段， 按照从左到有的顺序依次传入的值。
特点：按照顺序与形参一一对应
func(1,2) -
关键字参数（关键字实参）
关键字实参：在函数调用阶段，按照 key = value 的形式传入的值。
特点：指名道姓给某个形参传值，可以完全不参照顺序
def func(x, y): print(x, y) # 1 2 func(y=2, x=1)当位置实参与关键字实参混合使用时，强调：
-
位置实参必须放在关键字实参前
def func(x, y): print(x, y) func(1, y=2) # 1 2 # func(y=2, 1) # 报错 -
不能为同一个形参重复传值
def func(x, y): print(x, y) # func(1, y=2, x=3) # 报错 # func(1, 2, x=3, y=4) # 报错
-
-
默认参数（默认形参）
默认形参：在定义函数阶段，就已经被赋值的形参，称之为默认参数。
特点：在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值(但还是支持再被赋值的)。
def func(x, y=3): print(x, y) func(1) # 1 3 func(x=1, y=444) # 1 444def register(name, age, gender='男'): print(name, age, gender) register('张三', 18) # 张三 18 男 register('李四', 19) # 李四 19 男 register('王五', 19) # 王五 19 男 register('小六', 19, '女') # 小六 19 女当位置形参与默认形参混用时，强调：
-
位置形参必须在默认形参的左边
def func(x, y=3): pass # def func1(y=2, x): # 报错，有语法错误 # pass -
默认形参的值是在函数定义阶段被赋值的，准确地说被赋予的是值的内存地址
m = 2 def func(x, y=m): # y=>2的内存地址 print(x, y) m = 333 func(1) # 1 2m = [111, ] def func(x, y=m): # y ==> [111, ]的内存地址 print(x, y) m.append(2333) func(1) # 1 [111, 2333]x = 10 def fun(a, b, c=x): # 代码从上至下执行，c与10的内存地址绑定，故下面的x=20对这里没有影响。 print(a, b, c) x = 20 print(x) # 20 fun(1, 2) # 1 2 10 -
虽然默认形参的值可以被指定为任意数据类型，但是不推荐使用可变类型。因为函数最理想的状态是：“函数的调用只跟函数本身有关系，不外界代码的影响”。
def func(x, y, z, l=[]): # 虽然形参里l=[]外界没有能控制它的变量名，不会发生因为内存绑定而间接受外界影响发生改变的情况，但也不要这么写，这是约定俗成。 # 规范要求，默认参数最好是不可变类型，不受外界影响。如果需要用可变类型，先给None再转化。 l.append(x) l.append(y) l.append(z) print(l) # 进行优化后 def func(x, y, z, l=None): if l is None: # 如果l==None，表明传进来的实参没有改变它，就可以对它进行一个转化了。 l = [] l.append(x) l.append(y) l.append(z) print(l)def func(x, y, z, l=None): if l is None: l = [] l.append(x) l.append(y) l.append(z) print(l) func(1, 2, 3) # [1, 2, 3] func(4, 5, 6) # [4, 5, 6] new_l = [111, 222] func(1, 2, 3, new_l) # [111, 222, 1, 2, 3]
-
-
可变长度的参数(*与**的用法)
可变长度指的是在调用函数时，传入的值（实参）的个数不固定。
而实参是用来为形参赋值的，所以对应着，针对溢出的实参必须有对应的形参来接收。
-
可变长度的位置参数
-
“ * 形参名 ”：用来接收溢出的位置实参，溢出的位置实参会被保存成元组的格式然后赋值给紧跟在星号后的形参名。“ * ”后跟的可以是任意名字，但是约定俗成应该是args。
def func(x, y, *z): # z =（3,4,5,6） print(x, y, z) func(1, 2, 3, 4, 5, 6) # 1 2 (3, 4, 5, 6)# 求合 def my_sum(*args): res = 0 for item in args: res += item return res print(my_sum(1, 2)) # 3 print(my_sum(1, 2, -1)) # 2 print(my_sum(19, 20, 21)) # 60 -
* 可以用在实参中，实参中带 *，先将 * 后的值打散成位置实参（星号后的值一定是可以被for循环遍历的，实际上也是用for循环来把它“打散”的）。
def func(x, y, z): print(x, y, z) func(*[11,22,33]) # ==> func(11，22，33) # 11 22 33 l = [11, 22, 33] # func(l) # 报错 func(*l) # 11 22 33 -
形参与实参中都带 *，先把实参打散成位置实参，再对应给形参。
def func(x, y, *args): # args=(3,4,5,6) print(x, y, args) func(1, 2, [3, 4, 5, 6]) # 1 2 ([3, 4, 5, 6],) # 元组里面一个列表 func(1, 2, *[3, 4, 5, 6]) # ==> func(1,2,3,4,5,6) # 1 2 (3, 4, 5, 6) func(*'hello') # ==> func('h','e','l','l','o') # h e ('l', 'l', 'o')
-
-
可变长度的关键字参数
-
“ **形参名 ”：用来接收溢出的关键字实参，**会将溢出的关键字实参保存成字典格式，然后赋值给紧跟其后的形参名。**后跟的可以是任意名字，但约定俗成应该是kwargs。
def func(x, y, **kwargs): print(x, y, kwargs) func(1, y=2, a=1, b=2, c=3) # 1 2 {'a': 1, 'b': 2, 'c': 3} func(1, 2, 3) # 溢出的位置实参直接报错 -
** 可以用在实参中（** 后跟的只能是字典），实参中带 **，先将 ** 后的值打散成关键字实参。
def func(x, y, z): print(x, y, z) # func({'x': 1, 'y': 2, 'z': 3}) # 少两个实参，报错 func(*{'x': 1, 'y': 2, 'z': 3}) # x y z # for循环遍历字典遍历的是key，所以这里是 ==> func('x','y','z') func(**{'x': 1, 'y': 2, 'z': 3}) # ==> func(x=1,y=2,z=3) # 1 2 3 # 错误写法： # func(**{'x': 1, 'y': 2, }) # func(x=1,y=2) 实参少了，报错 # func(**{'x': 1, 'a': 2, 'z': 3})# func(x=1,a=2,z=3) 实参中出现了不能与形参对应的值，报错；而且y形参没有与其对应的实参，报错。 -
形参与实参中都带 **，先把实参打散成关键字实参，再对应给形参。
def func(x, y, **kwargs): print(x, y, kwargs) func(y=222, x=111, a=333, b=444) # 111 222 {'a': 333, 'b': 444} func(**{'y': 222, 'x': 111, 'a': 333, 'b': 444}) # 111 222 {'a': 333, 'b': 444}
-
-
* 与 ** 混用：* args 必须在 ** kwargs 之前
def func(x, **kwargs, *args): pass # 报错，有语法错误如果一个函数的形参为 *args 与 **kwargs ，那么代表该函数可以接收任何形式、任意长度的参数。利用这一点，可以帮助我们在开发中设计函数的可扩展性。因为这样的话，我们可以按照位置参数传进来得到的元组形式通过索引获取想要的值，按照关键字参数传进来得到的字典形式通过 key 获取想要的 value 。
def func(*args, **kwargs): print(args) print(kwargs) func(1, 2, 3, 4, 5, a=1, b=2, c=3) # (1, 2, 3, 4, 5) # {'a': 1, 'b': 2, 'c': 3}通过两个函数都使用 *args + **kwargs 再嵌套的方法，还可以实现一个函数把接收到的参数原封不动的传给另外一个函数的功能。
def index(x, y, z): print('index=>>> ', x, y, z) def wrapper(*args, **kwargs): index(*args, **kwargs) wrapper(1, z=3, y=2) # 结果为：index=>>> 1 2 3分析：按照上述写法，在为函数wrapper传参时，其实遵循的是函数index的参数规则，调用函数wrapper的过程分析如下：
-
位置实参1被 *args 接收，以元组的形式保存下来，赋值给 args ，即 args = (1, ) 。关键字实参z=3，y=2被 **kwargs 接收，以字典的形式保存下来，赋值给 kwargs，即 kwargs = { ‘y’ : 2 , ‘z’ : 3 }。
def index(x, y, z): print('index=>>> ', x, y, z) def wrapper(*args, **kwargs): index(*args, **kwargs) # 此时这句代码可以这么写：index(*(1, ), **{ 'y' : 2 , 'z' : 3 }) wrapper(1, z=3, y=2) -
我们知道，* 与 ** 都可以用在实参中( ** 后面只能是字典)，现在（index(*(1, ), **{ ‘y’ : 2 , ‘z’ : 3 })）就是这种情况。而* 与 ** 用在实参中是要将后面的值打散的，将 * 后的值打散成位置实参，将 ** 后的值打散成关键字实参。
def index(x, y, z): print('index=>>> ', x, y, z) def wrapper(*args, **kwargs): index(*args, **kwargs) # 此时传入index函数的真正形式是：index(1,y=2,z=3) wrapper(1, z=3, y=2)所以，给wrapper函数传递的参数是给index函数用的，遵循的是函数index的参数规则；而且这个参数传递的过程相当于“ 原格式 —》汇总 -----》打散回原形 ”。
-
-
-
命名关键字参数(了解)
在定义函数时，* 之后(不是紧跟其后)定义的参数，如下所示，称之为命名关键字参数。而且命名关键字参数必须要被传值，不传就会报错。
def func(x, y, *, a, b): # 其中，a和b称之为命名关键字参数 print(x, y) print(a, b)def func(x, y, *, a, b): print(x, y) print(a, b) func(1, 2, 222, 111) # 报错，只有两个位置形参却给了四个位置实参def func(x, y, *, a, b): print(x, y) print(a, b) func(1, 2, b=222, a=111) # 正常运行，不报错 # 程序运行结果： # 1 2 # 111 222特点：给命名关键字形参传值，实参必须按照 key = value 的形式为其传值。
我们还可以给命名关键字形参赋默认值，有了默认值就可以不用再给这个命名关键字形参传值。
def func(x, y, *, a=11111, b): print(x, y) print(a, b) func(1, 2, b=22222) # 程序运行结果： # 1 2 # 11111 22222注意：我们规定定义函数时，位置形参必须写在关键字形参(默认形参)之前，否则会报错。但这里为什么不报错呢？因为前面有星号存在，故a和b都已经是命名关键字形参，a=11111只不过是给a赋了一个初始值。要注意这里的a不是默认参数，b也不是位置参数，他们都是命名关键字参数。
-
组合使用(了解)
语法规定组合使用时形参遵守的顺序为：位置形参，默认形参，*args，命名关键字形参，**kwargs
def func(x, y=111, *args, z, **kwargs): print(x) print(y) print(args) print(z) print(kwargs)实参混用的顺序：
def func(x, y, z, a, b, c): print(x, y, z, a, b, c) # func(1, y=2, *[3, 4], **{'b': 5, 'c': 6}) # 报错 # 打散后为：func(1, y=2, 3, 4, b=5, c=6)，关键字实参y=2在位置实参之前，所以报错 func(1, *[2, 3], a=4, **{'b': 5, 'c': 6}) # 1 2 3 4 5 6
80
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
