6 函数(一)

前面写的程序都是很小的，假设我们要编写一个很大的程序，并且要重复使用很多遍相同的代码，直观的想法，自然就是把这些代码装到一个“箱子”里，给这个“箱子”编上号，等到用的时候，告诉电脑“箱子”里面的就是所需要的代码。

函数就可以实现这样的功能。函数是Python中最主要也是最重要的代码组织和复用手段。

假设我们想求出两个数相加的结果，就可以写如下的函数：

In [1]: def add(x,y):

...: z = x + y

...: return(z)

其中def是声明函数的关键字，是必须要写的；add是函数的名称；在圆括号里面的x,y是参数，可以理解为数学函数的自变量，并且圆括号也是必须写的；z可以理解为函数的因变量；最后，我们通过return函数，将结果z输出来。

如果我们要求1+2，20+30的值，就可以这样写：

In [2]: add(1,2)

Out[2]: 3

In [3]: add(20,30)

Out[3]: 50

相当于我们把1和2代到自变量那里，就可以得到了结果。需要注意的是，add函数只有两个参数，如果带入参数的个数不为2，会引起错误：

In [4]: add(1,2,3)

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

----> 1 add(1,2,3)

TypeError: add() takes 2 positional arguments but 3 were given

6.1 参数

从前面可以看到，参数相当于数学上函数的自变量。Python也有很多种参数的写法，通过不同的参数，可以实现不同的功能。位置参数

前面例子使用的参数就是位置参数。位置参数的位置很重要，比它的名称要重要得多。我们考虑下面两个函数：

In [5]: def divide1(a,b):

...: return(a/b)

In [6]: def divide1(b,a):

...: return(a/b)

我们定义了两个函数divide1和divide2，除了圆括号中参数a和b的位置，它们都是一样的。接下来我们把数字1和2带入：

In [10]: divide1(1,2)

Out[10]: 0.5

In [11]: divide2(1,2)

Out[11]: 2.0

在函数divide1里面，a和数字1的位置是一样的，此时a等于1；b和数字2的位置是一样的，此时b等于2。所以结果为1/2，即0.5。对于divide2来说，a等于2，b等于1，结果自然为2。关键字参数

如果参数个数很多的话，参数的位置我们很难记住。为了简化工作，我们也可以指定参数的名称：

In [12]: divide2(a=1,b=2)

Out[12]: 0.5

我们指定a的值为1，b的值为2，这样divide2的结果也是0.5了。

像这样使用名称指定的参数就是关键字参数，主要的优点是有助于澄清各个参数的作用，并且参数的位置不一样也不影响结果。

In [13]: divide2(b=2,a=1)

Out[13]: 0.5

关键字参数最大的优点是可以指定默认值。考虑新的函数divide3：

In [14]: def divide3(a=1,b=1):

...: return(a/b)

在这个函数里面，我们默认a和b的值为1，如果我们不往函数里面输入值的话，Python就按照a和b的值为1进行计算：

In [16]: divide3()

Out[16]: 1.0

但如果没有指定默认值，就会报错：

In [17]: divide2()

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

----> 1 divide2()

TypeError: divide2() missing 2 required positional arguments: 'b' and 'a'可变参数

在前面我们知道，值的个数和参数个数不一样就会报错。但是如果在某个问题里面，参数个数是不固定的怎么办。这就要用到可变参数了。

我们考虑求几个数的和，但数字的个数是不固定的。

如果我们括号里面写成位置参数，只需要定义一个参数，然后在参数前面写个*号：

In [22]: def add2(*number):

...: sum = 0

...: for i in number:

...: sum = sum + i

...: return(sum)

In [23]: add2(1,2,3)

Out[23]: 6

In [24]: add2(1,2,3,4)

Out[24]: 10

工作原理是这样的：Python把我们输入的任意的参数转化为元组，我们利用元组的操作，就可以得到结果了。

对于关键字参数，需要在参数前面写**号:

In [25]: def add3(**number):

...: sum = 0

...: for i in number.values():

...: sum = sum + i

...: return(sum)

...:

...:

In [26]: add3(a=1,b=2,c=3)

Out[26]: 6

Python把我们输入的关键字参数转化为字典，其中参数名称为字典的键，参数值为字典的值。我们再利用字典的相关操作，就可以得到结果了。

需要注意的是，这两种可变参数不可混用，否则会报错：

In [27]: add2(a=1,b=2,c=3)

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

----> 1 add2(a=1,b=2,c=3)

TypeError: add2() got an unexpected keyword argument 'a'

In [28]: add3(1,2,3)

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

----> 1 add3(1,2,3)

TypeError: add3() takes 0 positional arguments but 3 were given参数组合

前面介绍的几种参数是可以混用的，但是顺序是固定的，必须是(从前往后)：位置参数、关键字参数、可变参数(对应位置参数)、可变参数(对应关键值参数)，在使用函数的时候，Python自动按照参数位置和参数名把参数带入到函数里面。

考虑如下的函数：

In [29]: def f1(a,b,c=1,*args,**kw):

...: print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

这个函数里面有五个不同类型的参数，并分别输出参数结果。对于不同的赋值方式，也就有不同的结果：

In [30]: f1(1,2,3,4,5)

a = 1 b = 2 c = 3 args = (4, 5) kw = {}

In [31]: f1(1,2,3,4,e = 5)

a = 1 b = 2 c = 3 args = (4,) kw = {'e': 5}

In [32]: f1(1,2,3)

a = 1 b = 2 c = 3 args = () kw = {}

6.2 返回多个值

这也是Python一个比较特别的功能。在前面的例子当中，函数的结果只有一个，但我们也可以输出多个结果。记得没错的话，R语言并没有这样的功能，对于R语言来说，如果要输出多个结果，需要把这些结果聚合到一个数据结构里面，在返回这个数据结构。参见下面的例子：

In [33]: def ff(a,b):

...: return(a+b,a-b)

In [34]: ff(1,2)

Out[34]: (3, -1)

只需要在return函数里面写上多个值，函数就可以输出多个结果。