默认参数
函数定义时，为参数设置一个默认值，当函数调用时，没有传入这个参数值，直接使用这个默认值。指定有默认值的形参，必须是在没有默认值的参数的最后，否则会产生语法错误；而且默认参数必须指向不可变对象，如果指向可变对象，多次调用时，可能得到的不是意料之内的结果 def func(x, y=0): """ :param x: int :param x: int :return: """ return x + y print(func(3)) # 传入参数x=3 print(func(3, 4)) # 传入参数x=3, y=4 # 结果 ''' 3 7 '''关键字参数：函数调用时，是指使用形式参数的名字来确定输入的参数值,（形参的名字=输入的参数值），通过此方式指定函数实参时，不再需要与形参的位置完全一致，只要将参数名写正确即可；使用位置参数和关键字参数混合传参的方式时，关键字参数必须位于所有的位置参数（即前面必须传位置参数，最后在传关键字参数，位置得对应）。
def func(x, y): """ :param x: int :param x: int :return: """ return x + y print(func(3, 4)) # 位置参数 print(func(x=3, y=4)) # 关键字参数 print(func(y=4, x=3)) # 关键字参数，位置改变 print(func(3, y=4)) # 位置参数与关键字混合 # 结果 ''' 7 7 7 7 ''' 可变位置参数：定义参数时前面加一个*，表示这个参数是可变的，可以接受任意多个参数，这些参数构成一个元组，只能通过位置参数传递。 # 可以接收不定参数，返回的类型是元组 def func(*args): """ :param args: :return: """ print(type(args)) sum = 0 for i in args: sum += i return sum print(func(1, 2, 3)) print(func(*(1, 2, 3))) # 使用*解构 # 结果 ''' <class 'tuple'> 6 <class 'tuple'> 6 ''' 可变关键字参数：定义参数时，在前面加**，**kwargs表示这个参数可变，可以接受零个或多个关键字参数，并以字典的形式传入函数体，关键字为字典的key，关键字绑定的值为value，如果可变关键字没有接收到任何参数，则传入函数体一个空字典{}。 # 只接收可变关键字参数 def func(**kwargs): """ :param kwargs: :return: """ kwargs_type = (str(type(kwargs))).split("'")[1] print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs)) func() # 未传任何参数，返回空字典 func(x=1, y=2, z=3) # 关键字对传参 func(**{'x': 1, 'y': 2, 'z': 3}) # 使用**解包字典 # 结果 ''' kwargs: 类型为dict, 值为{} kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3} kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3} ''' # 可变位置参数与可变关键字参数一起使用，这是可变位置参数必须在前面 def func(*args, **kwargs): """ :param args: :param kwargs: :return: """ args_type = (str(type(args))).split("'")[1] kwargs_type = (str(type(kwargs))).split("'")[1] print("args: 类型为{0}, 值为{1}".format(args_type, args)) print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs)) print("未传任何参数：") func() # 未传任何参数，返回args为空元组，kwargs我空字典 print("只传入可变位置参数：") func(1, 2, 3) print("只传入可变关键字参数：") func(x='a', y='b', z='c') print("传入可变位置参数和可变关键字参数：") func(1, 2, 3, x='a', y='b', z='c') func(1, 2, 3, **{'x': 1, 'y': 2, 'z': 3}) # 使用 **解包 # 结果 ''' 未传任何参数： args: 类型为tuple, 值为() kwargs: 类型为dict, 值为{} 只传入可变位置参数： args: 类型为tuple, 值为(1, 2, 3) kwargs: 类型为dict, 值为{} 只传入可变关键字参数： args: 类型为tuple, 值为() kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'} 传入可变位置参数和可变关键字参数： args: 类型为tuple, 值为(1, 2, 3) kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'} args: 类型为tuple, 值为(1, 2, 3) kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3} ''' # 位置参数，可变位置参数、默认参数、可变关键字参数结合 # 参数定义顺序：位置参数->*args->默认参数->**kwargs def func(m, n, *args, flag=0, **kwargs): """ :param args: :param kwargs: :return: """ print("m: %s" % m) print("n: %s" % n) print("flag: %s" % flag) args_type = (str(type(args))).split("'")[1] kwargs_type = (str(type(kwargs))).split("'")[1] print("args: 类型为{0}, 值为{1}".format(args_type, args)) print("kwargs: 类型为{0}, 值为{1}".format(kwargs_type, kwargs)) print("只传位置参数：") func(22, 33) # 这时默认参数flag=0 print("以关键字参数形式传入位置参数：") func(m=22, n=33) print("传入位置参数和可变位置参数：") func(22, 33, 1, 2, 3) print("位置参数、可变位置参数、默认参数：") func(22, 33, 1, 2, 3, flag=666) print("位置参数、可变位置参数、默认参数和可变关键字参数：") func(22, 33, 1, 2, 3, flag=666, x='a', y='b', z='c') print("以**解包形式传入位置参数：") func(22, 33, 1, 2, 3, flag=666, **{'x': 1, 'y': 2, 'z': 3}) # 结果 ''' 只传位置参数： m: 22 n: 33 flag: 0 args: 类型为tuple, 值为() kwargs: 类型为dict, 值为{} 以关键字参数形式传入位置参数： m: 22 n: 33 flag: 0 args: 类型为tuple, 值为() kwargs: 类型为dict, 值为{} 传入位置参数和可变位置参数： m: 22 n: 33 flag: 0 args: 类型为tuple, 值为(1, 2, 3) kwargs: 类型为dict, 值为{} 位置参数、可变位置参数、默认参数： m: 22 n: 33 flag: 666 args: 类型为tuple, 值为(1, 2, 3) kwargs: 类型为dict, 值为{} 位置参数、可变位置参数、默认参数和可变关键字参数： m: 22 n: 33 flag: 666 args: 类型为tuple, 值为(1, 2, 3) kwargs: 类型为dict, 值为{'x': 'a', 'y': 'b', 'z': 'c'} 以**解包形式传入位置参数： m: 22 n: 33 flag: 666 args: 类型为tuple, 值为(1, 2, 3) kwargs: 类型为dict, 值为{'x': 1, 'y': 2, 'z': 3} ''' 仅限关键字参数：在*号之后的参数只能通过关键字参数传递的叫keyword-only参数。其中，可变位置参数之后的参数也是keyword-only参数 # *号的参数用关键字参数形式传参 def func(*, x): """ :param x: :return: """ print(x) func(x=3) # 结果 ''' 3 ''' # 可变位置参数后的参数，也是仅限关键字参数 def func(*args, x): """ :param args: :param x: :return: """ args_type = (str(type(args))).split("'")[1] print("args: 类型为{0}, 值为{1}".format(args_type, args)) print("x: %s" % x) print("---- 只传关键字参数: ----") func(x=3) print("---- 传入可变位置参数和关键字参数：----") func(1,2,3, x=666) # 结果 ''' ---- 只传关键字参数: ---- args: 类型为tuple, 值为() x: 3 ---- 传入可变位置参数和关键字参数：---- args: 类型为tuple, 值为(1, 2, 3) x: 666 ''' # 可变位置参数、普通参数、默认参数组成仅限关键字参数 def func(*args, x, y=0): """ :param args: :param x: :param y: :return: """ args_type = (str(type(args))).split("'")[1] print("args: 类型为{0}, 值为{1}".format(args_type, args)) print("x: %s" % x) print("y: %s" % y) print("---- 只传关键字参数: ----") func(x=3) print("---- 传入可变位置参数和关键字参数：----") func(1,2,3, x=666) print("---- 传入可变位置参数、关键字参数和默认参数：----") func(1,2,3, x=666, y=333) # 结果 '''---- 只传关键字参数: ---- args: 类型为tuple, 值为() x: 3 y: 0 ---- 传入可变位置参数和关键字参数：---- args: 类型为tuple, 值为(1, 2, 3) x: 666 y: 0 ---- 传入可变位置参数、关键字参数和默认参数：---- args: 类型为tuple, 值为(1, 2, 3) x: 666 y: 333 ''' 参数解构：参数解构发生在函数调用时，可变参数发生在函数定义的时 *解构：解构对象是可迭代对象，结构后的结果为位置参数**解构：解构对象是字典，解构后的结果为关键字参数，这里key必须是str类型，且和函数定义的形参名一致，否则抛出TypeError异常 def add(x, y): return x + y # 位置参数解构 data1 = (1, 2) print(add(*data1)) # 关键字参数解构 data2 = {'x': 3, 'y': 4} print(add(**data2)) # 结果 ''' 3 7 '''