相关疑难解决方法(0)

如何在Python中生成列表的所有排列,与该列表中的元素类型无关？

例如:

permutations([])
[]

permutations([1])
[1]

permutations([1, 2])
[1, 2]
[2, 1]

permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

是否有一种简单的方法可以使用列表推导来展平迭代列表,或者失败,你会认为什么是平衡这样的浅层列表,平衡性能和可读性的最佳方法？

我尝试使用嵌套列表理解来压缩这样的列表,如下所示:

[image for image in menuitem for menuitem in list_of_menuitems]

但我在NameError那里遇到麻烦,因为name 'menuitem' is not defined.谷歌搜索并浏览Stack Overflow后,我得到了一个reduce声明所需的结果:

reduce(list.__add__, map(lambda x: list(x), list_of_menuitems))

但是这个方法相当难以理解,因为我需要那个list(x)调用,因为x是一个Django QuerySet对象.

结论:

感谢所有为此问题做出贡献的人.以下是我学到的内容摘要.我也将其作为社区维基,以防其他人想要添加或更正这些观察结果.

我原来的reduce语句是多余的,用这种方式编写得更好:

>>> reduce(list.__add__, (list(mi) for mi in list_of_menuitems))

这是嵌套列表理解的正确语法(Brilliant summary dF!):

>>> [image for mi in list_of_menuitems for image in mi]

但这些方法都不如使用效率高itertools.chain:

>>> from itertools import chain
>>> list(chain(*list_of_menuitems))

正如@cdleary指出的那样,通过使用chain.from_iterable如下所示来避免*操作符魔术可能是更好的风格:

>>> chain = itertools.chain.from_iterable([[1,2],[3],[5,89],[],[6]])
>>> print(list(chain))
>>> [1, 2, …

如何从一组列表中获取笛卡尔积(每种可能的值组合)？

输入:

somelists = [
   [1, 2, 3],
   ['a', 'b'],
   [4, 5]
]

期望的输出:

[(1, 'a', 4), (1, 'a', 5), (1, 'b', 4), (1, 'b', 5), (2, 'a', 4), (2, 'a', 5) ...]

什么是Pythonic方法来实现以下目标？

# Original lists:

list_a = [1, 2, 3, 4]
list_b = [5, 6, 7, 8]

# List of tuples from 'list_a' and 'list_b':

list_c = [(1,5), (2,6), (3,7), (4,8)]

每个成员list_c都是一个元组,其第一个成员来自list_a,而第二个来自list_b.

我有格式为token/tag的标记文件,我尝试了一个函数,它返回一个带有来自(word,tag)列表的单词的元组.

def text_from_tagged_ngram(ngram): 
    if type(ngram) == tuple:
        return ngram[0]
    return " ".join(zip(*ngram)[0]) # zip(*ngram)[0] returns a tuple with words from a (word,tag) list

在python 2.7中它运行良好,但在python 3.4中它给我以下错误:

return " ".join(list[zip(*ngram)[0]])
TypeError: 'zip' object is not subscriptable

有人可以帮忙吗？

我有一些代码可以计算排列和组合,我正在努力让它更适合大数字.

我已经找到了一个更好的排列算法,避免了大的中间结果,但我仍然认为我可以做更好的组合.

到目前为止,我已经提出了一个特殊情况来反映nCr的对称性,但我仍然希望找到一种更好的算法来避免调用阶乘(r),这是一个不必要的大中间结果.如果没有这个优化,最后一次doctest尝试计算阶乘(99000)需要太长时间.

任何人都可以建议一种更有效的方法来计算组合？

from math import factorial

def product(iterable):
    prod = 1
    for n in iterable:
        prod *= n
    return prod

def npr(n, r):
    """
    Calculate the number of ordered permutations of r items taken from a
    population of size n.

    >>> npr(3, 2)
    6
    >>> npr(100, 20)
    1303995018204712451095685346159820800000
    """
    assert 0 <= r <= n
    return product(range(n - r + 1, n + 1))

def ncr(n, r):
    """
    Calculate the number of unordered combinations of r items taken …

注意:我正在使用python工作.

例如,给出一个列表:

list = ['a','b','c','d','e','f','g','h','i','j']

我想生成一个包含所有可能的3项组合的列表列表:

['a','b','c'],
['a','b','d'],
['a','b','e']

排列不应在排列中使用相同的项目两次,但顺序很重要并且表示应包括的不同排列,例如,

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

两者都应该包括在内.

"3"是我想要生成的排列的神奇长度,但我不会小看任意长度排列的解决方案.

谢谢你的帮助!

我有两个清单:

a = ['a', 'b']
b = [1, 2, 3]

我想得到列表b元素和列表a元素之间产生的组合,但是a作为对(或三元组等)处理元素,如下面的例子给出len(b) ** len(a)了组合的数量.

c = ["a_1 b_1", "a_1 b_2", "a_1 b_3", "a_2 b_1", "a_2 b_2", "a_2 b_3", "a_3 b_1", "a_3 b_2" "a_3 b_3"]

我曾尝试使用itertools.product(如描述在这里),但这将只给出6种可能的组合.

我有两个清单:

object = ['square','circle','triangle']
description = ['red','green']

我想要输出一个词典列表:

{'square': 'red', 'circle': 'red', 'triangle': 'red'}
{'square': 'red', 'circle': 'red', 'triangle': 'green'}
{'square': 'green', 'circle': 'red', 'triangle': 'green'}

等等

所以对象不重复,但描述可能会.每个字典都有原始的对象列表作为其键.

我不确定我想要的算法的名称,所以我找不到正确的算法.(我已经查看了python中两个列表的排列,但是它正在寻求不同的结果.两个列表的排列是同一个问题,但是使用OCAML.)

我有两个清单[1,2,3]和[4,5,6].我想使用以下生成所有组合的列表itertools

ResultingList = [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]

到目前为止,我只调查了itertools.combinations函数,它似乎只能处理这样的事情:

list(itertools.combinations([1,2,3,4,5,6],2))

哪个输出不正确的结果.我怎样才能生成ResultingList以上内容？

谢谢

我真的想知道如何从两个列表中提取所有元素并相互相乘.例如,如果有两个列表

A=[1,3,5,7,9]
B=[2,4,6,8]

我想做1X2,1X4,1X6,1x8,3x2 ......等.来自AX的一个元素来自B的一个元素.我试图使用zip但由于长度差异,我无法得到正确的答案.