3.3.2 函数参数不得不说的几件事

　　函数定义时圆括号内是使用逗号分隔开的形式参数列表（parameters），一个函数可以没有参数，但是定义和调用时一对圆括号必须要有，表示这是一个函数并且不接受参数。函数调用时向其传递实参（arguments），根据不同的参数类型，将实参的值或引用传递给形参。

　　定义函数时，对参数个数并没有限制，如果有多个形参，则需要使用逗号进行分隔。例如，下面的函数用来接受2个参数，并输出其中的最大值。

def printMax(a,b):
    if a > b :
        print(a,'is the max')
    else:
        print(b,'is the max')

　　注意：这里只是为了，演示，忽略了一些细节，如果输入的参数不支持比较运算符，则会出错，可以参考后面第7章中介绍的异常结构来解决这个问题。

　　对于绝大多数情况下，在函数内部直接修改形参的值不会影响实参。例如：

def addOne(a):
    print(a)   #输出原变量 a 的值
    a += 1
    print(a)   #这条语句会得到一个新的变量a

a = 3
addOne(3)

# 3
# 4

print(a)
# 3

　　从运行结果可以看出，在函数内部修改了形参a的值，但是当函数运行结束以后，实参a的值并没有被修改。然而，在有些情况下，可以通过特殊的方式在函数内部修改实参的值，例如：

>>> def modify(v):             #修改列表元素值
    v[0] += 1

    
>>> a = [2]
>>> modify(a)
>>> a
[3]
>>> 
>>> 
>>> def modify(v,item):       #为列表增加元素
    v.append(item)

    
>>> a = [2]
>>> modify(a,3)
>>> a
[2, 3]
>>> 
>>> 
>>> 
>>> def modify(d):            #修改字典元素值或为字典增加元素
    d['age'] = 38

    
>>> a = {'name':'Dong','age':37,'sex':'Male'}
>>> 
>>> modify(a)
>>> 
>>> a
{'name': 'Dong', 'sex': 'Male', 'age': 38}
>>> 

　　也就是说，如果传递给函数的是Python可变序列，并且在函数内部使用下标或序列自身支持的方式为可变序列增加、删除元素或修改元素值时，修改后的结果是可以反映到函数之外的，即实参也得到了相应的修改。

1 默认值参数

　　在定义函数时，Python支持默认参数，即在定义函数时为形参设置默认值。在调用带有默认值参数的函数时，可以不用为设置了默认值的参数进行传值，此时函数将会直接使用函数定义时设置的默认值，也可以通过显式赋值来替换其默认值。也就是说，在调用函数时是否为默认值参数传递实参是可选的，具有较大的灵活性。带有默认值参数的函数定义语法如下：

def 函数名(...,形参名 = 默认值):
    函数体

　　可以使用 函数名.__defaults__ 随时查看函数所有默认值参数的当前值，其返回值为一个元组，其中的元素依次表示每个默认值参数的当前值。

>>> def say(message,times = 1):
    print((message + ' ')* times)

    
>>>
>>> 
>>> dir(say)
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', 
    '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', 
    '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__',
    '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>> 
>>> say.__defaults__
(1,)
>>> 

　　调用该函数时，如果只为第一个参数传递实参，则第二个参数使用默认值 1 ；如果为第二个参数传递参数，则不再使用默认值 1 ，而是使用调用者显式传递的值。

>>> say('hello')
hello 
>>> 
>>> say('hello',3)
hello hello hello 
>>> 
>>> say('hi',5)
hi hi hi hi hi 
>>> 

　　注意：在定义带有默认值参数的函数时，默认值参数必须出现在函数参数列表的最右端，任何一个默认值参数右边都不能再出现非默认值参数。

　　注意：一般情况下，都是调用函数时为其传递参数，这时形参的值由调用函数时实参的值确定。但如果函数的默认值参数不是调用时传递的，而是通过其他方式对其赋值，那么默认值参数的值可能会在函数定义是确定，而不是函数调用时。例如：

>>> i = 5
>>> def demo(v):
    print(v)

    
>>> i = 6
>>> demo(i)
6
>>> 
>>> i = 5
>>> 

>>> def demo(v = i):     #等价于def demo(v = 5):
    print(v)             #相当于定义函数时设置默认值参数 5 
 
    
>>> i = 6
>>> 
>>> demo()
5
>>> 

　　注意：多次调用函数并且不为默认值参数传递值时，默认值参数只在第一次调用时进行解释，对于列表，字典这样可变类型的默认值参数，这一点可能会导致很严重的逻辑错误，而这种错误或许会耗费大量精力来定位和纠正。例如：

>>> 
>>> def demo(newitem,old_list=[]):
    old_list.append(newitem)
    return old_list

>>> 
>>> print(demo('5',[1,2,3,4]))
[1, 2, 3, 4, '5']
>>> 
>>> print(demo('aaa',['a','b']))
['a', 'b', 'aaa']
>>> 
>>> print(demo('a'))
['a']
>>> 
>>> print(demo('b'))
['a', 'b']
>>> 
>>> print(demo('c'))
['a', 'b', 'c']
>>> 

　　上面的函数使用列表作为默认值参数，由于其可记忆性，连续多次调用该函数而不给该参数传值，再次调用时将保留上一次调用的结果，从而导致很难发现的错误。下面的代码就不存在这个问题：

>>> 
>>> def demo(newitem,old_list=None):
    if old_list is None:
        old_list = []
    old_list.append(newitem)
    return old_list

>>> 

　　

2 关键字参数

　　关键字参数主要指调用函数时的参数传递方式，与函数定义无关。通过关键字参数可以按参数名字传递值，实参顺序可以和形参顺序不一致，但不影响参数值的传递结果，避免了用户需要牢记参数位置和顺序的麻烦，使得函数的调用和参数传递更加灵活方便。

>>> 
>>> def demo(newitem,old_list=None):
    if old_list is None:
        old_list = []
    old_list.append(newitem)
    return old_list

>>> 
>>> 
>>> 
>>> 
>>> def demo(a,b,c = 5):
    print(a,b,c)

    
>>> 
>>> demo(3,7)
3 7 5
>>> 
>>> demo(a=7,b=3,c=6)
7 3 6
>>> 
>>> demo(c=8,a=9,b=0)
9 0 8
>>> 

3 可变长度参数

　　可变长度参数在定义函数时主要有两种形式：*parameter 和 **parameter，前者用于接受任意多个实参并将其放在一个元组中，后者接受类似于关键字参数一样显式赋值形式的多个实参并将其放入字典中。

　　下面代码演示了第一种形式可变长度参数的用法，即无论调用该函数时传递了多少实参，一律将其放入元组中：

>>> 
>>> def demo(*p):
    print(p)

    
>>> demo(1,2,3)
(1, 2, 3)
>>> 
>>> #其实 1,2,3 本身就是元组
>>> a = 1,2,3
>>> type(a)
<class 'tuple'>
>>> 
>>> demo(1,2,3,4,5,6,7)
(1, 2, 3, 4, 5, 6, 7)
>>> 

　　下面的代码演示了第二种形式可变长度参数的用法，即在调用函数时自动将接收的参数转换为字典：

>>> 
>>> def demo(**p):
    for item in p.items():
        print(item)

        
>>> demo(x = 1,y = 2,z = 3)
('y', 2)
('z', 3)
('x', 1)
>>> 

　　注意：Python定义函数时可以同时使用位置参数、关键字参数、默认值参数和可变长度参数，但是除非真的很必要，否则请不要这样用，因为这会使得代码非常混乱而严重降低可读性，并导致程序查错非常困难。另外，一般而言，一个函数如果可以接受很多不同类型参数的话，很可能是函数设计得不好，例如函数功能过多，需要进行必要的拆分和重新设计，以满足模块高内聚的要求。

4 传递参数时的序列解包

　　调用含有多个参数的函数时，可以使用Python列表、元组、集合、字典以及其他可迭代对象作为实参，并在实参名称前加一个星号，Python解释器将自动进行解包，然后传递给多个单变量形参。

>>> 
>>> seq = [1,2,3]
>>> 
>>> demo(*seq)
6
>>> 
>>> tup = (1,2,3)
>>> 
>>> demo(*tup)
6
>>> 
>>> 
>>> dic = {1:'a',2:'b',3:'c'}
>>> demo(*dic)
6
>>> 
>>> set = {1,2,3}
>>> demo(*set)
6
>>> 
>>> demo(*dic.values())
abc
>>> 
>>> demo(*dic.keys())
6
>>> 
>>> demo(*dic.items())
(1, 'a', 2, 'b', 3, 'c')
>>> 

　　小提示：

　　　　（1）字典对象作为实参时默认使用字典的“键”，如果需要将字典中的“键:值”元素作为参数则需要使用items()方法明确说明，如果需要将字典的“值”作为参数则需要调用字典的values()方法明确说明；

　　　　（2）实参中元素个数与形参个数必须相等，否则将出现错误。

　　

　　注意：调用函数时如果对实参使用一个星号（*）进行序列解包，那么这些解包后的实参将会被当做普通位置参数对待，并且会在关键参数和使用两个星号（**）进行序列解包的参数之前进行处理。

>>>  
>>> def demo(a,b,c):   #定义函数
    print(a,b,c)

    
>>> 
>>> demo(*(1,2,3))     #调用，序列解包
1 2 3
>>> 
>>> demo(1,*(2,3))     #位置参数和序列解包同时使用
1 2 3
>>> 
>>> demo(1,*(2,),3)
1 2 3
>>> 
>>> 
>>> demo(a = 1,*(2,3))          #序列解包相当于位置参数，优先处理
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    demo(a = 1,*(2,3))          #序列解包相当于位置参数，优先处理
TypeError: demo() got multiple values for argument 'a'
>>> 
>>> demo(b = 1,*(2,3))
Traceback (most recent call last):
  File "<pyshell#49>", line 1, in <module>
    demo(b = 1,*(2,3))
TypeError: demo() got multiple values for argument 'b'
>>> 
>>> 
>>> demo(c = 1,*(2,3))
2 3 1
>>> 
>>> 
>>> 
>>> 
>>> demo(**{'a':1,'b':2},*(3,))   #序列解包相当于位置参数，优先处理
SyntaxError: iterable argument unpacking follows keyword argument unpacking
>>> 
>>> 
>>> 
>>> 
>>> 
>>> demo(*(3,)，**{'a':1,'b':2})
SyntaxError: invalid character in identifier
>>> 
>>> demo(*(3,),**{'a':1,'b':2})
Traceback (most recent call last):
  File "<pyshell#72>", line 1, in <module>
    demo(*(3,),**{'a':1,'b':2})
TypeError: demo() got multiple values for argument 'a'
>>> 
>>> 
>>> demo(*(3,),**{'c':1,'b':2})
3 2 1
>>>