标签: iterator

next_permutation是一个C++函数,它按字典顺序给出字符串的下一个排列.有关其实现的详细信息可以从这个非常棒的帖子中获得.http://wordaligned.org/articles/next-permutation

1. 有人知道Python中的类似实现吗？
2. STL迭代器是否有直接的python等价物？

我有一个简单的方法,使用迭代器块返回IEnumerable<T>:

IEnumerable<MyItem> GetItems()
{
    foreach (var item in Items)
    {
        yield return item;
    }
}

通常,此方法工作正常,但如果我将一个[SecurityCritical]属性应用于程序集(或包含上述方法的类),它会TypeLoadException在尝试调用该方法时抛出一个.无法加载的类型是编译器生成的类,它对应于迭代器方法,它GetEnumerator是导致问题的方法,因为它是安全透明的.

为了比较,如果我修改上面的方法,使其填充并返回a List<MyItem>,一切正常.

有什么建议？

谢谢,

蒂姆.

我试图使用mimetypes模块基于MIME类型的第一部分获取文件扩展名列表.例如.'image'是'image/jpeg','image/png'等的第一部分.

这是我的代码:

import mimetypes

def get_extensions_for_type(general_type):
    for ext in mimetypes.types_map:
        if mimetypes.types_map[ext].split('/')[0] == general_type:
            yield ext

VIDEO = tuple(get_extensions_for_type('video'))
AUDIO = tuple(get_extensions_for_type('audio'))
IMAGE = tuple(get_extensions_for_type('image'))

print("VIDEO = " + str(VIDEO))
print('')
print("AUDIO = " + str(AUDIO))
print('')
print("IMAGE = " + str(IMAGE))

这是输出:

VIDEO = ('.m1v', '.mpeg', '.mov', '.qt', '.mpa', '.mpg', '.mpe', '.avi', '.movie', '.mp4')

AUDIO = ('.ra', '.aif', '.aiff', '.aifc', '.wav', '.au', '.snd', '.mp3', '.mp2')

IMAGE = ('.ras', '.xwd', '.bmp', '.jpe', '.jpg', '.jpeg', '.xpm', '.ief', '.pbm', '.tif', '.gif', '.ppm', …

我遍历一个列表并删除满足我条件的元素.但是,为什么这不起作用,如下所述？谢谢.

>>> a=[ i for i in range(4)]
>>> a
[0, 1, 2, 3]
>>> for e in a:
...     if (e > 1) and (e < 4):
...         a.remove(e)
... 
>>> a
[0, 1, 3]
>>> a=[ i for i in range(4)]
>>> for e in a:
...     if (e > -1) and (e < 3):
...         a.remove(e)
... 
>>> a
[1, 3]

我一直在研究boost :: multi_array库,寻找一个迭代器,它允许你在一个for循环中遍历整个 multi_array.

我不认为该库中有任何这样的迭代器.(在那里找到的迭代器允许您遍历multi_array的单个维度)

我错了吗？
如果没有,是否有任何库定义这样的迭代器？

进入细节,我想写一些类似的东西:

boost::multi_array< double, 3 > ma(boost::extents[3][4][2]);  

for( my_iterator it = ma.begin(); it != ma.end(); ++it )  
{  
    // do something  
    // here *it has element type (in this case double)  
}  

并获得一个重复3x4x2次的循环

假设我有一些Python代码,如下所示:

input = open("input.txt")
x = (process_line(line) for line in input)
y = (process_item(item) for item in x)
z = (generate_output_line(item) + "\n" for item in y)
output = open("output.txt", "w")
output.writelines(z)

此代码从输入文件中读取每一行,通过多个函数运行它,并将输出写入输出文件.现在我知道函数process_line,process_item并且generate_output_line永远不会相互干扰,让我们假设输入和输出文件位于不同的磁盘上,这样读写就不会相互干扰.

但Python可能不知道这些.我的理解是Python将读取一行,依次应用每个函数,并将结果写入输出,然后只有在将第一行发送到输出后才会读取第二行,这样第二行就不会进入管道直到第一个退出.我是否正确理解该程序将如何流动？如果这是它的工作方式,是否有任何简单的方法可以使多个行同时在管道中,以便程序并行读取,写入和处理每个步骤？

我承认我很难找到合理的描述.我想不出一个能够准确描述我正在寻找什么的好词.也许这可以称为切片迭代器.

假设我有这样的事情:

struct S
{
    int i;
    char *s;
    float f;
};

std::vector<S> v(10);

我正在寻找的是一种构造迭代器的方法,它将指向一个成员S.我希望能够将它传递给类似于std::min_element在每种情况下都不创建谓词的东西.可能看起来像这样的东西:

std::min_element(slicing_iterator(v.begin(), S::f), slicing_iterator(v.end(), S::f));

有没有我可以用来实现这个的模板技巧？或许它已经在Boost或其他一些图书馆的某个地方完成了？

我有一个包含一些数据的类,我想添加begin()和end()提供迭代器的数据ID.

我正在使用Boost counting_iterator:

#include <iostream>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/iterator/counting_iterator.hpp>

template<class T>   
class ContainerTpl {
 public:
  typedef std::size_t Id;
  typedef boost::counting_iterator<Id> const_iterator;
  ContainerTpl() {}
  const_iterator begin() {
    return boost::counting_iterator<Id>(0);
  }
  const_iterator end() {
    return boost::counting_iterator<Id>(container_.size());
  }
 private:
  std::vector<T> container_;
};

int main () {
  typedef ContainerTpl<double> Container;
  Container c;
  BOOST_FOREACH (Container::Id cid, c) {
    std::cerr << cid << std::endl;
  }
  return 0;
}

请注意,这是最小的示例代码; 现实中的类包含更多的功能,因此,例如,typedef到vector是不够的.我真的需要那个类,带有ID的迭代器.

不幸的是,上面的代码给了我非常讨厌的编译器错误:

In file included from …

请你好 - 这是我的第一个问题.= P

基本上作为夏季项目,我一直在浏览维基百科页面上的数据结构列表并尝试实现它们.我上学期参加了C++课程并发现它非常有趣,作为我实施二项式堆的最终项目 - 这也非常有趣.也许我很讨厌,但我喜欢数据结构.

无论如何,足够的背景故事.项目进展顺利,我从二叉树开始.为了更进一步,我需要创建迭代器来遍历树.我已经决定为每个遍历方法(常规迭代器和常量迭代器)创建两种类型的迭代器,我只是不知道如何做到这一点.我听说过从stl的迭代器继承,甚至使用boosts iterator_facade(这似乎是个不错的选择)

我还没有尝试编写迭代器代码,因为我不知道从哪里开始,但我确实在github上有我当前的代码.你可以在这里查看.

如果你反对github,我会粘贴相关的类定义.这些功能的实现实际上没有任何帮助,但如果您出于某种原因需要它们,请告诉我.此外,节点类具有用于迭代目的的父指针.

#ifndef __TREES_HXX
#define __TREES_HXX
#include <cstdlib>  // For NULL
#include <algorithm> // for std::max

// Node class definition. These nodes are to be used for any
// tree where the structure is
//    node
//     /\
// left  right
//  /\    /\
//
// etc., basically two children.
template <typename T>
class Node
{
  public:
    T data_;
    Node<T>* left_;
    Node<T>* right_;
    Node<T>* parent_; // Needed …

我有Iterator[(A1,B1)]两个功能

• fA: (Iterator[A1]) => Iterator[A2] 和
• fB: (Iterator[B1]) => Iterator[B2].

是否有可能在fAB: (Iterator[(A1,B1)]) => Iterator[(A2,B2)]没有将迭代器转换为Seq 的情况下进行转换？

编辑

以下两个答案都很好.我选择了@ Aivean的答案,因为代码更简单,它使用专门的scala数据结构(Stream).

唯一的缺点是stackoverfow限制,但对于大多数用例来说它应该不是问题.如果你的迭代器非常(非常)长,那么@ Alexey的解决方案应该是首选的.