装饰器 迭代器 生成器

1, 装饰器

定义： 在不修改原函数代码和函数调用方式的前提下 给函数添加新功能

双层装饰器执行流程
1、开始的时候执行外部函数 顺序 从下往上
2执行嵌套函数 顺序 从上往下
3、执行原函数
4、结束的时候 顺序 从下往上

def outer(func):
    def inner():
        name = input('请输入注册名字：')
        psw = input('请输入用户名密码：')
        with open('3.txt','w',encoding='utf-8') as f:
            f.write(name+'\n'+psw)
        func()

    return inner
def outer1(func):
    def inner():
        with open('3.txt','r',encoding='utf-8') as f:
            list1 = f.readlines()
            name1 = input('请输入用户名：')
            psw1 = input('请输入用户密码：')
            if name1 == list1[0].strip() and psw1 == list1[1]:
                func()
            else:
                print('认证失败，请确认！')

    return inner

@outer
@outer1
def func():
    print('欢迎来到宝宝的宝宝是宝宝官方网站')
func()

#flask路由
urls = {

}  # 路由，字典，路径=>函数


def router(path):
    def warp(func):
        urls[path] = func

        def inner(request):
            resp = func(request)
            return resp

    return warp


@router('/index/')
def index(request):
    return '执行了index函数'


@router('/user/')
def user(request):
    return '执行了user函数'


print(urls['/user/']('request'))

2,迭代器

1、什么是迭代
迭代即--------遍历

2、能被遍历的数据类型有

str  list  dict set  tuple

for i in 序列：
    print（i）

3、什么是可迭代对象？

能被for 遍历的对象  就是可迭代对象   Iterable

4、如何判断一个对象是否是可迭代对象？

1、能被for 遍历
2、用isinstance（o，t）
    o   object     要判断的对象
    t   type       判断的类型
iterable 可迭代对象   /  iterator  迭代器
    如果 返回  True  代表是可迭代对象
    如果 返回  False  代表不是可迭代对象

5、自己定义一个可迭代对象

	1、通过 类
    2、类里面必须有  __iter__ 方法   的对象就是可迭代对象

6、迭代器 Iterator
能够帮助我们记录遍历当前元素的 ’人‘

7、可迭代对象是迭代器吗？
不是

8、判断一个迭代对象是不是迭代器？
用isinstance（o，t） iterator 迭代器
o object 要判断的对象
t type 判断的类型

9、如何把迭代对象变成迭代器
1、对已知数据类型转换
iter（可迭代对象） 和 next（）
2、对自定义的对象进行转换
在类里加一个 __ next__ 方法

一个具备__iter__ 方法  和 __next__方法的对象   就是迭代器

10、迭代器的输出方式
1、next（）
2、for 循环遍历
3、list tuple 强转

11、for 循环的本质
1、先通过 iter（） 获取可迭代对象的迭代器
2、通过next（） 获取值 并把值符给i
3、当遇到 StopIteration 就停止

12、用迭代器实现斐波那契数列

class FeiBo():
    def __init__(self,n):
        self.n = n          #斐波那契个数
        self.num1 = 0       # 第一个数
        self.num2 = 1       #第二个数
        self.index = 0      #下标
    def __iter__(self):
            return self
    def __next__(self):
        if self.index <self.n:
            num = self.num1
            self.num1 , self.num2 = self.num2,self.num1+self.num2
            self.index += 1
            return num
        else:
            raise StopIteration
feibo = FeiBo(9)
print(list(feibo))



from collections.abc import Iterator
from collections.abc import Iterable
list1 = [1,2,3,4]
list2 = iter(list1)


print(isinstance(list2,Iterable))       #判断可迭代对象
print(isinstance(list2,Iterator))       #判断迭代器

3，了解生成器

1， 生成器 generator

        是特殊的迭代器
        一边循环  以边计算  的机制
    用查看迭代器的方式 查看生成器的方式
        1、next（）
        2、for 循环遍历
        3、list（）   、  tuple （）  强转  

2、创建生成器

1、将列表推导式的中括号[]  换成小括号（）
    2、将函数中的return  换成  yield
        如果一个函数中有 yield  那么这个函数就是生成器

3、yield的作用

	1、将返回值返回
    2、保持运行状态  将函数挂起

    唤醒生成器的三种方式
	    1、next（）
	    2、__next__()
	    3、send()  不能放第一个

4、用生成器实现斐波那契数列

#-------------生成器实现斐波那契数列-------
def FeiBo(n):
    a , b = 0,1
    for i in range(1,n):
        yield a     #将函数挂起   将返回值返回  #将生成器返回的值给num
        # num = yield a     #将函数挂起   将返回值返回  #将生成器返回的值给num

        # print(num)          ##输出send添加的元素，和yield原有的返回值
        a,b = b, a+b
f = FeiBo(9)

# print(list(f))

# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.send('liu'))
# print(f.send('zai'))
# print(f.send('an'))
# print(f.send('g'))


print(next(f))          #遇到next 将生成器 唤醒
print(next(f))
print(next(f))
print(next(f))