『Python核心技术与实战』不可或缺的自定义函数以及匿名函数！

旧城等待， 2022-09-13 13:23 221阅读 0赞

<table> 
 <tbody> 
  <tr> 
   <td><font>不可或缺的自定义函数！</font> </td> 
  </tr> 
 </tbody> 
</table>

### 文章目录 ###

*  一. 自定义函数
 *   *  1.1. 函数基础
     *  1.2. 函数变量作用域
     *  1.3. 闭包
     *  1.4. 总结
 *  二. 匿名函数
 *   *  2.1. 匿名函数基础
     *  2.2. 为什么要使用匿名函数？
     *  2.3. Python 函数式编程
     *   *  1. map()函数
         *  2. filter()函数
         *  3. reduce()函数
     *  2.4. 总结

# 一. 自定义函数 #

## 1.1. 函数基础 ##

>  *  说白了，**函数就是为了实现某一功能的代码段**，只要写好以后，就**可以重复利用**。

def my_func(message):
        print('Got a message: {}'.format(message))
    # 调用函数 my_func()
    my_func('Hello World')
    # 输出
    Got a message: Hello World

>  *  def 是函数的声明；
>  *  my\_func 是函数的名称；
>  *  括号里面的 message 则是函数的参数；
>  *  而 print 那行则是函数的主体部分，可以执行相应的语句；
>  *  在函数最后，你可以返回调用结果(return 或 yield)，也可以不返回。

>  *  和其他需要编译的语言(比如C语言) **不一样的是，def 是可执行语句，这意味着函数直到被调用前，都是不存在的**。当程序调用函数时，def 语句才会创建一个新的**函数对象**，并赋予其名字。

>  *  **需要注意**，**主程序调用函数时，必须保证这个函数此前已经定义过**，不然就会报错，比如：

my_func('hello world')
    def my_func(message):
        print('Got a message: {}'.format(message))
        
    # 输出
    NameError: name 'my_func' is not defined

>  *  但是，**如果我们在函数内部调用其他函数，函数间哪个声明在前、哪个在后就无所谓**，因为 def 是可执行语句，函数在调用之前都不存在，我们只需保证调用时，所需的函数都已经声明定义：

def my_func(message):
        my_sub_func(message) # 调用my_sub_func()在其声明之前不影响程序执行
        
    def my_sub_func(message):
        print('Got a message: {}'.format(message))
    
    my_func('hello world')
    
    # 输出
    Got a message: hello world

>  *  另外，Python 函数的**参数可以设定默认值**，比如下面这样的写法：

def func(param = 0):
        ...

>  *  这样，在调用函数`func()`时，如果参数 `param` 没有传入，则参数 **默认为 0**；而如果传入了参数 `param`，其就会覆盖默认值。

>  *  Python 和其他语言相比的一大特点是，Python是dynamically typed的，可以接受任何数据类型(**整型，浮点，列表，字符串**等等)。
>  *  Python 不用考虑输入的数据类型，而是将其交给具体的代码去判断执行，同样的一个函数，可以同时应用在整型、列表、字符串等等的操作中。在编程语言中，我们把这种行为称为多态。这也是 Python 和其他语言，比如 Java、C 等很大的一个不同点。当然，Python 这种方便的特性，在实际使用中也会带来诸多问题。因此，必要时请你在开头加上数据的类型检查。

>  *  Python 函数的另一大特性，**是 Python 支持函数的嵌套**。所谓的函数嵌套，就是指函数里面又有函数，比如：

def f1():
        print('hello')
        def f2():
            print('world')
        f2()
    f1()
    
    # 输出
    hello
    world

>  *  其实，函数的嵌套，主要有下面两个方面的作用。
>  *  **第一，函数的嵌套能够保证内部函数的隐私**。内部函数只能被外部函数所调用和访问，**不会暴露在全局作用域**，因此，如果你的函数内部有一些隐私数据（比如数据库的用户、密码等），不想暴露在外，那你就可以使用函数的的嵌套，将其封装在内部函数中，只通过外部函数来访问。比如(这里的函数 get\_DB\_configuration，便是内部函数，它无法在 connect\_DB() 函数以外被单独调用)：

def connect_DB():
        def get_DB_configuration():
            ...
            return host, username, password
        conn = connector.connect(get_DB_configuration())
        return conn

## 1.2. 函数变量作用域 ##

>  *  Python 函数中变量的作用域和其他语言类似。**如果变量是在函数内部定义的，就称为局部变量，只在函数内部有效**。一旦函数执行完毕，局部变量就会被回收，无法访问，比如下面的例子：
>  *  **全局变量则是定义在整个文件层次上的**，比如下面这段代码：

MIN_VALUE = 1
    MAX_VALUE = 10
    def validation_check(value):
        if value < MIN_VALUE or value > MAX_VALUE:
            raise Exception('validation check fails')

>  *  这里的 MIN\_VALUE 和 MAX\_VALUE **就是全局变量**，可以在文件内的任何地方被访问，当然在函数内部也是可以的。不过，我们不能在函数内部随意改变全局变量的值。比如，下面的写法就是错误的：

MIN_VALUE = 1
    MAX_VALUE = 10
    def validation_check(value):
        ...
        MIN_VALUE += 1
        ...
    validation_check(5)
    # 如果运行这段代码，程序便会报错：
    # UnboundLocalError: local variable 'MIN_VALUE' referenced before assignment

>  *  因为，**Python 的解释器会默认函数内部的变量为局部变量**，但是又发现局部变量 MIN\_VALUE 并没有声明，因此就无法执行相关操作。所以，如果我们一定要在函数内部改变全局变量的值，就必须加上 global 这个声明：

MIN_VALUE = 1
    MAX_VALUE = 10
    def validation_check(value):
        global MIN_VALUE
        ...
        MIN_VALUE += 1
        ...
    validation_check(5)

>  *  这里的 global 关键字，并不表示重新创建了一个全局变量 MIN\_VALUE，而是告诉 Python 解释器，函数内部的变量 MIN\_VALUE，**就是之前定义的全局变量**，**并不是新的全局变量，也不是局部变量**。这样，程序就可以在函数内部访问全局变量，并修改它的值了。

>  *  另外，如果遇到函数内部局部变量和全局变量同名的情况，那么在函数内部，局部变量会覆盖全局变量，比如下面这种：

MIN_VALUE = 1
    MAX_VALUE = 10
    def validation_check(value):
        MIN_VALUE = 3
        ...

>  *  在函数 validation\_check() 内部，我们定义了和全局变量同名的局部变量 MIN\_VALUE，那么，MIN\_VALUE 在函数内部的值，就应该是 3 而不是 1 了。

>  *  类似的，对于**嵌套函数**来说，内部函数可以访问外部函数定义的变量，但是无法修改，若要修改，**必须加上 nonlocal 这个关键字**：

def outer():
        x = "local"
        def inner():
            nonlocal x # nonlocal关键字表示这里的x就是外部函数outer定义的变量x
            x = 'nonlocal'
            print("inner:", x)
        inner()
        print("outer:", x)
    outer()
    # 输出
    inner: nonlocal
    outer: nonlocal

>  *  **如果不加上 nonlocal 这个关键字，而内部函数的变量又和外部函数变量同名，那么同样的，内部函数变量会覆盖外部函数的变量。**

def outer():
        x = "local"
        def inner():
            x = 'nonlocal' # 这里的x是inner这个函数的局部变量
            print("inner:", x)
        inner()
        print("outer:", x)
    outer()
    # 输出
    inner: nonlocal
    outer: local

## 1.3. 闭包 ##

>  *  介绍一下 **闭包(closure)**。**闭包其实和刚刚讲的嵌套函数类似，不同的是，这里外部函数返回的是一个函数，而不是一个具体的值**。返回的函数通常赋于一个变量，这个变量可以在**后面被继续执行调用**。
>  *  举个例子你就更容易理解了。比如，我们想计算一个数的 n 次幂，用闭包可以写成下面的代码：

def nth_power(exponent):
        def exponent_of(base):
            return base ** exponent
        return exponent_of # 返回值是exponent_of函数
    
    square = nth_power(2) # 计算一个数的平方
    cube = nth_power(3) # 计算一个数的立方 
    square
    # 输出
    <function __main__.nth_power.<locals>.exponent(base)>
    
    cube
    # 输出
    <function __main__.nth_power.<locals>.exponent(base)>
    
    print(square(2))  # 计算2的平方
    print(cube(2)) # 计算2的立方
    # 输出
    4 # 2^2
    8 # 2^3

>  *  这里 **外部函数 nth\_power() 返回值，是函数 exponent\_of()**，而不是一个具体的数值。**需要注意的是，在执行完square = nth\_power(2)和cube = nth\_power(3)后，外部函数 nth\_power() 的参数 exponent，仍然会被内部函数 exponent\_of() 记住**。这样，**之后我们调用 square(2) 或者 cube(2) 时，程序就能顺利地输出结果**，而不会报错说参数 exponent 没有定义了。
>  *  看到这里，你也许会思考，为什么要闭包呢？上面的程序，我也可以写成下面的形式啊！

def nth_power_rewrite(base, exponent):
        return base ** exponent

>  *  确实可以，不过，要知道，使用闭包的一个原因，是让程序变得更简洁易读。设想一下，比如你需要计算很多个数的平方，那么你觉得写成下面哪一种形式更好呢？

# 不适用闭包
    res1 = nth_power_rewrite(base1, 2)
    res2 = nth_power_rewrite(base2, 2)
    res3 = nth_power_rewrite(base3, 2)
    ...
    
    # 使用闭包
    square = nth_power(2)
    res1 = square(base1)
    res2 = square(base2)
    res3 = square(base3)
    ...

>  *  显然是第二种，是不是？首先直观来看，第二种形式，让你每次调用函数都可以少输入一个参数，表达更为简洁。
>  *  其次，和上面讲到的嵌套函数优点类似，函数开头需要做一些额外工作，而你又需要多次调用这个函数时，将那些额外工作的代码放在外部函数，就可以**减少多次调用导致的不必要的开销**，**提高程序的运行效率**。
>  *  另外还有一点，我们后面会讲到，**闭包常常和装饰器(decorator)一起使用**。

## 1.4. 总结 ##

>  *  总结这节课，一起学习了 Python 函数的概念及其应用，有这么几点你需要注意:
>  *  Python 中函数的参数 **可以接受任意的数据类型**，使用起来需要注意，必要时请在函数开头加入数据类型的检查；
>  *  和其他语言不同，**Python中函数的参数可以设定默认值**；
>  *  **嵌套函数的使用，能保证数据的隐私性**，提高程序运行效率；
>  *  **合理地使用闭包，则可以简化程序的复杂度，提高可读性。**

# 二. 匿名函数 #

>  *  上一节一起学习了 Python 中的 **“常规”函数**，用途十分广泛。不过，除了常规函数，你应该也会在代码中见到一些 **“非常规”函数**，它们往往很简短，就一行，并且有个很酷炫的名字——lambda，没错，这就是**匿名函数**。

## 2.1. 匿名函数基础 ##

>  *  首先，什么是匿名函数呢？以下是匿名函数的格式：

lambda argument1, argument2,... argumentN : expression

>  *  **冒号之前的是参数，冒号之后是表达式。** 匿名函数的**关键字是 lambda**，之后是一系列的参数，然后用冒号隔开，最后则是由这些参数组成的表达式：

square = lambda x: x**2
    square(3)
    
    9

>  *  这里的匿名函数只输入一个参数 x，输出则是输入 x 的平方。因此当输入是 3 时，输出便是 9。如果把这个匿名函数写成常规函数的形式，则是下面这样：

def square(x):
        return x**2
    square(3)
     
    9

>  *  可以看到，匿名函数 lambda 和常规函数一样，返回的都是一个函数对象（function object），它们的用法也极其相似，**不过还是有下面几点区别**。

>  *  ①. 第一，lambda **是一个表达式**（expression），并**不是一个语句**（statement）。所谓的表达式，就是用一系列“公式”去表达一个东西，比如x + 2、 x\*\*2等等；而所谓的语句，则一定是完成了某些功能，比如赋值语句x = 1完成了赋值，print 语句print(x)完成了打印，条件语句 if x < 0:完成了选择功能等等。
>  *  因此，lambda 可以用在一些常规函数 def 不能用的地方，**比如，lambda 可以用在列表内部**，而常规函数却不能：

[(lambda x: x*x)(x) for x in range(10)]
    # 输出
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>  *  再比如，**lambda 可以被用作某些函数的参数**，而常规函数 def 也不能：

l = [(1, 4), (5, 8), (2, 6), (5, 19), (22, 15)]
    l.sort(key = lambda x:x[1])
    # sorted(l, key = lambda x:x[1], reverse=True)
    l
    # 输出如下
    [(1, 4), (2, 6), (5, 8), (22, 15), (5, 19)]

>  *  常规函数 def 必须通过其函数名被调用，因此必须首先被定义。但是作为一个表达式的 lambda，返回的函数对象就不需要名字了。

>  *  **②. lambda 的主体是只有一行的简单表达式，并不能扩展成一个多行的代码块。**
>  *  这其实是出于设计的考虑。Python 之所以发明 lambda，就是为了让它和常规函数各司其职：lambda 专注于简单的任务，而常规函数则负责更复杂的多行逻辑。关于这点，Python 之父 Guido van Rossum 曾发了一篇文章解释 [链接文章][Link 1]，你有兴趣的话可以自己阅读。

## 2.2. 为什么要使用匿名函数？ ##

>  *  **通常，我们用函数的目的无非是这么几点：**
>  *  **① 减少代码的重复性；** 如果你的程序在不同地方包含了相同的代码，那么我们就会把这部分相同的代码写成一个函数，并为它取一个名字，方便在相对应的不同地方调用。
>  *  **② 模块化代码。** 如果你的一块儿代码是为了实现一个功能，但内容非常多，写在一起降低了代码的可读性，那么通常我们也会把这部分代码单独写成一个函数，然后加以调用。

>  *  不过，再试想一下这样的情况。你需要一个函数，但它非常简短，只需要一行就能完成；**同时它在程序中只被调用一次而已。那么请问，你还需要像常规函数一样，给它一个定义和名字吗？**
>  *  答案当然是否定的。这种情况下，函数就可以是匿名的，你只需要在适当的地方定义并使用，就能让匿名函数发挥作用了。
>  *  **举个例子**，如果你想对一个列表中的所有元素做平方操作，而这个操作在你的程序中只需要进行一次，用 lambda 函数可以表示成下面这样：

squared = map(lambda x: x**2, [1, 2, 3, 4, 5])
    list(squared)
    # [1, 4, 9, 16, 25]

>  *  **map(f, list) 是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。**

# 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]
    # 如果希望把list的每个元素都作平方，就可以用map()函数：
    # 因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算：
    def f(x):
        return x*x
    print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

## 2.3. Python 函数式编程 ##

>  *  所谓**函数式编程**，是指**代码中每一块都是不可变的（immutable）**，都由纯函数（pure function）的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。
>  *  举个很简单的例子，比如对于一个列表，我想让列表中的元素值都变为原来的两倍，我们可以写成下面的形式：

def multiply_2(l):
        for index in range(0, len(l)):
            l[index] *= 2
        return l

>  *  这段代码就不是一个纯函数的形式，因为列表中元素的值被改变了，如果我多次调用 multiply\_2() 这个函数，那么每次得到的结果都不一样。要想让它成为一个纯函数的形式，就得写成下面这种形式，重新创建一个新的列表并返回。

def multiply_2_pure(l):
        new_list = []
        for item in l:
            new_list.append(item * 2)
        return new_list

>  *  函数式编程的优点，主要在于其纯函数和不可变的特性使程序更加健壮，易于调试（debug）和测试；缺点主要在于限制多，难写。当然，Python 不同于一些语言（比如 Scala），它并不是一门函数式编程语言，不过，Python 也提供了一些函数式编程的特性，值得我们了解和学习。

>  *  **Python 主要提供了这么几个函数：map()、filter() 和 reduce()**，通常结合匿名函数 lambda 一起使用。这些都是你需要掌握的东西，接下来我逐一介绍。

### 1. map()函数 ###

>  *  首先是 `map(function, iterable)` 函数，前面的例子提到过，它表示，对 iterable 中的每个元素，都运用 function 这个函数，最后返回一个新的可遍历的集合。比如刚才列表的例子，要对列表中的每个元素乘以 2，那么用 map 就可以表示为下面这样：

l = [1, 2, 3, 4, 5]
    new_list = map(lambda x: x * 2, l) # [2， 4， 6， 8， 10]

>  *  我们可以以 map() 函数为例，**看一下 Python 提供的函数式编程接口的性能**。还是同样的列表例子，它还可以用 for 循环和 list comprehension（目前没有统一中文叫法，你也可以直译为列表理解等）实现，我们来比较一下它们的速度：

python3 -mtimeit -s'xs=range(1000000)' 'map(lambda x: x*2, xs)'
    2000000 loops, best of 5: 171 nsec per loop
    
    python3 -mtimeit -s'xs=range(1000000)' '[x * 2 for x in xs]'
    5 loops, best of 5: 62.9 msec per loop
    
    python3 -mtimeit -s'xs=range(1000000)' 'l = []' 'for i in xs: l.append(i * 2)'
    5 loops, best of 5: 92.7 msec per loop

>  *  你可以看到，**map() 是最快的。因为 map() 函数直接由 C 语言写的，运行时不需要通过 Python 解释器间接调用，并且内部做了诸多优化，所以运行速度最快**。

### 2. filter()函数 ###

>  *  接下来来看 `filter(function, iterable)` 函数，它和 map 函数类似，**function 同样表示一个函数对象。filter() 函数表示对 iterable 中的每个元素，都使用 function 判断，并返回 True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合**。

>  *  举个例子，比如我要返回一个列表中的所有偶数，可以写成下面这样：

l = [1, 2, 3, 4, 5]
    new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]

### 3. reduce()函数 ###

>  *  举最后我们来看 `reduce(function, iterable)` 函数，**它通常用来对一个集合做一些累积操作。**
>  *  function 同样是一个函数对象，**规定它有两个参数，表示对 iterable 中的每个元素以及上一次调用后的结果，运用 function 进行计算**，所以最后返回的是一个单独的数值。
>  *  举个例子，我想要计算某个列表元素的乘积，就可以用 reduce() 函数来表示：

l = [1, 2, 3, 4, 5]
    product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120

>  *  当然，类似的，filter() 和 reduce() 的功能，也可以用 for 循环或者 list comprehension 来实现。

>  *  通常来说，在我们想对集合中的元素进行一些操作时，如果操作非常简单，比如相加、累积这种，那么**我们优先考虑 map()、filter()、reduce()** 这类或者 list comprehension 的形式。至于这两种方式的选择：
>  *  **在数据量非常多的情况下，比如机器学习的应用，那我们一般更倾向于函数式编程的表示，因为效率更高**；
>  *  在数据量不多的情况下，并且你想要程序更加 Pythonic 的话，那么 list comprehension 也不失为一个好选择。

>  *  不过，如果你要对集合中的元素，做一些比较复杂的操作，那么，考虑到代码的可读性，我们通常会使用 for 循环，这样更加清晰明了。

## 2.4. 总结 ##

>  *  这节课一起学习了 Python 中的匿名函数 lambda，它的主要用途是减少代码的复杂度。**需要注意的是 lambda 是一个表达式，并不是一个语句**；它只能写成一行的表达形式，语法上并不支持多行。匿名函数通常的使用场景是：程序中需要使用一个函数完成一个简单的功能，并且该函数只调用一次。
>  *  其次，我们也入门了 Python 的函数式编程，主要了解了常见的 map()，fiilter() 和 reduce() 三个函数，并比较了它们与其他形式（for 循环，comprehension）的性能，显然，它们的性能效率是最优的。

[Link 1]: https://www.artima.com/weblogs/viewpost.jsp?thread=147358