标签: generator

我可以使用这样的递归函数创建一个嵌套的迭代器组:

def rprint(n):
    for i in range(n):
        print('n = %d' % n)
        yield rprint(n-1)         

然后,举一个简单的例子,我可以手动评估嵌套生成器.

>>> p3 = rprint(3)
>>> p3
<generator object rprint at 0x1043b7048>
>>> p2_0 = next(p3)
>>> p2_1 = next(p3)
>>> p2_2 = next(p3)
n = 3
n = 3
n = 3
>>> next(p3) # will raise an error
StopIteration
>>> p1_0_0 = next(p2_0)
>>> p1_0_1 = next(p2_0)
n = 2
n = 2
>>> next(p2_0)# will raise an error
StopIteration
>>> p0_0_0_0 = next(p1_0_0) …

我正在努力写这样的事情:

list(reversed(list(el.iterancestors()))) + [1,2,3]

生成器很糟糕,因为我被迫将它们用于列表中.

有没有办法简化这个？我认为reversed()应该接受迭代器,我错了吗？

今天我玩弄了嵌套的生成器函数,发现了一个有趣的属性/行为,我无法向自己解释.

也许这与缺乏对yield from... 的理解有关.但是,现在问题是:

def foo():
    for iter in range(10):
        yield iter

generator = foo()

def bar():
    yield from generator

print(next(bar()), end=' ')
print(next(bar()), end=' ')
...

所以我排除的输出就是0 1 ....

但是,在第一次成功调用之后next,我得到:Traceback(最近一次调用最后一次):文件"",第1行,在StopIteration中

所以我的问题是:为什么发电机已经到了终点？

N = [1, 2, 3]
print(n for n in N)

结果:

<generator object <genexpr> at 0x000000000108E780>

为什么这段代码无法打印:

1
2
3

但是代码:

sum(n for n in N) 

可以总结N中的所有数字.

你能告诉我为什么sum()可以工作但print()faild？

让我们假设一个具有已定义迭代器的对象的两个类似实现:一个使用生成器的迭代器,另一个使用迭代.这两个都可以使用Array.from,并且它们都可以迭代.这两种方法有哪些区别,哪一种更受欢迎,为什么？是否需要较小的方法？

class Foo {
  constructor( ...args ) {
    this.f = args;
  }
  [Symbol.iterator]() {
    let c = 0;

    const i = {

      next: () => {
        if ( c < this.f.length ) {
          return {value:this.f[c++], done: false};
        }
        else {
          return {value:undefined,done:true};
        }
      }

    };
    return i;
  }

};

class Bar {
  constructor( ...args ) {
    this.f = args;
  }
  *[Symbol.iterator]() {
    let c = 0;

    if ( c < this.f.length ) …

通常情况下,人们需要无限循环直到达到某种条件.例如,如果我想继续收集随机整数,直到我找到一个数字== n,然后我打破.我这样做:

import random

rlist = []
n = ...
low, high = ..., ...
while True:
    num = random.randint(low, high)
    if num == n:
        break
    rlist.append(num)

这很有效,但非常笨重.有一个更多的pythonic替代品使用iter:

iter(o [,sentinel])

返回一个迭代器对象.根据第二个参数的存在,第一个参数的解释非常不同.[...]如果给出第二个参数sentinel,则o必须是可调用对象.在这种情况下创建的迭代器将为每个对其next()方法的调用调用o而不带参数; 如果返回的值等于sentinel,则会引发StopIteration,否则返回该值.

上面的循环可以替换为

import random
from functools import partial

f = partial(random.randint, low, high)
rlist = list(iter(f, 10))

要将此原则扩展到已创建的列表,需要稍作更改.我需要定义一个像这样的部分函数:

f = partial(next, iter(x)) # where x is some list I want to keep taking items from until I hit a sentinel

其余的保持不变,但这种方法与while循环的主要警告是我不能应用泛型布尔条件.

例如,我不能应用"生成数字,直到遇到大于1000的第一个偶数".

底线是这样的:是否有另一种替代while循环并 …

假设我有一个生成函数,它产生两个值:

def gen_func():
    for i in range(5):
        yield i, i**2

我想检索我的函数的所有迭代器值.目前我为此目的使用此代码段:

x1, x2 = [], []
for a, b in gen_func():
    x1.append(a)
    x2.append(b)

这对我有用,但看起来有点笨重.是否有更紧凑的编码方式？我想的是:

x1, x2 = map(list, zip(*(a, b for a, b in gen_func())))

但是,这只会给我一个语法错误.

PS:我知道我可能不应该为此目的使用发电机,但我需要其他地方.

编辑:任何类型的x1和x2将工作,但是,我更喜欢列表我的情况.

MDN文档

async/await函数的目的是简化同步使用promises的行为,并对一组Promises执行某些行为.就像Promise类似于结构化回调一样,async/await类似于组合生成器和promise.

我理解async/await,generator和promise的基本概念.但是,我并不完全理解async/await类似于组合生成器和promise的含义.

那么异步/等待简化了生成器和承诺可以一起做什么？任何例子？

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

# [[1], [2, 3, 4, 5]]
# [[1, 2], [3, 4, 5]]
# [[1, 2, 3], [4, 5]]
# [[1, 2, 3, 4], [5]]


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

# [[1], [2], [3, 4, 5]]
# [[1, 2], [3], [4, 5]]
# [[1, 2, 3], [4], [5]]
# [[1, 2], [3, 4], [5]]
# ...

我该如何实施generate_chunks(list, n)？

本质上讲generate_chunks确实是分裂list的n …

我在文件中有一个数字矩阵（用于解决TSP的城市之间的距离）。我将其加载到列表中。之后，列表中的每一行如下所示：

' 9999    3    5   48   48    8    8    5    5    3    3    0    3    5    8    8    5\n'

每行上数字之间的空格数可能不同。现在，我只想将其转换为整数/浮点数列表。我有一个循环：

matrix = []
for row in lines[begin:end]:
    matrix.append([float(x) for x in row.split()])

它工作正常。我很好奇我是否可以在这里使用生成器（就像我在循环中使用它），但不是在循环中，而是在一行中。我尝试了类似的方法[float(x) for x in [y.split() for y in lines[begin:end]]]，但是它说：

float() argument must be a string or a number, not 'list'

那么它可以像一行一样解决吗，还是应该让它循环处理？