标签: python-itertools

我有一个清单A。我想要特定的排列，以便列表中同一元素不会多次占用同一位置。我介绍当前和预期的产出。我还希望代码适用于任何长度的A.

from itertools import permutations

A = [1, 2, 3]

# Generate all possible permutations and convert tuples to lists
all_permutations = [list(perm) for perm in permutations(A)]

# Print the permutations
for perm in all_permutations:
    print(perm)

当前输出为

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

预期输出是

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

所以我有一个try/except块设置,它将根据某些条件通过数据库:

try:
    for searchnumber in itertools.count(0):
        print searchnumber
        c.execute("""SELECT words from searchterms where onstate = 1 AND progid = %d;""") % searchnumber
        searchterms = (c.fetchall())
        searchterms = [",".join(x) for x in searchterms]
        print searchterms
except:
    pass

由于某种原因,它不是在progid上迭代,事实上,它甚至没有为它分配第一个值(0).为什么会这样？据我所知,%d应该用searchnumber的整数值代替

我想知道当我执行此代码时发生了什么,以及是否有更好的方法来完成相同的任务.是否在内存中创建列表以执行排序,然后将bar指定为foo.values()的迭代器？或者可能foo.values()在分配的字典内存空间中排序(似乎不太可能)？

想象一下,列表中的第一个值,整数,是指文件中的行号.我想打开文件并仅更新foo.values()列表中引用的行与列表中的其余数据(EG更新行1,字符串'123'和'097').

from itertools import imap

>>> foo = {'2134':[1, '123', '097'], '6543543':[3, '1'], '12315':[2, '454']}
>>> bar = imap([].sort(), foo.values())

谢谢〜

例如,如果q = 2,那么我必须生成[1,1]到[2,2]之间的所有序列.如果q = 3,则生成[1,1,1]到[3,3,3]之间的序列.对于q = 4,则生成[1,1,1,1]至[4,4,4,4]之间的序列等.

序列的例子.对于q = 3

(1, 1, 1)
(1, 1, 2)
(1, 1, 3)
(1, 2, 1)
(1, 2, 2)
(1, 2, 3)
(1, 3, 1)
(1, 3, 2)
(1, 3, 3)
(2, 1, 1)
(2, 1, 2)
(2, 1, 3)
(2, 2, 1)
(2, 2, 2)
(2, 2, 3)
(2, 3, 1)
(2, 3, 2)
(2, 3, 3)
(3, 1, 1)
(3, 1, 2)
(3, 1, 3)
(3, 2, 1)
(3, 2, 2)
(3, …

我有一个大字典:600个键,项目=大列表(约10000-20000元素).

我的目标是从dict中的每个列表中获取对,并将其合并到一个列表中.

我有:

d1 = {'key1': ['a', 'b', 'c', 'd'], 'key2': ['f', 'a']}

预期结果:

d2 = ['a_b', 'a_c', 'a_d', 'b_c', 'b_d', 'c_d', 'a_f']

我的代码:

d2 = [] 
for k, v in d1.items():
    for i, j in itertools.product(v, v):
        if i>j:
            a = "_".join(list(set([i, j])))
            d2.append(a)

我有一个问题:在终端我的python脚本说'杀了'.

这可能是由于内存使用不当造成的.有办法解决这个问题吗？

我是Python的新手,我需要一个循环列表.我有一个5个标签的列表:

taglist = ["faint", "shocking", "frosty", "loved", "sadness"]

我有另一个单调增加值的列表:

list = [1,2,3,4,5,6,7]

我想用taglist长度来创建另一个列表list.如果list有7个项目,我想要一个新的标签列表,如下所示.

newtaglist = ["faint", "shocking", "frosty", "loved", "sadness","faint", "shocking"]

这个列表将继续像圆​​形填充一样.我怎样才能做到这一点？

已解决:谢谢所有在这篇文章中回答的人.现在我很困惑地选择了答案.:(每个人看起来都很好.虽然我使用的是更简单的一个.

我遇到了两种不同的方法来分成iterable"块"(超过1项).

一种方法使用itertools:

from itertools import izip_longest
def grouper(iterable, n, fillvalue=None):
    args = [iter(iterable)] * n
    return izip_longest(*args, fillvalue=fillvalue)

另一种方法是直接python:

def chunker(seq, size):
    return (seq[pos:pos + size] for pos in xrange(0, len(seq), size))

itertools实现是否会为您带来"额外"的收益？

"额外"的地方,可能更快或更灵活或更安全.

我问,因为这里显示的itertools实现肯定不是更可读/直观的IMO.

我正在四处玩groupby,以便对itertools有一个更好的感觉,因此我按照数字对元组列表进行了分组,并尝试获取结果组的列表.groupby然而,当我将结果转换为列表时,我得到一个奇怪的结果:除最后一组之外的所有组都是空的.这是为什么？我假设将迭代器转换为列表效率较低但从不改变行为.我猜这些列表是空的,因为遍历了内部迭代器但是何时/何地发生？

import itertools

l=list(zip([1,2,2,3,3,3],['a','b','c','d','e','f']))
#[(1, 'a'), (2, 'b'), (2, 'c'), (3, 'd'), (3, 'e'), (3, 'f')]

grouped_l = list(itertools.groupby(l, key=lambda x:x[0]))
#[(1, <itertools._grouper at ...>), (2, <itertools._grouper at ...>), (3, <itertools._grouper at ...>)]

[list(x[1]) for x in grouped_l]
[[], [], [(3, 'f')]]


grouped_i = itertools.groupby(l, key=lambda x:x[0])
#<itertools.groupby at ...>
[list(x[1]) for x in grouped_i]
[[(1, 'a')], [(2, 'b'), (2, 'c')], [(3, 'd'), (3, 'e'), (3, 'f')]]

我有一个如下所示的列表,我想找到一点点修改的简单排列,

例如

l=['a', 'b']

输出:

[('a', 'a'), ('a', 'b'), ('b', 'b')]

我跟着,

尝试-1

list(itertools.product(L, repeat=2))

回报,

[('a', 'a'), ('a', 'b'), ('b', 'a'), ('b', 'b')]

试试-2

print list(itertools.permutations(['a', 'b']))

回报,

[('a', 'b'), ('b', 'a')]

尝试-3

我可以这样做,

temp= [tuple(sorted((i,j))) for i in ['a', 'b'] for j in ['a', 'b']]
print list(set(temp))

但这似乎是解决这个问题的低效方法.

我有这些清单:

list_a = set(["A", "B", "C", "D", "E", "F"])
list_b = set(["1", "2", "3", "4", "5", "6"])
list_c = set(["red", "yellow", "blue", "green"])  

我想找到这些列表的可能组合总数(每个列表一个项目)

使用较小的列表很容易实现这一点

import itertools as it

list_set = [list_a, list_b, list_c] 

len(list(it.product(*list_of_unq_vars)))

这将返回组合的数量.

但是对于较大的列表,我遇到了一个记忆错误.

有没有办法以这种方式计算可能的组合数而不实际创建组合(如上所述)？

非常感谢,J