装饰器，匿名函数

装饰器

装饰器的开放封闭原则：

装饰器对扩展是开放的，对修改源代码是封闭的，不能改变原函数的调用方式

基本完整的装饰器函数示例
import time                                       #时间模块
def warpper(f):                                 #接受被装饰的函数内存地址
    def inner(*args,**kwargs):           #接受被装饰函数的参数  inner里面函数是扩展的功能
        start_time = time.time()           #计时功能
        ret = f(*args,**kwargs)           #调用被装饰的函数，带着被装饰函数的参数
        end_time = time.time()             #计时功能
        print('%s函数的运行时间:%s'%(f.__name__,end_time-start_time))
                                                        #计时功能
        return ret                                  #被装饰函数的返回值
    return inner                                   #通过这一步令func() = inner()

@warpper                                         #语法糖，相当于func = warpper(func)
def func(*args,**kwargs):                #被装饰函数
    print(args)                                    #主函数功能
    print('这是主功能')                          #主函数功能
    time.sleep(1)                                #计时功能
    return '你好'                                  #被装饰函数的返回值，返回到inner里的ret
#其实语法糖缩写的函数位置在这里，此处相当于有一个func = warpper(func)
ret = func(5)                                    #func(5) = inner(5)  此处的ret来自inner
print(ret)                                          #ret是func的return，但不由func返回

def wrapper1(func1):  #　func1 = f原函数
    def inner1():
        print('wrapper1 ,before func')  # 2
        func1()
        print('wrapper1 ,after func')  # 4
    return inner1

def wrapper2(func2):  # func2 == inner1
    def inner2():
        print('wrapper2 ,before func')  # 1
        func2()  # inner1
        print('wrapper2 ,after func')  # 5
    return inner2


@wrapper2  # f = wrapper2(f) 里面的f == inner1  外面的f == inner2
@wrapper1  # f = wrapper1(f) 里面的f == func1  外面的 f == inner1
def f():
    print('in f')  # 3

f()  # inner2()

def wrapper_out(n):
    def wrapper(f):
        def inner(*args,**kwargs):
            username = input('请输入用户名：').strip()
            password = input('请输入密码：').strip()
            with open(n,encoding='utf-8') as f1:
                for line in f1:
                    user,pwd = line.strip().split('|')
                    if username == user and password == pwd:
                        print('登陆成功')
                        ret = f(*args,**kwargs)
                        return ret
                return False
        return inner
    return wrapper

"""
看到带参数的装饰器分两步执行：
    1. 执行wrapper_out('腾讯') 这个函数，把相应的参数'腾讯' 传给 n,并且得到返回值 wrapper函数名。
    2. 将@与wrapper结合，得到我们之前熟悉的标准版的装饰器按照装饰器的执行流程执行。
"""


@wrapper_out('qq')
def qq():
    print('成功访问qq')


@wrapper_out('tiktok')
def tiktok():
    print('成功访问抖音')

qq()
tiktok()
# 开发思路：增强耦合性

内置函数  :

匿名函数lambda: 为了解决那些功能很简单的需求而设计的一句话函数

参数可以有多个，用逗号隔开

匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值

返回值和正常的数据一样可以是任意数据类型

排序函数sorted：

字典排序返回的就是排序后的key

和lambda组合使用：

筛选过滤filter：

映射函数map：

改写成lambda

reduce：

reduce的使用方式

reduce（函数名，可迭代对象）  这两个参数必须要有，缺一不行

和lambda一起使用

在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要从functools这个包中导入

龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce

最后lambda没删除是因为和一个人写信写了好多封,进行交流然后把lambda保住了