python函数及其参数

python函数及其参数

python函数及其参数

位置参数

假如说我们需要计算一个x²的函数

def power(x):
    return x * x

对于这个power(x)函数，参数x就是一个位置参数

而我们在调用这个power函数时，就必须向其传入有且仅有的一个参数x

>>> power(3)
9
>>> power(4)
16

以上是计算x²的，那计算xⁿ呢
代码如下：

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

而这个power2函数，则可以计算xⁿ，

>>> power2(5,3)
125
>>> power2(2,3)
8

改进后的power2函数，就有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值必须按照顺序依次赋给x和n。

默认参数

顾名思义，默认参数就是在参数中给它初始化，
例如：计算x²，就可以写成power(x,n=2)，这样我们在调用这个函数power(5)时，就相当于调用power(5,2)

在我们使用默认参数时，特别需要注意的是：

必选参数必须在前，默认参数在后，否则python解释器会报错
在设置默认参数时，函数有多个参数，把变化大的参数放在前面，变化小的参数放在后面。变化小的参数就可以作为默认参数

使用默认参数的好处就是能够降低调用函数的难度

小结

默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无论是简单调用还是复杂调用，函数只需要定义一个，这就是默认参数的优点之一。

在有多个默认参数时，调用的时候，既可以按照顺序提供默认参数，也可以不按顺序提供默认参数

当不按顺序提供默认参数时，需要把参数名字写上，此时其他的默认参数才可以继续使用默认值

顺序调用

>>> def student(name,gender,age=19,city="北京"):
...     print('name',name)
...     print('gender',gender)
...     print('age',age)
...     print('city',city)
...
>>> student('何曲豆','男')
name 何曲豆
gender 男
age 19
city 北京
>>>

非顺序调用

>>> def student(name,gender,age=19,city="北京"):
...     print('name',name)
...     print('gender',gender)
...     print('age',age)
...     print('city',city)
...
>>> student('小芊芊','女',city="北京")
name 小芊芊
gender 女
age 19
city 北京
>>>

坑点：

定义默认参数时，默认参数必须指向不变对象！！！.

>>> def add_end(L=[]):
...     L.append('END')
...     return L
...
>>> add_end([1,2,3])
[1, 2, 3, 'END']
>>> 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']
>>> add_end()
['END', 'END', 'END', 'END']

结果发现，无论调用多少次，后面都会跟上END
所以我们需要修改上述代码

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

小结

不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误，此外，由于对象不变，多任务环境下同时读取对象不需要加锁。
所以在编写程序时，如果可以设计一个不变对象，就尽量设计成不变对象

可变参数

在python中，还可定义可变参数，意思就是传入的参数个数是可以变化的。
例如，计算a²+b²+c²+.....。
要定义这么个函数，必须确定需要输入的参数。由于参数个数不确定，此时我们可以将参数作为一个list或者是tuple传进来，这样，函数可以如下定义：

>>> def calc(number):
...     sum = 0
...     for n in number:
...         sum = sum + n * n
...     return sum
...
>>> calc([1,2,3,4])
30
>>> calc((1,4,7,11))
187

那么如何将函数的参数变成可变参数呢？
此时我们只需要在参数number前面加上一个*即

>>> def calc(*number):
...     sum = 0
...     for n in number:
...         sum = sum + n * n
...     return sum
...
>>> calc(1,2,4)
21
>>> calc(2,4,5,6)
81
>>> calc()
0

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数
*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

关键字参数

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

>>> def person(name,age,**kw):
...     print("name:",name,"age:",age,"other:",kw)
...
>>> person("leisurely",20)
name: leisurely age: 20 other: {}

在person函数中，name和age是必选参数，在调用时，可以选择只传入必选参数，也可以选择任意个数的关键字参数：

>>> def person(name,age,**kw):
...     print("name:",name,"age:",age,"other:",kw)
...
>>> person("hleisurely",21,city="Beijing",gender="男")
name: hleisurely age: 21 other: {'city': 'Beijing', 'gender': '男'}

关键字的作用是可以扩展函数的功能
利用关键字参数，可以在保证必选参数能够接收到时，任意加入其他可选参数，此类关键字参数非常适用于用户注册的需求
和可变参数类似，也可以先组装出一个dict，然后，把该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获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra

命名关键字参数

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

>>> def person(name,age,*,city,job):
...     print(name,age,city,job)
...
>>> person("Jack",23,city="beijing",job="engineer")
Jack 23 beijing engineer

命名关键字参数和关键字参数**kw不同之处在于命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数*
如果函数参数中已经有了一个可变参数，那后面跟着的命名关键字参数就不再需要分隔符*
使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个作为特殊分隔符。如果缺少，Python解释器将无法识别位置参数和命名关键字参数

参数组合

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

在函数调用的时候，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)
...
>>> 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}

有意思的是还可以通过tuple和dict调用上述函数

>>> 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': '#'}

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

（函数--参数）小结

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的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。