我正在寻找一种有效的方法,将一个系列转换为其索引的元组及其值.
s = pd.Series([1, 2, 3], ['a', 'b', 'c'])
我想要一个数组,列表,系列,一些可迭代:
[(1, 'a'), (2, 'b'), (3, 'c')]
可以使用番石榴轻松过滤列表或Iterables filter(Iterable<?> unfiltered, Class<T> type).此操作执行两个任务:列表被过滤并转换为给定类型T的序列.
然而,我常常最终Iterables<Something<?>>
得到Iterables<Something<T>>一些专门的T 的后续序列.
很明显,由于类型擦除,番石榴无法解决这个问题:Something<T>没有提供有关其T的任何直接信息.
可以说我有类似的东西S<? extends Number>.如果我能够定义一些谓词告诉我是否S<?>可以将其转换为S<Double>我可以将其用作文件管理器:
<T extends Number> Predicate<S<?>> isOfType(Class<N> type) {...}
有:
Iterable<S<?>> numbers;
Iterable<S<?>> filtered = Iterable.filter(numbers, isOfType(Double.class));
这执行过滤任务,但它错过了转换步骤.如果我认为我的Predicate运作良好,我甚至可以考虑转换:
Iterable<S<Double>> doubles = (Iterable<S<Double>>) filtered;
但这暴露了一些丑陋的演员操作.
作为替代方案,我可以提供Function<S<?>, S<Double>>执行演员表演.Class.cast()但是,如果元素不能被转换(或转换),则它不应该抛出ClassCastException但只是返回null.这样可以在没有任何显式转换的情况下转换序列:
<T extends Number> Function<S<?>, S<T>> castOrNull(Class<N> type) {...}
Iterable<S<Double>> doubles = Iterable.filter(numbers, castOrNull(Double.class));
但是列表并没有真正过滤:相反,它仍然包含无法转换或转换为每个元素的空对象S<Double>.但这可以通过额外的过滤步骤轻松解决,如:
Iterable<S<Double>> doubles = Iterables.filter(doubles, Predicates.notNull());
第二种解决方案对我来说似乎更聪明.在 …
这是我的班级
public class csWordSimilarity
{
public int irColumn1 = 0;
public int irColumn2 = 0;
public int irColumn3 = 0;
public int irColumn4 = 0;
public int irColumn5 = 0;
}
我想使该类可迭代使用,如下所示
foreach (int irVal in myVarWordSimilarity)
{
}
myVarWordSimilarity是csWordSimilarity类型.所以我想迭代所有公共int变量.我如何修改csWordSimilarity类以使其像上面的方式一样进行迭代.
Python列表理解非常简单:
>>> l = [x for x in range(1, 10) if x % 2 == 0]
>>> [2, 4, 6, 8]
Rust是否具有如下等效语法:
let vector = vec![x for x in (1..10) if x % 2 == 0]
// [2, 4, 6, 8]
我想知道是否有办法在某些东西上运行地图.map的工作方式是它需要一个iterable并将一个函数应用于该iterable中的每个项目,从而生成一个列表.有没有办法让map修改可迭代对象本身？
为什么在接口java.util.Collection上定义了iterator()方法,它已经扩展了java.util.Iterable,它定义了这个方法.
我正在考虑某种向后兼容性或在集合级别上对方法编写一些JavaDoc的机会.
还有其他想法吗？
我正在尝试理解Java Iterator和Iterable接口
我正在写这门课
class MyClass implements Iterable<String> {
public String[] a = null;
public MyClass(String[] arr) {
a = arr;
}
public MyClassIterator iterator() {
return new MyClassIterator(this);
}
public class MyClassIterator implements Iterator<String> {
private MyClass myclass = null;
private int count = 0;
public MyClassIterator(MyClass m) {
myclass = m;
}
public boolean hasNext() {
return count < myclass.a.length;
}
public String next() {
int t = count;
count++;
return myclass.a[t];
}
public void remove() …从Java 5开始,我们有了一个java.lang.Iterable可以在foreach循环中使用的新类型:
for (Object element : iterable);
该Iterable合同没有规定是否其iterator()方法可以在可迭代的处理之前被调用一次以上.即,不清楚以下是否可以为所有人工作Iterables:
for (Object element : iterable);
for (Object element : iterable);
例如,Iterator包装实现不能使用两次:
public class OneShotIterable<T> implements Iterable<T> {
private final Iterator<T> it;
public OneShotIterable(Iterator<T> it) {
this.it = it;
}
@Override
public Iterator<T> iterator() {
return it;
}
}
对于大多数Iterables,这是无关紧要的,因为它们实际上是改装收集API类型,例如List,Set,这已经为自己定义明确合同iterator()的方法.
我的问题是:我的OneShotIterable实施是否违反了我忽略的一些合同？换句话说,用户是否Iterable希望它可以重复使用？如果是这样,Java 5专家组是否有"官方"建议如何处理这样的"一次性" Iterables(例如,IllegalStateException在第二次通话时抛出)？
我有一个list自定义类对象(示例如下).
使用:list(itertools.chain.from_iterable(myBigList))我想将所有stations子列表"合并" 到一个大列表中.所以我认为我需要使自定义类成为可迭代的.
这是我的自定义类的示例.
class direction(object) :
def __init__(self, id) :
self.id = id
self.__stations = list()
def __iter__(self):
self.__i = 0 # iterable current item
return iter(self.__stations)
def __next__(self):
if self.__i<len(self.__stations)-1:
self.__i += 1
return self.__stations[self.__i]
else:
raise StopIteration
我实施了__iter__,__next__但似乎没有用.他们甚至没有被召唤.
知道我能做错什么吗？
注意:使用Python 3.3
我找到:
>>> a={'x':42, 'y':3.14, 'z':7}
>>> b=a.__iter__()
>>> b.__dir__()
['__next__', ..., '__iter__', ...]
>>> b
<set_iterator object at 0x7efdd4e5afc0>
迭代器是否总是有__iter__方法？
根据/sf/answers/691898161/,迭代器也是可迭代的.如果迭代器总是有__iter__方法是真的吗？