Python 函数

Python 函数

今天学习下Python的一些函数，以及如何自定义函数。

定义函数

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

import os

def my_abs(x):          #定义自己的绝对值函数
    if x >= 0:
        return x
    else:
        return -x

def multReturn(x, y):   #返回多个值函数
    nx = x + y
    ny = x - y
    return nx, ny

def doNone():           #定义一个函数，什么都不做
    pass

def main():
    a = my_abs(-20)     #调用函数
    print(a)
    numX, numY = multReturn(10, 5)
    print(numX,' ', numY)
    doNone() 

if __name__ == '__main__':
    main()

输出结果：

20
15   5

函数的参数

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。

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

位置参数

def my_power(x):        #计算x平方函数
    return x*x

# 定义一个计算x次方的函数
def my_power(x, n):
    s = 1
    while n > 0:
        n -= 1
        s *= x
    return s

默认参数

# 定义一个计算x次方的函数, 默认n为2
# my_power(3)=9 ; my_power(3,3)=27
def my_power(x, n=2):
    s = 1
    while n > 0:
        n -= 1
        s *= x
    return s

默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑，演示如下：

先定义一个函数，传入一个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()时，结果就不对了：

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

很多初学者很疑惑，默认参数是[]，但是函数似乎每次都“记住了”上次添加了'END'后的list。
注： 定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用`None这个不变对象来实现：

def add_end(L=None):
    if L is None:    #参数检查
        L = []
    L.append('END')
    return L

现在，无论调用多少次，都不会有问题：

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

可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
我们以数学题为例子，给定一组数字$a，b，c……$，请计算$a^2 + b^2 + c^2 + ……$。
要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

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

但是调用的时候，需要先组装出一个list或tuple：

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

如果利用可变参数，调用函数的方式可以简化成这样：

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84

内置函数

Python内置很多参数，比如上述的参数检查函数，我们只需知道函数的名称和参数，就可以直接调用。Python官网文档：
内置函数：https://docs.python.org/3/library/functions.html

Built-in Functions
abs()	delattr()	hash()	memoryview()
all()	dict()	help()	min()
any()	dir()	hex()	next()
ascii()	divmod()	id()	object()
bin()	enumerate()	input()	oct()
bool()	eval()	int()	open()
breakpoint()	exec()	isinstance()	ord()
bytearray()	filter()	issubclass()	pow()
bytes()	float()	iter()	print()
callable()	format()	len()	property()
chr()	frozenset()	list()	range()
classmethod()	getattr()	locals()	repr()
compile()	globals()	map()	reversed()
complex()	hasattr()	max()	round()

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
举个例子，我们来计算阶乘 $n! = 1 * 2 * 3 * ... *n$，用函数fact(n)表示，可以看出：
$fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n$
所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。
于是，fact(n)用递归的方式写出来就是：

def fact(n):    #递归函数：求斐波那列
    if n == 1:
        return n
    return n * fact(n-1)

结果：

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