标签: python-itertools

例如,如果我使用创建迭代器chain,我可以在多个线程上调用它吗？请注意,依赖于GIL的线程安全性是可以接受的,但不是优选的.

(请注意,这与此问题略有不同,后者处理生成器,而不是用C编写的迭代器).

我有一个对象的树形结构.我需要遍历叶子中的所有项目("值").为此,我目前正在使用如下所示的生成器方法:

class Node(object):
    def __init__(self):
        self.items = [Leaf(1), Leaf(2), Leaf(3)]

    def values(self):
        for item in self.items:
            for value in item.values():
                yield value

class Leaf(object):
    def __init__(self, value):
        self.value = value

    def values(self):
        for i in range(2):
            yield self.value

n = Node()
for value in n.values():
    print(value)

这打印:

1
1
2
2
3
3

现在,a返回的值Leaf将取决于外部参数.我正在考虑使用协程能够将此参数传递给叶节点:

import itertools

class Node2(object):
    def __init__(self):
        self.items = [Leaf2(1), Leaf2(2), Leaf2(3)]

    def values(self):
        parameter = yield
        for item in self.items:
            item_values = item.values()
            next(item_values) …

我试图使用itertools.permutations()来返回字符串的所有排列,并仅返回作为一组单词成员的那些排列.

import itertools

def permutations_in_dict(string, words): 
    '''
    Parameters
    ----------
    string : {str}
    words : {set}

    Returns
    -------
    list : {list} of {str}    

    Example
    -------
    >>> permutations_in_dict('act', {'cat', 'rat', 'dog', 'act'})
    ['act', 'cat']
    '''

我目前的解决方案在终端上运行良好,但不知何故无法通过测试用例...

return list(set([''.join(p) for p in itertools.permutations(string)]) & words)

任何帮助将不胜感激.

我正在尝试为幻想自行车比赛计算最佳团队。我有一个csv文件，其中包含176个自行车手，他们的球队，所获得的积分以及将其放入我的球队的价格。我试图找到得分最高的16个自行车队。

适用于任何团队组成的规则是：

• 团队的总费用不能超过100。
• 同一支队伍中的幻想自行车参赛者不得超过4名。

我的csv文件的简短摘录可以在下面找到。

THOMAS Geraint,Team INEOS,142,13
SAGAN Peter,BORA - hansgrohe,522,11.5
GROENEWEGEN Dylan,Team Jumbo-Visma,205,11
FUGLSANG Jakob,Astana Pro Team,46,10
BERNAL Egan,Team INEOS,110,10
BARDET Romain,AG2R La Mondiale,21,9.5
QUINTANA Nairo,Movistar Team,58,9.5
YATES Adam,Mitchelton-Scott,40,9.5
VIVIANI Elia,Deceuninck - Quick Step,273,9.5
YATES Simon,Mitchelton-Scott,13,9
EWAN Caleb,Lotto Soudal,13,9

解决此问题的最简单方法是生成团队所有可能组合的列表，然后应用规则排除不符合上述规则的团队。此后，很容易计算每个团队的总得分并选择得分最高的团队。从理论上讲，可以通过以下代码生成可用团队列表。

database_csv = pd.read_csv('renner_db_example.csv')
renners = database_csv.to_dict(orient='records')

budget = 100
max_same_team = 4
team_total = 16

combos = itertools.combinations(renners,team_total)
usable_combos = []

for i in combos:
    if sum(persoon["Waarde"] for persoon in i)  < budget and all(z <= max_same_team for …

从前一个问题我学到了一些有趣的东西.如果Python itertools.product是由一系列迭代器提供的,那么这些迭代器将在笛卡尔积开始之前转换为元组.相关 问题查看源代码,itertools.product得出结论:虽然没有中间结果存储在内存中,但是在产品迭代开始之前创建了原始迭代器的元组版本.

问题:当(元组转换的)输入太大而无法保存在内存中时,有没有办法为笛卡尔积创建迭代器？琐碎的例子:

import itertools
A = itertools.permutations(xrange(100))
itertools.product(A)

一个更实际的用例将采用一系列(*iterables[, repeat])类似于函数的原始实现 - 上面只是一个例子.它看起来不像你可以使用当前的实现itertools.product,所以我欢迎在纯python中提交(虽然你不能击败C后端itertools!).

Python的itertools.combinations()创建的结果是数字的组合.例如:

a = [7, 5, 5, 4]
b = list(itertools.combinations(a, 2))

# b = [(7, 5), (7, 5), (7, 4), (5, 5), (5, 4), (5, 4)]

但我想获得组合的指数,如:

index = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]

我该怎么做？

我需要迭代一个索引元组.所有指数必须在[0, N)条件范围内 i > j.我在这里介绍的玩具示例只涉及两个指数; 我需要将其扩展到三个(有i > j > k)或更多.

基本版本是这样的:

N = 5
for i in range(N):
    for j in range(i):
        print(i, j)

它工作得很好; 输出是

1 0
2 0
2 1
3 0
3 1
3 2
4 0
4 1
4 2
4 3

我不希望每个附加索引都有一个缩进级别,因此我更喜欢这个版本:

for i, j in ((i, j) for i in range(N) for j in range(i)):
    print(i, j)

这非常有效,它应该做什么,并摆脱额外的缩进水平.

我希望能够有更优雅的东西(两个指数并非完全相关,但三个或更多指数变得更相关).到目前为止我想出的是:

from itertools import combinations

for j, i in combinations(range(N), 2): …

拿这个代码:

import itertools as it
import numpy as np
data = ['a','b','c','d']
dw = np.array([1, 3], dtype=np.int64)
print(list(it.islice(data,dw[0],dw[1],1)))

在Python 2.7上,它['b', 'c',]按预期打印.

在Python 3.6上它抛出一个异常:

ValueError: Stop argument for islice() must be None or an integer: 0 <= x <= sys.maxsize.

同样的np.int32方法,并且itertools包的其他方法抛出类似的错误,例如当你使用permutations时得到TypeError: Expected int as r.

除了这个numpy问题和相关问题之外,我找不到太多关于此 问题,但是那个问题在3年前被关闭,暗示它已经解决了.

基本的东西,比如使用numpy int进行索引data[dw[0]]或布尔比较dw[0] == 1就好了.

我错过了什么吗？这可能是Python 3的错误吗？

我试图制作一个纯python(没有外部依赖)两个序列的元素比较.我的第一个解决方案是

list(map(operator.eq, seq1, seq2))

然后我发现了starmap函数itertools,这看起来和我很相似.但在最坏的情况下,我的计算机上的速度提高了37%.由于对我来说不是很明显,我测量了从生成器中检索1个元素所需的时间(不知道这种方式是否正确):

from operator import eq
from itertools import starmap

seq1 = [1,2,3]*10000
seq2 = [1,2,3]*10000
seq2[-1] = 5

gen1 = map(eq, seq1, seq2))
gen2 = starmap(eq, zip(seq1, seq2))

%timeit -n1000 -r10 next(gen1)
%timeit -n1000 -r10 next(gen2)

271 ns ± 1.26 ns per loop (mean ± std. dev. of 10 runs, 1000 loops each)
208 ns ± 1.72 ns per loop (mean ± std. dev. of 10 runs, 1000 loops each)

在检索元素时,第二种解决方案的性能提高了24%.在那之后,他们都产生相同的结果list …

我有两台发电机g1和g2

for line in g1:
    print line[0]

[a,a,a]
[b,b,b]
[c,c,c]

for line1 in g2:
    print line1[0]

[1,1,1]
[2,2,2]
[3,3,3]

for line in itertools.chain(g1, g2):
    print line[0]

并[a,A,A]
[B,B,B]
[C,C,C]
[1,1,1]
[2,2,2]
[3,3,3]

怎么样

得到如下输出:

[a,a,a],[1,1,1]
[b,b,b],[2,2,2]
[c,c,c],[3,3, 3]

或

并[a,A,A,1,1,1]
[B,B,B,2,2,2]
[C,C,C,3,3,3]

谢谢您的帮助.