参数传递的几种方式

Python支持多种函数参数传递。从传递方式上，可分为：

直接传递
参数名传递
元组传递(本质上属于直接传递)
字典传递(本质上属于参数名传递)

def funA(a, b):
    print(a, b)

# 1. 直接传递
funA(1, 2)
# 2. 参数名传递
funA(1, b=2)
funA(a=1, b=2)
funA(b=2, a=1)
# 3. 元组传递
params = (3, 4)
funA(*params)
# 4. 字典传递
data = { 'a': 5, 'b': 6 }
funA(**data)

为参数添加默认值

def funB(a, b=2):
    print(a, b)
    
'''
参数b默认值为2，因此funB(1)可以正常输出，结果为：1 2
'''
funB(1)

不定参的实现

当函数参数的数量不确定时，我们就需要函数对接收的参数数量没有限制，比如我们经常使用的print函数就可以接收多个字符串并进行拼接输出。

不定量参数定义又分为元组和字典两种方式：

元组方式：在参数名前加”*”，传递的参数会被打包成一个元组
字典方式：在参数名前加”**”，传递的参数会被打包成一个字典


# 1. 元组方式：在参数名前加"*"，传递的参数会被打包成一个元组
def funC(*args):
    print(type(args), args)
    
funC(1, 2, 3)


# 2. 字典方式：在参数名前加"**"，传递的参数会被打包成一个字典
def funD(**kwargs):
    print(type(kwargs), kwargs)

funD(a=1, b=2, c=3)


'''
将两种方式结合，咱们模拟实现print函数
sep是指定字符串元组str_tuple拼接时的分隔符，end是输出的结束符，默认为换行符
'''
def myprint(*str_tuple, **settings):
    sep = settings.get('sep')
    string = sep.join(str_tuple)
    end_str = settings.get('end') if settings.get('end') else '\n'
    print(string, end=end_str)

myprint("hello", "Amy", "Bertram", "Sam!", sep=', ')

一个有趣的语法糖：/和*

/和*是Python函数中有趣的语法糖：

在函数参数中插入”/”参数，那么在其前面的参数就只能直接传递而无法用参数名传递
在函数参数中插入”*”参数，那么在其后面的参数只能参数名传递而不能直接传递

# 这是一个正常的函数
def funE(a, b, c, d):
    print(a, b, c, d)
# 它可以这么调用
funE(1, 2, 3, 4)
funE(1, 2, 3, d=4)
funE(a=1, b=2, c=3, d=4)

# 如果加上"/"，那么在其前面的参数就只能直接传递而无法用参数名传递
def funE_A(a, b, /, c, d):
    print(a, b, c, d)
# 它可以这么调用
funE_A(1, 2, 3, 4)
funE_A(1, 2, c=3, d=4)
# 但不能这么调用
# funE_A(1, b=2, c=3, d=4)
# funE_A(a=1, b=2, c=3, d=4)

# 如果加上"*"，那么在其后面的参数只能参数名传递而不能直接传递
def funE_B(a, b, *, c, d):
    print(a, b, c, d)
# 它可以这么调用
funE_B(a=1, b=2, c=3, d=4)
funE_B(1, 2, c=3, d=4)
# 但不能这么调用
# funE_B(1, 2, 3, d=4)
# funE_B(1, 2, 3, 4)

我们还是与上一节一样，模拟实现print函数

# sep是指定字符串元组str_tuple拼接时的分隔符，默认为空格，end是输出的结束符，默认为换行符
def myprint2(str_list, /, *, sep=' ', end='\n'):
    string = sep.join(str_list)
    print(string, end=end)

str_list = ["hello", "Amy", "Bertram", "Sam!"]
myprint2(str_list, sep=', ')