迭代器和发生器有什么区别？

Question

迭代器和发生器有什么区别？

Answer 1

一个迭代器在同一时间遍历集合之一.

甲发生器产生的序列,一次一个项目.

例如,您可以迭代生成器的结果......

Answer 2

生成器是迭代器,但并非所有迭代器都是生成器.

迭代器通常是具有从流中获取下一个元素的下一个方法的东西.生成器是与函数关联的迭代器.

例如python中的生成器:

def genCountingNumbers():
  n = 0
  while True:
    yield n
    n = n + 1

这样做的好处是,您不需要在内存中存储无限数字来迭代它们.

您可以像使用任何迭代器一样使用它:

for i in genCountingNumbers():
  print i
  if i > 20: break  # Avoid infinite loop

你也可以迭代一个数组:

for i in ['a', 'b', 'c']:
  print i

Answer 3

这里有太多的Python,太多人说生成器是实现无限迭代器的唯一方法.这是我提到的示例(所有自然数的正方形)在C#中实现的.ExplicitSquares显式实现了一个迭代器(在C#中称为IEnumerator).ImplicitSquares使用生成器来做同样的事情.两者都是无限迭代器,没有后台集合.唯一的区别是状态机是否拼写出来,或者是否使用了发电机.

using System.Collections;
using System.Collections.Generic;
using System;

class ExplicitSquares : IEnumerable<int>
{
    private class ExplicitSquaresEnumerator : IEnumerator<int>
    {
        private int counter = 0;

        public void Reset()
        {
            counter = 0;
        }

        public int Current { get { return counter * counter; }}

        public bool MoveNext()
        {
            counter++;
            return true;
        }

        object IEnumerator.Current { get { return Current; } }

        public void Dispose(){}
    }

    public IEnumerator<int> GetEnumerator()
    {
        return new ExplicitSquaresEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

class ImplicitSquares : IEnumerable<int>
{
    public IEnumerator<int> GetEnumerator()
    {
        int counter = 1;
        while(true)
        {
            int square = counter * counter;
            yield return square;
            counter++;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class AllSquares
{
    private static readonly int MAX = 10;

    public static void Main()
    {
        int i = 0;
        foreach(int square in new ExplicitSquares())
        {
            i++;
            if(i >= MAX)
                break;
            Console.WriteLine(square);
        }

        Console.WriteLine();

        int j = 0;
        foreach(int square in new ImplicitSquares())
        {
            j++;
            if(j >= MAX)
                break;
            Console.WriteLine(square);
        }
    }
}

Answer 4

生成器是迭代器的实现.它通常是一个例程,它向调用者产生多个值而不是一个.

在c#中

// yield-example.cs
using System;
using System.Collections;
public class List
{
    public static IEnumerable Power(int number, int exponent)
    {
        int counter = 0;
        int result = 1;
        while (counter++ < exponent)
       {
            result = result * number;
            yield return result;
    }
}

static void Main()
{
    // Display powers of 2 up to the exponent 8:
    foreach (int i in Power(2, 8))
    {
        Console.Write("{0} ", i);
    }
}
}

请参阅维基百科的条目

Answer 5

Generator 是一个特殊的函数，它可以作为 Iterator 运行，每次被调用时都会返回一个值。因为它是一个函数，它可以按需计算每个值。并且因为它很特殊，它可以记住上次调用时的状态，因此生成的代码看起来非常简单。

例如，python 中的这个生成器将产生一个整数序列

def integers():
    int n = 0
    while True:
        yield n
        n += 1

在这个例子中重要的是 yield n语句。该函数将返回该值，下次调用时，它将从该点继续。

此链接对 python 中的生成器有更长的解释： 链接文本