『无为则无心』Python函数 — 26、Python函数参数的传递方式

2022-03-04 10:59:21

1、位置参数
2、关键字参数
3、缺省参数（默认参数）
4、不定长参数（可变参数）
- （1）包裹位置传递
- （2）包裹关键字传递
5、位置参数、默认参数、可变参数的混合使用
6、拓展：参数解包

提示：上一篇文章介绍了Python中函数的基本使用，本篇文章主要说明一下Python函数实参的传递方式。

1、位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

def user_info(name, age, gender):

    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

# 调用函数

user_info('TOM', 20, '男')

注意：传递和定义参数的顺序及个数必须一致。就是将对应位置的实参复制给对应位置的形参，第一个实参赋值给第一个形参，第二个实参赋值给第二个形参，以此类推。

示例：

def user_info(name, age, gender):

    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

# 1.调用函数，传递的参数个数不正确

# 结果：TypeError: user_info() missing 1 required positional argument: 'gender'

user_info('TOM', 20)

# 2.调用函数，传递的参数的顺序不正确

# 不会报错，但输出的内容完全歧义。

# 结果：您的名字是男, 年龄是TOM, 性别是20

user_info('男', 'TOM', 20)

2、关键字参数

可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数。

函数调用，通过键=值形式加以指定。

可以让函数更加清晰、容易使用，同时也清除了参数的需求。

def user_info(name, age, gender):

    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

# 正确用法

user_info('Rose', age=20, gender='女')

user_info('小明', gender='男', age=16)

# 位置参数必须写在关键字参数的前面

# 结果：SyntaxError: positional argument follows keyword argument

user_info(gender='男', age=16, "孙悟空")

# 位置参数必须写在关键字参数的前面，同时位置参数的顺序也要对应

# 结果：TypeError: user_info() got multiple values for argument 'age'

user_info("孙悟空", '男', age=16)

# 格式正确，但是位置参数的顺序不正确，结果也会产生歧义。

# 结果：您的名字是20, 年龄是孙悟空, 性别是男

user_info(20, "孙悟空", gender='男')

"""

总结：定义参数时，位置参数和关键字参数，尽量统一使用一种。

"""

注意：

位置参数和关键字参数可以混合使用。

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

3、缺省参数（默认参数）

缺省参数也叫默认参数，用于定义函数时，为参数提供默认值，调用函数时可不传该默认参数的值。

提示：所有位置参数必须出现在默认参数前（因为默认参数的格式和关键字参数格式一样，所以都要写在所有参数之后），包括函数定义和调用。

def user_info(name, age, gender='男'):

    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

# 没有为缺省参数传值，表示使用默认值。

user_info('TOM', 20)

# 为缺省参数传值，使用这个值，即修改了默认值。

user_info('Rose', 18, '女')

注意：函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值。

4、不定长参数（可变参数）

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。此时，可用包裹位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

（1）包裹位置传递

"""

1.在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参，

它将会将所有的实参保存到一个元组中

2.*args说明：*一定要写，args表示形参，可以自定义名称。

但在实际工作中，一般默认使用*args做为不定长包裹位置传递参数的表示，不做修改。

"""

def user_info(*args):

    print(args)

# ('TOM',)

user_info('TOM')

# ('TOM', 18)

user_info('TOM', 18)

# ()

user_info()

注意：传进的所有参数都会被args变量收集，它会根据传进的所有的位置实参，合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。（这个过程也叫装包或者组包）

小应用：

# 定义一个函数，可以求任意个数字的和

def sum(*nums):

    # 定义一个变量，来保存结果

    result = 0

    # 遍历元组，并将元组中的数进行累加

    for n in nums:

        result += n

    print(result)

sum(123, 456, 789, 10, 20, 30, 40)

注意事项：

# 注意事项1

# 带星号的形参只能有一个

# 带星号的参数，可以和其他参数配合使用

# 第一个参数给a，第二个参数给b，剩下的都保存到c的元组中

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)

"""

# 注意事项2

# 可变参数不是必须写在最后，但是注意，

# 带*的参数后的所有参数，必须以关键字参数的形式传递

# 第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数

def fn2(a, *b, c):

    print('a =', a)

    print('b =', b)

    print('c =', c)

# TypeError: fn2() missing 1 required keyword-only argument: 'c'

# fn2(1, 2, 3, 4, 5) # 报错

fn2(1, 2, 3, 4, c=5)

"""

输出结果：

a = 1

b = (2, 3, 4)

c = 5

"""

# 注意事项3

# 所有的位置参数都给a，b和c必须使用关键字参数，

# 且必须写在最后。

def fn2(*a, b, c):

    print('a =', a)

    print('b =', b)

    print('c =', c)

fn2(1, 2, 3, b=4, c=5)

"""

输出结果：

a = (1, 2, 3)

b = 4

c = 5

"""

# 注意事项4

# 如果在形参的开头直接写一个*,

# 则要求我们的所有的参数必须以关键字参数的形式传递。

def fn2(*, a, b, c):

    print('a =', a)

    print('b =', b)

    print('c =', c)

fn2(a=3, b=4, c=5)

"""

输出结果：

a = 3

b = 4

c = 5

"""

# 注意事项5

# *形参只能接收位置参数，而不能接收关键字参数

def fn3(*a):

    print('a =', a)

# TypeError: fn3() got an unexpected keyword argument 'a'

fn3(a=3, b=4, c=5)

（2）包裹关键字传递

"""

**kwargs说明：**一定要写，args表示形参，可以自定义名称。

但在实际工作中，一般默认使用**kwargs做为不定长包裹关键字传递参数的表示，不做修改。

"""

# 收集所有关键字参数，它会将这些参数统一保存到一个字典中返回。

# 字典的key就是参数的名字，字典的value就是参数的值

def user_info(**kwargs):

    print(kwargs)

# {'name': 'TOM', 'age': 18, 'id': 110}

# 关键字不能加引号，应为关键字对应的是形参。

user_info(name='TOM', age=18, id=110)

# 包裹关键字传递只能有一个，并且必须写在所有参数的最后

# 实参可以不按顺序传递

def fn3(b, c, **a):

    print('a =', a, type(a))

    print('b =', b)

    print('c =', c)

fn3(e=10, b=1, d=2, c=3, f=20)

"""

输出结果：

a = {'e': 10, 'd': 2, 'f': 20} <class 'dict'>

b = 1

c = 3

"""

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程（组包简单的说，就是收集分散的参数，返回一个整体数据）。关于组包对应就是拆包，在之前的文章【Python元组】中有介绍，可以对应的查看。

5、位置参数、默认参数、可变参数的混合使用

参数定义与调用顺序的基本原则是：位置参数，默认参数，包裹位置，包裹关键字。(定义和调用都应遵循)

提示：默认参数与包裹位置参数可以根据需求进行位置调换。

def user_info(name, age, sex=1, *args, **kargs):

    print name, age, sex, args, kargs

user_info('tanggu', 25, 2, 'music', 'sport', class=2)

# 输出结果

# tanggu 25 1 ('music', 'sport') {'class'=2}

6、拓展：参数解包

关于组包对应就是拆包，在之前的文章【Python元组】中有介绍，可以对应的查看。

（1）通过包裹位置对一个元组进行解包

操作方式：使用*号。

如下示例：

# 参数的解包（拆包）

def fn4(a, b, c):

    print('a =', a)

    print('b =', b)

    print('c =', c)

# 创建一个元组

t = (10, 20, 30)

# 我们直接传递t，会报错

# TypeError: fn4() missing 2 required positional arguments: 'b' and 'c'

# fn4(t)

# 而以前我们是这样拆包的

# fn4(t[0], t[1], t[2])

"""

输出结果：

a = 10

b = 20

c = 30

"""

# *号拆包

# 传递实参时，也可以在序列类型的参数前添加星号，

# #这样他会自动将序列中的元素依次作为参数传递。

# 这里要求序列中元素的个数必须和形参的个数的一致

fn4(*t)

"""

输出结果：

a = 10

b = 20

c = 30

"""

（2）通过包裹关键字对一个字典进行解包

操作方式：使用**号。