标签: iterator

我试图在循环中访问先前迭代的元素,遍历列表的所有元素.

更具体地说,我的循环看起来像这样:

for (iter=list_object.begin(); iter!= list_object_.end(); iter++)
  {
    function_1(*iter);
    function_2(*PREVIOUS_VALUE_IN_THE_LIST);
  }

如何在列表中访问此前一个值？

我不时感觉需要某种迭代器(除了前面这个问题的标题之外,我不能说出一个好名字).

假设我们有一个函数(或函数对象)将整数映射到类型T.也就是说,我们有一个数学序列的定义,但我们实际上并没有将它存储在内存中.我想用它做一个迭代器.迭代器类看起来像这样:

template <class F, class T>
class sequence_iterator : public std::iterator<...>
{
    int i;
    F f;
    public:
    sequence_iterator (F f, int i = 0):f(f), i(i){}
    //operators ==, ++, +, -, etc. will compare, increment, etc. the value of i.
    T operator*() const
    {
        return f(i);
    }    
};

template <class T, class F>
sequence_iterator<F, T> make_sequence_iterator(F f, int i)
{
    return sequence_iterator<F, T>(f, i);
}

也许我天真,但我个人觉得这个迭代器会非常有用.例如,假设我有一个函数来检查数字是否为素数.我想计算区间[a,b]中素数的数量.我会这样做;

int identity(int i)
{
   return i;
}
count_if(make_sequence_iterator<int>(identity, a), make_sequence_iterator<int>(identity, b), isPrime); …

我想从迭代器中收集一些项目，然后迭代其余的项目，如下所示：

let iterator = text.split_whitespace();
let first_ten_words = iterator.take(10).collect();

for word in iterator {
    // This should iterate over the remaining words.
}

这不起作用，因为take()消耗了迭代器。

显然我可以使用split_whitespace()两次，skip(10)但我认为这会将前 10 个单词分割两次，因此效率很低。

有更好的方法吗？

迭代器与迭代器相同还是不同？

从规范来看，iterable似乎是一个对象，obj例如，obj[Symbol.iterator]引用一个函数，以便在调用时返回一个具有next可以返回{value: ___, done: ___}对象的方法的对象：

function foo() {
    let i = 0;
    const wah = {
        next: function() {
            if (i <= 2) return { value: (1 + 2 * i++), done: false }
            else return { value: undefined, done: true }
        }
    };
    return wah;     // wah is iterator
}

let bar = {}        // bar is iterable

bar[Symbol.iterator] = foo;

console.log([...bar]);             // [1, 3, 5]   
for (a of bar) …

就个人而言,我发现java.util.Iterator提供的功能范围相当可怜.至少,我想要的方法如下:

• peek()返回下一个元素而不向前移动迭代器
• previous()返回前一个元素

虽然有很多其他的可能性,比如first()和last().

有谁知道这样的第三方迭代器是否存在？它可能需要作为java.util.Iterator的装饰器实现,以便它可以使用现有的Java集合.理想情况下,它应该是"泛型意识".

唐先生,提前谢谢

我手动将Java转换为C#并具有以下代码:

for (Iterator<SGroup> theSGroupIterator = SGroup.getSGroupIterator();
     theSGroupIterator.hasNext();)
{
    SGroup nextSGroup = theSGroupIterator.next();
}

是否有相当于Iterator<T>C#或有更好的C#成语？

在示例代码中,我经常看到代码,例如*it++输出迭代器.表达式*it++复制it,递增it,然后返回最终解除引用的副本.据我了解,制作输出迭代器的副本会使源无效.但是it,在创建副本之后执行的增量将是非法的,对吧？我对输出迭代器的理解有缺陷吗？

我有疯狂的大目录.我需要通过python获取文件列表.

在代码中我需要获取迭代器,而不是列表.所以这不起作用:

os.listdir
glob.glob  (uses listdir!)
os.walk

我找不到任何好的lib.救命!也许c ++ lib？

我正在寻找一种在Python中执行此操作的简洁方法:

假设我有两个迭代器"iter1"和"iter2":也许是一个素数生成器和itertools.count().我先验地知道两者都是无限的并且单调递增.现在我想利用有两个参数的一些操作简单的"OP"(也许operator.add或operator.mul),并计算出每个元素的第一个迭代器与每一个元素的下一个,采用上述操作,则产生逐一时间,排序.显然,这本身就是一个无限的序列.(正如@RyanThompson在评论中所提到的:这将被称为这些序列的笛卡尔积 ...或者更准确地说,是该产品的第1类.)

什么是最好的方式:

• 总结"iter1","iter2"和"op"在一个迭代中,它本身产生单调增加输出的值.

允许的简化假设:

• 如果有帮助,我们可以假设op(a,b)> = a和op(a,b)> = b.
• 如果它有帮助,我们可以假设所有b> c的op(a,b)> op(a,c).

也允许:

• 同样可以接受的是迭代器以"通常增加"的顺序产生值......我的意思是迭代可能偶尔给我一个小于前一个的数字,但它会以某种方式使"辅助信息"可用(如通过这个对象的方法会说"我不会保证我给你的下一个值会比我给你的那个更大,但我确定所有未来的值至少都会比N更大.".. ..和"N"本身是单调增加的.

我能想到这样做的唯一方法是一种"对角化"过程,在这种过程中,我保留了越来越多的部分处理的迭代,并且"向前看"所有可能的next()值的最小值,并产生.但是,即使在我开始对它进行编码之前,这种古怪的聚集和一堆deques似乎都是异乎寻常的.

请:那不是立足于事实,我的例子中提到的质数或计数()你的答案....我对这个非常的概念,不相关的素数和计算多种用途().

更新:天啊!多么棒的讨论!并通过非常彻底的解释得到一些很好的答案.非常感谢.StackOverflow摇滚; 你们好棒.

我将尽快深入研究每个答案,并给出示例代码.从我到目前为止所读到的内容来看,我最初的怀疑是确认没有"简单的Python成语"来做到这一点.相反,通过这种或那种方式,我无法避免无限期地保持iter1和iter2的所有产生的值.

FWIW:如果你想尝试你的解决方案,这是一个官方的"测试案例".

import operator

def powers_of_ten():
    n = 0
    while True:
        yield 10**n
        n += 1

def series_of_nines():
    yield 1
    n = 1
    while True:
        yield int("9"*n)
        n += 1

op = operator.mul
iter1 = powers_of_ten()
iter2 = series_of_nines()

# given (iter1, iter2, op), create an iterator that yields:
# [1, …

如果我有一个包含字符串的iterable,是否有一种简单的方法可以将其转换为流？我想做这样的事情:

def make_file():
    yield "hello\n"
    yield "world\n"

output = tarfile.TarFile(…)
stream = iterable_to_stream(make_file())
output.addfile(…, stream)