子列表列表提供了子列表及其元素的数量

Question

def listOfLists(ntimes,lines,list_val):
    a = []
    i = 0
    j = 0

    if ntimes >= lines:
        inner_loop = ntimes
        outer_loop = lines
    else:
        inner_loop = lines
        outer_loop = ntimes

    while i < outer_loop:
        while j < inner_loop+i:
            if (j*inner_loop-i < len(list_val)):
                a.append(list_val[j*inner_loop-i])
                j=j+1

            else:
                j=1
                a.append(list_val[j*inner_loop-i])
                break

        j = i+1
        i = i+1
        print a
    y = [a[x:x+ntimes] for x in range(0, len(a), ntimes)]
    print y

我想要的是一个包含子列表的列表，其中元素的数量是n次，行是子列表的数量。如果输入像listOfLists(2,3,[1,2,3,4,5,6])，那么输出应该是：

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

我现在得到：

[[1, 4], [4, 3], [6, 3]]

如何修复代码来实现这一点

Answer 1

您可以这样做：

def listOfLists(ntimes, lines, list_val):
    return zip(*zip(*(iter(list_val),) * lines))

输出：

[(1, 4), (2, 5), (3, 6)]

Answer 2

使用^{} recipe from ^{}：

>>> L
[1, 2, 3, 4, 5, 6]
>>> zip(*grouper(L, 3))
[(1, 4), (2, 5), (3, 6)]

拉链里面有元组。如果出于某种原因需要列表，请理解：

>>> [list(t) for t in _]
[[1, 4], [2, 5], [3, 6]]

Answer 3

如果lst的长度是lines的乘法，则下面的代码可以工作

>>> lst = [1, 2, 3, 4, 5, 6]
>>> lines = 3
>>> zip(*zip(*[iter(lst)]*lines))
[(1, 4), (2, 5), (3, 6)]

这个魔法来自wim提到的grouper

解释魔法

有一个值列表

>>> lst = [1,2,3,4,5,6]

对列表值创建迭代器：

>>> iter(lst)
<listiterator at 0x7f641480d490>

注意：迭代器能够从自身逐项生成，在本例中，它可以从lst中逐项生成

创建包含一个迭代器的列表：

>>> [iter(lst)]
[<listiterator at 0x7f641480d750>]

列表是可变结构，因此即使从多个变量引用，它仍然引用 内存中相同的数据结构。如果这些引用中的任何一个在内部使用迭代器，那么迭代器 对该列表的所有引用都进行了修改

现在创建列表的乘法，乘以期望的行数

>>> [iter(lst)] * 3
[<listiterator at 0x7f641480dc50>,
 <listiterator at 0x7f641480dc50>,
 <listiterator at 0x7f641480dc50>]

注意，所有迭代器都显示相同的地址，此列表中的所有三项都引用 到同一迭代器

现在是filan步骤，将所有内容压缩到一起：

>>> zip(*[iter(lst)] * 3)
[(1, 2, 3), (4, 5, 6)]

可以重写为：

zip(*[<listiterator at 0x7f641480dc50>, <listiterator at 0x7f641480dc50>, <listiterator at 0x7f641480dc50>])

什么（通过*取消引用）转换为：

>>> zip(<listiterator at 0x7f641480dc50>, <listiterator at 0x7f641480dc50>, <listiterator at 0x7f641480dc50>)
[(1, 2, 3), (4, 5, 6)]

zip的工作方式是，它要求每个迭代器提供一个值并创建一个元组 从这3个值。诀窍是，每次从迭代器请求一个值时，都会从 所有引用，所以下次它询问任何迭代器时，将出现下一个值

最后一步是做最后的拉链：

zip(*[(1, 2, 3), (4, 5, 6)])

转换为：

zip((1, 2, 3), (4, 5, 6))

结果是：

[(1, 4), (2, 5), (3, 6)]