22、yield表达式形式和面向过程编程

一 yield的表达式

def foo():
    print(‘starting‘)
    while True:
        x=yield None#return 2
        print(‘value :‘,x)
g=foo()
print(next(g))
print(g.send(2))

运行结果:
starting  #运行函数,打印starting后碰到yield停住
None    #next()触发后 yield将None赋值给x,打印None后循环碰到yield停住
value : 2  #g.send(2)将2赋值给yield,yield将2赋值给x,继续循环打印出2碰到yield停住
None      #碰到yield停住并返回None,print的结果就是None

以上将yield接受到的值赋值给了x,这样形式就叫做yield的表达式形式。

函数foo中有yield,那它就是迭代器。可以使用next()。yield可以返回结果,默认为None。

g.send()前生成器必须先next一次才能发送值。所以写一个装饰器,让foo自动next一次。

def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper

@init #foo=init(foo)
def foo():
    print(‘starting‘)
    while True:
        x=yield
        print(‘value :‘,x)
g=foo() #wrapper()
g.send(2)

运行结果:
starting
value :2

send的效果:
1:先从为暂停位置的那个yield传一个值,然后yield会把值赋值x
2:与next的功能一样

# _*_ coding:utf-8 _*_
def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper
@init
def eater(name):
    print(‘%s ready to eat‘%name)
    food_list=[]
    while True:
        food=yield food_list
        food_list.append(food)
        print(‘%s start to eat %s‘%(name,food))

e=eater(‘alex‘)
print(e.send(‘food1‘))
print(e.send(‘food2‘))
print(e.send(‘food3‘))

运行结果:
alex ready to eat
alex start to eat food1
[‘food1‘]
alex start to eat food2
[‘food1‘, ‘food2‘]
alex start to eat food3
[‘food1‘, ‘food2‘, ‘food3‘]

二、面向过程编程

应用:grep -rl ‘root‘  /etc

实现打印出/etc目录下所有包含‘root’的文件的文件路径

分析完成功能的阶段:

阶段一:递归地找出目录下所有文件的绝对路径,把路径发给阶段二

阶段二:收到文件路径,打开文件获取文件对象,把文件对象发给阶段三

阶段三:收到文件对象,for循环读取文件的每一行内容,把每一行内容发给阶段四

阶段四:收到一行内容,判断root是否在这一行中,如果在,则把文件名发给阶段五

阶段五:收到文件名,打印结果

import os
#装饰器,自动next()
def init(func):
    def wrapper(*args,**kwargs):
        g = func(*args,**kwargs)
        next(g)
        return g
    return wrapper
#j阶段一:递归地找出目录下所有文件的绝对路径,把路径发给阶段二
@init
def search(target):
    ‘search file abspath‘
    while True:
        start_path=yield
        g = os.walk(start_path)
        for par_dir,_,files in g:
            for file in files:
                file_path = r‘%s\%s‘ %(par_dir,file)
                target.send(file_path)
#阶段二:收到文件路径,打开文件获取文件对象,把文件对象发给阶段三
@init
def opener(target):
    while True:
        file_path = yield
        with open(file_path,encoding = ‘utf-8‘) as f:
            target.send((file_path,f))
#阶段三:收到文件对象,for循环读取文件的每一行内容,把每一行内容发给阶段四
@init
def cat(target):
    while True:
        file_path,f = yield
        for line in f:
            res=target.send((file_path,line))
            if res:
                break
#阶段四:收到一行内容,判断root是否在这一行中,如果在,则把文件名发给阶段五
@init
def grep(target,pattern):
    tag=False
    while True:
        filepath,line=yield tag
        tag=False
        if pattern in line:
            target.send(filepath)
            tag=True
#阶段五:收到文件名,打印结果
@init
def printer():
    while True:
        filename = yield
        print(filename)
start_path = r‘E:\PycharmProjects\qz5\day9‘
# search(opener(cat(grep(printer(),‘Jack‘))),start_path)
g=search(opener(cat(grep(printer(),‘Jack‘))))
g.send(start_path)
时间: 2024-10-08 10:03:42

22、yield表达式形式和面向过程编程的相关文章

第五章---面向过程编程

编程范式(流派): 面向对象编程,面向过程编程 各有用处!! 编程:语法+数据结构(list dict)+算法(逻辑) 1.面向过程编程:核心是过程二字,过程指得是解决问题的步骤,相当于设计一条流水线,机械式的思维方式 优点:复杂的问题流程化,进而简单化       缺点:可扩展性差       运用场景:系统监控脚本,自动部署脚本之类的,eg:软件包解压安装(不再需要扩展了)就可以使用面向过程的思维编写代码 1 ''' 2 面向过程实例:用户登录注册 3 第一步:用户输入用户名密码 4 第二步

迭代器、生成器、面向过程编程

一 迭代器 1.迭代的概念 #迭代是一个重复的过程,每次重复即一次迭代,并且每次迭代的结果都是下一次迭代的初始值 while True: #只是单纯地重复,因而不是迭代 print('===>') l=[1,2,3] count=0 while count < len(l): #迭代 print(l[count]) count+=1 2.为何要有迭代器?什么是可迭代对象?什么是迭代器对象? #1.为何要有迭代器? 对于序列类型:字符串.列表.元组,我们可以使用索引的方式迭代取出其包含的元素.但

如何从普通程序员晋升为架构师 面向过程编程OP和面向编程OO

引言 计算机科学是一门应用科学,它的知识体系是典型的倒三角结构,所用的基础知识并不多,只是随着应用领域和方向的不同,产生了很多的分支,所以说编程并不是一件很困难的事情,一个高中生经过特定的训练就可以做得到.但是,会编程和编好程绝对是两码事,同样的程序员,有的人几年之后成为了架构师,有的人却还在不停地coding,只不过ctrl-c.ctrl-v用得更加纯熟了.在中国,编程人员最终的归途无外乎两条:一是转向技术管理,它的终点是CTO:二是继续深入,它的终点是首席架构师,成为CEO的人毕竟是少数.如

Python 面向过程编程

一.解释 面向过程:核心是过程二字,过程即解决问题的步骤,基于面向过程去设计程序就像是在设计,流水线式的编程思想,在设计程序时,需要把整个流程设计出来, 一条工业流水线,是一种机械式的思维方式 二.优缺点 优点:程序体系结构清晰,可以把复杂的问题简单化,流程化 缺点:可扩展性差,一条流线只是用来解决一个问题,所以说面向过程的应用多为不需要经常变化的软件 应用场景:linux内核,git,httpd,shell脚本 三.实例(利用协程函数进行面向过程编程) 过滤一个文件下的子文件.字文件夹的内容中

yield表达式形式

首先了解 1.iterator iterator叫做迭代器,用来遍历可以序列化的数据,比如一个list,set 等,当然如果对象想要能够使用迭代器来遍历,只要在该对象的类中添加__iter__()方法,该方法返回一个迭代器对象,迭代器对象中需要实现next()方法 for example: >>> class sequenceClass(object):   ...     def __init__(self, *args):   ...             self._data =

十三、面向过程编程

运用上次的 yiled 模拟 grep -rl 'root' /etc (递归找etc下所有文件并打开,过滤有'root'的文件) # import os # g = os.walk(r'C:\Users\56360\Desktop\city\mycity') # print(next(g)) # 拿到当前文件夹下的子目录和子文件 格式:('C:\Users\56360\Desktop\city\mycity',['src', 'static', 'test'],['index.html', '

day5-python之面向过程编程

一.面向过程编程 #1.首先强调:面向过程编程绝对不是用函数编程这么简单,面向过程是一种编程思路.思想,而编程思路是不依赖于具体的语言或语法的.言外之意是即使我们不依赖于函数,也可以基于面向过程的思想编写程序 #2.定义 面向过程的核心是过程二字,过程指的是解决问题的步骤,即先干什么再干什么 基于面向过程设计程序就好比在设计一条流水线,是一种机械式的思维方式 #3.优点:复杂的问题流程化,进而简单化 #4.缺点:可扩展性差,修改流水线的任意一个阶段,都会牵一发而动全身 #5.应用:扩展性要求不高

python学习第四节 迭代器 生成器 面向过程编程

1:什么是迭代 可以直接作用于for循环的对象统称为可迭代对象(Iterable). 可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator). 所有的Iterable均可以通过内置函数iter()来转变为Iterator. 对迭代器来讲,有一个__next()就够了.在你使用for 和 in 语句时,程序就会自动调用即将被处理的对象的迭代器对象,然后使用它的next__()方法,直到监测到一个StopIteration异常. >>> L = [1,2,3]>

Python函数之面向过程编程

一.解释 面向过程:核心是过程二字,过程即解决问题的步骤,基于面向过程去设计程序就像是在设计,流水线式的编程思想,在设计程序时,需要把整个流程设计出来, 一条工业流水线,是一种机械式的思维方式 二.优缺点 优点:程序体系结构清晰,可以把复杂的问题简单化,流程化 缺点:可扩展性差,一条流线只是用来解决一个问题,所以说面向过程的应用多为不需要经常变化的软件 应用场景:linux内核,git,httpd,shell脚本 三.实例(利用协程函数进行面向过程编程) 过滤一个文件下的子文件.字文件夹的内容中