python之旅：迭代器、生成器、面向过程编程

1、什么是迭代器？

1、什么是迭代器
迭代的工具

什么是迭代？
迭代是一个重复的过程，每一次重复都是基于上一次结果而进行的

# 单纯的重复并不是迭代
while True:
print('=====>')

2、为什么要用迭代器
找到一种可以不依赖索引的迭代取值方式

3、怎么用迭代器
可迭代对象？
在python中，但凡内置有__iter__方法对象，都是可迭代的对象

迭代器对象？
执行可迭代对象下__iter__方法得到的返回值就是一个迭代器对象

迭代器对象内置
__next__方法
__iter__方法,执行该方法得到仍然是迭代器本身，干什么用？？

迭代器对象一定是可迭代的对象
可迭代的对象不一定是迭代器对象

以下都是可迭代的对象: ( 你可以自己在对象后面 ._ 看下有没有__iter__ )

str='hello'

list=[1,2,3]

tup={1,2,3}

dic={'x':1}

s1={'a','b','c'}

f=open('a.txt','w',encoding='utf-8')

2、迭代器

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

dic={'x':1,'y':2,'z':3}
iter_dic=dic.__iter__()     #第一件事是获得一个可迭代器，即调用了__iter__()函数
print(iter_dic.__next__())  #第二件事是循环的过程，循环调用__next__()函数。
print(iter_dic.__next__())
print(iter_dic.__next__())

print(iter_dic.__next__()) #第四行会提示哦，也相当于报错，只有三个值，你取第四个值的时候会停止迭代
　　　　　　　　　　　　　　　　#    print(iter_dic.__next__())
　　　　　　　　　　　　　　　　　　StopIteratio

3 为何要有迭代器？什么是可迭代对象？什么是迭代器对象？

#1、为何要有迭代器？
对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

#2、什么是可迭代对象？
可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下
'hello'.__iter__
(1,2,3).__iter__
[1,2,3].__iter__
{'a':1}.__iter__
{'a','b'}.__iter__
open('a.txt').__iter__

#3、什么是迭代器对象？
可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

文件类型是迭代器对象
open('a.txt').__iter__()
open('a.txt').__next__()

#4、注意：
迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

4、可迭代的对象vs迭代器对象？

可迭代的对象：str，list，tuple，dict，set，file
　　1、获取可迭代对象的方式：python内置的有str，list，tuple，dict，set，file都是可迭代对象

　　2、特点：内置有__iter__方法的都叫可迭代的对象，执行该方法会拿到一个迭代器对象。

迭代器对象：文件对象本身就是迭代器对象
　　1、获取迭代器对象的方式：
   　　　　 执行可迭代对象的__iter__方法，拿到的返回值就是迭代器对象
　　2、特点：
    　　　　内置有__next__方法，执行该方法会拿到迭代器对象中的一个值
   　　　　 内置有__iter__方法，执行该方法会拿到迭代器本身

str1='hello'
list1=[1,2,3]
tup1=(1,2,3)
dic={'x':1}
s1={'a','b','c'}
#文件本身就是迭代器对象
f=open('a.txt','w',encoding='utf-8')
f.__next__()

5、迭代器的优缺点分析

迭代器的优点：

　　　　　　　提供了一种可不依赖于索引的取值方式

　　　　　　　迭代器更加节省内存

迭代器的缺点：

　　　　　　　取值麻烦，只能一个一个取，只能往后取

　　　　　　　并且是一次性的，无法用len获取长度

1、提供了一种可不依赖于索引的取值方式
#这是a.txt文件的内容
adadaaasdasd
dasdas
das

l=open('a.txt','r',encoding='utf-8')
iter=l.__iter__()
while True:  #死循环
    try:   #用这个参数来检测
        print(iter.__next__(),end='')
    except StopIteration:  #检测什么时候出现StopIteration
        break  #监测到出现StopIteration 就break
l.close()

#结果如下
adadaaasdasd
dasdas
das
#没有报错

2、迭代器更加节省内存

item=range(0,100000000000000000000000000000000000000000000)  #如rang，python2中会依次打印1，2，3，4，5，6.。。。python3中优化了迭代器直接打印出来，所以更省内存

print(item)

#结果如下
range(0, 100000000000000000000000000000000000000000000)

#取值麻烦，只能一个一个取，只能往后取

x=[1,2,3]
iter_x=x.__iter__()
while True:
    try:
        print(iter_x.__next__())
    except StopIteration:
        break
print('第二次=================================》')
iter_x=x.__iter__()
while True:
    try:
        print(iter_x.__next__())
    except StopIteration:
        break
#结果如下
1
2
3
第二次=================================》
1
2
3

6、for循环原理分析：

#6.1、for 循环称之为迭代器循环，in后跟的必须是可迭代的对象
#6.2、for循环会执行in后对象的__iter__方法，拿到迭代器对象
#6.3、然后调用迭代器对象的__next__方法，拿到一个返回值赋值给line，执行一次循环体
#6.4、周而复始，直到取值完毕，for循环会检测到异常自动结束循环
l=open('a.txt','r',encoding='utf-8')
for line in l: #iter_l=l.__iter__()
    print(line,end='')

for item in {'x':1,'y':2}:
    print(item,end='')

#结果如下
adadaaasdasd
dasdas
das
xy

7、迭代器的优缺点

#优点：
  - 提供一种统一的、不依赖于索引的迭代方式
  - 惰性计算，节省内存
#缺点：
  - 无法获取长度（只有在next完毕才知道到底有几个值）
  - 一次性的，只能往后走，不能往前退

生成器

一 什么是生成器

#只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

def func():
    print('====>first')
    yield 1
    print('====>second')
    yield 2
    print('====>third')
    yield 3
    print('====>end')

g=func()
print(g) #<generator object func at 0x0000000002184360> 

二 生成器就是迭代器

g.__iter__
g.__next__
#2、所以生成器就是迭代器，因此可以这么取值
res=next(g)
print(res)

三 练习

1、自定义函数模拟range(1,7,2)

2、模拟管道，实现功能:tail -f access.log | grep '404'

#题目一：
def my_range(start,stop,step=1):
    while start < stop:
        yield start
        start+=step

#执行函数得到生成器，本质就是迭代器
obj=my_range(1,7,2) #1  3  5
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj)) #StopIteration

#应用于for循环
for i in my_range(1,7,2):
    print(i)

#题目二
import time
def tail(filepath):
    with open(filepath,'rb') as f:
        f.seek(0,2)
        while True:
            line=f.readline()
            if line:
                yield line
            else:
                time.sleep(0.2)

def grep(pattern,lines):
    for line in lines:
        line=line.decode('utf-8')
        if pattern in line:
            yield line

for line in grep('',tail('access.log')):
    print(line,end='')

#测试
with open('access.log','a',encoding='utf-8') as f:
    f.write('出错啦404\n')

四 协程函数

#yield关键字的另外一种使用形式：表达式形式的yield
def eater(name):
    print('%s 准备开始吃饭啦' %name)
    food_list=[]
    while True:
        food=yield food_list
        print('%s 吃了 %s' % (name,food))
        food_list.append(food)

g=eater('egon')
g.send(None) #对于表达式形式的yield，在使用时，第一次必须传None，g.send(None)等同于next(g)
g.send('蒸羊羔')
g.send('蒸鹿茸')
g.send('蒸熊掌')
g.send('烧素鸭')
g.close()
g.send('烧素鹅')
g.send('烧鹿尾')

五 练习
1、编写装饰器，实现初始化协程函数的功能

2、实现功能：grep  -rl  'python'  /etc

#题目一：
def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper
@init
def eater(name):
    print('%s 准备开始吃饭啦' %name)
    food_list=[]
    while True:
        food=yield food_list
        print('%s 吃了 %s' % (name,food))
        food_list.append(food)

g=eater('egon')
g.send('蒸羊羔')

#题目二：
#注意：target.send(...)在拿到target的返回值后才算执行结束
import os
def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper

@init
def search(target):
    while True:
        filepath=yield
        g=os.walk(filepath)
        for dirname,_,files in g:
            for file in files:
                abs_path=r'%s\%s' %(dirname,file)
                target.send(abs_path)
@init
def opener(target):
    while True:
        abs_path=yield
        with open(abs_path,'rb') as f:
            target.send((f,abs_path))
@init
def cat(target):
    while True:
        f,abs_path=yield
        for line in f:
            res=target.send((line,abs_path))
            if res:
                break
@init
def grep(pattern,target):
    tag=False
    while True:
        line,abs_path=yield tag
        tag=False
        if pattern.encode('utf-8') in line:
            target.send(abs_path)
            tag=True
@init
def printer():
    while True:
        abs_path=yield
        print(abs_path)

g=search(opener(cat(grep('你好',printer()))))
# g.send(r'E:\CMS\aaa\db')
g=search(opener(cat(grep('python',printer()))))
g.send(r'E:\CMS\aaa\db')

六 yield总结

#1、把函数做成迭代器
#2、对比return，可以返回多次值，可以挂起/保存函数的运行状态

七 迭代器总结

1、什么是生成器
    在函数内但凡有yield关键字，再调用函数就不会执行函数体代码，得到返回值就是一个生成器对象，
    强调：生成器本质就是迭代器

    next(g)=g.__next__过程：
        会触发生成器g所对应的函数的执行，直到遇到yield才停下来，然后把yiled后的返回值当做
        本次next操作的结果

2、为何要用生成器：
    学习生成器是为了掌握一种自定义迭代器的方式

3、总结yield：
    1、yield提供一种自定义迭代器的方式
    2、与return对比，都能返回值，都能返回多个值，都没有类型限制，而return只能返回一次值，而yield可以返回多次值（yield可以
    帮我们保存函数的执行状态）
    3、.send('')会把值递给yield

面向过程编程

#1、首先强调：面向过程编程绝对不是用函数编程这么简单，面向过程是一种编程思路、思想，而编程思路是不依赖于具体的语言或语法的。言外之意是即使我们不依赖于函数，也可以基于面向过程的思想编写程序

#2、定义
面向过程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么

基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式

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

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

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

#6、举例
流水线1：
用户输入用户名、密码--->用户验证--->欢迎界面

流水线2：
用户输入sql--->sql解析--->执行功能

ps：函数的参数传入，是函数吃进去的食物，而函数return的返回值，是函数拉出来的结果，面向过程的思路就是，把程序的执行当做一串首尾相连的功能，该功能可以是函数的形式，然后一个函数吃，拉出的东西给另外一个函数吃，另外一个函数吃了再继续拉给下一个函数吃。。。

#=============复杂的问题变得简单
#注册功能:
#阶段1: 接收用户输入账号与密码,完成合法性校验
def talk():
    while True:
        username=input('请输入你的用户名: ').strip()
        if username.isalpha():
            break
        else:
            print('用户必须为字母')

    while True:
        password1=input('请输入你的密码: ').strip()
        password2=input('请再次输入你的密码: ').strip()
        if password1 == password2:
            break
        else:
            print('两次输入的密码不一致')

    return username,password1

#阶段2: 将账号密码拼成固定的格式
def register_interface(username,password):
    format_str='%s:%s\n' %(username,password)
    return format_str

#阶段3: 将拼好的格式写入文件
def handle_file(format_str,filepath):
    with open(r'%s' %filepath,'at',encoding='utf-8') as f:
        f.write(format_str)

def register():
    user,pwd=talk()
    format_str=register_interface(user,pwd)
    handle_file(format_str,'user.txt')

register()

#=============牵一发而动全身,扩展功能麻烦
#阶段1: 接收用户输入账号与密码,完成合法性校验
def talk():
    while True:
        username=input('请输入你的用户名: ').strip()
        if username.isalpha():
            break
        else:
            print('用户必须为字母')

    while True:
        password1=input('请输入你的密码: ').strip()
        password2=input('请再次输入你的密码: ').strip()
        if password1 == password2:
            break
        else:
            print('两次输入的密码不一致')

    role_dic={
        '':'user',
        '':'admin'
    }
    while True:
        for k in role_dic:
            print(k,role_dic[k])

        choice=input('请输入您的身份>>: ').strip()
        if choice not in role_dic:
            print('输入的身份不存在')
            continue
        role=role_dic[choice]

    return username,password1,role

#阶段2: 将账号密码拼成固定的格式
def register_interface(username,password,role):
    format_str='%s:%s:%s\n' %(username,password,role)
    return format_str

#阶段3: 将拼好的格式写入文件
def handle_file(format_str,filepath):
    with open(r'%s' %filepath,'at',encoding='utf-8') as f:
        f.write(format_str)

def register():
    user,pwd,role=talk()
    format_str=register_interface(user,pwd,role)
    handle_file(format_str,'user.txt')

register()

#ps:talk内对用户名\密码\角色的合法性校验也可以摘出来做成单独的功能,但本例就写到一个函数内了,力求用更少的逻辑来为大家说明过程式编程的思路

示例:复杂的问题变得简单,但扩展功能麻烦