装饰器的补充(叠加多个装饰器,有参装饰器,三元表达式,生成式,匿名函数)

1,叠加多个装饰器

  1),加载顺序(outter函数的调用顺序):自下而上

  2),执行顺序(wrapper函数的执行顺序):自上而下

def outter1(func1): #func1=wrapper2的内存地址
    print(‘加载了outter1‘)
    def wrapper1(*args,**kwargs):
        print(‘执行了wrapper1‘)
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def outter2(func2): #func2=wrapper3的内存地址
    print(‘加载了outter2‘)
    def wrapper2(*args,**kwargs):
        print(‘执行了wrapper2‘)
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def outter3(func3): # func3=最原始的那个index的内存地址
    print(‘加载了outter3‘)
    def wrapper3(*args,**kwargs):
        print(‘执行了wrapper3‘)
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3

@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址
@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址
@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址
def index():
    print(‘from index‘)
import time

#时间统计函数
def timmer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        stop = time.time()
        print(‘run %s‘ % (stop - start))
        return res

    return wrapper

#账户登录验证函数
def duth(func):
    def wrapper(*args, **kwargs):
        name = input(‘please input your name:‘)
        pwd = input(‘please input your password:‘)
        if name == ‘egom‘ and pwd == ‘123‘:
            print(‘login successful‘)
            res = func(*args, **kwargs)
            return res
        else:
            print(‘your name or password error‘)
    return wrapper

@timmer
@duth
#装饰器将下面函数的函数名当做参数,然后将运行的结果在赋值给原函数index

#
def index():
    time.sleep(1)
    print(‘from index‘)

index()

2,有参装饰器

current_user = {‘user‘:None}

def duth(engine=‘file‘):
    def outter(func):
        def wrapper(*args,**kwargs):

            #确认current字典内是否有存在的数据
            if current_user[‘user‘] is not None:
                res = func(*args,**kwargs)
                return res

            name = input(‘your name :‘).strip()
            password = input(‘your password :‘).strip()

            #基于‘file‘文件认证
            if engine == ‘file‘:
                if name == ‘egon‘ and password == ‘123‘:
                    print(‘login successful‘)
                    current_user[‘user‘]=name
                    res=func(*args,**kwargs)
                    return res
                else:
                    print(‘your name or password error‘)

            elif engine == ‘mysql‘ :
                print(‘基于mysql认证‘)

            elif engine == ‘ldap‘ :
                print(‘基于ldap认证‘)

            else:
                print(‘hello‘)

        return wrapper
    return outter

3,三元表达式

def max2(x,y):
    if x > y:
        return x
    else:
        return y

res=max2(10,20)

x=10
y=20

# res=x if x > y else y
# print(res)

res=‘OK‘ if False else ‘No‘
print(res)

4,生成式

  列表生成式

l=[]
for i in range(10):
    if i > 4:
        l.append(i**2)

l=[i**2 for i in range(10) if i > 4]
print(l)
names=[‘egon‘,‘alex_sb‘,‘kevin_sb‘,‘hxx_sb‘,‘cxx_sb‘]
sbs=[]
for name in names:
    if name.endswith(‘sb‘):
        sbs.append(name)

sbs=[name.upper() for name in names if name.endswith(‘sb‘)]

  字典生成器

res={i:i**2 for i in range(10) if i > 3}
print(res)

print({i for i in ‘hello‘})

 5,匿名函数

原文地址:https://www.cnblogs.com/kp1995/p/10046610.html

时间: 2024-10-22 07:56:05

装饰器的补充(叠加多个装饰器,有参装饰器,三元表达式,生成式,匿名函数)的相关文章

python装饰器(补充完整)

一.什么是装饰器         1.对现有已经实现功能的代码进行扩展. 2.不用修改被撞时对象的源代码和调用方法 二.装饰器的使用 无参数装饰器: 示例: def zsq(func): def yz(args): print("验证") return func(args) return yz @zsq def hs(name): print("我是一个函数%s"%name) return "hs fanhuizhi" ceshi = hs(&q

第四课 函数补充--装饰器、迭代器、生成器、匿名函数、递归函数

1.装饰器(补充) (在原有的函数前后增加功能,且不改变原函数的调用方式) 1.1.简单的装饰器构成: def timer(func): def inner(*args,**kwargs): '''执行函数之前要做的''' re = func(*args,**kwargs) '''执行函数之后要做的''' return re return inner def outer(flag): def timer(func): def inner(*args,**kwargs): if flag: pri

叠加多个装饰器、yield表达式、三元表达式、生成式、函数的递归

叠加多个装饰器 # 一.叠加多个装饰器的加载.运行分析(了解***) # def deco1(func1): # func1 = wrapper2的内存地址# def wrapper1(*args,**kwargs):# print('正在运行===>deco1.wrapper1')# res1=func1(*args,**kwargs)# return res1# return wrapper1 # def deco2(func2): # func2 = wrapper3的内存地址# def

python_day04 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式

本节课重要知识点内容如下: 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式 1.函数嵌套 函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数 def bar(): print('from nbar')def foo(): print('from foo') bar()foo()def max2(x,y): if x > y: return x else: return ydef max4(a,

python局部变量、高级函数、匿名函数、嵌套函数、装饰器

1.局部变量 在函数内部,可以用Global,显式的声明为全局变量.这种方式永远不要这么用. Ctrl+?多行注释i 2.高级函数 把函数名当做参数,传给函数 def add(a,b,f): return f(a)+f(b) res = add(3,-6,abs) abs是内置函数 def bar(): print("in the bar") def test1(func): 首先看第一个例子:def bar(): print("in the bar") def t

ⅩⅥ:无参装饰器

一:储备知识 1.*args, **kwargs def index(x,y): print(x,y) def wrapper(*args,**kwargs): index(*args,**kwargs) # # index(y=222,x=111) wrapper(y=222,x=111) 2.名称空间与作用域:名称空间的的"嵌套"关系是在函数定义阶段,即检测语法的时候确定的 3.函数对象: # 可以把函数当做参数传入 # 可以把函数当做返回值返回 def index(): retu

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

闭包函数 装饰器 有参装饰器

闭包函数: 1 内部函数 2 包含对外部作用域而非全局作用域的引用闭包函数的特点: 自带作用域  延迟计算 #闭包函数定义 1 def timmer(func): 2 def inner(*args,**kwargs): 3 re = func(*args,**kwargs) 4 return re 5 return inner 6 7 index(): 8 print("hello") 9 10 index = timmer(index) #index == inner 11 ind

闭包函数、无参装饰器2

一.闭包函数 闭包函数:函数内部定义函数,成为内部函数.该内部函数包含对外部作用域,而不是对全局作用域名字的引用,那么该内部函数成为闭包函数. name='alex' #定义全局变量name='alex' def func(): name='egon' #定义局部变量name='egon' def bar(): print(name) return bar #返回bar函数名 b=func() #执行func()结果为bar的函数名 相当于b=bar name='haha' #重新定义全局变量n