Day12 of learning python--迭代器进阶及生成器

1.*args和**kwargs的使用

调用函数是进行打散操作，函数的行参是聚合操作

def outer(*args):  #聚合
    print(args)            #（1，2，3，4）
    print(*args)   #打散     # 1，2，3，4
    def inner(*args):     #传输参数是聚合
        print('inner:',args)    #inner:(1,2,3,4)
    inner(*args)   #调用是打散

outer(1,2,3,4)  # outer(*[1,2,3,4])  outer(*(1,2,3,4))

 2.readline()，readlines()的区别

readline()，一行一行地读，readlines()，每一行当成列表中地一个元素，添加到List中，且元素后带有换行符‘\n’，‘\r’是回车键的意思

f = open('E:\log.txt',mode='r+',encoding='gbk')
line = f.readline().strip() #一行一行地读
print(line)
line = f.readlines()   #每一行当成列表中地一个元素，添加倒list中
print(line)

3. wraps的使用

wraps的作用是，因为语法糖的原因，原函数名的func已经不存在于全局了，而是存放了inner的地址了。而wraps是能够重新获取原函数的__doc__，__name__

from functools import wraps
import time
def timmer(f):
    @wraps(f)       #没有这个话，原来函数名func已经不存在于全局了，而是存放了inner的地址了
    def inner(*args,**kwargs):
        start = time.time()
        ret = f(*args,**kwargs)
        end = time.time()
        print(end-start)
        return ret
    return inner

@timmer
def func(a,b):
    '''
    这个是问候语
    :param a:
    :param b:
    :return:
    '''
    time.sleep(0.01)
    print('老板好，大家好',a,b)
    return '新年好'

print(func.__name__)   #查看字符串格式的函数名, func
print(func.__doc__)    #docunment
re = func(1,2)
print(re)

 4.装饰器的进阶

装饰器的作用是：在不改变原函数的调用方式的情况下，在函数的请后添加功能，本质是：闭包函数

三层装饰器，应用例子：如果有500个函数，都添加了语法糖，如果要删除这个功能，得一个一个得去删除。但是三层装饰器在外部定义一flag标志符，可以控制装饰器添加的内容不生效

mport time
FLAG = False
def timmer_out(flag):   #用于传入flag
    def timmer(func):      # 装饰器
        def inner(*args,**kwargs):   #闭包函数，用于装饰功能
            if flag:     #如果flag是真的，则执行起到装饰的代码，否则则，执行原函数体
                start = time.time()
                ret = func(*args,**kwargs)
                end = time.time()
                print(end-start)
                return ret
            else:
                ret = func(*args, **kwargs)
                return ret
        return inner
    return timmer

@timmer_out(FLAG)    #先执行@右边的，timmer_out(FLAG) == timmer @timmer == wahaha =timmer(wahaha)
def wahaha():
    time.sleep(0.1)
    print('wahahahahahah')

@timmer_out(FLAG)
def ergoutou():
    time.sleep(0.1)
    print('erguotoutoutou')

wahaha()
ergoutou()

多个装饰器装饰一个函数

def wrapper1(func):  # func -->f
    def inner1():
        print('wrapper1,before func')
        func()
        print('wrapper1,after func')
    return inner1

def wrapper2(func): # func -->inner1
    def inner2():
        print('wrapper2,before func')
        func()
        print('wrapper2,after func')
    return inner2

@wrapper2    # 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

和俄罗斯的套娃娃一样，注意的是执行的先后顺序

5.生成器

生成器--迭代器

生成器函数--本质上就是自己写的函数

定义：只要含有yield关键字的函数都是生成器函数，而且不能和return公用，二期只能用于函数内部

def generator():
    print(1)
    yield 'a'
#生成器函数：执行之后会得到一个生成器作为返回值，就是一个迭代器
ret = generator()
print(ret)
print(ret.__next__())   #触发生成器的函数体

执行函数体的时候，遇到yield，不会退出函数。

def generator():  #生成器函数
    print(1)
    yield 'a'
    print(2)
    yield 'b'
    yield 'c'
g = generator()    #g是生成器
# print(g)
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
for i in g:
    print(i)    # 一个一个触发yield的返回值
结果：1  a  2  b  c  

假如我我想定义一个函数，打印200万个哇哈哈，那么一般的方方法会消耗很多的内存资源，用生成器就可以解决了

#娃哈哈%i
def wahaha():
    for i in range(200000):
        yield 'wahahah%s'%i

g = wahaha()

for i in g:     # 一边生成一边打印，打印完了前一个，就不存在于内存当中了
    print(i)

for i in g:
　　print(i)   #从上个for的yield继续往后面打印

注意，列表是一个迭代对象，但执行多个for的时候，每个for生成的迭代器都是一个新的，不同的

l = [1,2,3,4,5]  # 列表是一个可迭代对象
for i in l:    # 遇到for，在内部转换成一个迭代器
    print(i)
    if i == 3:
        break

for i in l:    # 重新转换成一个迭代器
    print(i)
    
for i in l:   
    print(i)

监听文件输入的例子

def tell(filename):
    f = open(filename,'r',encoding='gbk')
    while True:  # for循环只能读存在的，不能读新写，而且不能操作
        line = f.readline()
        if line.strip():    # strip(),默认去掉空格，换行符。或者去掉特定字符串
            yield line.strip()

g = tell('F:\hi.txt')    # 该迭代器可以对文件中的内容进行操作
for i in g:
    print('***',i)

6.作业讲解

1）编写装饰器，为多个函数加上认证的功能（用户的账号和密码来源于文件），要求登陆成功一次，后续的函数都无需再输入用户名和密码

flag = False
def dec(f):
    def inner(*args,**kwargs):
        global flag       # 在函数内部定义全局变量，让局部函数影响全局变量
        if flag == False:
            username = input("请输入登陆名：")
            password = input("请输入密码：")
            with open('F:\hello.txt',mode='r+',encoding='gbk') as file:
                if username == file.readline().strip() and password == file.readline().strip():
                    flag = True
                    ret = f(*args, **kwargs)
                    return ret
                else:
                    print("输入错误")
        else:
            ret = f(*args, **kwargs)
            return ret
    return inner

@dec
def shopping_add():
    print('增加一个物品')

@dec
def shopping_del():
    print('删除一个物品')

shopping_add()
shopping_del()

2）编写装饰器，为多个函数加上记录调用功能，要求每次调用函数都将被调用的函数名称写入文件

def remmber(f):
    def inner(*args,**kwargs):
        ret = f(*args,**kwargs)
        with open('F:\hao.txt','a',encoding='gbk') as file:
            file.write(f.__name__+'\n')
        return ret
    return inner

@remmber
def shopping_add():
    print('增加一个物品')

@remmber
def shopping_del():
    print('删除一个物品')

shopping_add()
shopping_del()
with open('F:\hao.txt','r',encoding='gbk') as f1:
    k = f1.read()
    print(k)

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

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

from urllib.request import urlopen
import os
def cache(f):
    def inner(*args,**kwargs):
        if os.path.getsize('F:\hello.txt'):
            with open('F:\hello.txt', 'rb') as file:
                return file.read()
        ret = f(*args,**kwargs)
        with open('F:\hello.txt','wb') as file:
            file.write(b'***'+ret)
        return ret
    return inner
@cache
def get(url):
    code = urlopen(url).read()  #得到的是一个bytes的代码
    return code

ret = get('http://www.baidu.com')
print(ret)
ret = get('http://www.baidu.com')
print(ret)
ret = get('http://www.baidu.com')
print(ret)