闭包函数、无参装饰器

一、闭包函数

闭包函数：函数内部定义函数，成为内部函数。该内部函数包含对外部作用域，而不是对全局作用域名字的引用，那么该内部函数成为闭包函数。

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'　　#重新定义全局变量name='haha'
print(b)　　　　#打印bar
b()　　　　　　　#执行bar(),name='egon'

执行结果：
<function func.<locals>.bar at 0x000000000222BAE8>
egon 

def func():
    name='egon'
    x=1000000000000000000000
    def bar():
        print(name)
        print(x)
    return bar
f=func()
print(f.__closure__)    #打印出闭包函数外层作用域的变量
print(f.__closure__[0].cell_contents)  #打印出闭包函数外层作用域的第一个变量的值
print(f.__closure__[1].cell_contents)  #打印出闭包函数外层作用域的第一个变量的值
运行结果：
(<cell at 0x0000000001E16528: str object at 0x0000000001E993B0>, <cell at 0x0000000001E16558: int object at 0x0000000001EA3C10>)
egon
1000000000000000000000

闭包函数：1 内部函数 2 包含对外部作用域而非全局作用域的引用
闭包函数的特点：
　　　　自带作用域
　　　　延迟计算

以上两个实例都是包一层，闭包函数可以包多层：

#包两层的闭包函数
def func():
    name='egon'     #第2层作用域的变量
    def wrapper():
        money=1000      #第1层作用域的变量
        def tell_info():
            print('my namn is %s' % name)   #使用第2层作用域的变量
            print('egon have money %s' %(money))    #使用第1层作用域的变量
        print(tell_info.__closure__)        #打印闭包函数的变量
        return tell_info
    return wrapper
w=func()
tell_info=w()
print(tell_info.__closure__[0].cell_contents)　　#闭包函数变量位置在定义时就定下来了，不因为使用的顺序变化
print(tell_info.__closure__[1].cell_contents)
运行结果：
(<cell at 0x0000000001E16558: int object at 0x000000000048AED0>, <cell at 0x0000000001E16528: str object at 0x0000000001E993B0>)
1000
egon

定义闭包函数的基本形式：

def 外部函数名():
    内部函数需要的变量
    def 内部函数():
        引用外部变量
    return 内部函数

def deco():
    x=1
    def wrapper():
        print(x)
    return wrapper

wrapper=deco()
print(wrapper)

#包两层
def deco1():
    y=2
    def deco():
        x=1
        def wrapper():
            print(x)
            print(y)

        return wrapper
    return deco
deco=deco1()
wrapper=deco()
wrapper()

二、无参装饰器

1、开放封闭原则，对扩展是开放的，对修改是封闭的

2、装饰器，装饰器本质可以任意可调用对象，被装饰的对象也可以是任意
可调用对象，
装饰器的功能是：
在不修改被装饰对象源代码以及调用方式的前提下为期添加新功能

原则：
1.不修改源代码
2.不修改调用方法
目标：添加新功能

无参装饰器=高级函数+函数嵌套

基本框架

#这就是一个实现一个装饰器最基本的架子
def timer(func):
    def wrapper():
        func()
    return wrapper

加上参数

def timer(func):
    def wrapper(*args,**kwargs):
        func(*args,**kwargs)
    return wrapper

加上功能

import time
def timer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print('函数[%s],运行时间是[%s]' %(func.__name__,stop_time-start_time))
    return wrapper

加上返回值

import time
def timer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print('函数[%s],运行时间是[%s]' %(func.__name__,stop_time-start_time))
        return res
    return wrapper

使用装饰器的方法一：

import time
def timer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print('函数[%s],运行时间是[%s]' %(func.__name__,stop_time-start_time))
        return res
    return wrapper

def cal(array):
    res=0
    for i in array:
        res+=i
    return res

cal=timer(cal)
cal(range(100000))

运行结果：
函数[cal],运行时间是[0.0070002079010009766]

使用@装饰器名称的方法：

import time
def timer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print('函数[%s],运行时间是[%s]' %(func.__name__,stop_time-start_time))
        return res
    return wrapper
@timer
def cal(array):
    res=0
    for i in array:
        res+=i
    return res

cal(range(100000))
函数[cal],运行时间是[0.007000446319580078]

上课实例：

#装饰器修订
import time
import random
#装饰器
def timmer(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print('run time is %s' %(stop_time-start_time))
        return res
    return wrapper
#被装饰函数

@timmer
def index():
    time.sleep(random.randrange(1,5))
    print('welecome to index page')
@timmer
def home(name):
    time.sleep(random.randrange(1,3))
    print('welecome to %s HOME page' %name)
    return 1231231231

index()

res1=index()
print('index return %s' %res1)
res2=home('egon') #wraper()
print('home return %s' %res2)


运行结果：
welecome to index page
run time is 2.0001144409179688
welecome to index page
run time is 3.001171350479126
index return None
welecome to egon HOME page
run time is 1.0000574588775635
home return 1231231231

 三、课后作业

一：编写函数，（函数执行的时间是随机的）

import time
import random
def pool():
    s=1
    chi=[]
    for i in range(1,random.randrange(2,20)):
        s*=i
    time.sleep(0.05)
        chi.append(i)
    print('%s的乘积为%d' %(chi,s))
pool()

二：编写装饰器，为函数加上统计时间的功能

import time
import random
def dec(func):
    def war():
        start_time=time.time()
        func()
        stop_time=time.time()
        print('%s函数的运行时间为%f'%(func.__name__,stop_time-start_time))
    return war
def pool():
    s=1
    chi=[]
    for i in range(1,random.randrange(2,20)):
        s*=i
        time.sleep(0.05)
        chi.append(i)
    print('%s的乘积为%d' %(chi,s))
pool=dec(pool)
pool()

三：编写装饰器，为函数加上认证的功能

import time
import random
def approve(func):
    def war():
        while True:
            name=input('name:')
            pwd=input('password:')
            if name=='ogen' and pwd=='123456':
                func()
                break
            else:
                print('请重新输入')
                continue
    return war

def dec(func):
    def war():
        start_time=time.time()
        func()
        stop_time=time.time()
        print('%s函数的运行时间为%f'%(func.__name__,stop_time-start_time))
    return war
@approve
@dec
def pool():
    s=1
    chi=[]
    for i in range(1,random.randrange(2,20)):
        s*=i
        time.sleep(0.05)
        chi.append(i)
    print('%s的乘积为%d' %(chi,s))
pool()

四：编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
    注意：从文件中读出字符串形式的字典，可以用eval('{"name":"egon","password":"123"}')转成字典格式
{'name': 'egon', 'password': '123'}

{'name': 'alex', 'password': '123'}

{'name': 'wupeiqi', 'password': '123'}

{'name': 'yuanhao', 'password': '123'}

{'name': 'fengsongtao', 'password': '123'}

import time
import random
tag = True
def approve(func):
    def war(*k,**kk):
        global tag
        app=[]
        with open('a.txt', encoding='utf-8') as f:
            for line in f:
                app.append(eval(line))
        while tag:
            name=input('name:')
            pwd=input('password:')
            for i in app:
                if name == i['name'] and pwd == i['password']:
                    print('login successful')
                    func(*k,**kk)
                    tag=False
                    break
            else:continue
            break
        else:
            func(*k, **kk)
    return war
def dec(func):
    def war(*k,**kk):
        start_time=time.time()
        func(*k,**kk)
        stop_time=time.time()
        print('%s函数的运行时间为%f'%(func.__name__,stop_time-start_time))
    return war
@approve
@dec
def pool():
    s=1
    chi=[]
    for i in range(1,random.randrange(2,20)):
        s*=i
        time.sleep(0.05)
        chi.append(i)
    print('%s的乘积为%d' %(chi,s))
@approve
@dec
def cal(array):
    array=range(array)
    res=0
    for i in array:
        res+=i
    print('%s的和为%s'%(array,res))
    return res
pool()
cal(10010)

db_path=r'E:\PycharmProjects\qz5\db.txt'
user_dic={
    'egon':'123',
    'alex':'alex3714',
    'wupeiqi':'123',
    'yunahao':'123',
}
with open(db_path,'w',encoding='utf-8') as f:
    f.write(str(user_dic))
login_dic={
    'user':None,
    'status':False,
}
def auth(func):
    def wrapper(*args,**kwargs):
        with open(db_path,'r',encoding='utf-8') as f:
            user_dic=eval(f.read())
        while not login_dic['user'] and not login_dic['status']:
            name = input('name:')
            pwd = input('password:')
            if name in user_dic:
                if pwd==user_dic[name]:
                    print('login successful')
                    login_dic['user']=name
                    login_dic['status']=True
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('password err')
                    continue
            else:print('no user')
        else:
            res = func(*args, **kwargs)
            return res
    return wrapper
@auth
def index():
    print('welcome to index')
@auth
def home(name):
    print('welcome %s to home page'%name)
index()
home('egon')

五：编写下载网页内容的函数，要求功能是：用户传入一个url，函数返回下载页面的结果

from urllib.request import urlopen
def get(url):
    url='http://'+url
    print(urlopen(url).read())
    return url
url=input('请输入网址：')
get(url)

def get(url):
    return urlopen(url).read()
print(get('https://www.python.org'))

六：为题目五编写装饰器，实现缓存网页内容的功能：
    具体：实现下载的页面存放于文件中，如果文件内有值（文件大小不为0），就优先从文件中读取网页内容，否则，就去下载，然后存到文件中

from urllib.request import urlopen
def dec(func):
    def huan(url):
        tag=False     #做一个标志位
        with open('url.txt',encoding='utf-8') as f:
            for i in f:         #遍历文件的每行
                if i.startswith(url):       #如果是以网址开头
                    tag=True                #标志位置为True
                    continue               #跳出本次循环
                if tag:                     #读取到网址开头行的下一行内容
                    print(i)                #答应当前行内容
                    break                  #退出循环
            else:                          #上面的循环正常结束说明文件中无网址的内容则进行写操作
                with open('url.txt', 'a+', encoding='utf-8') as f:
                    url=func(url)           #运行原函数，打印内容，返回网址
                    word = urlopen(url).read()
                    f.write('%s\n%s\n' % (url[7:], word))       #文件写操作
    return huan
@dec
def get(url):
    url='http://'+url
    print(urlopen(url).read())
    return url
url=input('请输入网址：')
get(url)

from urllib.request import urlopen
import os
cache_path=r'E:\PycharmProjects\qz5\cache.txt'
def make_cache(func):
    def wrapper(*args,**kwargs):
        if os.path.getsize(cache_path):
            #有缓存
            print('\033[45m=======>有缓存\033[0m')
            with open(cache_path,'rb') as f:
                res=f.read()
        else:
            res=func(*args,**kwargs)
            with open(cache_path,'wb') as f:
                f.write(res)
        return res
    return wrapper
@make_cache
def get(url):
    return urlopen(url).read()
print('========>first')
print(get('https://www.python.org'))
print('========>second')
print(get('https://www.python.org'))
print('========>third')
print(get('https://www.python.org'))

选做内容：

基于上面网页缓存装饰器的基础上，实现缓存不同网页的功能
要求，用户提交的不同url，都能缓存下来，对相同的url发起下载请求，优先从缓存里取内容。

from urllib.request import urlopen
import os
import os.path
files_hash = []     #给缓存文件的文件名哈希值存放在一个列表内
cache_path = r'E:\PycharmProjects\qz5\cache'    #缓存网页的文件夹
for root,dirs,files in os.walk(cache_path):        #遍历文件夹下的内容 root为根目录  dirs为子文件夹  files为文件名
    for fn in files:
        files_hash.append(hash(fn))     #将文件名遍历出来并将其哈希值存放在列表中
# print(files_hash)
def make_cache(func):
    def wrapper(*args,**kwargs):
        url=args[0][12:]+'.txt'     #www.baidu.com的网页以baidu.com.txt命名
        #print(url,type(url))
        if hash(url) in files_hash and os.path.getsize(root+'\\'+url):  #文件存在且大小不为零
            #有缓存
            print('\033[45m=======>有缓存\033[0m')
            with open(cache_path+'\\'+url,'rb') as f:
                res=f.read()
        else:
            res=func(*args,**kwargs)
            with open(cache_path+'\\'+url,'wb') as f:
                f.write(res)
        return res
    return wrapper
@make_cache
def get(url):
    return urlopen(url).read()
print(get('https://www.python.org'))
print(get('https://www.baidu.com'))

七：还记得我们用函数对象的概念，制作一个函数字典的操作吗，来来来，我们有更高大上的做法，在文件开头声明一个空字典，然后在每个函数前加上装饰器，完成自动添加到字典的操作

hanshu={}
def dic(func):
    def war(*kwargs):
        func(*kwargs)
        hanshu[func.__name__]=func
    return war
@dic
def pool():
    print('fouc1')
@dic
def get(url):
    print(url)
pool()
get('fouc2')
print(hanshu)

func_dic={}
def deco(key):
    def deco2(func):
        func_dic[key]=func
    return deco2
@deco('f1')
def f1():
    print('from f1')
@deco('f2')
def f2():
    print('from f2')
@deco('f3')
def f3():
    print('from f3')
while True:
    cmd=input('>>:').strip()
    if cmd in func_dic:
        func_dic[cmd]()
        print(func_dic)
    print()