文章目录

  • 高阶函数
  • 匿名函数
  • 闭包
  • 装饰器decorator


高阶函数

函数作为参数或者函数作为返回值称为高阶函数。

1. 使用函数作为参数
def fn(n):
    return n%2 == 0
l = [1,2,3,4,5,6,7,8,9]
def fn1(func,l):  #传入函数作为参数，这里函数没用()表示函数对象
    lst = []
    for i in l:
        if func(i):  #这里调用函数，并传入参数
            lst.append(i)
    return lst
print(fn1(fn,l))#[2,4,6,8]

2.使用函数作为返回值
def fn1():
    def fn(n):
        return n % 2 == 0
    return fn  #子函数作为返回值
print(fn1()(3))执行完fn1()得到fn对象，再来(3)表示传递参数，结果为False

匿名函数

lambda表达式
创建简单函数,lambda表达式一般作为参数使用，使用后从内存消失。
语法: lambda 参数列表 : 返回值
lambda表达式是一个简单版函数对象，如果需要调用，将整体括号起来，加上元组参数即可。

1. 让l序列中的每个元素自增1
l = [1,2,3,4,5,6,7,8,9]
r = [(lambda i:i+1)(i) for i in l]
print(r)#[2, 3, 4, 5, 6, 7, 8, 9, 10]

2.2个数和
print((lambda a,b : a + b)(5,2))#7

filter()函数
filter(function or None, iterable) --> filter object 返回可迭代对象中符合功能函数的filter对象

l = [1,2,3,4,5,6,7,8,9]
def fn(n):
    return n % 2 == 0
print(list(filter(fn,l)))#[2,4,6,8],用list强制转换

map()函数
map(func, *iterables) --> map object 返回可迭代对象中执行完func函数后的map对象

l = [1,2,3,4,5,6,7,8,9]
r = map(lambda i : i + 1,l)
print(list(r))#用list强制转换，返回[2, 3, 4, 5, 6, 7, 8, 9, 10]

sort(),对自身对象进行排序，如
列表排序
L.sort(key=None, reverse=False) -> None

lst = [3,2,'1','6',4]
lst.sort(key=int)#key=int表示将元素转成int类型
print(lst)#['1', 2, 3, 4, '6']

sorted()函数
sorted(*args, **kwargs) 返回一个排序后的新列表

lst = [3,2,'1','6',4]
lst1 = sorted(lst,key=int)
print(lst,lst1,sep='\n')
结果
[3, 2, '1', '6', 4]
['1', 2, 3, 4, '6']

闭包

将函数作为返回值，闭包就是函数里面创建函数，将内部函数作为返回值。

  1. 函数嵌套
  2. 将内部函数作为返回值返回
  3. 内部函数必须使用到外部函数的变量
nums = [1,2,3,4]
def new_avg():
    nums = []
    def avg(n):
        nums.append(n)
        return sum(nums)/len(nums)
    return avg
r = new_avg()
print(r(10))#10	函数内的nums[10]
print(r(10))#10	函数内的nums[10,10]
print(r(40))#20	函数内的nums[10,10,20]
print(r(40))#25	函数内的nums[10,10,20,25]
print(nums) #全局变量nums还是[1,2,3,4]

通过闭包可以换创建一些只有当前函数才能访问的对象，还可以将一些私有的数据藏到闭包中

装饰器decorator

不修改源函数，对源函数进行扩展。
装饰器是一个返回值为函数的高阶函数。

定义装饰器
def start_end(func):
    # 参数func 为需要扩展的函数对象
   
    # 创建一个新的函数，增加新功能
    def new_function(*args,**kwargs):
        print('函数开始执行')
        result = func(*args,**kwargs)
        print('函数执行结束')
        # 返回函数执行结果
        return result
    # 返回新函数
    return new_function

@start_end  #引入装饰器 
def say_hello(a,b):
    print(a+b)
    print('hello')
say_hello(1,2)
'''
结果
函数开始执行
3
hello
函数执行结束
'''


import time,functools
def metric(fn):
    @functools.wraps(fn)  #引入fn函数的属性
    def wrapper(*args,**kw):
        start=time.time()*1000
        fn(*args,**kw)
        end=time.time()*1000
        print('%s executed in %s ms' % (fn.__name__,end-start))
        return fn
    return wrapper
@metric
def say_hello(a,b):
    time.sleep(3)
    print(a+b)
    print('hello')
say_hello(1,2)

'''
结果
3
hello
say_hello executed in 3000.169677734375 ms
'''