装饰器--装饰器的种类

没有装饰器实例：

#!/usr/bin/env python
# -*- coding:utf8 -*-
# Author:Dong Ye
 
 
#定义个全局变量,用于存放用户状态信息：
LOGIN_USER = {"is_login": False, "current_user": None}
 
 
#查看订单：
def order():
    if LOGIN_USER['is_login']:
        print('欢迎%s登录' % LOGIN_USER['current_user'])
    else:
        print('请登录')
 
 
#修改密码：
def changepwd():
    if LOGIN_USER['is_login']:
        print('欢迎%s登录' % LOGIN_USER['current_user'])
    else:
        print('请登录')
 
 
#后台管理：
def manager():
    if LOGIN_USER['is_login']:
        print('欢迎%s登录' % LOGIN_USER['current_user'])
    else:
        print('请登录')
 
 
#登入
def login(user,pwd):
    if user == 'alex' and pwd == '123':
        LOGIN_USER['is_login']  = True  #表示登录成功
        LOGIN_USER['current_user'] = user  #当前用户名称
        manager()  #登入成功后，就可以访问后台管理。
 
 
#用户输入判断：
def main():
    while True:
        inp = input("1、后台管理；2、登录")
        if inp =='1':
            manager()
        elif inp == '2':
            username = input('请输入用户名：')
            pwd = input('请输入密码：')
            login(username,pwd)
 
 
#调用方法
main()

一级装饰器：（用户登录）

一个函数用一个装饰器装饰

实例1：

#!/usr/bin/env python
# -*- coding:utf8 -*-
# Author:Dong Ye

#第一步，定义outer函数
def outer(func):
    #第五步、func = 原来的f1函数的内存地址
    def inner():
        print('hello')   #第六步
        print('hello')
        print('hello')
        #第七步、找到原来的f1并执行f1的函数体
        #第八步、将原来f1的返回值赋值给r
        r = func()
        print('end')    #第九步
        print('end')
        print('end')
        print('end')
        return r   #第十步、由于inner是被新f1的函数调用，返回原来f1的返回值，也会返回给新f1的ret变量
    return inner


#第二步、在python中@代码具有特殊性，只要解析器执行到@，就会有下面的2个操作：
#1、执行outer函数，并且将其下面的函数名当做参数。
#2、将outer返回值重新赋值给f1
@outer
def f1():            #第三步、f1接收outer的返回值变成inner的内存地址f1 = inner的内存地址
    print('F1')


ret = f1()     #第四部、调用f1的时候，直接执行inner的函数体
                #第十一步、由于inner是被新f1的函数调用，返回原来f1的返回值，也会返回给新f1的ret变量

print(ret)

实例2：

#定义个全局变量,用于存放用户状态信息：
LOGIN_USER = {"is_login": False, "current_user": None}
 
#装饰器：
def outer(func):
    def inner(*argsm,**kwargs):
        if LOGIN_USER['is_login']:
            print('欢迎%s登录' % LOGIN_USER['current_user'])
            r = func()
            return r
        else:
            print('请登录')
    return inner
 
 
 
 
#查看订单：
@outer
def order():
    print('欢迎%s登录' % LOGIN_USER['current_user'])
 
 
#修改密码：
@outer
def changepwd():
    print('欢迎%s登录' % LOGIN_USER['current_user'])
 
 
#后台管理：
@outer
def manager():
    print('欢迎%s登录' % LOGIN_USER['current_user'])
 
 
#登入
def login(user,pwd):
    if user == 'alex' and pwd == '123':
        LOGIN_USER['is_login']  = True  #表示登录成功
        LOGIN_USER['current_user'] = user  #当前用户名称
        manager()  #登入成功后，就可以访问后台管理。
 
 
#用户输入判断：
def main():
    while True:
        inp = input("1、后台管理；2、登录")
        if inp =='1':
            manager()
        elif inp == '2':
            username = input('请输入用户名：')
            pwd = input('请输入密码：')
            login(username,pwd)
 
 
#调用方法
main()

二级装饰器：（用户登录和权限认证）

注意：一个函数可以你被多个装饰器装饰

#!/usr/bin/env python
# -*- coding:utf8 -*-
# Author:Dong Ye

#定义全局字典：
USER_INFO = {}

#判读用户登录：
def check_login(func):
    def inner(*args,**kwargs):
        if USER_INFO.get('is_login',None):  #如果获取不到返回None
            ret =func(*args,**kwargs)
            return  ret
        else:
            print('请先登录。。。')
    return inner


#判读用户管理：
def check_admin(func):
    def inner(*args,**kwargs):
        if USER_INFO.get('user_type',None)==2:
            ret =func(*args,**kwargs)
            return  ret
        else:
            print('无权限查看。。。')
    return inner



@check_login
@check_admin
def index():
    '''
    管理员登录
    :return:
    '''

    print('index')

@check_login
def home():
    print('home')


def login():
    user = input('请输入用户名：')
    if user == 'admin':    #如果用户登录属于管理员。
        USER_INFO['is_login'] = True   #登录状态为True
        USER_INFO['user_type'] = 2     #用户类型为2（管理员）。
    else:
        USER_INFO['is_login'] = True
        USER_INFO['user_type'] = 1      #用户类型为1(普通用户)。


def main():
    while True:
        inp = input('1、登录；2、查看信息；3、超级管理员 
 >>>')
        if inp == '1':
            login()
        elif inp =='2':
            home()
        elif inp == '3':
            index()


main()

超级装饰器

实例1：

#!/usr/bin/env python
# -*- coding:utf8 -*-
# Author:Dong Ye

 
import time
user,passwd = 'dy','asd'
#装饰器
def auth(auth_type):  #定义一个装饰器标签函数，auth_type是装饰器的标签（auth_type = "local" & auth_type="ldap"）
    print("auth func:",auth_type)
    def outer_wrapper(func):  #定义接收@auth传过来的home的内存地址，并赋值给func
        def wrapper(*args,**kwargs):   #定义嵌套函数，做功能装饰home() & bbs()，并且home(args1) & bbs(args1)的参数会传到这里
            #print("wrapper func args:",*args,**kwargs)
            if auth_type == 'local':
                username = input('username: ').strip()
                password = input('password: ').strip()
                if user == username and passwd == password:
                    print("33[32;1mUser has passed authentication33[0m")
                    return func(*args,**kwargs)   #执行源代码home() & bbs()，并且home(args1) & bbs(args1)的参数会传到这里
                else:
                    exit("33[31;1mInvalid username or password33[0m")
 
            elif auth_type=='ldap':
                print('是以ldap的方式登录')
        return wrapper
    return outer_wrapper
 
#注释：
#home----传参：内存地址和装饰器标签（local&ldap）----> auth(解封装),auth_type=装饰器标签 -----home的内存参数---->outer_warpper（解封装），func= home---->调用wrapper（*args,**kwargs）-->func函数func(*args,**kwargs)=home(*args,**kwargs)
#wrapper ----内存地址1---->outer_wrapper----内存地址1和2---->auth--内存地址（1、2）通过装饰器标签（local&ldap）---->home重新赋值
def index():
    print('welcome to index page')
 
#原代码
#home认证用本地认证
#auth_type = "local" 赋值给了auth(auth_type)
#@auth home = auth（outer_wrapper(func)）   func = home
#通过高阶函数的功能将wrapper的内存地址返回给outer_wrapper
#最后将outer_wrapper的内存地址返回给auth函数，并重新赋值给home
@auth(auth_type = "local")  
def home():
    print('welcome to home page')
    return "from home"

注意：调用2次，赋值一次：第一次auth_type调用auth（auth_type）；第二次@auth调用outer_wrapper(func)；第三次将home函数赋值给wrapper(*args,**kwargs)
 
 
 
#bbs用远程的ldap
@auth(auth_type="ldap")   #bbs = auth(bbs)
def bbs():
    print('welcome to bbs page')
 
 
 
 
 
#原调用
index()
home() #其实执行的是通过wraooer、outer_warpper、auth返回的内存地址，找到wrapper函数体执行的
bbs()

实例2：

def Before(request,kargs):
    print 'before'
      
def After(request,kargs):
    print 'after'
  
  
def Filter(before_func,after_func):
    def outer(main_func):
        def wrapper(request,kargs):
              
            before_result = before_func(request,kargs)
            if(before_result != None):
                return before_result;
              
            main_result = main_func(request,kargs)
            if(main_result != None):
                return main_result;
              
            after_result = after_func(request,kargs)
            if(after_result != None):
                return after_result;
              
        return wrapper
    return outer
      
@Filter(Before, After)
def Index(request,kargs):
    print 'index'