Python基础-函数及函数参数神奇的使用

函数

话不多说，python函数定义是以def开头，例如：

def sum(a,b):
    print('%s + %s = %s' % (a,b,a+b))

sum(1,2)
> 1 + 2 = 3

以上就包含了简单的定义函数、调用函数。

当然python中提供了很多自带的内置函数，例如len()，print()。
这些可以在python官网查看文档。
https://docs.python.org/3/library/functions.html

val = 'abcd'
print(len(val))
> 4

数据类型转换

python内部常用的函数还包括数据类型转换函数，比如int(),str()，具体使用如下：

print(int('123'))
> 123
print(float('123.4'))
> 123.4
print(bool('123.4'))
> True
print(bool(''))
> False
print(str(99))
> "99"
print(hex(16))
> 0x10

定义函数

具体的定义函数要是用def开头，并依次写出函数名、括号、参数、冒号、和具体实现。就如上面的sum函数一样。
例如我们实现一个十进制转换为二进制的函数：

def Dec2Bin(num):
    L = []   #存储二进制
    while num > 0:
        L.insert(0, int(num % 2))
        num = int(num / 2)
    print(L)

Dec2Bin(16)
> [1, 0, 0, 0, 0] #打印出存储二进制

空函数

函数体写一个pass，例如：

def nop():
    pass

pass代表什么都不错，可以用来做占位符，类似于C++中空函数体。

参数检查

当我们给函数传入不合适的参数时，应该能给出合理的打印信息，帮助使用者正确使用该函数，例如我们实现一个绝对值函数，并且和python内置的abs做对比：

def myabs(num):
    if num >= 0:
        print(num)
    else:
        print(-num)

print(abs_int('A'))
print(abs('A'))
#分别打印错误信息
#myabs
> TypeError: '>=' not supported between instances of 'str' and 'int'
#abs
>TypeError: bad operand type for abs(): 'str'

所以为了打印合理的信息，我们需要修改一下myabs的函数，使用isinstance()作为类型检查：

def myabs(num):
    if not isinstance(num, (int, float)):
        raise TypeError('bad operator type for myabs() : %s' % type(num))
    if num >= 0:
        print(num)
    else:
        print(-num)

print(myabs('A'))

> TypeError: bad operator type for myabs() : <class 'str'>

返回多个值

例如在一个平面上生成一些随机点，可以使用一个函数来完成这个功能。

import random
def randomPoint():
    return random.random() * 100, random.random() * 100

print(randomPoint())
> (73.30794748743236, 41.20707185275483)

以上是生成100以内的随机数。其实从打印结果我们看出它是不是和tuple的输出结果一样呢？
我们可以使用type()函数测试一下

print(type(randomPoint()))
> <class 'tuple'>

果然他是个tuple。在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

函数参数

位置参数

我们前面写了一个十进制转换为二进制的，但是我们如果想要十进制转换为8进制、16进制或者其他的呢。
直接实现Dec2Oct或者Dec2Hex显然不太方便，不如我们实现
一个函数实现这些功能。所以我们可以传入第二个参数，如下：

def Dec2Bin(num, n): #函数名应该换一下
    L = []
    while num > 0:
        L.insert(0, int(num % n))
        num = int(num / n)
    print(L)

Dec2Bin(16, 8)

我们可以很轻松的十进制转换八进制。
例如num，n这种参数，是按顺序给出的，我们称为位置参数。

默认参数

但是我们每次都需要输出第二个参数，能不能方便点呢，于是默认参数诞生了。

def Dec2Bin(num, n = 2):
    L = []
    while num > 0:
        L.insert(0, int(num % n))
        num = int(num / n)
    print(L)

Dec2Bin(16)
Dec2Bin(16, 8)

> [1, 0, 0, 0, 0]
> [2, 0]

虽然这样很方便，但是使用默认参数也有一些需要注意的地方，那就是修改参数的时候。
例如，定义一个函数给list增加结束标识：

#先定义一个函数，传入一个list，添加一个END再返回：
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']

原因解释如下：
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用None这个不变对象来实现：

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

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

可变参数

在python中还可以定义可变参数，例如C语言的printf函数。可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
举个例子，我们计算一组数的和，可以使用list、tuple这些，但是调用的时候还是需要凑一个list、或者tuple我们可以简化一下：

def sum(*numbers):
    all = 0
    for i in numbers:
        all += i
    print(all)

sum(1,2,3,4,5)
> 15

是不是很方便，只需要在参数前加’*’即可。

关键字参数

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

def student(name, id, **kw):
    print('Student: name', name, ' id: ', id, ' other: ', kw)

student('Jack', 100)
student('Jack', 100, home='ShangHai', sex='Man')

> Student: name Jack  id:  100  other:  {}
> Student: name Jack  id:  100  other:  {'home': 'ShangHai', 'sex': 'Man'}

函数可以传入必选参数name和id，kw可选传入，但是必须是关键字参数。也可以直接传入一个字典。

d = {'home':'ShangHai', 'sex':'Man'}

student('Jack', 100, city='Beijing')
student('Jack', 100, **d)

> Student: name Jack  id:  100  other:  {'city': 'Beijing'}
> Student: name Jack  id:  100  other:  {'home': 'ShangHai', 'sex': 'Man'}

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

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过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)

但是调用者仍可以传入不受限制的关键字参数，如下使用：

person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收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

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

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()函数仅接受2个位置参数。
命名关键字参数可以有缺省值，从而简化调用：

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

由于命名关键字参数city具有默认值，调用时，可不传入city参数：

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

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：

def person(name, age, city, job):
    # 缺少 *，city和job被视为位置参数
    pass

参数组合

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

例如：

def func(a, b, c = 0, *args, **kwargs):
    print(a, b, c, ' args: ',args, ' kwargs: ', kwargs)

func(1,2)
func(1,2,3,'a','b',{'c':'d'}, e='f')

> 1 2 0  args:  ()  kwargs:  {}
> 1 2 3  args:  ('a', 'b', {'c': 'd'})  kwargs:  {'e': 'f'}

很神奇的是可以通过一个tuple和一个dict调用上述函数

tup = (1,2,3,4)
dic = {'1': 10, '2':20}
func(*tup, **dic)

> 1 2 3  args:  (4,)  kwargs:  {'1': 10, '2': 20}

很有必要研究一下这个输出：123作为abc的参数传入，而4作为一个tuple传入，最后传入一个字典。
所以，对于任意函数，都可以通过类似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的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。