python之高阶函数,闭包,装饰器

一.高阶函数

高阶函数的特点（满足一下任一条特点的函数即为高阶函数）：

• 1.接收函数作为参数.
• 2.将函数作为返回值返回的函数.

# 高阶函数的特点（必须至少满足一个）：
# 1. 接受一个或多个函数作为参数
# 2. 将函数作为返回值返回
def fun():
    def fun1():
        pass

    return fun1

• 练习：对列表中的元素进行筛选，找出为偶数的元素。

  • 使用普通函数完成

  list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  def fun(list1):
      list2 = []
      for i in list1:
          if i % 2 == 0:
              list2.append(i)
      return list2
  
  
  print(fun(list1))
  '''
  输出结果为：
  [2, 4, 6, 8, 10]
  '''
  

  • 第一步修改

  list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  def fun(list1):
      def fun2(i):
          if i % 2 == 0:
              return True
      list2 = []
      for i in list1:
          if fun2(i):
              list2.append(i)
      return list2
  
  
  print(fun(list1))
  '''
  输出结果为：
  [2, 4, 6, 8, 10]
  '''
  

  此时此函数仍不为高阶函数，因为它还是不满足高阶函数的两个特点之一：
  1.接收函数作为参数.
  2.将函数作为返回值返回的函数.

  • 最终修改

  def fun2(i):
      if i % 2 == 0:
          return True
  
  
  def fun(fun3, list):
      list2 = []
      for i in list:
          if fun3(i):
              list2.append(i)
      return list2
  
  
  list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  print(fun(fun2, list1))
  '''
  输出结果为：
  [2, 4, 6, 8, 10]
  '''
  

  此时为高阶函数，满足条件：接收函数作为参数.

二.匿名函数

针对实现简单效果的函数，为了防止函数名重复冲突，可使用匿名函数。

• 匿名函数lambda函数就是专门用来创建一些简单的函数
• 特点：
  • 1.不需要 取名字，不占用命名空间。
  • 2.运行完直接销毁，不会占内存。
• 语法：lambda 参数：表达式
• 示例：

函数示例	说明
lambda x, y: x*y	函数输入是x和y，输出是它们的积x*y
lambda:None	函数没有输入参数，输出是None
lambda *args: sum(args)	输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)
lambda **kwargs: 1	输入是任意键值对参数，输出是1

博客: 细说Python的lambda函数用法，建议收藏.

print((lambda a, b: a*b)(2, 3))
'''
输出结果为：
6
'''

r = lambda a, b: a*b
print(r(3, 4))
'''
输出结果为：
12
'''

三.filter类

• filter() 需要传递两个参数按照你设定的规则，过滤出你想要的数据：
  • 1、 传递一个函数。
  • 2 、传递一个需要过滤的序列（可迭代的）。
• filter类的使用：依旧是对数据筛选的更改。

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def fun1(i):
    if i % 2 == 0:
        return True
print(list(filter(fun1, list1)))
'''
输出结果为：
[2, 4, 6, 8, 10]
'''

filter类 与 lambda函数结合使用

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = lambda i: i % 2 == 0
print(list(filter(result, list1)))
'''
输出结果为：
[2, 4, 6, 8, 10]
'''

四.闭包

• 将函数作为返回值也是高阶函数我们也称为闭包
• 闭包的好处
  • 通过闭包可以创建一些只有当前函数能访问的变量
  • 可以将一些私有数据藏到闭包中
• 行成闭包的条件
  • 函数嵌套
  • 将内部函数作为返回值返回
  • 内部函数必须要使用到外部函数的变量

闭包代码原理是c语言编写，感兴趣的可看这篇博客。
博客: Python 闭包原理.

函数在运行结束后变量会被内存清除掉，也就是说变量会被销毁掉.——博客:python垃圾回收机制
闭包则可使变量不被销毁。

1.外部函数变量不被销毁:

def func_out(num1):

    def func_inner(num2):
        result = num1 + num2
        return result
    return func_inner


f = func_out(1)
a = f(3)

print(a)

b = f(5)  #这里并没有再次传入num1变量的值,如果num1被销毁了,那么b就无法正常计算.
print(b)
'''
4
6      #这里b正常计算了,所以表示num1的值并没有被销毁.
'''

2.变量不可被更改.

def func_out(num1):

    def func_inner(num2):
        num1 = 10    #在这里对num1重新设置值,尝试修改
        result = num1 + num2
        print(result)

    print(num1)
    
    func_inner(1)
    print(num1)	#从打印的结果可以看出,num1的值并没有被修改.
    return func_inner


f = func_out(1)
'''
1
11
1
'''

1.在这一示例中,当在内部函数func_inner中对num1进行赋值时,实际上是重新定义了一个内部函数func_inner的局部变量num1,虽然和外部函数func_out的变量num1同名,但是他们两个并不是同一个变量.
2.并且,由于内部函数func_inner中重新定义了局部变量num1,内部函数并没有使用到外部函数的变量.所以这个函数已经并不满足形成闭包的条件.因此,它也不是闭包.

3.使变量可以被修改.

def func_out(num1):

    def func_inner(num2):
    	nonlocal num1
        num1 = 10    #在这里对num1重新设置值,尝试修改
        result = num1 + num2
        print(result)

    print(num1)
    
    func_inner(1)
    print(num1)	#从打印的结果可以看出,num1的值已经被修改.
    return func_inner


f = func_out(1)
'''
1
11
10
'''

nonlocal:申明内部函数中的num1变量为外部变量num1,并不是重新定义新的局部变量num1.

五.装饰器

5.1装饰器的引入

我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题:

• 如果修改的函数多，修改起来会比较麻烦.
• 不方便后期的维护.
• 这样做会违反开闭原则(ocp).

ocp原则:
程序的设计，要求开发对程序的扩展，要关闭对程序的修改.

(1).现在有一个函数

def fun():
	print("我是fun函数")

(2).需要增添功能:
在输出"我是fun函数"前增加输出"函数开始执行".
在输出"我是fun函数"后增加输出"函数执行完毕"

---

(3).如果我们直接修改原函数，就会违反OCP原则.

#违反OCP原则,不推荐这样使用.
def fun():
	print("函数开始执行")
	print("我是fun函数")
	print("函数执行完毕")

(4).推荐修改写法

def fun():
    print("我是fun函数")


def fun1():
    print("函数开始执行")
    fun()
    print("函数执行完毕")


fun1()
'''
函数开始执行
我是fun函数
函数执行完毕
'''

(5).修改有参数的函数.

def add(a, b):
    print(a + b)


def fun1(a, b):
    print("函数开始执行")
    add(a, b)
    print("函数执行完毕")


fun1(1, 3)
'''
函数开始执行
4
函数执行完毕
'''

虽然这样装饰修改可以达到我们的需求,并且也不违反OCP原则,但是针对不同的有无参数的函数,每次装饰都需要修改,不是很方便,下面看一下通用装饰函数.

(6).通用装饰函数.

def add(a, b):
    print(a + b)

def fun():
    print("我是fun函数")



def fun1(fn, *args, **kwargs):
    print("函数开始执行")
    fn(*args, **kwargs)
    print("函数执行完毕")


fun1(add, 1, 3)
fun1(fun)
'''
函数开始执行
4
函数执行完毕
函数开始执行
我是fun函数
函数执行完毕
'''

5.2装饰器的使用

• 前面所说的只是装饰函数,还不是装饰器,正式的装饰器是一个闭包.
• 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展.
• 在开发中，我们都是通过装饰器来扩展函数的功能的.

---

(1).通用装饰器

def add(a, b):
    print(a + b)


def fn():
    print("我是fn函数")
    

def fun_out(fn, *args, **kwargs):

    def fun_inner(*args, **kwargs):
        print('函数开始执行')
        fn(*args, **kwargs)
        print('函数执行完毕')

    return fun_inner


f = fun_out(add, 1, 2)
f(1, 2)

f = fun_out(fn)
f()
'''
函数开始执行
3
函数执行完毕
函数开始执行
我是fn函数
函数执行完毕
'''

(2)语法糖的使用

• 这里使用闭包,与之前装饰函数所达到的效果一样,并且使用闭包导致函数更加复杂了,那么使用闭包的意义在哪?下面介绍语法糖的使用,可以配合闭包实现快速的使用装饰器.

def fun_out(fun, *args, **kwargs):
    def fun_inner(*args, **kwargs):
        print('函数开始执行')
        fun(*args, **kwargs)
        print('函数执行完毕')

    return fun_inner


@fun_out	#语法糖
def add(a, b):
    print(a + b)


@fun_out	#语法糖
def fn():
    print("我是fn函数")


add(1, 2)
fn()
'''
函数开始执行
3
函数执行完毕
函数开始执行
我是fn函数
函数执行完毕
'''

语法糖的使用:在需要被装饰的函数上使用@+装饰器外部函数.

PEP8代码编写规范

PEP8: Python代码风格指南——此处引用Cheney老师文章

PEP8 提供了 Python 代码的编写约定. 本节知识点旨在提高代码的可读性, 并使其在各种 Python 代码中编写风格保持一致.
虽然不遵守 PEP8 规范不会报错，但是会出现波浪线，而且遵守了规范看起来也很舒服！！

1. 缩进使用4个空格, 空格是首选的缩进方式. Python3 不允许混合使用制表符和空格来缩进.

2. 每一行最大长度限制在79个字符以内.

3. 顶层函数、类的定义, 前后使用两个空行隔开.

4. import 导入
   导入建议在不同的行, 例如:

   	import os
   	import sys
   

   不建议如下导包

   	import os, sys
   

   但是可以如下:

   from subprocess import Popen, PIPE
   

5. 导包位于文件顶部, 在模块注释、文档字符串之后, 全局变量、常量之前. 导入按照以下顺序分组:
   标准库导入
   相关第三方导入
   本地应用/库导入
   在每一组导入之间加入空行

6. Python 中定义字符串使用双引号、单引号是相同的, 尽量保持使用同一方式定义字符串. 当一个字符串包含单引号或者双引号时, 在最外层使用不同的符号来避免使用反斜杠转义, 从而提高可读性.

7. 表达式和语句中的空格:

   避免在小括号、方括号、花括号后跟空格.
   避免在逗号、分好、冒号之前添加空格.
   冒号在切片中就像二元运算符, 两边要有相同数量的空格. 如果某个切片参数省略, 空格也省略.
   避免为了和另外一个赋值语句对齐, 在赋值运算符附加多个空格.
   避免在表达式尾部添加空格, 因为尾部空格通常看不见, 会产生混乱.
   总是在二元运算符两边加一个空格, 赋值（=），增量赋值（+=，-=），比较（==,<,>,!=,<>,<=,>=,in,not,in,is,is not），布尔（and, or, not)
   避免将小的代码块和 if/for/while 放在同一行, 要避免代码行太长.

   if foo == 'blah': do_blah_thing()
   for x in lst: total += x
   while t < 10: t = delay()
   

8. 永远不要使用字母 ‘l’(小写的L), ‘O’(大写的O), 或者 ‘I’(大写的I) 作为单字符变量名. 在有些字体里, 这些字符无法和数字0和1区分, 如果想用 ‘l’, 用 ‘L’ 代替.

9. 类名一般使用首字母大写的约定.

10. 函数名应该小写, 如果想提高可读性可以用下划线分隔.

11. 如果函数的参数名和已有的关键词冲突, 在最后加单一下划线比缩写或随意拼写更好. 因此 class_ 比 clss 更好.(也许最好用同义词来避免这种冲突).

12. 方法名和实例变量使用下划线分割的小写单词, 以提高可读性.