【Python】8“函数的参数“

位置参数

按函数参数顺序传入参数，这样的参数就叫做位置参数。Java的函数中，规定调用者必须按形式参数顺序依次传入参数，这样也可以看做是位置。
案例（幂运算）：

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

默认参数

在定义函数的时候，可以定义默认参数，也就是参数含有默认值。
案例（info）：

>>> def info(name,age,gender,city = 'guangzhou'):...     print(name,age,gender,city)... >>> info('张三',20,'male')张三 20 male guangzhou

要注意的是，默认参数要放在函数形参最后的位置，这样能让调用者在调用函数时传入的值是必须传入的参数。
应用场景：比如需要一批数据，而数据的某一项的内容大部分都是相同的，这样就可以使用默认参数在定义这项内容，能提高调用的效率。

• 默认参数坑
  △默认参数必须指向不可变对象！

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

  因为list是可变对象，L指向的对象在函数定义时的内容是[]，在调用后，函数往L所指向的对象[]append'END'，这时[]就变成['END']，下次再调用时，就在这个对象的基础上append，所以就成了上面的运行情况。
  解决：

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

  因为None是不可变对象，所以使用None能解决这个坑。

  为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

可变参数

也就是说传入的参数是可变的，比如函数需要传入一个list。
案例(calc)：

• 常规方法：需要先组一个list或者tuple，然后传入函数

  >>> def calc(numbers):...     sum = 0...     for n in numbers:...             sum = sum + n * n...     return sum... >>> calc([1,2,3])14>>> list = [1,2,3]>>> calc(list)14

• 定义可变参数方法：将N个参数直接传入

  >>> def calc(*numbers):...     sum = 0...     for n in numbers:...             sum = sum + n * n...     return sum... >>> calc(1,2,3)14>>> calc(2,4,6,8)120

• 如果需要传入list或者tuple：在list或者tuple前面加上*

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

  *list表示把list这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

关键字参数

关键字参数允许调用者传入0个或者任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

这句话有点拗口，一开始我并不理解‘含参数名的参数’，但通过代码，可以简单明了地理解：

>>> def person(name,age,**kw):...     print('name:', name, 'age:', age, 'other:', kw)... >>> person('张三',20)name: 张三 age: 20 other: {}>>> person('张三',20,gender = 'male')name: 张三 age: 20 other: {'gender': 'male'}>>> person('张三',20,gender = 'male',city = 'guangzhou',hight = 175)name: 张三 age: 20 other: {'gender': 'male', 'city': 'guangzhou', 'hight': 175}

其实就是让调用者传入带参数名的参数，这样做能让函数更具有拓展性。比如在上面这个代码案例中，姓名和年龄是必传属性，而函数定义的**kw就是关键字参数，能让调用者传入一些额外的信息。
也可以将dict传入：

>>> extra = {'gender':'male','city':'guangzhou'}>>> person('李四',21,**extra)name: 李四 age: 21 other: {'gender': 'male', 'city': 'guangzhou'}

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

命名关键字参数

命名关键字可以检查调用者传入的从参数是否有指定的参数。

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

在定义参数时，命名关键字要使用*符号分隔开，表示*后面的参数都是命名关键字。
在调用时，调用者必须传入city和job关键字参数，否则会报错:

>>> person('张三',34,city = 'guangzhou',job = 'monkey')张三 34 guangzhou monkey

△如果函数定义中已经有一个可变参数，那么就不需要*分隔命名关键字了：

>>> def person(name,age,*args,city,job):...     print(name, age, args, city, job)... >>> args = ['1','2','3']>>> >>> person('张三','34',args,city = 'guangzhou',job = 'monkey')张三 34 (['1', '2', '3'],) guangzhou monkey>>> person('张三','34',city = 'guangzhou',job = 'monkey')张三 34 () guangzhou monkey

△命名关键字也可以有默认值(缺省值)，在函数定义的时候可以设置默认值：

>>> def person(name,age,*,city = 'guangzhou',job):...     print(name, age, city, job )... >>> person('jack',23,job = 'monkey')jack 23 guangzhou monkey

参数组合

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

我们先来定义两个函数，它们的参数不止一种：

>>> def f1(a,b,c=1,*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)...

我们可以用多种符合python语法形式的参数传入调用：

#调用f1>>> f1(1,2)a = 1 b = 2 c = 1 args = () kw = {}>>> f1(1,2,3)a = 1 b = 2 c = 3 args = () kw = {}>>> f1(1,2,3,[1,2,3])a = 1 b = 2 c = 3 args = ([1, 2, 3],) kw = {}>>> f1(1,2,3,[1,2,3],num1 = 1,num2 = 2)a = 1 b = 2 c = 3 args = ([1, 2, 3],) kw = {'num1': 1, 'num2': 2}#调用f2>>> f2(1,2,d = 3,num1 = 1,num2 = 2)a = 1 b = 2 c = 0 d = 3 kw = {'num1': 1, 'num2': 2}>>> f2(1,2,d = 3)a = 1 b = 2 c = 0 d = 3 kw = {}

△调用f2的时候，我产生一个疑惑，命名关键字参数*后面的参数是必须要传入的，不传入就会报错，这一点已经证实过。
我尝试没有传入**kw的值，发现并没有报错，这样就说明，*分隔命名关键字的同时，不包含python定义参数顺序的后面的参数类型，所以d是命名关键字参数，**kw是关键字参数
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

func(*args, **kw)写法

△对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

>>> def func(*args,**kw):...     print(args)...     print(kw)... >>> func(a = 1,b = 2)(){'a': 1, 'b': 2}>>> func(1,2,3)(1, 2, 3){}>>> func(1,2,3,a = 1,b = 2)(1, 2, 3){'a': 1, 'b': 2}

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。