饮冰三年-人工智能-Python-16Python基础之迭代器生成器装饰器

Posted 2021-01-10 逍遥小天狼

一：迭代器：

　　最大的特点：节省内存

　　1.1 迭代器协议

　　　　a：对象必须提供一个next方法，

　　　　b：执行方法要么返回迭代中的下一项，要么抛弃一个Stopiteration异常，

　　　　c：只能向后不能向前。

　　1.2 可迭代对象

　　　　实现了迭代器协议的对象。（对象内部定义一个__iter__()方法）

　　1.3 使用迭代器访问对象

　　　　for map sum max min 

　　　　注意：（字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过for循环调用了他们内部的__iter__()方法，把他们变成了可迭代对象

st="hello";
# 先将字符串对象转化为可迭代对象
iterSt = st.__iter__()
while True:
    try:
        print(iterSt.__next__())
    except StopIteration:
        # print(‘迭代完成‘)
        break

迭代器之for循环模拟

二：生成器

　　1.1 特征

　　　　不用调用__iter__()，生成器生成的元素直接可调用__next__()方法。

　　1.2 生成器在python中的实现方式

　　　　生成器函数：使用yield语句返回结果，在每个结果中间，挂起函数的状态，以便下次从此处继续执行。

def test():
    print("第一次next")
    yield 1
    print("第二次next")
    yield [2,3,4,5]
    print("第三次next")
    yield 6
res=test()
print(res.__next__())
print(res)
print(res.__next__())
‘‘‘
第一次next
1
<generator object test at 0x000000000232E390>
第二次next
[2, 3, 4, 5]
‘‘‘

生成器函数

def produceBaozi():
   for i in range(1,10):
       print("开始生产包子")
       yield "生产第%s笼包子" %i
       print("开始销售包子")

res=produceBaozi()
print(res.__next__())
print(res.__next__())
‘‘‘
开始生产包子
生产第1笼包子
开始销售包子
开始生产包子
生产第2笼包子
‘‘‘

produceBaozi()

　　　　生成器表达式：列表解析[]写成（）　　　　

laomuji = (‘老母鸡%s‘ %i for i in range(10) if i%2==0)
print(next(laomuji)); #这种next()方法等同于__next__()
print(laomuji.__next__());

生成器表达式

 　　1.3 人口普查小练习　　

{"location":"北京",‘count‘:100}
{"location":"上海",‘count‘:300}
{"location":"广州",‘count‘:200}
{"location":"深圳",‘count‘:400}

人口普查.txt

# 通过with as 的方式打开文件不用关闭
def getPeople():
    with open("人口普查","r",encoding="utf-8") as f:
        for i in f:
            yield i
g = getPeople();
amount=sum(eval(i)["count"] for i in g)
h=getPeople()
for i in h:
    print(eval(i)["location"]+"的人数为："+ str(eval(i)["count"]) +"，占统计总人数的"+str(eval(i)["count"]/amount)+"%")

‘‘‘
北京的人数为：100，占统计总人数的0.1%
上海的人数为：300，占统计总人数的0.3%
广州的人数为：200，占统计总人数的0.2%
深圳的人数为：400，占统计总人数的0.4%
‘‘‘

人口.py

 　　1.4 生产者消费者模式

def consumer(name):
    print(‘我是【%s】,我准备开始吃包子了‘ %name)
    while True:
        baozi = yield
        print("【%s】很开心的吃掉了【%s】" %(name,baozi))

def producer():
    c1=consumer(‘张三‘)
    c2=consumer("李四")
    c1.__next__()
    c2.__next__()
    for i in range(10):
        if i % 2 == 0:
            c1.send("包子 %s" %i )
        else:
            c2.send("包子 %s" %i)
producer()

‘‘‘
我是【张三】,我准备开始吃包子了
我是【李四】,我准备开始吃包子了
【张三】很开心的吃掉了【包子 0】
【李四】很开心的吃掉了【包子 1】
【张三】很开心的吃掉了【包子 2】
【李四】很开心的吃掉了【包子 3】
【张三】很开心的吃掉了【包子 4】
【李四】很开心的吃掉了【包子 5】
【张三】很开心的吃掉了【包子 6】
【李四】很开心的吃掉了【包子 7】
【张三】很开心的吃掉了【包子 8】
【李四】很开心的吃掉了【包子 9】
‘‘‘

生产者消费者模式

# 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
# 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下
# 的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。


# 方法一，递归调用
def getNum(day,cou=1):
    cou =2 *(cou + 1) ;
    day-=1
    if day==1:
        return cou;
    return getNum(day, cou)
print(getNum(10))
# 方法二，递归调用
def f(n):
    if n ==1:
        return 1
    return (f(n-1)+1)*2
print(f(10))
# 方法三，reduce函数
s=1
func=lambda x:(x+1)*2
for x in range(9):
    s=func(s)
print(s)

猴子吃桃

 三 装饰器 = 高阶函数 + 函数嵌套 + 闭包

　　本质就是函数，功能是为其他函数添加附加功能

　　原则：

　　　　1：不能修改被修饰函数的源代码

　　　　2：不能修改被修饰函数的调用方式　　　

# 装饰器=高阶函数+函数嵌套+闭包
# 高阶函数：传入参数或输出结果是一个函数
# 函数嵌套：函数中定义函数
import time
def timmer(func):
    def wrapper():
        startTime= time.time()
        func();
        endTime= time.time()
        print("被测试函数一共运行："+str(endTime-startTime)+"秒")
    return wrapper
@timmer  #语法糖，相当于#test=timmer(test)
def test():
    time.sleep(0.3);
    print("test函数运行完毕")
test()

装饰器-计算方法时间

# 装饰器=高阶函数+函数嵌套+闭包
# 高阶函数：传入参数或输出结果是一个函数
# 函数嵌套：函数中定义函数
import time
def timmer(func):
    def wrapper(*args,**kwargs):
        startTime= time.time()
        res=func(*args,**kwargs);
        endTime= time.time()
        print("被测试函数一共运行："+str(endTime-startTime)+"秒")
        return  res
    return wrapper
@timmer  #语法糖，相当于#test=timmer(test)
def test(a,b):
    return a+b

print(test(100,200))

装饰器-设置参数和返回值

# 装饰器=高阶函数+函数嵌套+闭包
# 高阶函数：传入参数或输出结果是一个函数
# 函数嵌套：函数中定义函数
import time
# 添加一个参数，如果参数是n就打n折
def disCount(n=1):
    def timmer(func):
        def wrapper(*args,**kwargs):
            startTime= time.time()
            res=func(*args,**kwargs)*n;
            endTime= time.time()
            print("今天是国庆节，每位客户打的折扣为："+str(n*10))
            return  res
        return wrapper
    return timmer
#@timmer  #语法糖，相当于#test=timmer(test)
@disCount(n=0.9)
def test(a,b):
    return a+b

print(test(100,200))

闭包，设置参数