python- - 函数 - - 迭代器和生成器

目录

• 迭代器
  • python中的for循环
  • 迭代和可迭代协议
  • 为什么要有for循环
• 生成器
  • 初识生成器
  • 生成器函数
• 列表推导式和生成器表达式
• 本章小结

• 生成器相关的面试题

  1，迭代器

  1.1 python中的for循环

  要了解for循环是怎么回事儿，还是要从代码的角度出发。
  首先，对一个列表进行for循环。

for i in [1, 2, 3, 4]:
    print(i)

# 结果呈现
1
2
3
4

上面这段代码肯定是没有问题的，但是我们换一种情况，来循环一个数字1234试试

for i in 1234:
    print(i)

# 结果呈现
Traceback (most recent call last):
  File "C:/Users/thinkpad/Envs/daily_test/test_project/test_file.py", line 1, in <module>
    for i in 1234:
TypeError: 'int' object is not iterable

报错了！“TypeError: 'int' object is not iterable” ，说int类型不是一个iterable，那这个iterable是个啥？

1.2 迭代和迭代协议

1.2.1 什么是迭代

• 首先，我们从报错来分析，“iterable”叫做“可迭代的”概念，之所以1234不可以for循环，是因为它不可迭代。那么如果“可迭代”，就应该可以被for循环了。
• list dic str set tuple f = open() range() enumerate都可以被for循环，说明他们都是可迭代的。

from collections import Iterable
# 注： 该模块的调用，将在python3.8 开始停止使用

l = [1, 2, 3, 4]
t = (1, 2, 3, 4)
d = {1: 2, 3: 4}
s = {1, 2, 3, 4}

print(isinstance(l, Iterable))
print(isinstance(t, Iterable))
print(isinstance(d, Iterable))
print(isinstance(s, Iterable))

# 结果呈现
True
True
True
True

• 结合使用for循环取值的现象，再从字面上理解一下，其实迭代就是可以将某个数据集内的数据“一个挨着一个的取出来”，就叫做迭代。

1.1.2 可迭代协议

• 现在是从结果分析原因，能被for循环的就是“可迭代的”，但是如果正着想，for怎么知道谁是可迭代的呢？
• 假如我们自己写了一个数据类型，希望这个数据类型里的东西也可以使用for被一个一个的取出来，那我们就必须满足for的要求。这个要求就叫做“协议”。

• 可以被迭代要满足的要求 就叫做 可迭代协议。可迭代协议的定义非常简单，就是内部实现了__iter__方法。

• print(dir([])) 打印列表拥有的所有方法
  • 双下划线的方法 叫 双下方法

# python 解释器在执行 '+' 时，实际上调用的是 ````__add__```` 方法 
print([1] + [2])
print([1].__add__([2]))

# 结果呈现
[1, 2]
[1, 2]

• 接下来验证一下：

print(dir([1,2]))
print(dir((2,3)))
print(dir({1:2}))
print(dir({1,2}))

# 结果呈现
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

• 只要是能被for循环的数据类型，就一定拥有 __iter__ 方法
• __iter__ 方法做了什么事情呢？

print([].__iter__())

# 结果呈现
<list_iterator object at 0x0000001BFD34A470>

• 执行了 list([]) 的 __iter__ 方法，好像得到了一个 `list_iterator，现在我们又得到了一个新名词—— iterator 。

• iterator，这里给我们标出来了，是一个计算机中的专属名词，叫做 迭代器。

• 总结：可以被for循环的都是可迭代的，要想可迭代，内部必须有一个 __iter__ 方法。

1.2.2 迭代器协议

• 现在已经有一个迭代器了，这个迭代器是一个列表的迭代器。

• 使用 set 集合 ，取 list str dic range 双下方法 的交集

ret = set(dir([]))&set(dir(""))&set(dir({}))&set(dir(range(10)))
print(ret)      # iterable

# 结果呈现
{'__lt__', '__init__', '__le__', '__hash__', '__reduce__', '__format__', '__init_subclass__', '__delattr__', '__ne__', '__setattr__', '__class__', '__ge__', '__new__', '__iter__', '__dir__', '__str__', '__repr__', '__eq__', '__subclasshook__', '__reduce_ex__', '__len__', '__doc__', '__getattribute__', '__getitem__', '__gt__', '__sizeof__', '__contains__'}

• 一个列表执行了 __iter__() 之后就是迭代器

print(dir([]))

# 结果呈现
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

• 使用set 集合 ，取 iter 和 list 的差集

'''
dir([1,2].__iter__())是列表迭代器中实现的所有方法，dir([1,2])是列表中实现的所有方法,都是以列表的形式返回给我们的，为了看的更清楚，我们分别把他们转换成集合，
然后取差集。
'''
print(dir([1,2].__iter__()))
print(dir([1,2]))
print(set(dir([1,2].__iter__()))-set(dir([1,2])))

# 结果呈现
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
{'__setstate__', '__next__', '__length_hint__'}                

• 在列表迭代器中有三个方法，那么这三个方法都分别做了什么事呢？

# print([1, "a", "kkk"].__iter__().__length_hint__())     # 元素个数 3
iter_l = [1,2,3,4,5,6].__iter__()
# 获取迭代器中元素的长度
print(iter_l.__length_hint__())
# 根据索引值指定从哪里开始迭代
print('*',iter_l.__setstate__(4))
# 一个一个的取值
print('**',iter_l.__next__())
print('***',iter_l.__next__())


# 结果呈现
6
* None
** 5
*** 6

• 能让我们一个一个取值的神奇方法是 __next__()
• 在for循环中，就是在内部调用了__next__方法才能取到一个一个的值
• 验证 __next__()

lis = [1, 2, 3]
print(lis.__iter__().__next__())
print(lis.__iter__().__next__())
print(lis.__iter__().__next__())
iterator = lis.__iter__()
print(iterator.__next__())
print(iterator.__next__())
print(iterator.__next__())

# 结果呈现
1
1
1
1
2
3

• 如果我们一直取next取到迭代器里已经没有元素了，就会抛出一个异常StopIteration，告诉我们，列表中已经没有有效的元素了。

lis = [1, 2, 3]
iterator = lis.__iter__()
print(iterator.__next__())
print(iterator.__next__())
print(iterator.__next__())
print(iterator.__next__())

# 结果呈现
1
Traceback (most recent call last):
2
  File "C:/Users/thinkpad/Envs/daily_test/test_project/test_file.py", line 6, in <module>
3
    print(iterator.__next__())
StopIteration

• 这个时候，我们就要使用异常处理机制来把这个异常处理掉。

lis = [1, 2, 3]
iterator = lis.__iter__()
while True:
    try:
        item = iterator.__next__()
        print(item)
    except StopIteration:
        break

# 结果呈现
1
2
3

• 使用while循环实现了原本for循环做的事情，从 iterator 那儿获取一个一个的值，这个 iterator 就是一个迭代器。

• 迭代器遵循迭代器协议：必须拥有 __iter__ 方法和 __next__ 方法。

• Iterable 可迭代 - - 》 __iter__ # 只要含有 __iter__ 方法的都是可迭代的，都可以被 for 循环
• [].__iter__() 迭代器 - - 》 __next__ # 通过 __next__ 方法就可以从迭代器中一个个的取值
• 只要含有 __iter__ 方法的都是可迭代的 - - 可迭代协议

• 迭代器协议 - - 》 内部含有 __next__ 和 __iter__ 方法的就是 迭代器

print("__iter__" in dir([].__iter__()))
print("__next__" in dir([].__iter__()))

# 结果呈现
True
True

from collections import Iterable
from collections import Iterator
print(isinstance([],Iterator))
print(isinstance([],Iterable))

class A:
    def __iter__(self):pass
    def __next__(self):pass

a = A()
print(isinstance(a,Iterator))
print(isinstance(a,Iterable))

l = [1, 2, 3, 4]
for i in l.__iter__():
    print(i)

# 结果呈现
False
True
True
True
1
2
3
4

• 还账：next和iter方法

• 如此一来，关于迭代器和生成器的方法我们就还清了两个，最后我们来看看range()是个啥。首先，它肯定是一个可迭代的对象，但是它是否是一个迭代器？我们来测试一下

print('__next__' in dir(range(12)))  #查看'__next__'是不是在range()方法执行之后内部是否有__next__
print('__iter__' in dir(range(12)))  #查看'__next__'是不是在range()方法执行之后内部是否有__next__

from collections import Iterator
print(isinstance(range(100000000),Iterator))  #验证range执行之后得到的结果不是一个迭代器

# 结果呈现
False
True
False

1.3 为什么要有for循环

for循环 就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的 __iter__ 方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了，而且你看到的效果也确实如此，这就是无所不能的 for循环

l=[1,2,3]

index=0
while index < len(l):
    print(l[index])
    index+=1

# 结果呈现
1
2
3

2，生成器

2.1 初识生成器

• 迭代器有两种：一种是调用方法直接返回的，一种是可迭代对象通过执行 __iter__ 方法得到的，迭代器有的好处是可以节省内存。

• 如果在某些情况下，我们也需要节省内存,就只能自己写。我们自己写的这个能实现迭代器功能的东西就叫生成器。

• Python中提供的生成器：
  • 1.生成器函数：常规函数定义，但是，使用 yield 语句而不是 return 语句返回结果。yield 语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
  • 2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
• 生成器Generator：
  • 本质：迭代器(所以自带了 __iter__ 方法和 __next__ 方法，不需要我们去实现)
  • 特点：惰性运算,开发者自定义

2.2 生成器函数

• 一个包含 yield 关键字的函数就是一个生成器函数。
• yield 可以为我们从函数中返回值，但是 yield 又不同于 return，return 的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。
• 生成器的好处：就是不会一下子在内存中生成太多数据

2.2.1 初识生成器

def generator():
    print(1)
    yield "a"
    print(2)
    yield "b"
    yield "c"

# 生成器函数：执行之后会得到一个生成器作为一个返回值
result = generator()
print(result)        # #打印result可以发现result就是一个生成器

print(result.__next__())
print(result.__next__())
print(result.__next__())
# 等同于以上几个print
# for i in result:
#     print(i)

# 结果呈现
<generator object generator at 0x0000007D40697C78>
1
a
2
b
c

2.2.2 生成器表达式例子

def generator():
    for i in range(20):
        yield "娃哈哈 %s" % i

g = generator()     # 调用生成器函数得到一个生成器
ret = g.__next__()        # 每一次执行 g.__next__()  就是从生成器中取值，预示着生成器函数中的代码继续执行
print("#*# %s" % ret)
num = 0
for i in g:
    num += 1
    if num > 10:
        break
    print(i)

print(list(g))        # 提取完后，剩余的值

# 结果呈现
#*# 娃哈哈 0
娃哈哈 1
娃哈哈 2
娃哈哈 3
娃哈哈 4
娃哈哈 5
娃哈哈 6
娃哈哈 7
娃哈哈 8
娃哈哈 9
娃哈哈 10
['娃哈哈 12', '娃哈哈 13', '娃哈哈 14', '娃哈哈 15', '娃哈哈 16', '娃哈哈 17', '娃哈哈 18', '娃哈哈 19']

2.2.3 监听文件输入的例子

generator_file 文件内容

sadf
qwer2415
avxv1245qgarg
sdf
sdfa
asdfafdaf

j89796960ok
aq24515af
12324151515
a123
sadf
python

def tail(filename):
    f = open(filename,encoding="utf-8")
    while True:
        line = f.readline()
        if line.strip():
            yield line.strip()

g = tail("generator_file")
for i in g:
    if "python" in i :
        print("***", i)

# 结果呈现
*** python

• 从生成器中取值的几个方法
  • next
  • for
  • 数据类型的强制转换 ,但是占内存，不推荐

2.2.4 生成器函数进阶 - - send

def generator():
    print(123)
    num = yield 1
    print("=====",num)
    print(456)
    yield 2
    print(789)

g = generator()
ret = g.__next__()
print("***", ret)
ret = g.send("Hello")      # send 的效果和 next 一样
print("***", ret)

# 结果呈现
123
*** 1
===== Hello
456
*** 2

• send 获取下一个值的效果和 next 基本一致
• 只是在获取下一个值的时候，给上一值的位置传递一个数据
• 使用 send 的注意事项
  • 第一次使用生成器的时候 是用的 next 获取下一个值
  • 最后一个 yield 不能接受外部的值

2.2.5 获取移动平均值

# avg = sum/count
def average():
    sum = 0
    count = 0
    avg = 0
    while True:
        num = yield avg
        sum += num      # 10
        count += 1      # 1
        avg = sum/count


avg_g = average()
avg_g.__next__()
avg1 = avg_g.send(10)
avg2 = avg_g.send(50)
print(avg2)

# 结果呈现
30.0

2.2.6 预激生成器的装饰器

def init(func):     # 装饰器
    def inner(*args, **kwargs):
        g = func(*args, **kwargs)   # g = average()
        g.__next__()
        return g
    return inner

@init
def average():
    sum = 0
    count = 0
    avg = 0
    while True:
        num = yield avg
        sum += num      # 10
        count += 1      # 1
        avg = sum/count

avg_g = average()
ret = avg_g.send(10)
print(ret)
ret = avg_g.send(20)
print(ret)

# 结果呈现
10.0
15.0

2.2.7 yield from

def generator():
    a = 'abcde'
    b = '12345'
    for i in a:
        yield i
    for i in b:
        yield  i

g = generator()
for i in g:
    print(i)

# 结果呈现
a
b
c
d
e
1
2
3
4
5

def generator():
    a = 'abcde'
    b = '12345'
    yield from a
    yield from b
g = generator()
for i in g:
    print(i)

# 结果呈现
a
b
c
d
e
1
2
3
4
5

3，列表推导式和生成器表达式

3.1 列表推导式

egg_list = []
for i in range(10):
    egg_list.append("鸡蛋 %s" % i )

egg_list = ["鸡蛋 %s" % i for i in range(10)]       # 列表推导式
print(egg_list)

print([i for i in range(10)])
print([i * i for i in range(10)])

# 结果呈现
['鸡蛋 0', '鸡蛋 1', '鸡蛋 2', '鸡蛋 3', '鸡蛋 4', '鸡蛋 5', '鸡蛋 6', '鸡蛋 7', '鸡蛋 8', '鸡蛋 9']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

3.2 生成器表达式

g = (i for i in range(10))
print(g)
for i in g:
    print(i)

# 结果呈现
<generator object <genexpr> at 0x00000065EE0D7C78>
0
1
2
3
4
5
6
7
8
9

3.3 生成器表达式 区别于 列表推导式

• 括号不一样
• 返回的值不一样 = = 几乎不占用内存

egg_list = ("鸡蛋 %s" % i for i in range(10))       # 生成器
print(egg_list)
for i in egg_list:
    print(i)

g = (i*i for i in range(10))
g.__next__()
for i in g:
    print(i)

# 结果呈现
<generator object <genexpr> at 0x000000C74DB47C78>
鸡蛋 0
鸡蛋 1
鸡蛋 2
鸡蛋 3
鸡蛋 4
鸡蛋 5
鸡蛋 6
鸡蛋 7
鸡蛋 8
鸡蛋 9
1
4
9
16
25
36
49
64
81

• 总结：
  • 1.把列表解析的[]换成()得到的就是生成器表达式
  • 2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
  • 3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：

sum(x ** 2 for x in range(4))

• 而不用多此一举的先构造一个列表：

sum([x ** 2 for x in range(4)]) 

4，本章小结

• 迭代器
  • 可迭代协议 - - 含有 iter 方法的都是可迭代的 （"__iter__" in dir (数据)）
    • 可迭代的一定可以被 for循环
    • 例如:range(),str,list,tuple,dict,set
  • 迭代器协议 - - 含有 next 和 iter 的都是迭代器
    • 迭代器一定可迭代，可迭代的通过调用 __iter()__ 方法就能得到一个迭代器
    • 例如: iter(range()),iter(str),iter(list),iter(tuple),iter(dict),iter(set),reversed(list_o),map(func,list_o),filter(func,list_o),file_o
  • 特点;
    • 方便逐个取值，一个迭代器只能取一次
    • 节省空间
• 生成器函数Generator
  • 本质：迭代器，所以拥有 __iter__ 方法和 __next__ 方法
  • 特点：惰性运算,开发者自定义
  • 含有 yield 关键字的函数都是生成器函数
  • 生成器函数的特点
    • 调用之后函数内的代码不执行，返回生成器
    • 每次调用 next 方法的时候会取到一个值
    • 每从生成器中取一个值就会执行一段代码，遇到yield就停止
  • 如何从生成其中取值：
    • for ：如果没有break会一直取到去完为止
    • next ：每次只取一个
    • send ：不能用在第一个，取下一个值的时候给上个位置传新的值
    • 数据类型强制转换 ：会一次性把所有数据都读取到内存里
• 生成器表达式
  - (条件成立想放在生成器中的值 for i in 可迭代的 if 条件)
• 使用生成器的优点：
  • 1.延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。
  • 2.提高代码可读性

#列表解析
sum([i for i in range(100000000)])#内存占用大,机器容易卡死
 
#生成器表达式
sum(i for i in range(100000000))#几乎不占内存

5，生成器相关的面试题

5.1 处理文件，用户指定要查找的文件和内容，将文件中包含要查找内容的每一行都输出到屏幕

# test_file.txt 文件内容
sadf
qwer2415
avxv1245qgarg
sdf
sdfa
asdfafdaf
j89796960ok
aq24515af
12324151515
a123
sadf
python
2f4qt4ypython

def check_file(filename, aim):
    with open(filename, encoding="utf-8") as f:   # 句柄：handler
        for i in f:
            if aim in i:
                yield i

g = check_file("test_file.txt","python")
for i in g:
    print(i.strip())

# 结果呈现
python
2f4qt4ypython

5.2写生成器，从文件中读取内容，在每一次读取得到的内容之前加上 “***” 之后返回给用户

def check_file(filename):
    with open(filename, encoding="utf-8") as f:   # 句柄：handler
        for i in f:
            yield "***" + i
for i in check_file("test_file.txt"):
    print(i.strip())

# 结果呈现
***sadf
***qwer2415
***avxv1245qgarg
***sdf
***sdfa
***asdfafdaf
***j89796960ok
***aq24515af
***12324151515
***a123
***sadf
***python
***2f4qt4ypython

5.3 求 g1 g2 的值各是什么？

def demo():
    for i in range(4):
        yield i

g = demo()

g1 = (i for i in g)
g2 = (i for i in g1)

print(list(g1))
print(list(g2))

# 结果呈现
[0, 1, 2, 3]
[]

5.4 求 g 的值是什么？

def add(n, i):
    return n + i

def test():
    for i in range(4):
        yield i

g = test()

for n in [1, 10]:
    g = (add(n, i) for i in g)

# 结果呈现
[20, 21, 22, 23]

5.5 tail & grep

import os

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

@init
def list_files(target):
    while 1:
        dir_to_search=yield
        for top_dir,dir,files in os.walk(dir_to_search):
            for file in files:
                target.send(os.path.join(top_dir,file))
@init
def opener(target):
    while 1:
        file=yield
        fn=open(file)
        target.send((file,fn))
@init
def cat(target):
    while 1:
        file,fn=yield
        for line in fn:
            target.send((file,line))

@init
def grep(pattern,target):
    while 1:
        file,line=yield
        if pattern in line:
            target.send(file)
@init
def printer():
    while 1:
        file=yield
        if file:
            print(file)

g=list_files(opener(cat(grep('python',printer()))))

g.send('/test1')

# 协程应用：grep -rl /dir