面向过程编程-迭代器和生成器

一：什么是迭代器？

1.什么是迭代

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

while True：
    print（‘------》’）

没有基于上一次的结果，while这里仅仅是循环

l=['a','b','c']
n=0
while n<len(l):    
    print(l[n])
    n+=1
每一次的n都是基于上一次n，这里是迭代

二：什么是迭代器

     要想了解迭代器到底是什么？必须了解一个概念，即什么是可迭代对象。

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

#以下都是可迭代的对象
strl='hello'
listl=[1,2,3]
tupl=(1,2,3)
dic={'x':1}
sl={'a','b','c'}
f=open('a.txt','w',encoding='utf-8')
除了数字类型

三：迭代器

1.什么是迭代器和举例

迭代取值的工具，可迭代对象执行_iter_方法得到的返回值就是迭代器对象。

以上都是可迭代的对象，我们以前学习的都是可以迭代，但是受限于必须有索引。

而迭代器对象可以避免引用索引，避开这个短处。

字典：

dic={'x':1,'y':2,'z':3}
iter_dic=dic._iter_()
print(tier_dic._next_())
print(tier_dic._next_())

电脑输出：
x
y
z

集合：

sl={'a','b','c'}
iter_sl=sl._iter_()
print(iter_sl._next_())
print(iter_sl._next_())
print(iter_sl._next_())
print(iter_sl._next_())
print(iter_sl._next_())
电脑输出：
b
a
c
print（iter_sl._next_()）
stopiteration

列表：

list=[1,2,3]
iter_list=list_iter_()
print(iter_list.-next-())
print(iter_list._next_())
print(iter_list._next_())

电脑输出：
1
2
3

字符串：

l=‘hello’
iter_l=l._iter_()
while True:
    print(iter_l._next_())
电脑输出：
h
e
l
l
o
但执行的时候会报错

增加抛出异常机制：

l=[1,2,3,4,5]
iter_l=l._iter_()
while True:
    try:
        print(tier_l._next_())
    except StopIteration:
        break

文件：

l=open('a.txt','r',encoding='utf-8')iter_l=l._iter_()
iter_l=l._iter_()

while True:
    try:
        print(iter_l._next_())
    except StopIteration:
        break
电脑输出：
11111111

222222

333333

444444

注意：

‘
’打印出来了空行 

 2.for循环称之为迭代器循环，in后必须是可迭代对象或者迭代器，因为for要调用系统内置的_iter_方法

l=open ('a.txt','r',encoding='utf-8')
for line in l :
    print(line)
for调用了系统内置方法_iter_

3.迭代器的优点：

1.提供了一种可以不依赖索引的取值方法

2.只生成一个迭代器对象，更加节省内存

l=open('a.txt','r',encoding='utf-8')
for line in l:
    print(line)
电脑输出：
只是一个内存空间地址而已

  4.迭代器的缺点：

1.取之麻烦，只能一个一个的next取出来

2.取值方向只能往后取，而且是一次性使用，无法复用

x=[1,2,3]
iter_x=x._iter_()
while True:
    try:
        print(tier_x._next_())
    except:
        break
print('第二次====================》‘)
iter_x=x._iter_().      (必须新建才能复用)
while True:
    try:
        print(iter_x._next_())
    except：
        break

5.可迭代的对象Vs迭代器对象

可迭代对象（list，str，tuple，dict，set，file）
　　1.获取可迭代对象的方式：无需获取，python内置str，list，dict，set，file都是可迭代对象
　　2.特点：
　　　　内置_iter_方法的都可以叫做可迭代对象，执行该方法会拿到一个迭代器对象
迭代对象：
　　1.获取迭代器对象的方式，执行可迭代对象的_iter_方法，拿到的返回值就是迭代器对象
　　2.内置有_next_方法，执行该方法会拿到迭代器对象的一个值（value）
　　3.内置有_iter_方法，执行该方法会拿到迭代器本身（内存地址）

》》》文件有时候本身较大，占用太多内存，必须定义为一个迭代器对象，节省内存
四、生成器yield基础
　　1.生成器本质就一个迭代器，相当于自己造了一个母鸡。
　　生成器的用法其实就是迭代器的用法：
　　yield的用法其实就是迭代器的用法：
　　yield的用法（针对任何可迭代对象）：
　　　　函数内包含yield关键字，在调用函数，就不会执行函数体代码，
　　　　拿到返回值就是一个生成器对象

def chicken ():
    print('----->first')
    yield 1
    print('------>second')
    yield 2
    print('------->third')
    yield 3
obj=chicken()
print(obj)

电脑输出：(输出的是内存地址)

<generator object chicken at 0x1031ed150>

def chicken ():
    print('----->first')
    yield 1
    print('------>second')
    yield 2
    print('------->third')
    yield 3
obj=chicken()
res=obj.__next__()
print(res)
res1=obj.__next__()
print(res1)
res2=obj.__next__()
print(res2)

电脑输出：

----->first
1
------>second
2
------->third
3

2.yield的过程：

　　1、iter_obj=obj._iter_(),拿到迭代器

　　2、出发iter_obj._next_(),拿到该方式的返回值，赋值给item

　　3、周而复始，直到函数内不再有yield，即取之完毕

　　4、for会检测到StopIteration异常，结束循环

for item in obj：

　　print（item）

3、yield的功能

　　　　a》与return类似，都可以返回值，不一样在于，yield可以返回多个值而且可暂停，

　　　　　　再次执行可继续下一步操作，return到了就停止不在继续执行。

　　　　b》为封装好的函数能够使用_iter_和_next_的方法。

　　　　c》遵循迭代器的取值方式._next_(),触发函数的执行和函数的保存方式都是通过yield保存起来的。

def foo():
    print('starting')
    while True:
        x=yield
        print('value:  ',x)
g=foo()
next(g)    
# (next(g)==g.send(None))
g.send(2)
# send的效果：1、将携带的值传给yield，注意的是yield，而不是x，然后yield赋值给x 2、send()方法和next()方法
# 一样的功能，也就是继续执行，直到碰到yield结束

yield表达形式（例如：x=yield）下，生成器会有一个send的操作：

send的效果：

　　　　1.先从一个暂停位置的那个yield传一个值，然后yield会把值赋值x

　　　　2.与next的功能一样

　　　　3.send传多个值，必须以元组的形式

def good(func):
    def good1(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return good1
@good
def eater(name):
    print('%s starting to eat'%name)
    food_list=[]
    while True:
        food=yield food_list
        food_list.append(food)
        print('% start to eat %'%(name,food))
m=eater('jason')
m.send('火腿')

注意点：

既然send（）方法有和next一样的作用，那么我们可不可以这样做：

def foo():
    while True:
        x=yield
函数yield，函数执行的结果就是生成器，即foo()就是生成器。而要执行的话就需要next(g)
        print('value',x)
g=foo()
g.send(1)
执行给yield传值，这样行不行呢？

很显然，是不行的：

TypeError: can't send non-None value to a just-started generator

错误提示：不能传递给一个非空值给一个未启动的生成器。

　　也就是说，在一个生成器函数未启动之前，是不能传递给数值进去的。必须先传递一个None进去

或者调用一次next（），才可以进行传值操作。

4.yield的总结：

　　a.为我们提供了一种自定义迭代器的方式，可以再函数内调用yield关键词，调用函数拿到的

　　生成器，生成器就是迭代器。

　　b.yield可以像是return一样用于返回值

　　c.yield可以保存函数的执行状态

五、生成器yield的表达形式

def eat(name):
    print('%s ready to eat' %name)
    while True:
        food=yield
        print('%s start to eat %s' %(name,food))
    

dog1=eat('alex')
dog1._next_()
dog1._next_()
dog1.send('骨头')

电脑输出：

alex ready to eat
alex start to eat None
alex start to eat 骨头

六：面向过程编程

　　1.什么是面向过程

　　“过程”是其核心，是解决问题的过程，即先做什么，在做什么。

　　2.基于面向过程编程程序，就好比设计一种流水线，类似机械思维方式

　　3.总结优缺点：

　　优点：复杂的问题流程化，进而简单化

　　缺点：可扩展性差，修改流水线的任意一个阶段都会牵一发而动全身。

　　应用：扩展性要求不高的场景，典型案例如linux内核，git，http

　　4.实例:

　　流水线1：

　　　　用户输入用户名、密码——》用户验证——》欢迎界面

　　流线线2:

　　　　用户输入sql——》sql解析——》执行功能