标签: python-itertools

假设我有一个列表:

l = [0, 1, 2, 3]

如何迭代列表,从列表中获取每个项目及其补充？那是,

for item, others in ...
    print(item, others)

会打印

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

理想情况下,我正在寻找一个简洁的表达,我可以在理解中使用.

我的函数创建了一个生成器链:

def bar(num):
    import itertools
    some_sequence = (x*1.5 for x in range(num))
    some_other_sequence = (x*2.6 for x in range(num))
    chained = itertools.chain(some_sequence, some_other_sequence)
    return chained

我的功能有时需要以chained相反的顺序返回.从概念上讲,以下是我希望能够做到的:

if num < 0:
    return reversed(chained)
return chained

不幸:

>>> reversed(chained)
TypeError: argument to reversed() must be a sequence

我有什么选择？

这是一些实时的图形渲染代码,所以我不想让它太复杂/慢.

编辑:当我第一次提出这个问题时,我没有考虑过发电机的可逆性.正如许多人所指出的那样,发电机无法逆转.

事实上,我想要扭转链条中扁平化的内容; 不仅仅是发电机的顺序.

根据响应,我没有单一的调用来反转itertools.chain,所以我认为这里唯一的解决方案是使用一个列表,至少在相反的情况下,也许两者都有.

在滑动对中迭代列表的Pythonic有效方法是什么？这是一个相关的例子:

>>> l
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> for x, y in itertools.izip(l, l[1::2]): print x, y
... 
a b
b d
c f

这是成对迭代,但我们如何在滑动对上进行迭代？意味着迭代对:

a b
b c
c d
d e
etc.

这是对的迭代,除了每次将1对元素滑动而不是2个元素.谢谢.

在Python中,给定一个排序整数列表,我会按连续值对它们进行分组,并容忍1的间隙.

例如,给出一个列表my_list:

In [66]: my_list
Out[66]: [0, 1, 2, 3, 5, 6, 10, 11, 15, 16, 18, 19, 20]

我想要以下输出:

[[0, 1, 2, 3, 5, 6], [10, 11], [15, 16, 18, 19, 20]]

现在,如果我不必忍受1的差距,我可以应用这里解释的整洁解决方案:

import itertools
import operator
results = []
for k, g in itertools.groupby(enumerate(my_list), lambda (i,x):i-x):
        group = map(operator.itemgetter(1), g)
        results.append(group)

有没有办法将我的额外要求纳入上述解决方案？如果没有,解决问题的最佳方法是什么？

我需要所有可能的长度为0的组合.

假设我想要k = 2 (0,0), (0,1), (1,0), (1,1)

我尝试了不同的功能,itertools但我找不到我想要的东西.

>>> list(itertools.combinations_with_replacement([0,1], 2))
[(0, 0), (0, 1), (1, 1)]
>>> list(itertools.product([0,1], [0,1])) #does not work if k>2
[(0, 0), (0, 1), (1, 0), (1, 1)]

from itertools import product
teams = ['india', 'australia', 'new zealand']
word_and = ['and']
tmp = '%s %s %s'
items = [teams, word_and, teams]
print(list(tmp % a for a in list(product(*items))))

打印:

['india and india',
 'india and australia',
 'india and new zealand',
 'australia and india',
 'australia and australia',
 'australia and new zealand',
 'new zealand and india',
 'new zealand and australia',
 'new zealand and new zealand']

如何:

1. 避免在一个句子中重复相同的名称(印度和印度)
2. 只产生一种组合(印度和澳大利亚或澳大利亚和印度)

http://pythonfiddle.com/product-without-matching-duplicates

我正在尝试加入两个列表并输出合并列表的所有可能组合,以维护原始两个列表的排序.例如:

list_1 = [9,8]
list_2 = [2,1]

#output
combo= [9821,9281,2981,2918,2198,9218]

在列表"combo"中的每个元素中,2总是在1之前,9总是在8之前.

到目前为止,我已经使用了来自itertools的排列来循环所有可能的排列,但它还不够快.

这是我得到的:

from itertools import permutations
seq = [5, 9, 8, 2, 1]
plist = []
root = seq[0]
left = filter(lambda x: x > root, seq)
right =  filter(lambda x: x < root, seq)  

for pseq in permutations(seq[1:]):
    pseq = (root,) + pseq
    if list(filter(lambda x: x > root, pseq)) == left and list(filter(lambda x: x < root, pseq)) == …

我试图压扁嵌套的发电机发电机,但我得到了一个意想不到的结果:

>>> g = ((3*i + j for j in range(3)) for i in range(3))
>>> list(itertools.chain(*g))
[6, 7, 8, 6, 7, 8, 6, 7, 8]

我希望结果看起来像这样:

[0, 1, 2, 3, 4, 5, 6, 7, 8]

我想我得到了意想不到的结果,因为内部生成器在外部生成器已被迭代之前没有被评估,设置i为2.我可以通过使用列表推导强制评估内部生成器来解决一个解决方案生成器表达式:

>>> g = ([3*i + j for j in range(3)] for i in range(3))
>>> list(itertools.chain(*g))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

理想情况下,我想要一个完全懒惰的解决方案,并且在使用之前不会强制评估内部嵌套元素.

有没有办法压缩任意深度的嵌套生成器表达式(可能使用其他东西itertools.chain)？

编辑:

不,我的问题不是类中生成器中的变量范围的重复.老实说,我不知道这两个问题是如何相关的.也许主持人可以解释为什么他认为这是重复的.

此外,我的问题的两个答案都是正确的,因为它们可以用来编写一个正确展平嵌套生成器的函数.

def flattened1(iterable):
    iter1, iter2 = …

我试图学习如何在Python中使用itertools.groupby,我想找到每组字符的大小.起初我试着看看我是否能找到一个组的长度:

from itertools import groupby
len(list(list( groupby("cccccaaaaatttttsssssss") )[0][1]))

我每次都会得0.

我做了一点研究,发现其他人这样做:

from itertools import groupby
for key,grouper in groupby("cccccaaaaatttttsssssss"):
    print key,len(list(grouper))

哪个效果很好.我感到困惑的是为什么后面的代码有效,但前者没有？如果我想在我的原始代码中尝试只使用第n组,我该怎么做？

我正在做一些谜语:

给定一个带有元组元组的字典:dictionary = {(p,q):n},我需要生成每个组合的新字典列表,这样在新字典中p和q都不会重复.并且在生成该词典列表期间或之后,基于使用字典值的计算,选择一个词典作为期望词典.

我的意思的例子(但更小):

dictionary = {(1,1): 1.0, (1,2): 2.0, (1,3): 2.5, (1,4): 5.0, (2,1): 3.5, (2,2): 6.0, (2,3): 4.0, (2,4): 1.0}

变

listofdictionaries = [{(1,1): 1.0, (2,2): 6.0}, {(1,1): 1.0, (2,3): 4.0}, (1,1): 1.0, (2,4): 1.0}, {(1,2): 2.0, (2,1): 3.5}, {(1,2): 2.0, (2,3): 4.0}, 等等

像这样的字典{(1,1): 1.0, (2,1): 3.5}是不允许的,因为q重复.

现在我的啜泣故事:我对编码很陌生......但我一直在尝试编写这个脚本来分析我的一些数据.但我也认为这是一个有趣的算法谜语.我写的东西适用于非常小的字典,但是当我输入一个大字典时,运行时间太长(下面复制).在我的脚本尝试中,我实际上生成了一个元组组合的列表,而不是我用来在脚本中引用我的主字典.我将在下面复制:

使用两个列表生成字典元组密钥:"ExpList1"和"ExpList2"

#first, I generate all the tuple combinations from my ExpDict dictionary
combos =(itertools.combinations(ExpDict,min(len(ExpList1),len(ExpList2))))

#then I generate a list of only the combinations that …