深度学习之Python函数篇

调用函数

Python内置了很多函数，可以直接调用。Python官网内置函数
也可以在交互式命令行通过help()函数获得帮助，例如使用help(abs)查看abs()函数的帮助信息。

>>> abs(100)
100
>>> abs(-100)
100
>>> abs(12.52)
12.52

调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会告诉你：abs()函数只有一个参数，但给出了两个。

>>> abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)

max()函数可以接收多个参数，并返回最大的那个。

>>> max(1, 85, 9656, 12)
9656

数据类型转换

Python内置的常用函数还包括数据类型转换函数。

>>> int('123')
123
>>> int(12.53)
12
>>> float('45.63')
45.63
>>> float(23)
23.0
>>> str(123)
'123'
>>> str(5.32)
'5.32'
>>> bool(1)
True
>>> bool('')
False
>>> hex(45)
'0x2d'

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

>>> A = abs
>>> A(-23.5)
23.5

定义函数

1、定义

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def isAdult(age):
    if age >= 18:
        return "adult"
    else:
        return "child"
print(isAdult(25))

PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
adult

函数体内部语句在执行过程中，遇到return时，函数执行完毕，并将结果返回。如果没有return语句，函数体执行完毕也会返回结果，只是结果为None。return None可以简写为return。
在Python交互环境中定义函数时，会出现...的提示，定义结束后需要按两次回车重新回到>>>提示符下。

2、空函数

可以用pass语句定义一个什么也不做的函数。

def nop():
    pass

pass可以用作占位符，还没想好函数代码，可以先放一个pass，让程序先能运行起来。
pass还可以放在if语句中，防止出现语法错误。

if age >= 18:
    pass

3、参数检查

调用函数时，参数的个数不对，Python解释器会自动检查出来，并抛出TypeError。
但是，参数的类型不对，Python解释器就无法检查出来。内置函数会检查出参数类型错误，而自定义的函数一般都是检查不出来的，这就需要用到内置函数isinstance()来实现对数据类型的检查。

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

PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
Traceback (most recent call last):
  File "d:\MyCode\PythonCode\Test\hello.py", line 86, in <module>
    print(my_abs('A'))
          ^^^^^^^^^^^
  File "d:\MyCode\PythonCode\Test\hello.py", line 81, in my_abs  
    raise TypeError("bad operand type")
TypeError: bad operand type

4、返回多个值

def answer(high, weight):
    return high-10, weight-10
h, w = answer(180, 120)
print(h, w)

PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
170 110

但是，这只是一个假象，返回值仍然是单一值！

def answer(high, weight):
    return high-10, weight-10
h, w = answer(180, 120)
print(h, w)

ans = answer(180, 120)
print(ans)

PS D:\MyCode\PythonCode\Test> & D:/Tool/Python/Python311/python.exe d:/MyCode/PythonCode/Test/hello.py
170 110
(170, 110)

返回值一个元组tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给相应的值，所以，python的函数返回多值就是返回一个tuple。

函数的参数

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

1、位置参数

先定义一个计算x^2的函数。

def power(x):
    return x * x

想要计算x^n，可以将power(x)函数修改为power(x, n)。

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

其中，power(x, n)有两个参数：x和n，这两个参数都是位置参数，调用参数时，传入的两个值按照位置顺序依次赋给参数x和n。

2、默认参数

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

将n默认为2，当调用power(x)时，第二个参数使用默认值2，相当于调用power(x, 2)，不会报错，默认计算的是x*x。当然，调用power(x, n)时，n就会覆盖掉2，使得计算x^n。
设置默认参数时，有几点要注意：
1、必选参数在前，默认参数在后。
2、变化大的参数在前，变化小的参数在后。
默认参数降低了函数调用的难度，而一旦需要复杂调用时，又可以传递更多的参数实现。无论简单调用还是复杂调用，函数只需要定义一个。
有多个默认参数时，调用的时候，也可以不按顺序提供默认参数，但是需要将参数名加上。例如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']

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

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

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

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

3、可变参数

可变参数就是传入的参数个数是可变的，可以是0个到任意个。在参数名前添加*号。在函数内部，参数接收到的是一个tuple。调用该函数时，可以传入任意个参数 ，甚至0个。

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

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

已经有一个 list 或者 tuple 时，直接在变量名前添加*号，将list或tuple中的元素变为可变参数传进去。

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

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

4、关键字参数

关键字参数允许传入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'}

关键字参数可以扩展函数的功能。某个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
也可以先组装一个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。

5、命名关键字参数

限制关键字参数的名字，就可以用命名关键字参数。需要一个特殊分隔符*，*之后的参数被视为命名关键字参数。
定义函数：（只接收city和job作为关键字参数。）

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

调用方式：

>>> 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() 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)

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

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

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

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

6、参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：1必选参数、2默认参数、3可变参数、4命名关键字参数和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 1 2 3 5
f2 的顺序为：1 1 2 4 5
在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

>>> 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是可变参数，args接收的是一个tuple。
# **kw是关键字参数，kw接收的是一个dict。
>>> args = (1, 2, 3, 4)  #元组
>>> kw = {'d': 99, 'x': '#'} #字典
>>> f1(*args, **kw) #args的前3个元素分别赋值给abc后，元组中只剩下一个元素4，即此时的元组是(4,)，直接传给args。
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw) #在传入的dict中d对应的value值是88，赋值给d，其余键-值对传给kw。
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。但是，虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。
*args是可变参数，args接收的是一个tuple。
**kw是关键字参数，kw接收的是一个dict。

递归函数

在一个函数内部调用自身本身，这个函数就是递归函数。
计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示。

所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

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

>>> fact(1)
1
>>> fact(5)
120

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

>>> fact(1000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in fact
  ...
  File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison

解决递归调用栈溢出的方法是通过尾递归优化，效果和循环的效果一样。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

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

上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归，就要把每一步的乘积传入到递归函数中。

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)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。