今天我很懒，但是你比我更懒——有参装饰器、迭代器，第二十一天

说实话，日子过的真快，不知不觉21天了，在这里很充实，同时是真的累，但是这种知识暴涨的快感令人很舒服，风雨兼程，有你有我，希望自己能够坚持下去，早日回归到10点睡6点起的幸福日子。

有参装饰器：

装饰器里添加参数，然后可以在装饰器上套一层函数，这个函数可以传任意个数的参数，最里层必须得传参数（*args, **kwargs），外层传（func），最外层任意传参数，里面都可以接收

import time

current_user={'user':None}

def deco(func):
    def wrapper(*args,**kwargs):
        if current_user['user']:
            #已经登陆过
            res = func(*args, **kwargs)
            return res
        user=input('username>>: ').strip()
        pwd=input('password>>: ').strip()
        if user == 'egon' and pwd == '123':
            print('login successful')
            # 记录用户登陆状态
            current_user['user']=user
            res=func(*args,**kwargs)
            return res
        else:
            print('user or password error')
    return wrapper

@deco
def index():
    print('welcome to index page')
    time.sleep(1)

@deco
def home(name):
    print('welecome %s to home page' %name)
    time.sleep(0.5)


index()
home('egon')
'''

'''

def f1():
    x=1
    def f2():
        def f3():
            print(x)
        return f3
    return f2

f2=f1()

f3=f2()

f3()

import time
current_user={'user':None}
def auth(engine='file'):
    def deco(func):
        def wrapper(*args,**kwargs):
            if current_user['user']:
                #已经登陆过
                res = func(*args, **kwargs)
                return res
            user=input('username>>: ').strip()
            pwd=input('password>>: ').strip()
            if engine == 'file':
                # 基于文件的认证
                if user == 'egon' and pwd == '123':
                    print('login successful')
                    # 记录用户登陆状态
                    current_user['user']=user
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('user or password error')
            elif engine == 'mysql':
                print('基于mysql的认证')
            elif engine == 'ldap':
                print('基于ldap的认证')
            else:
                print('无法识别认证来源')
        return wrapper
    return deco

@auth(engine='mysql') # @deco #index=deco(index) #index=wrapper
def index():
    print('welcome to index page')
    time.sleep(1)

@auth(engine='mysql')
def home(name):
    print('welecome %s to home page' %name)
    time.sleep(0.5)


index()
home('egon')

2.迭代器

什么是迭代器：

迭代器即取值的工具

迭代是一个重复的过程，每一次重复都是基于上一次的结果而来的。

单纯的重复并不是迭代

while True:
    print('1111')

迭代

迭代：
l=['a','b','c']

def iterator(item):
    i=0
    while i < len(item):
        print(l[i])
        i+=1

为什么要有迭代器

基于索引的迭代器取值方式只适用于列表、元组、字符串类型

而对于没有索引的字典、集合、文件，则不再适用

所以必须找到一种通用的并且不依赖于索引的迭代器取值方式-》迭代器

迭代器适用于可迭代的类型

3.如何用迭代器

l=['a','b','c']
i=0
while i < len(l):
    print(l[i])
    i+=1

l = ['a', 'b', 'c']
s='hello'

def iterator(item): #item='hello'
    i = 0
    while i < len(item):
        print(item[i])
        i += 1
# iterator(l)
iterator(s)

可迭代的对象

在python中但凡内置有__iter__方法的对象都是可迭代的对象

字符串、列表、元组、字典、集合、文件都是可迭代的对象

num1=10
num2=10.1
s1='hello'
l=[1,2,3]
t=(1,2,3)
d={'x':1}
s2={1,2,3}
f=open('a.txt','w')

s1.__iter__
l.__iter__
t.__iter__
d.__iter__
s2.__iter__
f.__iter__

迭代器对象：

指的是既内置__iter__方法，又内置__next__方法的对象

执行可迭代对象的__iter__方法得到的就是内置的迭代器对象

文件对象本身就是迭代器对象

强调：

迭代器对象一定是可迭代的对象，反之则不然

info={'name':'egon','age':18,'is_beautiful':True,'sex':'male'}
info_iter=info.__iter__()
# print(info_iter)

res1=info_iter.__next__()
print(res1)

res2=info_iter.__next__()
print(res2)

res3=info_iter.__next__()
print(res3)

res4=info_iter.__next__()
print(res4)

info_iter.__next__()# 一旦迭代器取值取干净，再继续取出就会抛出StopIteration

info={'name':'egon','age':18,'is_beautiful':True,'sex':'male'}
# info=[1,2,3,4,5]
info_iter=info.__iter__()
while True:
    try:
        print(info_iter.__next__())
    except StopIteration:
        break

for 循环：迭代器循环

info={'name':'egon','age':18,'is_beautiful':True,'sex':'male'}
in后跟的一定要是可迭代的对象
for k in info: # info_iter=info.__iter__()
    print(k)

in后跟的一定要是可迭代的对象

f=open('a.txt','r')
for k in f:
    print(k)

迭代器对象：指的是即内置又__iter__方法，又内置__next__方法的对象

执行迭代器对象的__next__得到的是迭代器的下一个值

执行迭代器对象的__iter__得到的仍然是迭代器本身

iter_info=info.__iter__()
print(iter_info)
print(iter_info is iter_info.__iter__() is iter_info.__iter__().__iter__().__iter__().__iter__().__iter__()

总结迭代器的缺点和优点：

优点：

1、提供了一种通用的、可以不依赖索引的迭代取值方式

2、迭代器对象更加节省内存

f=open('movie.tar.gz','rb')
f.__ next__()
f=open('db.txt','rt',encoding='utf-8')

print(f.__next__())
print(f.__next__())
print(next(f)) #f.__next__()

s='hello'
print(s.__len__())
print(len(s))
s.__iter__()
print(iter(s))

缺点：

1、迭代器的取值不如按照索引的方式更灵活，因为它只能往后取不i能往前退

2、无法预测迭代器值的个数

names=['egon','alex_SB','wxx_SB']
iter_names=iter(names)
print(next(iter_names))
print(next(iter_names))

iter_names=iter(names)
print(next(iter_names))
print(next(iter_names))
# print(next(iter_names))

print(names[1])
print(names[1])

s=set('helllllo')
print(s)


for i in 10:
    pass

list(10)

names=['a','b','c','d']
iter_names=iter(names)

l1=list(iter_names)
print(l1)

l2=list(iter_names)
print(l2)

f=open('db.txt','rt',encoding='utf-8')

print(list(f))
print(list(f))
print(list(f))
print(list(f))
print(list(f))


l1=[1,2,3,]
diedaiqi=l1.__iter__()
print(list(l1))
print(list(l1))
print(list(l1))
print(list(l1))
print(list(l1))
print(list(l1))

谢谢观看！