Python基础——函数5（匿名函数 lambda | filter | map | sort | sorted、装饰器）

一、匿名函数

1.知识准备：filter()函数

• filter()可以从序列中过滤出符合条件的元素，保存到一个新的序列中
• 参数：
  • 1.函数，根据该函数来过滤序列（可迭代的结构）
  • 2.需要过滤的序列（可迭代的结构）
• 返回值：
  • 过滤后的新序列（可迭代的结构）

# 创建一个列表
l = [1,2,3,4,5,6,7,8,9,10]

def fn4(i):
    if i % 3 == 0:
        return True    
    return False

# fn4是作为参数传递进filter()函数中
#   而fn4实际上只有一个作用，就是作为filter()的参数
#   filter()调用完毕以后，fn4就已经没用

print(list(filter(fn4, l)))

2.匿名函数 lambda 函数表达式 （语法糖）

• lambda函数表达式专门用来创建一些简单的函数，他是函数创建的又一种方式
• 语法：lambda 参数列表 : 返回值
• 匿名函数一般都是作为参数使用，其他地方一般不会使用

可以将匿名函数赋值给一个变量，但一般不会这么做

# 也可以将匿名函数赋值给一个变量，一般不会这么做
fn6 = lambda a,b : a + b
print(fn6(10,30))

也可以当函数调用，一般也不会这么做

(lambda a,b : a + b)(10,20)

一般使用实例

# 创建一个列表
l = [1,2,3,4,5,6,7,8,9,10]

def fn5(a , b):
    return a + b

r = filter(lambda i : i > 5 , l)
print(list(r))

3.map()函数

• map()函数可以对可迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回

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

r = map(lambda i : i ** 2 , l)

print(list(r))

4.sort()函数

• 该方法用来对列表中的元素进行排序
• sort()方法默认是直接比较列表中的元素的大小
• 在sort()可以接收一个关键字参数 ， key
  • key需要一个函数作为参数，当设置了函数作为参数，每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小

l = ['bb','aaaa','c','ddddddddd','fff']
l.sort(key=len)
print(l)

l = [2,5,'1',3,'6','4']
l.sort(key=int)
print(l)

5.sorted()函数

• 这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序，并且使用sorted()排序不会影响原来的对象，而是返回一个新对象

l = [2,5,'1',3,'6','4']

print('排序前:', l)
print(sorted(l, key=int))
print('排序后:', l)

二、装饰器

创建几个函数

# 创建几个函数
def add(a , b):
    '''
        求任意两个数的和
    '''
    r = a + b
    return r

def mul(a , b):
    '''
        求任意两个数的积
    '''
    r = a * b
    return r

r = add(123,456)
print(r) 

• 我们希望函数可以在计算前，打印开始计算，计算结束后打印计算完毕
• 我们可以直接通过修改函数中的代码来完成这个需求，但是会产生以下一些问题
  • ① 如果要修改的函数过多，修改起来会比较麻烦
  • ② 并且不方便后期的维护
  • ③ 并且这样做会违反开闭原则（OCP）
• 程序的设计，要求开发对程序的扩展，关闭对程序的修改
  

我们希望在不修改原函数的情况下，来对函数进行扩展，只需要根据现有的函数，来创建一个新的函数

def new_add(a,b):
    print('计算开始~~~')
    r = add(a,b)
    print('计算结束~~~')
    return r

r = new_add(111,222)    
print(r)

上面的方式，已经可以在不修改源代码的情况下对函数进行扩展了，但是，这种方式要求我们每扩展一个函数就要手动创建一个新的函数，实在是太麻烦了，为了解决这个问题，我们创建一个函数，让这个函数可以自动的帮助我们生产函数

def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''
    # 创建一个新函数
    def new_function(*args , **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args , **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function

f2 = begin_end(add)
f3 = begin_end(mul)

r = f2(123,456)
print(r)
r = f3(123,456)
print(r)

• 像begin_end()这种函数我们就称它为装饰器
• 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
• 在开发中，我们都是通过装饰器来扩展函数的功能的
• 在定义函数时，可以通过@装饰器，来使用指定的装饰器，来装饰当前的函数
• 可以同时为一个函数指定多个装饰器，这样函数将会安装从内向外的顺序被装饰

实例

def begin_end(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''
    # 创建一个新函数
    def new_function(*args , **kwargs):
        print('开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args , **kwargs)
        print('执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function

def fn3(old):
    '''
        用来对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束

        参数：
            old 要扩展的函数对象
    '''
    # 创建一个新函数
    def new_function(*args , **kwargs):
        print('fn3装饰~开始执行~~~~')
        # 调用被扩展的函数
        result = old(*args , **kwargs)
        print('fn3装饰~执行结束~~~~')
        # 返回函数的执行结果
        return result

    # 返回新函数        
    return new_function

@fn3
@begin_end
def say_hello():
    print('大家好~~~')

say_hello()