Python学习--函数的参数

意义

定义函数，可以简化调用者代码。封装

位置参数和默认参数就很有意思了，慢慢体会到高级语言的方便性。
人生苦短，我学python

位置参数

比如定义一个计算x**2的函数：

def power(x):
	return x * x 

但局限性很大，只能够计算x2无法计算x3，或者更改次方。
所以，写一个通用性更大的函数

def power(x, n):
	s = 1
	while n > 0:
		n -= 1
		s = s * x
	return s

解决了通用性，但是，又一个问题应运而生，这使得之前的power（2），即之前的调用出现了问题。这是因为函数加了一个参数，使得之前的调用出现了问题，解决方法就是使用默认参数。

默认参数

先看错误提示

>>> power(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: power() missing 1 required positional argument: 'n'

提示缺少一个位置参数n

因为x**2经常计算，所以可以把第二个参数的值改成2，即默认情况下（只传一个参数的情况下），计算平方。

def power(x, n = 2):
	s = 1
	while n > 0:
		n -= 1
		s *= x
	return s

此时问题就解决了

>>> power(5)
25
>>> power(5, 2)
25

那对于n大于2的情况下，就必须传入指定的n即可。
但是注意：
一是必选参数在前，默认参数在后（必须），否则Python的编译器会报错，肯定的，默认参数在前，使得传参的顺序发生了歧义，这与定义的传参方式相冲突了。
二是如何设置默认参数
那么默认参数的设置，就是变化小的做默认参数。
使用默认参数有什么好处？最大的好处是能降低调用函数的难度。

例如，写一个一年级小学生注册的函数，需要传入name和gender两个参数：

def enroll(name, gender):
	print('name:', name)
    print('gender:', gender)

这样，存在问题，因为一年级小学生注册，基本上年龄在6岁，且对于当地的学生，城市信息一般不需要更改，所以，如果每次传参都要传入这些变化很小的参数，就会显得繁琐，重复，这不符合高级语言越来越简便的趋势。
那么，代码设计如下

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)

这样，就简便得多

>>> enroll('Sarah', 'F')
name: Sarah
gender: F
age: 6
city: Beijing

只有与默认参数不符的学生才需要提供额外的信息：

enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')

默认参数的存在和设置，大大减低了函数调用的难度，这使得无论是简单调用还是复杂调用，函数只需要定义一个。

有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如调用enroll(‘Bob’, ‘M’, 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。

也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll(‘Adam’, ‘M’, city=‘Tianjin’)，意思是，city参数用传进去的值，其他默认参数继续使用默认值。（这时需要指定改变的是哪个默认参数）

虽然默认参数好处多，但是也存在巨大的坑
代码比如：

def add_end(L=[]):
    L.append('END')
    return L

调用：

>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']

没问题
再调用

>>> add_end()
['END']

还是对的，再调用

>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

发生了变化，这里的L不再是【】，而是每次都记住了上次的结果。
原因是因为对象每次都发生改变，而L只是变量。最开始学的时候，都知道，面向对象，面向数据对象，变量只是指向了数据对象而已，数据对象和变量本身没什么关系，数据对象每次都插入end，使得L指向的这个默认数据对象一直在改变，所以：
如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

== 定义默认参数要牢记一点：默认参数必须指向不变对象！==

修改：

def add_end(L = None):
	if L is None:
		L = []
	L.append('END')
	return L

这样就不会出现问题。

不变对象存在的意义

不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象就不需要加锁，同时读一点问题没有。所以，在编写程序的时候，如果可以设计一个不变对象，那就尽量设计成不变对象。（不需要加锁这个意义其实蛮重要的，因为加锁容易造成阻塞，以及有死锁的风险，又要解决死锁等，会很麻烦。）

可变参数

这里我想到了python是脚本语言，好像脚本语言都没有指针是吗？反正现在遇到的脚本语言没有指针，这使得其传可变参数就稍微不同了。
脚本语言：无需编译，直接顺序解释执行就行。

那么可变，自然相到list，tuple（因为tuple中可以有list？，也不能这么说）
上代码

def calc(numbers):
	sum = 0;
	for n in numbers:
		sum += n*n
	return sum

但是，在调用的时候，就要先组装出一个list或者tuple

>>>calc([1, 2, 3])
>14
>>>calc((1, 2, 3))
>14

那就会比较麻烦，那如果是用的可遍参数，调用就会变成这样：

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84

所以，将函数的参数写成可变参数：

def calc(*numbers):
	sum = 0
	for n in numbers:
		sum += n * n
	return sum

这是传参就不需要组装list或者tuple了

>>> calc(1, 2)
5
>>> calc()
0

那么问题又来了，你想传入可变参数怎么办呢？
第一种写法

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

这还不如不定义，所以，python允许在list或者tuple前面加一个==*==号，把list变成可变参数传进去
上代码

>>>nums = [1, 2, 3]
>>>calc(*nums)
>14

那这样就方便多了

关键字参数

可变参数允许你传入0个或者任意给参数，这些可变参数在函数调用时自动组装成为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
比如

def person(name, age, **kw):
	print('name: ', name, 'age: ', age, 'other: ', kw)

则函数person除了必选参数name和age外，还接受参数kw，在调用函数时候，可以指传入必选参数：

>>> person('Michael', 30)
name: Michael age: 30 other: {}

也可以传入任意个数的关键字参数：

>>>person('Bob', 35, city = 'Beijing')
>name:Bob age:35 other:{'city':'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
>name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

看到这里，那么关键字参数有什么用呢？还没有体会
它可以扩展函数的功能。比如，在person函数里，我们保证能接受到name和age两个参数，但是如果调用者愿意提供更多的参数，我们也能收到。比如说，正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的要求。

哦，明白了，这样就和数据库对上了。和实际开发对上了。

同样，传可变参数也可以先组装出一个dict，但这就不是它本来用意了。

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

那默认参数是加一个星号
同理，关键字参数就是加两个*号
上述写法简化为

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>>person('Jack', 24, **extra)
>name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

这里，extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数中，kw将获得一个dict。但是，kw获得的只是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。值语到底传入了哪些，就需要在函数内部通过kw检查。

仍以person()函数为例，我们希望检查是否有city和job参数：

def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)

到这，没看和关键字参数有任何不同

如果要限制关键字参数的名字，就可以用命名关键字参数。比如，只接受city和job作为关键字参数。这种定义的函数如下：

def person(name, age, *, city, job):
	print(name, age, city, job)

这就和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，而星号后面的参数被视为命名关键字参数。

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

那如果不按照city和job来调用呢

>>>person('Jack', 24, job = 'Beijing', city = 'Engineer')
>Jack 24 Engineer Beijing

结果可以输出

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
	print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

因为缺少参数名city和job，python解释器把这4个参数均视为位置参数，但person（）函数只接受两个位置参数。
同时，命名关键字参数可以有缺省值，简化调用

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

==注意：使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少星号，那么Python解释器就视为位置参数了。

参数组合

顾名思义，上述的参数类型，可以组合使用。
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0,*args, **kw):
	print('a = ', a, 'b = ', b, 'c = ', c, 'args = ', args, 'kw = ', kw)

def f2(a, b, c=0, *, d, **kw):
	print('a = ', a, 'b = ', b, 'c = ', c, 'd = ', d, 'kw = ', kw)

调用事例：

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

老实说，有点乱，不过还是能体会其中

调用的神奇之处func(*args, **kw)

>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

这里，怎么说呢，我只做了解，这样搞，会太复杂了，感觉还是要把函数接口写得容易调用一些。

练习

以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：

def product(x, y):
    return x * y

自然想到使用可变参数
改后：

def product(*args):
    p = 1
    for n in args:
        p *= n
    return p


if __name__ == '__main__':
    print(product(5))
    print(product(5, 6))
    print(product(5, 6, 7))
    print(product(5, 6, 7, 9))
    print(product(5, 6, 7, 9, 10))

小结

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，会产生逻辑错误（面向对象思想）。
要注意定义可变参数和冠军字参数的语法：
*args是可变参数，args接受的是一个tuple；
**kw是关键字参数，kw接受的是一个dict。
调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({‘a’: 1, ‘b’: 2})。

最后，使用*args和**kw是python的习惯写法，可以用其他参数名，但是最好用这个。约定俗成嘛，讲究。

以及定义命名关键字参数时候，在没有可变参数的情况下，需要加*号作为分隔符

那么总结

位置参数，就正常的参数
默认参数，在定义时候指出缺省值（有坑的，面向对象思想）
可变参数，*参数名，传入的时候自动组装成list或者tuple，可变嘛
关键字参数， 两个星号+参数名，传入组装成dict
命名关键字参数，如果没有可变参数的情况下，那么就要加一个星号分隔开。并且这个参数值是直接相对于key-value的。

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。