函数作业

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

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


def timmer(func):
    @wraps(func)#为了返回被装饰的函数的相同属性
    def warpper(*args,**kwargs):
        start = time.time()
        res=func(*args,**kwargs) # 为了返回被装饰函数的返回值
        stop=time.time()
        print("run time is %s"%(stop-start))
        return res #返回被装饰函数的返回值
    return warpper
@timmer
def index():
    print("index====>")
    time.sleep(0.5)
    return "成功执行"
index()
三：编写装饰器，为函数加上认证的功能
def auth(func):
    def warpper(*args, **kwargs):
        username = input("请输入您的账户:")
        passwd = input("请输入您的密码")
        with open('user.txt', mode='rt', encoding='utf-8') as f:
            for line in f:
                user, paswd = line.strip().split(',')
                if username == user and passwd == paswd:
                    print("登录成功")
                    res = func(*args, **kwargs)
                    return res
                    break
                else:
                    print("登录失败")

    return warpper


@auth
def login():
    print("欢迎回家")


login()
四：编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码
注意：从文件中读出字符串形式的字典，可以用eval('{"name":"egon","password":"123"}')转成字典格式
from functools import wraps
login_status={'user':None,'status':False} # 定义字典用于存放判断用户状态信息
def auth(auth_type='file'):#定义一个默认参数
    def auth1(func):
        @wraps(func)
        def wrapper(*args,**kwargs):
            if login_status['user'] and login_status['status']:
                return func(*args,**kwargs)
            if auth_type=='file':
                with open('db.txt',mode='rt',encoding='utf-8') as f:
                    dic=eval(f.read())
                name=input("请输入您的用户名：")
                paswd=input("请输入您的密码：")
                if name in dic and paswd ==dic[name]:
                    login_status['user']=name
                    login_status['status']=True
                    res=func(*args,**kwargs) #为被装饰的函数接收返回值
                    return res  # 返回被装饰的函数的返回值
                else:
                    print("用户名或密码错误")
        return wrapper # 千万不要带括号因为他返回的是整个函数(次函数的内存地址) 带了括号就是返回调用函数的结果了
    return auth1
@auth
def inde():
    print('欢迎')

@auth
def home():
    print('欢迎回家')

五：编写装饰器，为多个函数加上认证功能，要求登录成功一次，在超时时间内无需重复登录，超过了超时时间，则必须重新登录
import time,random
from functools import  wraps
user1={'user':None,'log_time':None,'timeout':0.000003}
def auth(func):
    @wraps(func)
    def warpper(*args,**kwargs):
        if user1['user']:
            timeout=time.time()-user1['log_time']
            if timeout <user1['timeout']:
                return func(*args,**kwargs)
        func(*args,**kwargs)
        with open('db.txt',mode='rt',encoding='utf-8') as f:
            dic=eval(f.read())
            name=input("请输入账户：")
            passwd = input("请输入密码")
            if name in dic and dic['name']:
                dic['name']=user1
                res=func(*args,**kwargs)
                return res
            else:
                print("账号或密码错误")
    return warpper
def timmer(func):
    def out(*args,**kwargs):
        start=time.time()
        res = func(*args, **kwargs)
        stop=time.time()
        return res
    return out
@auth
def index():
    print("index-------")
@auth
def home(name):
    print("欢迎。。。。。%s"%name)
六：编写下载网页内容的函数，要求功能是：用户传入一个url，函数返回下载页面的结果
import requests
def get(url):
    res=requests.get(url).text
    print(res)

get('https://www.python.org')
七：为题目五编写装饰器，实现缓存网页内容的功能：
具体：实现下载的页面存放于文件中，如果文件内有值（文件大小不为0），就优先从文件中读取网页内容，否则，就去下载，然后存到文件中
import requests,os
def make_cache(func):
    def wrapper(*args,**kwargs):
        if not os.path.exists('news.log'): #检查此文件路径是否存在
            with open('news.log','w'):
                pass
        if os.path.getsize('news.log'): #文件大小
            with open('news.log','rt',encoding='utf-8') as f:
                res=f.read()
        else:
            res=func(*args,**kwargs)
            with open('news.log','wt',encoding='utf-8') as f:
                f.write(res)
        return res
    return wrapper
@make_cache
def get(url):
    return requests.get(url).text
res=get('https://www.baidu.com')
print(res)
扩展
import requests,os,hashlib
dic={
    'file':{'dirname':'./db'},
    'mysql':{
        'host':'127.0.01',
        'port':3306,
        'user':'root',
        'password':'123'
    },
    'redis':{
        'host':'127.0.0.1',
        'port':6379,
        'user':'root',
        'password':'123'
    },
}
def make_cache(engine='file'): #设置默认参数
    if engine not in dic:
        raise TypeError('egine not valid')
    def deco(func):
        def wrapper(url):
            if engine == 'file':
                m=hashlib.md5(url.encode('utf-8'))
                cache_filename=m.hexdigest()
                cache_filepath=r'%s %s'%(dic['file']['dirname'],cache_filename)
                if os.path.exists(cache_filepath) and os.path.getsize(cache_filepath):
                    return open(cache_filepath,encoding='utf-8').read()
                res=func(url)
                with open(cache_filepath,'w',encoding='utf-8') as f:
                    f.write(res)
            elif engine == 'mysql':
                pass
            elif engine =='redis':
                pass
            else:
                pass
        return wrapper
    return deco
@make_cache(engine='file')
def get(url):
    return requests.get(url).text
print(get('https://www.baidu.com'))



八：还记得我们用函数对象的概念，制作一个函数字典的操作吗，来来来，我们有更高大上的做法，在文件开头声明一个空字典，然后在每个函数前加上装饰器，完成自动添加到字典的操作
name_dic={} #定义一个空字典
def make_dic(name):
    def deco(func):
        name_dic[name]=func
    return deco#千万不要写括号，
@make_dic('yjc')
def name1():
    print('yjc')

print(name_dic)
九 编写日志装饰器，实现功能如：一旦函数f1执行，则将消息2017-07-21 11:12:11 f1 run写入到日志文件中，日志文件路径可以指定
import time
from functools import wraps
def date(logfile):
    @wraps(logfile)
    def warpper(*args,**kwargs):
        res=logfile(*args,**kwargs)
        with open('news.log','at',encoding='utf-8') as f:
            f.write('%s %s run
' %(time.strftime('%Y-%m-%d %X'),'你若盛开微风自来'))
        return res
    return warpper
@date
def index(logfile):
    print('成功写入')

index('news.log')