标签: iterator

该java.lang.Iterator接口有3种方法:hasNext,next和remove.为了实现只读迭代器,您必须为其中的两个提供实现:hasNext和next.

我的问题是这些方法没有声明任何异常.因此,如果我在迭代过程中的代码声明异常,我必须将我的迭代代码包含在try/catch块中.

我目前的政策是重新抛出a中的例外情况RuntimeException.但这有问题,因为已检查的异常会丢失,客户端代码不再能明确捕获这些异常.

我如何在Iterator类中解决这个限制？

为清晰起见,这是一个示例代码:

class MyIterator implements Iterator
{
    @Override
    public boolean hasNext()
    {
        try
        {
            return implementation.testForNext();
        }
        catch ( SomethingBadException e ) 
        {
            throw new RuntimeException(e);
        }
    }

    @Override
    public boolean next()
    {
        try
        {
            return implementation.getNext();
        }

        catch ( SomethingBadException e ) 
        {
            throw new RuntimeException(e);
        }
    }

    ...
}

我有一个生成器(数字)和一个值(数字).我想迭代这些,好像它们是一个序列:

i for i in tuple(my_generator) + (my_value,)

问题是,据我所知,这会创建3个元组,只是立即丢弃它们,并且还会复制"my_generator"中的项目一次.

更好的approch将是:

def con(seq, item):
    for i in seq:
        yield seq
    yield item

i for i in con(my_generator, my_value)

但我想知道没有那个函数定义是否可以做到这一点

在Ruby中,我没有多次重复"require"(Python中的"import")字

%w{lib1 lib2 lib3 lib4 lib5}.each { |x| require x }

因此,它遍历"libs"和"require"(导入)它们中的每一个.现在我正在编写一个Python脚本,我想做类似的事情.有没有办法,或者我需要为所有人写"导入".

直接的"traduction"将类似于以下代码.无论如何,因为Python不会导入名为字符串的库,所以它不起作用.

requirements = [lib1, lib2, lib3, lib4, lib5]
for lib in requirements:
    import lib

提前致谢

在许多语言中,我们可以做类似的事情:

for (int i = 0; i < value; i++)
{
    if (condition)
    {
        i += 10;
    }
}

我怎样才能在Python中做同样的事情？以下(当然)不起作用:

for i in xrange(value):
    if condition:
        i += 10

我可以这样做:

i = 0
while i < value:
  if condition:
    i += 10
  i += 1

但我想知道在Python中是否有更优雅(pythonic？)的方式.

可以/我应该从STL迭代器继承来实现我自己的迭代器类吗？如果不是,为什么不呢？

如果我有一个迭代器并且我想检查最后一个值,我该如何检查它？喜欢

private Set<String> saarcCountries = new TreeSet<String>();
Iterator iter = saarcCountries.iterator();

while(iter.hasNext()) {

    String name = (String)iter.next();
    int countryId = Integer.parseInt(name);

    newsOrAnnouncementInsert.add(newsId);
    newsOrAnnouncementInsert.add(countryId);
    newsOrAnnouncementInsert.add(1);            //addby

    if (!(last value in iterator))) {
        newsOrAnnouncementInsert.add("~!~");//Delimiter for Multiple Detail Records
    }//end if

} //end of while

我该如何检查最后一个值.什么应该替换迭代器中的最后一个值？

我们都知道,在迭代它时从集合中删除对象的最安全的"可能只是安全的"方法是首先检索Iterator,执行循环并在需要时删除;

Iterator iter=Collection.iterator();
while(iter.hasNext()){
    Object o=iter.next()
    if(o.equals(what i'm looking for)){
        iter.remove();
    }
}

我想要了解的,并且遗憾的是没有找到深入的技术解释,是如何执行此删除,
如果:

for(Object o:myCollection().getObjects()){
    if(o.equals(what i'm looking for)){
        myCollection.remove(o);
    }
}

抛出一个ConcurrentModificationException,"技术术语" Iterator.remove()做什么？它会删除对象,打破循环并重新启动循环吗？

我在官方文档中看到:

"删除当前元素.IllegalStateException如果尝试调用remove()之前没有调用next(),则抛出."

部分"删除当前元素",让我想到在"常规"循环中发生的完全相同的情况=>(执行相等性测试并在需要时删除),但为什么Iterator循环ConcurrentModification安全？

给出列表的字典,例如

d = {'1':[11,12], '2':[21,21]}

哪个更pythonic或更好:

for k in d:
    for x in d[k]:
        # whatever with k, x

要么

for k, dk in d.iteritems():
    for x in dk:
        # whatever with k, x

还是还有别的东西需要考虑？

编辑,如果列表可能有用(例如,标准dicts不保留顺序),这可能是合适的,尽管它要慢得多.

d2 = d.items()
for k in d2:
        for x in d2[1]:
            # whatever with k, x

如果我理解正确,请将a=std::move(b)参考a绑定到b的地址.并且在此操作之后,b指向的内容不能得到保证.

move_iterator 这里的实现有这条线

auto operator[](difference_type n) const -> decltype(std::move(current[n]))
  { return std::move(current[n]); }

但是,我认为std::move数组中的元素没有意义.如果会发生什么a=std::move(b[n])？

以下示例也让我困惑:

std::string concat = std::accumulate(
                             std::move_iterator<iter_t>(source.begin()),
                             std::move_iterator<iter_t>(source.end()),
                             std::string("1234"));

由于concatwill本身会分配一个连续的内存块来存储结果,因此不会有任何重叠source.数据source将被复制到concat但不移动.

我正在generate()和generate_n()cppreference 一起看,并试图理解为什么generate()需要ForwardIterator,而generate_n()需要OutputIterator范围？(我检查了标准的最新工作草案,这是相同的要求.)

因为,至少他们可能的实现似乎需要相同的迭代器概念,OutputIterator似乎就足够了:

generate():

template<class ForwardIt, class Generator>
void generate(ForwardIt first, ForwardIt last, Generator g)
{
    while (first != last) {
        *first++ = g();
    }
}

generate_n():

template<class OutputIt, class Size, class Generator>
OutputIt generate_n(OutputIt first, Size count, Generator g)
{
    for (Size i = 0; i < count; i++) {
        *first++ = g();
    }
    return first;
}

与std::fill()和相同的故事std::fill_n().