装饰器、迭代器、生成器、内置函数

标签：inner   func   内部函数   来讲   博客   技术   user   计算   lse   

一、装饰器

1、装饰器：在原有函数的前后增加功能，且不改变原函数的调用方式

例子1（不带参数的装饰器）：计算func1函数的执行时间（计算一个函数的运行时间）

import time
def timer(f):
    def inner():
        starttime=time.time()
        ret=f()
        endtime=time.time()
        print(‘函数耗时：%s‘% (endtime-starttime))
        return ret
    return inner

def func1():
    print(‘begin....‘)
    time.sleep(0.1)
    print(‘end....‘)
    return 666

func1=timer(func1)
func1()


执行结果：

begin....
end....
函数耗时：0.1000056266784668

以上不是写成@timer那种形式，可以改写成：

import time
def timer(f):
    def inner():
        starttime=time.time()
        ret=f()
        endtime=time.time()
        print(‘函数耗时：%s‘% (endtime-starttime))
        return ret
    return inner
@timer
def func1():
    print(‘begin....‘)
    time.sleep(0.1)
    print(‘end....‘)
    return 666

result=func1()
print(result)
执行结果：

begin....
end....
函数耗时：0.1000056266784668
666

例子2（带参数的装饰器）

import time
def timer(f):
    def inner(*args,**kwargs):
        starttime=time.time()
        ret=f(*args,**kwargs)
        endtime=time.time()
        print(‘函数耗时：%s‘% (endtime-starttime))
        return ret
    return inner
@timer
def func1(a,b):
    print(‘begin....‘,a)
    time.sleep(0.1)
    print(‘end....‘,b)
    return True

result=func1(100,101)
print(result)

执行结果：

begin.... 100
end.... 101
函数耗时：0.1000056266784668
True

总结：装饰器的结构如下 

简单来讲，这个就是个外层函数，定义个inner内层函数，return inner函数

# def timmer(f):
#     def inner(*args,**kwargs):
#　　　　　调用函数之前可以加的功能
#         ret = f(*args,**kwargs)
#　　　　　调用函数之后可以加的功能
#         return ret
#     return inner

2、进阶的需求

第一种情况，500个函数，你可以设计你的装饰器 来确认是否生效（考虑给装饰器传参）

举例1：

import time

def outetr(flag):
    def timmer(f):
        def inner(*args,**kwargs):
            if flag==True:
                start_time = time.time()
                ret = f(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
            else:
                ret = f(*args, **kwargs)
            return ret
        return inner
    return timmer

@outetr(True)   # func = timmer(func) 这样话outetr(True)，这个只执行了outetr这个函数，其余的没有执行，返回timmer。就相当于outetr(True)=timmer，这样@timmer再去执行后面的

def func(a,b):
    print(‘begin func‘,a)
    time.sleep(0.1)
    print(‘end func‘,b)
    return True

ret = func(1,2)   #--> inner()

执行结果：

begin func 1
end func 2
0.10100579261779785

如果给装饰器传参是false

import time
def outetr(flag):
    def timmer(f):
        def inner(*args,**kwargs):
            if flag==True:  ##内部函数使用外部函数的变量
                start_time = time.time()
                ret = f(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
            else:
                ret = f(*args, **kwargs)
            return ret
        return inner
    return timmer

@outetr(False)   # func = timmer(func)
def func(a,b):
    print(‘begin func‘,a)
    time.sleep(0.1)
    print(‘end func‘,b)
    return True

ret = func(1,2)   #--> inner()

执行结果：

begin func 1
end func 2

以上可以再改造成：

import time
FLAG = True  ##全部变量，假如有500个函数，底下的都看这个定义的
def outer(flag):
    def timmer(f):
        def inner(*args,**kwargs):
            if flag == True:
                start_time = time.time()
                ret = f(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
            else:
                ret = f(*args, **kwargs)
            return ret
        return inner
    return timmer

@outer(FLAG)   # func = timmer(func)
def func(a,b):
    print(‘begin func‘,a)
    time.sleep(0.1)
    print(‘end func‘,b)
    return True

func(1,2)

执行结果：

begin func 1
end func 2
0.1000056266784668    #如果FLAG=False的话，就没有这一行的这个结果，其余的还有

第二种情况：两个函数同时装饰同一个函数

def wrapper1(func):  #f传进来了
    def inner1():
        print(‘wrapper1 ,before func‘)
        func()  #f
        print(‘wrapper1 ,after func‘)
    return inner1

def wrapper2(func):   #innner1传进来了
    def inner2():
        print(‘wrapper2 ,before func‘)
        func()  #inner1
        print(‘wrapper2 ,after func‘)
    return inner2

@wrapper2   #f=warpper2(f)  此时的f是inner1   f=wrapper2(inner1)=inner2
@wrapper1  #f=wrapper1(f) =inner1
def f():
    print(‘in f‘)

f() #这句等于inner2()

执行结果：

wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after func

 执行顺序如下：

 例子（上周day03作业可以用类似方法去做）

# 装饰器 登录 记录日志
import time
login_info = {‘alex‘:False}
def login(func):   # manager
    def inner(name):
        if login_info[name] != True:
            user = input(‘user ：‘)
            pwd = input(‘pwd ：‘)
            if user == ‘alex‘ and pwd == ‘alex3714‘:
                login_info[name] = True
        if login_info[name] == True:
            ret = func(name)     # timmer中的inner
            return ret
    return inner

def timmer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)     # 调用被装饰的方法
        end_time = time.time()      #
        print(end_time - start_time)
        return ret
    return inner

@login
@timmer
def index(name):
    print(‘欢迎%s来到博客园首页~‘%name)

@login
@timmer    # manager = login(manager)
def manager(name):
    print(‘欢迎%s来到博客园管理页~‘%name)

index(‘alex‘)
index(‘alex‘)
manager(‘alex‘)
manager(‘alex‘)

# 计算index 和 manager的执行时间

执行结果：

user ：alex
pwd ：alex3714
欢迎alex来到博客园首页~
0.0
欢迎alex来到博客园首页~
0.0
欢迎alex来到博客园管理页~
0.0
欢迎alex来到博客园管理页~
0.0

装饰器、迭代器、生成器、内置函数

标签：inner   func   内部函数   来讲   博客   技术   user   计算   lse   

原文地址：https://www.cnblogs.com/lucky-penguin/p/8979755.html