标签: iterator

我有一个map元素的迭代器,我希望gdb向我展示迭代器的"first"和"second"元素的值.例如:

std::map<int,double> aMap;
...fill map...
std::map<int,double>::const_iterator p = aMap.begin();

我可以在代码中使用p.first和p.second,但是在gdb中看不到它们.对于它的价值,在dbx中可以执行类似"print p.node.second_"的操作,但我可以在gbd中找到类似的东西.

我完全愿意有一个函数,我传递对象类型,但我也无法让它工作.

有任何想法吗？谢谢!

基本上我希望能够在循环迭代中告诉我何时在第N个项目上.有什么想法吗？

d = {1:2, 3:4, 5:6, 7:8, 9:0}

for x in d:
    if last item: # <-- this line is psuedo code
        print "last item :", x
    else:
        print x

我已经在Python工作了几个月了,我发现我经常忽略乍看之下逃避我的词汇,而不是试图获得一个想法的要点.现在,回顾过去,我仍然发现自己对于消费这个术语所指的内容感到困惑.我最初的兴趣来自迭代器的解释,它说明了迭代器的消耗价值.但是,环顾四周,这在Python词典中似乎并不常见.或者是吗？在这里挖掘主要是对Web服务的引用,以及关于如何隐藏这个或那个函数结果的一两个讨论.

我想那时,把我的无知分解为几个基点:

1. "消费"在不同的Pythonic环境中做不同的事情吗？
2. 数据被消耗时会发生什么,例如iter()？
3. 当一个变量被赋给迭代器的结果 - 所谓的消耗的数据 - 它不再属于迭代器吗？
4. 在对迭代器的单次调用中,您是否可以从迭代器对象中使用多个值？

我希望这有点道理.请注意,这不涉及任何特定需要; 我只是混淆了理性的合理性.

编辑:还有一件事......迭代值(当被调用时next())会留在内存中吗？

我已经看到一些帖子推荐isinstance(obj, collections.Sequence)而不是hasattr(obj, '__iter__')确定某些内容是否是列表.

len(object)或hasattr(object,__iter__)？

Python:检查对象是否是序列

起初我很兴奋,因为测试一个物体__iter__对我来说总是很脏.但经过进一步审查后,这似乎仍然是最好的解决方案,因为没有一个isinstance测试collection产生相同的结果.collections.Sequence是接近但它返回True字符串.

hasattr(obj, '__iter__')
    set([]): True
    {}: True
    []: True
    'str': False
    1: False

isinstance(obj, collections.Iterable)
    set([]): True
    {}: True
    []: True
    'str': True
    1: False

isinstance(obj, collections.Iterator)
    set([]): False
    {}: False
    []: False
    'str': False
    1: False

isinstance(obj, collections.Sequence)
    set([]): False
    {}: False
    []: True
    'str': True
    1: False

这是我用来生成这个的代码:

import collections

testObjs = [
    set(),
    dict(),
    list(),
    'str',
    1
] …

有人知道如何在Java中加入多个迭代器吗？我发现的解决方案首先迭代一个迭代器,然后继续下一个迭代器.但是,我想要的是当next()被调用时,它首先返回第一个迭代器中的第一个元素.下次调用next()时,它将返回第二个迭代器中的第一个元素,依此类推.

谢谢

C++标准库的max_element算法需要将迭代器作为模型的输入传递ForwardIterator.

我的理解是通过指定您可以使用a 多次迭代相同的范围来ForwardIterator提炼.因此,多遍算法需要s.InputIteratorForwardIteratorForwardIterator

但是,max_element不是多遍算法 - 只需迭代一次范围就可以确定其最大元素.那么为什么max_element需要额外的功能ForwardIterator呢？

我试图了解如何迭代实现的哈希表.我无法想象它.我对这种迭代的速度特别感兴趣.例如:

QHash<int, std::string> hashTable;
...
for (auto it = hashTable.begin(); it != hashTable.end(); ++it)
    std::cout << it.value() << std::endl;

这是一个O(hashTable.size())手术吗？

我试图挖掘源代码,但找不到合适的定义.

我正在使用Python 2.7.3.

考虑一个带有自定义(虽然很糟糕)迭代和项目获取行为的虚拟类:

class FooList(list):
    def __iter__(self):
        return iter(self)
    def next(self):
        return 3
    def __getitem__(self, idx):
        return 3

举个例子,看看奇怪的行为:

>>> zz = FooList([1,2,3])

>>> [x for x in zz]
# Hangs because of the self-reference in `__iter__`.

>>> zz[0]
3

>>> zz[1]
3

但现在,让我们创建一个函数,然后执行参数解包zz:

def add3(a, b, c):
    return a + b + c

>>> add3(*zz)
6
# I expected either 9 or for the interpreter to hang like the comprehension!

因此,参数解包以某种方式获取项数据,zz但不是通过使用其实现的迭代器迭代对象,也不是通过执行穷人的迭代器并调用__getitem__与对象一样多的项.

所以问题是:如果不通过这些方法,语法如何add3(*zz) …

在ES6中,我们现在有迭代器和for..of来迭代它们.我们有一些数组内置函数 ; 特别是键,值和条目.

这些方法允许人们执行通常执行的大部分迭代.但是,反向迭代怎么样？这也是一个非常常见的任务,我没有在规范中看到任何具体的内容吗？或许我错过了？

好的,我们有Array.prototype.reverse但是我不一定想要在适当的位置反转大型数组,然后在完成时再次反转它.我也不想使用Array.prototype.slice来制作一个临时的浅拷贝并反转那个迭代.

所以我看了一下发电机并提出了这些有效的解决方案.

(function() {
  'use strict';

  function* reverseKeys(arr) {
    let key = arr.length - 1;

    while (key >= 0) {
      yield key;
      key -= 1;
    }
  }

  function* reverseValues(arr) {
    for (let key of reverseKeys(arr)) {
      yield arr[key];
    }
  }

  function* reverseEntries(arr) {
    for (let key of reverseKeys(arr)) {
      yield [key, arr[key]];
    }
  }

  var …

对于python dict,我可以使用iteritems()同时循环键和值.但我找不到NumPy阵列的这种功能.我必须idx像这样手动跟踪:

idx = 0 
for j in theta:
   some_function(idx,j,theta)
   idx += 1

有一个更好的方法吗？