标签: iterator

反正有没有让python列表迭代器倒退？

基本上我有这个

class IterTest(object):
    def __init__(self, data):
        self.data = data
        self.__iter = None

    def all(self):
        self.__iter = iter(self.data)
        for each in self.__iter:
            mtd = getattr(self, type(each).__name__)
            mtd(each)

    def str(self, item):
        print item

        next = self.__iter.next()
        while isinstance(next, int):
            print next
            next = self.__iter.next()

    def int(self, item):
        print "Crap i skipped C"

if __name__ == '__main__':
    test = IterTest(['a', 1, 2,3,'c', 17])
    test.all()

运行此代码会产生输出:

a
1
2
3
Crap i skipped C

我知道为什么它给了我输出,但是有一种方法我可以在str()方法中向后退一步吗？

编辑

好吧也许可以让这个更清楚.我不想做完全反向,基本上我想知道是否有一种简单的方法在python中做相当于双向迭代器？

我有三个collection.deques,我需要做的是迭代它们并执行相同的操作:

for obj in deque1:  
    some_action(obj)  

for obj in deque2:  
    some_action(obj)

for obj in deque3:  
    some_action(obj)

我正在寻找一些功能XXX,理想情况下我可以写:

for obj in XXX(deque1, deque2, deque3):  
    some_action(obj)

这里重要的是XXX必须足够高效 - 没有复制或静默使用range()等.我期望在内置函数中找到它,但到目前为止我没有发现任何类似的东西.

Python中是否已有这样的东西,或者我必须自己编写一个函数？

我正在尝试在地图中创建地图:

typedef map<float,mytype> inner_map;
typedef map<float,inner_map> outer_map;

我能在内部地图中放置一些东西,或者iterator :: second会返回一个副本吗？

stl_pair.h建议后者:

74: _T2 second;          ///< @c second is a copy of the second object

但我的测试程序运行正常,代码如下:

it = my_map.lower_bound(3.1415);
(*it).second.insert(inner_map::value_type(2.71828,"Hello world!");

那真相在哪里？这是副本吗？

关于迭代器失效规则的这个问题,很明显标准的精神意味着,例如"deque中间的擦除使所有迭代器无效并且对deque元素的引用"也指最终迭代器.

但是,我无法找到标准使其明确的任何地方,严格来说,结束迭代器不是容器中元素的迭代器.

2003年的标准是否明确了这一点？

可能重复:
javascript >>>运营商？
JavaScript三倍大于

在这样的代码行中找到了这个运算符:

var t = Object(this),
        len = t.length >>> 0;

这个算子是什么意思？

完整代码如下.它是JS some方法的代码:

if (!Array.prototype.some) {
  Array.prototype.some = function(fun /*, thisp */) {
    "use strict";

    if (this == null) throw new TypeError();

    var t = Object(this),
        len = t.length >>> 0;

    if (typeof fun != "function") throw new TypeError();

    var thisp = arguments[1];

    for (var i = 0; i < len; i++) {
      if (i in t && fun.call(thisp, t[i], i, t))
        return true;
    } …

我有两个清单,让我们说:

keys1 = ['A', 'B', 'C', 'D', 'E',           'H', 'I']
keys2 = ['A', 'B',           'E', 'F', 'G', 'H',      'J', 'K']

如何创建没有重复项的合并列表,以保留两个列表的顺序,将缺少的元素插入它们所属的位置？像这样:

merged = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']

请注意,可以将元素与相等进行比较,但不进行排序(它们是复杂的字符串).这些元素不能通过比较来排序,但它们的顺序基于它们在原始列表中的出现次数.

如果出现矛盾(两个输入列表中的顺序不同),则包含所有元素的任何输出都是有效的.当然,如果解决方案在保留大部分订单时显示"常识",则可获得奖励积分.

再次(正如一些评论仍然争论它),列表通常不会在共同元素的顺序上相互矛盾.如果他们这样做,算法需要优雅地处理该错误.

我开始使用.next()遍历列表的版本,以推进包含不匹配元素的列表,但.next()只是不知道何时停止.

merged = []
L = iter(keys1)
H = iter(keys2)
l = L.next()
h = H.next()

for i in range(max(len(keys1, keys2))):
  if l == h:
    if l not in merged:
      merged.append(l)
    l = L.next()
    h = H.next()

  elif l not in keys2:
    if …

错误如下:

请求'arr'中的成员'begin','end'是非类型int [5],无法从表达式错误中推断出来.

我的代码:

#include <iostream>
using namespace std;

int main()
{
    int * mypointer;

    int arr[5] = {1,3,5,7,9};

    mypointer = arr;

    for(auto it = arr.begin(); it != arr.end(); ++it) {
        cout<<*mypointer<<endl;

        mypointer++;
    }

    return 0;
}

根据Eric Lippert的说法,匿名迭代器没有被添加到语言中,因为实现它会过于复杂.

这对我来说没关系,在他们继续实施匿名异步方法之前,它并没有打扰我.编译器必须对异步方法执行与迭代器相同的操作(将它们转换为状态机),所以我很困惑为什么匿名迭代器也不允许,当匿名异步方法时.

有人可以对此有所了解吗？

我有以下代码:

extern crate rand;

use rand::{thread_rng, Rng};

fn main() {
    let mut vec: Vec<u32> = (0..10).collect();
    let mut slice: &[u32] = vec.as_mut_slice();

    thread_rng().shuffle(slice);
}

并得到以下错误:

error[E0308]: mismatched types
 --> src/main.rs:9:26
  |
9 |     thread_rng().shuffle(slice);
  |                          ^^^^^ types differ in mutability
  |
  = note: expected type `&mut [_]`
             found type `&[u32]`

我想我明白向量和切片的内容是不可变的,这会导致错误,但我不确定.

签名as_mut_slice是pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T],所以切片应该是可变的,但它不知何故.

我知道必须有一个简单的解决办法,但我尽我所能,无法让它发挥作用.

我想要这样的东西:

fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> ??? {
    input.iter().filter(|&x| x == Int::one())
}

该函数的返回类型是什么？(我想要返回Iterator)

(我希望这不是太明显,我现在已经尝试了半个小时而且开始感到沮丧:p)

编辑:

我试着按照这里 =>游戏围栏链接的说明操作

编译器给我以下错误:

<anon>:5:1: 7:2 error: the trait `core::kinds::Sized` is not implemented for the type `for<'r> core::ops::Fn(&'r T) -> bool + 'a`
<anon>:5 fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> Filter<&T, Iter<'a, T>, Fn(&T) -> bool>{
<anon>:6     input.iter().filter(|&x| x == Int::one())
<anon>:7 }
<anon>:5:1: 7:2 note: required by `core::iter::Filter`
<anon>:5 fn filter_one<'a, T: Int>(input: &'a Vec<T>) -> Filter<&T, Iter<'a, …