什么是迭代器和发电机之间的区别？(What is the difference between an

什么是迭代器和发电机之间的区别？

Answer 1:

发电机迭代器，但不是所有的迭代器发电机。

迭代器是典型的东西，有一个未来的方法来从流中获取下一个元素。 发电机是被联系在一个函数的迭代器。

例如在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 2:

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

甲发生器产生的序列，一次一个项目。

你可能例如，遍历一个生成的结果...

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:

甲发生器是能够表现为一个Iterator，每次被调用时返回一个值的特殊功能。 因为它是一个功能，它可以计算需求的每个值。 而且因为它是特殊的，它可以从最后一次被称为记住它的状态，因此产生的代码看起来非常简单。

例如，该发生器在python会产生整数序列

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

在这个例子中重要的是yield n声明。 该函数将返回值，下一个被调用的时候，它会继续从该点。

此链接在Python生成的更详细的解释： 链接文本

Answer 6:

（从JavaScript useland，但同其他所有）

一个迭代符是具有的.next（）函数的对象

发电机是一个函数 ，调用一次，产生一个迭代器，它是迭代的工厂。

在JavaScript中，生成器函数需要特殊的语法功能*（）{}和yield关键字使用

见MDN这个： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators

Answer 7:

迭代器用于遍历集合中的对象，是一个数组，链表，树，哈希表，等等。 你有一大堆的对象，你想与他们做的每一个东西。

发电机不只是从某些对象的有限集合返回的项目。 相反，它生成它们的飞行。 你可以概念化这跟是当你在遍历它创建，并不具有有限的尺寸集合的迭代器。

例如，你可以有一个发电机吐出素数从2到无穷远。 有没有办法，你可以有“全素数”的集合，并遍历它的迭代器。 你需要一台发电机。

或者你可以有一台发电机，它接受一个整数并产头号因素在同一时间。 发电机将在这里你受益，你可以通过一个没有对所有的前期因素分配内存考察的因素之一。 它也允许你使用它们，因为它们产生的，而不是生成整个列表前面，这可能是慢于你喜欢的。 下面是用Python这种发电机的例子：

def factors(n):
    for i in xrange(1, n+1):
        if n % i == 0:
            yield i

for n in factors(1234567890):
    print n

如果你运行这个你可以看到，他们正在计算打印的因素。 我们并不需要实际保持在内存中的所有因素的完整列表。

Answer 8:

迭代器通常用于通过项目的集合移动。 通常具有的MoveNext（）和电流（）方法。 的MoveNext（）将指针移动到下一个集合项目（如果可能的话），并返回基于成功的true / false。 目前（）将提供实际值。

发电机是迭代器的实现，但不是指向现有集合，它创建于各的MoveNext（）调用新的项目。

Answer 9:

通常步行迭代器在现有的序列（诸如数组或列表）和发电机计算在每次请求一个新的值。

文章来源: What is the difference between an Iterator and a Generator?