Python_函数

一、调用函数

Python内置了很多有用的线程函数，可以直接调用。与C+类似，要调用一个函数，需要知道函数的名称和参数。

例：

abs(100) # 100
abs(-100)# 100
 
max(1,2,3,4) #4

• 数据类型转换

Python内置的常用函数还包括数据类型转换函数，比如int() 、float()、 str() 、bool()等等…

函数名归根结底就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”；

a = abs
a(-1) 
print(a)  #1

二、定义函数

在Python中，定义一个函数使用def语句打头，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。需要注意的是如果没有return语句，会自动return none

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
 
print(my_abs(-99))
 

• 空函数

如果想定义个什么事都不做的空函数，或者没想好要具体怎么实现但为了让代码跑通，都可以用pass语句来进行定义

def nop():
	pass

• 参数检查

调用函数的时候，如果参数个数不对，解释器会自动弹出相应的报错信息

a = my_abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: my_abs() takes 1 positional argument but 2 were given

但是如果是参数类型不对，解释器就无法帮我们检查，因此，我们自己定义的函数，需要在传参的时候做出相应检测。例如：上面定义的my_abs()没有规定，那我们在函数中用内置函数isisntance()来规定值允许浮点数和整数参数

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

• 返回多个值

看起来这是Python与C+和Java的一个区别，Python可以直接返回多个值，但是另外两个不能直接返回，而是要通过其他途径才能直接返回多个值。但其实Python返回的是一个tuple类型，只是可以省略掉括号。

a = abs  #相当于把函数取了个别名，注意此处不带括号
b = a(-1)
print(b) 

三、函数的参数

​ Python的函数定义非常简单，但灵活度却非常大。除了正常的必选参数外，还可以使用默认参数、可变参数、关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

（一）位置参数

最常见的参数形式，传参的时候需要按照位置顺序进行传入。

def power(x):   #此处的x就是最常见的位置参数
    return x * x

当你如果想再定义一个适用于n次方的平方函数，那么就可以定义power(x,n)靠着参数n进行幂的控制，不过这样的话，旧函数就没用了，那这个时候默认参数就可以发挥作用了。

（二）默认参数

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

这样当我们调用power(5)的时候，就相当于调用power(5,2)；或者换一种方式理解，就算我们没有前面的power(x)的定义，我们的power(x,n=2)有了默认参数，当直接调用却没有传入幂的参数时候，解释器会自动使用默认的参数，只有默认参数不匹配的才需要额外传入参数，从而降低调用函数的复杂度。

Tips：

​ 1.必选参数在前，默认参数在后

​ 2.如何设置默认参数：把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

​ 3.当有很多个默认参数的时候，可以不按照顺序来提供，但是需要把参数名写上。例如：

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

​ 4.默认参数必须指向不变对象！

#错误示范
def add_end(L=[]):
    L.append('END')
    return L
 
print(add_end()) #['END']
print(add_end()) #['END', 'END']
print(add_end()) #['END', 'END', 'END']
 
 

​ 底层逻辑是因为：在定义完def函数后，会计算出默认参数的值，并且分配一块内存空间进行绑定，作为函数的func._default_属性，此后每次调用的时候func._default_属性都会因为默认参数是可变对象而被修改，一步步叠加。

​ 解决上述的问题办法是，使用None来当哨兵：

def add_end(L=None):
    if L is None:
        L = []   # 每次调用创建新列表
    L.append('END')
    return L

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

（三）可变参数

​ 在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

​ 一般的做法是先定义一个list或者tuple（注意tuple是不可变对象，可变参数的可变指的是个数，是指函数可以同时处理多个不同量的参数）：

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
print(calc([1, 2, 3]))  #14
print(calc((1, 3, 5, 7))) #84

​ 如果利用的是可变参数，则会简便很多，定义的方法就是在参数前面加上*****：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
 
calc(1, 2, 3)
calc(1, 3, 5, 7) #效果同上

​ 在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数；如果已经有一个list或者tuple，要调用一个可变对象怎么办？可以这样做：

nums = [1, 2, 3]
 
calc(nums[0],nums[1],nums[2]) #14
calc(*nums) #效果同上

​ *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。这种用法有点类似于C++中指针的解引用。

（四）关键字参数

​ 而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。用**来表示关键字参数。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
    
    
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，然后，把该dict转换为关键字参数传进去：

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, city=extra['city'], job=extra['job'])
# name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
 
 
也可以简略写成
person('Jack', 24, **extra)  #效果同上

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

（五）命名关键字参数

​ 关键字参数是不限制，如果要限制关键字参数的名字，就可以用命名关键字参数，可以说是，命名关键字参数是关键字参数的一种特殊表现形式。它的作用就是要求命名关键字参数必须要提供，而且提供的时候必须要带上确切的命名。例如，只接收city和job作为关键字参数。这种方式定义的函数如下

特性	关键字参数 (**kwargs)	命名关键字参数
参数数量	任意数量	固定数量
参数名称	任意名称	预定义名称
强制性	可选	可强制要求
默认值	不支持单个参数的默认值	支持默认值
错误检查	宽松，接受任何参数	严格，只接受定义的参数
使用场景	处理不确定的参数	处理明确的、需要强制命名的参数

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

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

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

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 ... , in <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'
 
# ********重难点********
#由于调用时缺少参数名city和job，Python解释器把前两个参数视为位置参数，后两个参数传给*args，但缺少命名关键字参数导致报错。

同时命名关键字参数可以有缺省值（默认值），从而简化调用：

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

（六）参数组合

​ 在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)

​ 将所有类型参数抽象后，可以发现，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的，最神奇的是通过一个tuple和dict，你也可以调用上述所有类型的函数。

小练习：

请稍加改造，将函数变成可接收一个或多个数并计算乘积：，

def mul(x, y):
    return x * y
 
# 测试
print('mul(5) =', mul(5))
print('mul(5, 6) =', mul(5, 6))
print('mul(5, 6, 7) =', mul(5, 6, 7))
print('mul(5, 6, 7, 9) =', mul(5, 6, 7, 9))
if mul(5) != 5:
    print('mul(5)测试失败!')
elif mul(5, 6) != 30:
    print('mul(5, 6)测试失败!')
elif mul(5, 6, 7) != 210:
    print('mul(5, 6, 7)测试失败!')
elif mul(5, 6, 7, 9) != 1890:
    print('mul(5, 6, 7, 9)测试失败!')
else:
    try:
        mul()
        print('mul()测试失败!')
    except TypeError:
        print('测试成功!')

def mul(x, *y):  
    z = x
    for i in y:
        z *= i
    return z

​ 函数要确保至少有一个参数，否则的话还要在函数内部进行一个参数的个数判断，所以可以利用一个必要的参数，加上可变参数，因为可变参可是0个，这就实现了函数的参数个数的控制。

四、递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，不断地套娃，这个函数就是递归函数。

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

⇒ fact(5) ⇒ 5 * fact(4) ⇒ 5 * (4 * fact(3)) ⇒ 5 * (4 * (3 * fact(2))) ⇒ 5 * (4 * (3 * (2 * fact(1)))) ⇒ 5 * (4 * (3 * (2 * 1))) ⇒ 5 * (4 * (3 * 2)) ⇒ 5 * (4 * 6) ⇒ 5 * 24 ⇒ 120

递归函数的优点是定义简单，逻辑清晰。理论上来说，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

需要注意的是，使用递归函数需要防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

def fact(n):
    return fact_iter(n, 1)
 
def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)