【Python】函数

Python 函数专题

函数是一个接受输入、进行特定计算并产生输出的语句集。

我们把一些经常或反复被使用的任务放在一起，创建一个函数，而不是为不同的输入反复编写相同的代码。

Python提供了print、sorted、max、map等内置函数，但我们也可以创建自己的函数，称为用户定义函数。

基础部分

1 函数组成

如下自定义函数：

def foo(nums):
    """ 返回偶数序列"""
    evens = []
    for num in nums:
        if num%2==0:
            evens.append(num)
    return evens

可以看到函数主要组成部分：

函数名：foo
函数形参：nums
: : 函数体的控制字符，作用类似Java或C++的一对{}
缩进：一般为4个字符
“”"：为函数添加注释
return: 函数返回值
以上函数求出列表nums中的所有偶数并返回，通过它了解Python函数的主要组成部分。

2 引用传参

定义好一个函数后，使用：函数名+()+实参，调用函数，如下方法：

foo([10,2,5,4])

其中[10,2,5,4]为实参，它通过by reference方式传给形参nums，即nums指向列表头，而不是重新复制一个列表给nums.

再看一个引用的例子：

def myFun(x): 
    x[0] = 20

如下调用：

lst = [10, 11, 12, 13, 14, 15] 
myFun(lst)

实参lst和形参x都指向同一个列表：

因此，对x[0]修改实际就是对实参lst的修改，结果如下：

但是，有时在函数内部形参指向改变，因此实参与形参的指向分离，如下例子：

def myFun(x):  
    x = [20, 30, 40]
    x[0] = 0

调用：

lst = [10, 11, 12, 13, 14, 15] 
myFun(lst)

x 被传参后初始指向lst，如下所示：

但是，执行x = [20, 30, 40]后，对象x重新指向一个新的列表对象[20,30,40]：

因此，对于x内元素的任何修改，都不会同时影响到lst，因为指向已经分离。

3 默认参数与关键字参数

Python函数的参数，可以有初始默认值，在调用时如果不赋值，则取值为默认值，如下例子：

def foo(length,width,height=1.0):
    return length*width*height

调用foo函数，没有为height传参，所以取为默认值1.0：

r = foo(1.2,2.0)
print(r) # 2.4

使用默认值有一点需要区分，有的朋友会与关键字参数混淆，因为它们都是para=value的结构，但是有一个很明显的不同：默认值是声明在函数定义时，关键字参数是在函数调用时使用的此结构。如下例子：

def foo(length,width,height=1.0): # height是默认参数
    return length*width*height

foo(width=2.0,length=1.2) #确定这种调用后才确定width和length是关键字参数

确定以上调用后，才确定width和length是关键字参数，并且关键字参数不必按照形参表的顺序调用。

4 可变参数

Java和C++在解决同一个函数但参数个数不同时，会使用函数重载的方法。Python使用可变参数的方法，非常灵活。

可变参数是指形参前带有*的变量，如下所示：

def foo(length,*others):
    s = length
    for para in others:
        s *= para
    return s

我们可以像下面这样方便的调用：

foo(1.2,2.0,1.0) # 2.4

如上，带一个星号的参数被传参后，实际被解释为元组对象。我们还可以这样调用：

foo(1.2) # 1.2

5 内置函数

总结完函数的参数后，再举几个Python内置的常用函数。

1. pow
   大部分朋友应该知道pow是个幂次函数，比如求：

   pow(2,3)
   

   除此以外，pow还有第三个参数，使用更高效的算法实现求幂后再求余数：

   pow(2,3,5) # 3
   

2. max,min
   max,min用来求解最大最小值，实现relu函数：

   def relu(x):
       return max(x,0)
   

3. sorted
   sorted函数完成对象排序，它能接收一个指定排序规则的函数，完成定制排序。如下，根据字典值绝对值从小到大排序：

   d = {'a':0,'b':-2,'c':1}
   dr = sorted(d.items(),key=lambda x:abs(x[1])) 
   print(dr) # [('a', 0), ('c', 1), ('b', -2)]
   

进阶部分

Python有一个专门操作函数的模块：functools，能实现一些关于函数的特殊操作。

6 偏函数

偏函数固定函数的某些参数后，重新生成一个新的函数。

通常用法，当函数的参数个数太多，需要简化时，使用partial创建一个新的函数。

假设我们要经常调用int函数转换二进制字符，设置参数base为2:

int('1010',base=2)

为了避免每次都写一个参数base，我们重新定义一个函数：

def int2(s):
    return int(s,base=2)

以后每次转化字符串时，只需int2(‘1010’)即可，更加简便。

偏函数也能实现上述功能：

from functools import partial

intp = partial(int,base=2) 

那么有的朋友会问，偏函数就是个鸡肋，重新定义的int2更加直观容易理解，这个角度讲确实是这样。但是int2不能再接收base参数，但是intp函数还是能接收base参数，依然保留了原来的参数：

intp('10',base=16) # 16

可能看到这里的读者还是有些迷糊，不太确定怎么使用偏函数。可以先记住：修改内置函数的默认参数，就像内置函数int默认参数base等于10，使用偏函数调整默认base值为2.

7 递归函数

递归函数是指调用自身的函数。如下使用递归反转字符串：

def reverseStr(s): 
    if not s:
        return s 
    return reverseStr(s[1:])+s[0]
    
print(reverseStr('nohtyp')) # python

reverseStr函数里面又调用了函数reverseStr，所以它是递归函数。

使用递归函数需要注意找到正确的递归基，防止陷入无限递归。

更多使用递归的例子大家可参考此公众号之前推送。

8 匿名函数

匿名函数是指使用lambda关键字创建的函数。它的标准结构如下：

lambda 形参列表: 含有形参列表的表达式

表达式的计算值即为lambda函数的返回值。

如下lambda函数：

lambda x,y: x+y

它等价于下面的f函数:

def f(x,y):
    return x+y

lambda函数常做为max,sorted,map,filter等函数的key参数。

9 高阶函数

可以用来接收另一个函数作为参数的函数叫做高阶函数。

如下f有一个参数g，而g又是函数，所以f是高阶函数：

def f(g):
    g()

Python 中经常会遇到高阶函数，今天介绍几个内置的常用的高阶函数。

1. map
   map 函数第一个参数为函数，它作用于列表中每个的元素。

   如下，列表中的单词未按照首字母大写其他字符小写的规则，使用map一一capitalize每个元素：

   m = map(lambda s: s.capitalize(), ['python','Very','BEAUTIFUL'])
   print(list(m))
   

   结果：

   ['Python', 'Very', 'Beautiful']
   

2. reduce
   reduce 高阶函数实现化简列表，它实现的效果如下：
   $$reduce(x_1,x_2,x_3)=f(f(x_1,x_2),x_3)$$

   如下例子，函数f等于x+y，求得两数之和，然后再与第三个数相加，依次下去，直到列表尾部，进而得到整个列表的和：

   from functools import reduce 
   
   def f(x,y):
   	return x+y
   
   r = reduce(f, [1,3,2,4])
   print(r) # 10
   

   以上reduce求解过程等于：
   $$f(f(f(1,3),2),4)=f(f(4,2),4)=f(6,4)=10$$
   需要注意：reduce函数要求f必须带2个参数，只有这样才能完成归约化简。

10 嵌套函数

嵌套函数是指里面再嵌套函数的函数。

如下例子，将列表转化为二叉树。已知列表nums，

nums = [3,9,20,None,None,15,7]，转化为下面二叉树:

二叉树定义：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

构建满足以上结构的二叉树，可以观察到：树的父节点和左右子节点在列表中下标的关系：
$$lef{t}_{i}ndex=2\ast paren{t}_{i}ndex+1$$
$$righ{t}_{i}ndex=2\ast paren{t}_{i}ndex+2$$

基于以上公式，再使用递归构建二叉树。

递归基情况：

if index >= len(nums) or nums[index] is None:
    return None

递归方程：
$$lef{t}_{n}ode=f(2\ast paren{t}_{i}ndex+1)$$
$$righ{t}_{n}ode=f(2\ast paren{t}_{i}ndex+2)$$

根据以上分析，得到如下代码，list_to_binarytree函数是嵌套函数，它里面还有一个level子函数：

def list_to_binarytree(nums):
    def level(index):
        if index >= len(nums) or nums[index] is None:
            return None
        
        root = TreeNode(nums[index])
        root.left = level(2 * index + 1)
        root.right = level(2 * index + 2)
        return root

    return level(0)

binary_tree = list_to_binarytree([3,9,20,None,None,15,7])

通常使用嵌套函数的场景：实现一个功能只需要编写2个函数，写成一个class好像显得有些不必要，写成嵌套后更简洁，并且某些参数能共享，亲和性会更好。不妨体会上面的nums参数。