javascript

git

java

python

loops

github

django

c#

reactjs

git-remote

scope

jquery

iteration

namespaces

using-directives

file-io

iterator

yield

spring

annotations

锈-如何为一个简单的结构实现Iterator和IntoIterator?

有人将如何为以下结构实现IteratorIntoIterator特征?

struct Pixel {
    r: i8,
    g: i8,
    b: i8,
}

我尝试了以下各种形式的尝试,但均未成功。

impl IntoIterator for Pixel {
    type Item = i8;
    type IntoIter = Iterator<Item=Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        [&self.r, &self.b, &self.g].into_iter()
    }
}

这段代码给我一个编译错误

error[E0277]: the trait bound `std::iter::Iterator<Item=i8> + 'static: std::marker::Sized` is not satisfied
 --> src/main.rs:7:6
  |
7 | impl IntoIterator for Pixel {
  |      ^^^^^^^^^^^^ the trait `std::marker::Sized` is not implemented for `std::iter::Iterator<Item=i8> + 'static`
  |
  = note: `std::iter::Iterator<Item=i8> + 'static` does not have a constant size known at compile-time
  = note: required by `std::iter::IntoIterator`
trans by 2020-08-11T03:40:09Z

C#:foreach中的收益返回失败-主体不能为迭代器b

考虑一下这段混淆的代码。 目的是通过匿名构造函数动态创建一个新对象,然后yield return对其进行创建。 目的是避免仅维护return就不必维护本地集合。

public static List<DesktopComputer> BuildComputerAssets()
{           
    List<string> idTags = GetComputerIdTags();

    foreach (var pcTag in idTags)
    {
        yield return new DesktopComputer() {AssetTag= pcTag
                                          , Description = "PC " + pcTag
                                          , AcquireDate = DateTime.Now
                                           };
    }            
}

不幸的是,这段代码产生了一个异常:

错误28'Foo.BuildComputerAssets()'的正文不能是迭代器块,因为'System.Collections.Generic.List'不是迭代器接口类型

问题

  • 此错误消息是什么意思?
  • 如何避免此错误并正确使用yield return
trans by 2020-08-11T01:42:51Z

是否可以在Java中合并迭代器?

是否可以在Java中合并迭代器? 我有两个迭代器,我想合并/合并它们,以便我可以一次遍历它们的元素(在同一循环中)而不是两步。 那可能吗?

请注意,两个列表中的元素数量可以不同,因此无法解决两个列表中的一个循环问题。

Iterator<User> pUsers = userService.getPrimaryUsersInGroup(group.getId());
Iterator<User> sUsers = userService.getSecondaryUsersInGroup(group.getId());

while(pUsers.hasNext()) {
  User user = pUsers.next();
  .....
}

while(sUsers.hasNext()) {
  User user = sUsers.next();
  .....
}
trans by 2020-08-06T20:48:08Z

Python for循环和迭代器行为

我想了解更多有关for的信息,所以如果我错了,请纠正我。

迭代器是一个对象,该对象具有指向下一个对象的指针,并作为缓冲区或流(即链表)读取。 它们特别有效,因为它们所做的只是通过引用而不是使用索引来告诉您下一步是什么。

但是我仍然不明白为什么会发生以下行为:

In [1]: iter = (i for i in range(5))

In [2]: for _ in iter:
   ....:     print _
   ....:     
0
1
2
3
4

In [3]: for _ in iter:
   ....:     print _
   ....:     

In [4]: 

在遍历迭代器(for)的第一个循环之后,就好像它已被消耗并留空,因此第二个循环(In [3])不打印任何内容。

但是,我从未为for变量分配新值。

for循环的幕后到底发生了什么?

trans by 2020-08-06T10:04:17Z

如何删除const_iterator的常数?

作为此问题的扩展,const_iterator更快吗?我在const_iterator上还有另一个问题。如何删除const_iterator的常数?尽管迭代器是指针的通用形式,但const_iteratoriterator还是两回事。 因此,我相信,我也无法使用const_cast<>const_iterator转换为iterator

一种方法是定义一个迭代器,该迭代器将移动直到const_iterator指向的元素。 但这似乎是线性时间算法。

关于实现此目标的最佳方法的任何想法?

trans by 2020-08-05T11:58:15Z

在Python文件obj上使用迭代器时是否需要close()

这个问题已经在这里有了答案:

  • 明确关闭文件重要吗? 6个答案

是否执行以下操作并且不显式处理文件对象并调用其close()方法是不好的做法吗?

for line in open('hello.txt'):
    print line

注意:这是针对尚没有with语句的Python版本。

我问,因为Python文档似乎建议这样做:

f = open("hello.txt")
try:
    for line in f:
        print line
finally:
    f.close()

这似乎比必要的更为冗长。

trans by 2020-08-04T23:19:01Z

如何使用Python C API创建生成器/迭代器?

如何使用Python C API复制以下Python代码?

class Sequence():
    def __init__(self, max):
        self.max = max
    def data(self):
        i = 0
        while i < self.max:
            yield i
            i += 1

到目前为止,我有这个:

#include <Python/Python.h>
#include <Python/structmember.h>

/* Define a new object class, Sequence. */
typedef struct {
    PyObject_HEAD
    size_t max;
} SequenceObject;

/* Instance variables */
static PyMemberDef Sequence_members[] = {
    {"max", T_UINT, offsetof(SequenceObject, max), 0, NULL},
    {NULL} /* Sentinel */
};

static int Sequence_Init(SequenceObject *self, PyObject *args, PyObject *kwds)
{
    if (!PyArg_ParseTuple(args, "k", &(self->max))) {
        return -1;
    }
    return 0;
}

static PyObject *Sequence_data(SequenceObject *self, PyObject *args);

/* Methods */
static PyMethodDef Sequence_methods[] = {
    {"data", (PyCFunction)Sequence_data, METH_NOARGS,
     "sequence.data() -> iterator object\n"
     "Returns iterator of range [0, sequence.max)."},
    {NULL} /* Sentinel */
};

/* Define new object type */
PyTypeObject Sequence_Type = {
   PyObject_HEAD_INIT(NULL)
   0,                         /* ob_size */
   "Sequence",                /* tp_name */
   sizeof(SequenceObject),    /* tp_basicsize */
   0,                         /* tp_itemsize */
   0,                         /* tp_dealloc */
   0,                         /* tp_print */
   0,                         /* tp_getattr */
   0,                         /* tp_setattr */
   0,                         /* tp_compare */
   0,                         /* tp_repr */
   0,                         /* tp_as_number */
   0,                         /* tp_as_sequence */
   0,                         /* tp_as_mapping */
   0,                         /* tp_hash */
   0,                         /* tp_call */
   0,                         /* tp_str */
   0,                         /* tp_getattro */
   0,                         /* tp_setattro */
   0,                         /* tp_as_buffer */
   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags*/
   "Test generator object",   /* tp_doc */
   0,                         /* tp_traverse */
   0,                         /* tp_clear */
   0,                         /* tp_richcompare */
   0,                         /* tp_weaklistoffset */
   0,                         /* tp_iter */
   0,                         /* tp_iternext */
   0,                         /* tp_methods */
   Sequence_members,          /* tp_members */
   0,                         /* tp_getset */
   0,                         /* tp_base */
   0,                         /* tp_dict */
   0,                         /* tp_descr_get */
   0,                         /* tp_descr_set */
   0,                         /* tp_dictoffset */
   (initproc)Sequence_init,   /* tp_init */
   0,                         /* tp_alloc */
   PyType_GenericNew,         /* tp_new */
};

static PyObject *Sequence_data(SequenceObject *self, PyObject *args)
{
    /* Now what? */
}

但我不确定下一步要去哪里。 有人可以提供一些建议吗?

编辑

我想我遇到的主要问题是模拟StopIteration语句。 据我了解,这是一个看起来很简单但实际上很复杂的语句-它使用自己的2994411917034390590529和2994411917034390590530方法创建了一个生成器,这些方法会自动调用。 搜索文档,它似乎与PyGenObject相关联; 但是,如何创建该对象的新实例尚不清楚。 PyGen_New()PyFrameObject作为其参数,我可以找到的唯一参考是StopIteration,这似乎不是我想要的(或者我弄错了吗?)。 有谁可以分享这些经验吗?

进一步编辑

当我(基本上)扩展Python在幕后所做的工作时,我发现这一点更加清楚:

class IterObject():
    def __init__(self, max):
        self.max = max
    def __iter__(self):
        self.i = 0
        return self
    def next(self):
        if self.i >= self.max:
            raise StopIteration
        self.i += 1
        return self.i

class Sequence():
    def __init__(self, max):
        self.max = max
    def data(self):
        return IterObject(self.max)

从技术上讲,顺序是一一完成的,但是您可以理解。

唯一的问题是,每当需要一个生成器时创建一个新对象就很烦人。由于定义新类型会带来怪异,因此在Python中使用C生成的对象比使用C生成的对象还要多。 由于C没有闭包,因此C中不能有StopIteration语句。 相反,我所做的是(因为我无法在Python API中找到它-如果已经存在,请指向一个标准对象!)是创建一个简单的通用生成器对象类,该类针对每个next()方法调用都调用一个C函数 。 在这里(请注意,我尚未尝试编译它,因为它不完整-见下文):

#include <Python/Python.h>
#include <Python/structmember.h>
#include <stdlib.h>

/* A convenient, generic generator object. */

typedef PyObject *(*callback)(PyObject *callee, void *info) PyGeneratorCallback;

typedef struct {
    PyObject HEAD
    PyGeneratorCallback callback;
    PyObject *callee;
    void *callbackInfo; /* info to be passed along to callback function. */
    bool freeInfo; /* true if |callbackInfo| should be free'()d when object
                    * dealloc's, false if not. */
} GeneratorObject;

static PyObject *Generator_iter(PyObject *self, PyObject *args)
{
    Py_INCREF(self);
    return self;
}

static PyObject *Generator_next(PyObject *self, PyObject *args)
{
    return self->callback(self->callee, self->callbackInfo);
}

static PyMethodDef Generator_methods[] = {
    {"__iter__", (PyCFunction)Generator_iter, METH_NOARGS, NULL},
    {"next", (PyCFunction)Generator_next, METH_NOARGS, NULL},
    {NULL} /* Sentinel */
};

static void Generator_dealloc(GenericEventObject *self)
{
    if (self->freeInfo && self->callbackInfo != NULL) {
        free(self->callbackInfo);
    }
    self->ob_type->tp_free((PyObject *)self);
}

PyTypeObject Generator_Type = {
   PyObject_HEAD_INIT(NULL)
   0,                         /* ob_size */
   "Generator",               /* tp_name */
   sizeof(GeneratorObject),   /* tp_basicsize */
   0,                         /* tp_itemsize */
   Generator_dealloc,         /* tp_dealloc */
   0,                         /* tp_print */
   0,                         /* tp_getattr */
   0,                         /* tp_setattr */
   0,                         /* tp_compare */
   0,                         /* tp_repr */
   0,                         /* tp_as_number */
   0,                         /* tp_as_sequence */
   0,                         /* tp_as_mapping */
   0,                         /* tp_hash */
   0,                         /* tp_call */
   0,                         /* tp_str */
   0,                         /* tp_getattro */
   0,                         /* tp_setattro */
   0,                         /* tp_as_buffer */
   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags*/
   0,                         /* tp_doc */
   0,                         /* tp_traverse */
   0,                         /* tp_clear */
   0,                         /* tp_richcompare */
   0,                         /* tp_weaklistoffset */
   0,                         /* tp_iter */
   0,                         /* tp_iternext */
   0,                         /* tp_methods */
   0,                         /* tp_members */
   0,                         /* tp_getset */
   0,                         /* tp_base */
   0,                         /* tp_dict */
   0,                         /* tp_descr_get */
   0,                         /* tp_descr_set */
   0,                         /* tp_dictoffset */
   0,                         /* tp_init */
   0,                         /* tp_alloc */
   PyType_GenericNew,         /* tp_new */
};

/* Returns a new generator object with the given callback function
 * and arguments. */
PyObject *Generator_New(PyObject *callee, void *info,
                        bool freeInfo, PyGeneratorCallback callback)
{
    GeneratorObject *generator = (GeneratorObject *)_PyObject_New(&Generator_Type);
    if (generator == NULL) return NULL;

    generator->callee = callee;
    generator->info = info;
    generator->callback = callback;
    self->freeInfo = freeInfo;

    return (PyObject *)generator;
}

/* End of Generator definition. */

/* Define a new object class, Sequence. */
typedef struct {
    PyObject_HEAD
    size_t max;
} SequenceObject;

/* Instance variables */
static PyMemberDef Sequence_members[] = {
    {"max", T_UINT, offsetof(SequenceObject, max), 0, NULL},
    {NULL} /* Sentinel */
}

static int Sequence_Init(SequenceObject *self, PyObject *args, PyObject *kwds)
{
    if (!PyArg_ParseTuple(args, "k", &self->max)) {
        return -1;
    }
    return 0;
}

static PyObject *Sequence_data(SequenceObject *self, PyObject *args);

/* Methods */
static PyMethodDef Sequence_methods[] = {
    {"data", (PyCFunction)Sequence_data, METH_NOARGS,
     "sequence.data() -> iterator object\n"
     "Returns generator of range [0, sequence.max)."},
    {NULL} /* Sentinel */
};

/* Define new object type */
PyTypeObject Sequence_Type = {
   PyObject_HEAD_INIT(NULL)
   0,                         /* ob_size */
   "Sequence",                /* tp_name */
   sizeof(SequenceObject),    /* tp_basicsize */
   0,                         /* tp_itemsize */
   0,                         /* tp_dealloc */
   0,                         /* tp_print */
   0,                         /* tp_getattr */
   0,                         /* tp_setattr */
   0,                         /* tp_compare */
   0,                         /* tp_repr */
   0,                         /* tp_as_number */
   0,                         /* tp_as_sequence */
   0,                         /* tp_as_mapping */
   0,                         /* tp_hash */
   0,                         /* tp_call */
   0,                         /* tp_str */
   0,                         /* tp_getattro */
   0,                         /* tp_setattro */
   0,                         /* tp_as_buffer */
   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags*/
   "Test generator object",   /* tp_doc */
   0,                         /* tp_traverse */
   0,                         /* tp_clear */
   0,                         /* tp_richcompare */
   0,                         /* tp_weaklistoffset */
   0,                         /* tp_iter */
   0,                         /* tp_iternext */
   0,                         /* tp_methods */
   Sequence_members,          /* tp_members */
   0,                         /* tp_getset */
   0,                         /* tp_base */
   0,                         /* tp_dict */
   0,                         /* tp_descr_get */
   0,                         /* tp_descr_set */
   0,                         /* tp_dictoffset */
   (initproc)Sequence_init,   /* tp_init */
   0,                         /* tp_alloc */
   PyType_GenericNew,         /* tp_new */
};

static PyObject *Sequence_data(SequenceObject *self, PyObject *args)
{
    size_t *info = malloc(sizeof(size_t));
    if (info == NULL) return NULL;
    *info = 0;

    /* |info| will be free'()d by the returned generator object. */
    GeneratorObject *ret = Generator_New(self, info, true,
                                         &Sequence_data_next_callback);
    if (ret == NULL) {
        free(info); /* Watch out for memory leaks! */
    }
    return ret;
}

PyObject *Sequence_data_next_callback(PyObject *self, void *info)
{
    size_t i = info;
    if (i > self->max) {
        return NULL; /* TODO: How do I raise StopIteration here? I can't seem to find
                      *       a standard exception. */
    } else {
        return Py_BuildValue("k", i++);
    }
}

但是,不幸的是,我还没有完成。 我剩下的唯一问题是:如何使用C API引发StopIteration异常? 我似乎找不到标准例外中列出的内容。 另外,也许更重要的是,这是解决此问题的正确方法吗?

感谢任何仍在遵循此规则的人。

trans by 2020-08-03T01:36:49Z

事件,流,可观察对象,异步迭代器

当前,在JavaScript中处理一系列异步结果的唯一稳定方法是使用事件系统。 但是,正在开发三种替代方法:

信息流:[https://streams.spec.whatwg.org]
可观察到的:[https://tc39.github.io/proposal-observable]
异步迭代器:[https://tc39.github.io/proposal-async-iteration]

每个事件与其他事件相比有什么区别和好处?

这些中的任何一个是否打算替换事件?

trans by 2020-07-29T06:11:01Z

java-在ArrayList上进行操作时AbstractList.remove()中出现UnsupportedOperationException

List<String>的列表迭代器确实实现了remove方法,但是,我抛出了以下异常:

UnsupportedOperationException at java.util.AbstractList.remove(AbstractList.java:144)

通过此代码:

protected void removeZeroLengthStringsFrom(List<String> stringList)
{
    ListIterator<String> iter = stringList.listIterator();
    String s;
    while (iter.hasNext())
    {
        s = iter.next();
        if (s.length() == 0)
        {
            iter.remove();
        }
    }
}

我在这里想念什么? 我已验证我传入的List<String>确实是ArrayList<String>

谢谢!

trans by 2020-07-28T05:05:27Z

列表-可通过迭代器和索引访问的Python类

可能是一个n00b问题,但是我目前有一个实现迭代器的类,因此我可以做类似的事情

for i in class():

但是我希望能够通过索引访问类

class()[1]

我怎样才能做到这一点?

谢谢!

trans by 2020-07-24T12:31:01Z

将迭代器转换为指针?

我有一个findunordered_set<std::vector*>元素。 现在,我需要将指针传递给具有最后n-1个元素的向量。

例如,我的find包含unordered_set<std::vector*>。一个函数需要n-1,我想将其传递给foo的指针。

我可以(安全地)使用迭代器find,将其转换为指针并将其传递给函数吗? 还是使用unordered_set<std::vector*>

更新:人们建议我将函数更改为采用迭代器而不是指针。 在我的情况下,这似乎是不可能的,因为我提到的函数是unordered_set<std::vector*>find函数。那么在这种情况下,是将foo中的n-1个元素复制到一个新的向量中,并使用指向该唯一选项的指针调用find吗? 效率很低! 就像画家Shlemiel一样,尤其是因为我必须查询许多子集:最后的n-1,然后是n-2等元素,然后查看它们是否在unordered_set中。

trans by 2020-07-24T03:24:29Z

我可以将反向迭代器转换为正向迭代器吗?

我有一个名为Move的类,它实际上是围绕Move对象的双端队列的包装。

因为我需要向前和向后遍历Move的双端队列,所以我有一个正向迭代器和一个reverse_iterator作为类的成员变量。 这样做的原因是因为我需要知道何时我已经超越了双端队列的“末端”,无论是前进还是后退。

该类如下所示:

class Action
{
public:
    SetMoves(std::deque<Move> & dmoves) { _moves = dmoves; }
    void Advance();
    bool Finished() 
    {
        if( bForward )
            return (currentfwd==_moves.end());
        else
            return (currentbck==_moves.rend());
    }
private:
    std::deque<Move> _moves;
    std::deque<Move>::const_iterator currentfwd;
    std::deque<Move>::const_reverse_iterator currentbck;
    bool bForward;
};

Move功能如下:

void Action::Advance
{
    if( bForward)
        currentfwd++;
    else
        currentbck++;
}

我的问题是,我希望能够检索到当前Move对象的迭代器,而无需查询我向前还是向后。 这意味着一个函数返回一种迭代器,但是我有两种类型。

我应该忘记返回迭代器,而是返回对Move对象的const引用吗?

最好的祝愿,

蜜蜂乐队

trans by 2020-07-19T23:53:14Z

为什么在C ++ 11或C ++ 14中没有安置迭代器?

C ++ 98具有front_inserterback_inserterinserter,但C ++ 11或C ++ 14草案中似乎没有这些版本的任何安装版本。 是否有任何技术原因无法提供front_emplacerback_emplaceremplacer

trans by 2020-07-14T13:34:42Z

动作3-通过AS3字典进行有效循环

for (var k in dictionary) 
{
  var key:KeyType = KeyType(k);
  var value:ValType = ValType(dictionary[k]); // <-- lookup
  // do stuff
}

这就是我用来遍历字典中条目的内容。 正如您在每次迭代中看到的那样,我在字典中执行查找。 有没有更有效的方法来迭代字典(同时保持对密钥的访问)?

trans by 2020-07-09T21:23:06Z

怎么在不增加(减少)迭代器的情况下获取std :: list中的下一个(上一个)元素?

假设我有一个std::list<int> lst和一些std::list<int>::iterator it用于遍历该列表。 并取决于it的值,我想在我的代码中使用it + 1it - 1。 有什么好办法可以做到这一点,例如next()prev()(我在stl文档中找不到这样的东西)吗? 还是应该每次复制it并递增(递减)副本?

trans by 2020-07-09T01:05:57Z

java-如何在流式传输时删除HashMap的元素(lambda)

在以下情况下,我需要从流中删除元素。

map.entrySet().stream().filter(t -> t.getValue().equals("0")).
            forEach(t -> map.remove(t.getKey()));

在Java 8之前的代码中,可以从迭代器中删除-在这里处理这种情况的最佳方法是什么?

trans by 2020-07-08T22:45:05Z

java-For-each与Iterator。 哪个是更好的选择

请考虑以下情形。

List<String> list = new ArrayList<>();

现在,我为此列表添加了for-each值。

我使用以下方法访问列表中的每个元素。

选项一-使用for-each

for (String i : list) {
        System.out.println(i);
    } 

选项二-使用for-each

Iterator it=list.iterator();
while (it.hasNext()){
   System.out.println(it.next());
}

我只是想知道如果我使用for-each而不是Iterator会有任何性能上的优势。而且现在在Java中使用Iterator是一种不好的做法吗?

trans by 2020-07-07T14:01:34Z

C ++迭代器和循环优化

我看到很多C ++代码看起来像这样:

for( const_iterator it = list.begin(),
     const_iterator ite = list.end();
     it != ite; ++it)

与更简洁的版本相反:

for( const_iterator it = list.begin();
     it != list.end(); ++it)

这两个约定之间的速度会有所不同吗? 天真的第一个会稍微快一点,因为list.end()只被调用一次。 但是由于迭代器是const,因此似乎编译器会将测试从循环中拉出来,为两者生成等效的程序集。

trans by 2020-06-27T12:48:55Z

python在循环内任意增加迭代器

我可能会以错误的方式处理此问题,但我想知道如何在python中处理此问题。

首先一些C代码:

int i;

for(i=0;i<100;i++){
  if(i == 50)
    i = i + 10;
  printf("%i\n", i);
}

好吧,我们永远不会看到50年代...

我的问题是,如何在python中做类似的事情? 例如:

for line in cdata.split('\n'):
  if exp.match(line):
    #increment the position of the iterator by 5?
    pass
  print line

由于我在python方面的有限经验,我只有一个解决方案,介绍了一个计数器和另一个if语句。 中断循环,直到exp.match(line)为true后计数器达到5。

必须有一种更好的方法来执行此操作,希望它不涉及导入另一个模块。

提前致谢!

trans by 2020-06-25T22:20:57Z

C ++迭代器被认为有害吗?

在今天的Boost库会议上,《现代C ++设计》和《 Loki C ++库》一书的作者Andrei Alexandrescu作了题为“迭代器必须走”的演讲(视频,幻灯片),讨论了迭代器为什么不好,他有更好的解决方案。

我试图阅读演示幻灯片,但是我从中受益匪浅。

  1. 迭代器不好吗?
  2. 他的替补真的更好吗?
  3. C ++实现者会接受他的想法吗?
trans by 2020-06-24T22:41:22Z

1 2 3 4 5 6 7 下一页 共7页