Python 迭代每N个元素，放入一个元素（元组），然后每N个元素，放入另一个元素（元组）

如何遍历列表中的每5个元素，并将它们组成一个元组，然后将同一列表中的第6个元素作为第二个元组，然后对接下来的5个元素和第6个元素执行相同的操作

我读过

运算符.itemgetter（*项）

我也读过关于

阵列

我在想这样的事情：

first_N_element=[generator.next() for i in range(N)]

但这不可能只使用下一个元素并重复完全相同的操作

例如，如果您有：

l = [1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],...

我们如何组成这样的新列表：

new_l = [1,2,3,4,5],[6],[7,8,9,10,11],[12],...

---

实现这一点的一种方法是与列表理解表达式一起使用：

>>> from itertools import chain
>>> l = [1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12]

>>> list(chain(*[[[j[0] for j in l[i:i+5]], l[i+5]] for i in range(0, len(l), 6)]))
[[1, 2, 3, 4, 5], [6], [7, 8, 9, 10, 11], [12]]

---

根据用户的评论编辑：。预期的行为是在列表中包装项，而不是连接项。在这种情况下，可以通过以下方式进行：

>>> l = ('qw','er','ty','ui','op','as','df','gh','jk','l','zx','cv')

>>> list(chain(*[(list(chain(l[i:i+5])), [l[i+5]]) for i in range(0, len(l), 6)]))
[['qw', 'er', 'ty', 'ui', 'op'], ['as'], ['df', 'gh', 'jk', 'l', 'zx'], ['cv']]

在这种情况下，上述

列表将返回：

[[[1], [2], [3], [4], [5]], [[6]], [[7], [8], [9], [10], [11]], [[12]]]

实现这一点的一种方法是与列表理解表达式一起使用：

>>> from itertools import chain
>>> l = [1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12]

>>> list(chain(*[[[j[0] for j in l[i:i+5]], l[i+5]] for i in range(0, len(l), 6)]))
[[1, 2, 3, 4, 5], [6], [7, 8, 9, 10, 11], [12]]


根据用户的评论编辑：。预期的行为是在列表中包装项，而不是连接项。在这种情况下，可以通过以下方式进行：

>>> l = ('qw','er','ty','ui','op','as','df','gh','jk','l','zx','cv')

>>> list(chain(*[(list(chain(l[i:i+5])), [l[i+5]]) for i in range(0, len(l), 6)]))
[['qw', 'er', 'ty', 'ui', 'op'], ['as'], ['df', 'gh', 'jk', 'l', 'zx'], ['cv']]

在这种情况下，上述
列表将返回：

[[[1], [2], [3], [4], [5]], [[6]], [[7], [8], [9], [10], [11]], [[12]]]

右图：您可能不希望通过一次操作来完成此操作。相反，使用一对相关的操作。请注意，您的语法不会生成列表：您在每个列表赋值语句中都省略了最外面的一对括号

我将把这个循环，以确保你理解逻辑。你也可以把整个过程放在一行的列表理解中，但我猜你会发现很难阅读

ord_list = [[i] for i in range(24)]
print ord_list

new_l = []
for n in range(0, len(ord_list)-5, 6):
    new_l += [[ord_list[n+i][0] for i in range(5)]] + [ord_list[n+5]]
print new_l

输出：

[[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19], [20], [21], [22], [23]]
[[0, 1, 2, 3, 4], [5], [6, 7, 8, 9, 10], [11], [12, 13, 14, 15, 16], [17], [18, 19, 20, 21, 22], [23]]

这就是您所需要的吗？
对：您可能不想通过一次操作来实现这一点。相反，使用一对相关的操作。请注意，您的语法不会生成列表：您在每个列表赋值语句中都省略了最外面的一对括号

我将把这个循环，以确保你理解逻辑。你也可以把整个过程放在一行的列表理解中，但我猜你会发现很难阅读

ord_list = [[i] for i in range(24)]
print ord_list

new_l = []
for n in range(0, len(ord_list)-5, 6):
    new_l += [[ord_list[n+i][0] for i in range(5)]] + [ord_list[n+5]]
print new_l

输出：

[[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19], [20], [21], [22], [23]]
[[0, 1, 2, 3, 4], [5], [6, 7, 8, 9, 10], [11], [12, 13, 14, 15, 16], [17], [18, 19, 20, 21, 22], [23]]

这就是你需要的吗？
你可以写一个生成器。注意，这不会处理任何边缘情况，并且假设您的数据表现良好：

>>> def my_gen(sequence):
...   it = iter(sequence)
...   while True:
...     yield [next(it) for _ in range(6)]
...     yield [next(it)]
...
>>> l = range(1, 7*4 +1)
>>> list(my_gen(l))
[[1, 2, 3, 4, 5, 6], [7], [8, 9, 10, 11, 12, 13], [14], [15, 16, 17, 18, 19, 20], [21], [22, 23, 24, 25, 26, 27], [28]]
>>>

您可以根据自己的需要对此进行改进。例如，使用itertools导入切片中的
，您可以处理“不均匀”列表-不是7的倍数的列表，返回尾随位，如下所示：

>>> def my_gen(sequence):
...   it = iter(sequence)
...   while True:
...     six = list(islice(it, 6))
...     if six:
...       yield six
...     yield [next(it)]
...
>>> l = range(1, 7*4 -3)
>>> list(my_gen(l))
[[1, 2, 3, 4, 5, 6], [7], [8, 9, 10, 11, 12, 13], [14], [15, 16, 17, 18, 19, 20], [21], [22, 23, 24]]
>>>

你可以写一个发电机。注意，这不会处理任何边缘情况，并且假设您的数据表现良好：

>>> def my_gen(sequence):
...   it = iter(sequence)
...   while True:
...     yield [next(it) for _ in range(6)]
...     yield [next(it)]
...
>>> l = range(1, 7*4 +1)
>>> list(my_gen(l))
[[1, 2, 3, 4, 5, 6], [7], [8, 9, 10, 11, 12, 13], [14], [15, 16, 17, 18, 19, 20], [21], [22, 23, 24, 25, 26, 27], [28]]
>>>

您可以根据自己的需要对此进行改进。例如，使用itertools导入切片中的
，您可以处理“不均匀”列表-不是7的倍数的列表，返回尾随位，如下所示：

>>> def my_gen(sequence):
...   it = iter(sequence)
...   while True:
...     six = list(islice(it, 6))
...     if six:
...       yield six
...     yield [next(it)]
...
>>> l = range(1, 7*4 -3)
>>> list(my_gen(l))
[[1, 2, 3, 4, 5, 6], [7], [8, 9, 10, 11, 12, 13], [14], [15, 16, 17, 18, 19, 20], [21], [22, 23, 24]]
>>>

内置和列表理解。美丽这是输出：
>>l=（'qw'、'er'、'ty'、'ui'、'op'、'as'、'df'、'gh'、'jk'、'l'、'zx'、'cv'）
>列表（链（*[[j[0]表示j在l[i:i+5]]，l[i+5]]表示i在（0，len（l），6）]）['q'，'e'，'t'，'u'，'o'，'as'，'d'，'g'，'j'，'cv l']
我不知道为什么，但我只能说这不是理想的答案。这是因为您在问题中提到的示例与此示例的内容不同。在我的示例中，我使用索引0访问
j
，假设存在单个元素，而您在这里提到的示例中并非如此。很抱歉，我没有充分解释它-每个元素可能由不同数量的符号组成。因此，只有当元素包含一个符号时，才能使用非常好的代码？您的解决方案非常优雅，确实，谢谢，@MoinuddinQuadri！内置和列表理解。美丽这是输出：
>>l=（'qw'、'er'、'ty'、'ui'、'op'、'as'、'df'、'gh'、'jk'、'l'、'zx'、'cv'）
>列表（链（*[[j[0]表示j在l[i:i+5]]，l[i+5]]表示i在（0，len（l），6）]）['q'，'e'，'t'，'u'，'o'，'as'，'d'，'g'，'j'，'cv l']
我不知道为什么，但我只能说这不是理想的答案。这是因为您在问题中提到的示例与此示例的内容不同。在我的示例中，我使用索引0访问
j
，假设存在单个元素，而您在这里提到的示例中并非如此。很抱歉，我没有充分解释它-每个元素可能由不同数量的符号组成。因此，只有当元素包含一个符号时，才能使用非常好的代码？您的解决方案非常优雅，确实，谢谢，@MoinuddinQuadri！发电机的巧妙使用啊，我喜欢发电机方法的一点是逻辑清晰。不需要弄清楚范围和指数到底是怎么回事。。。只需在列表中生成6项，然后在列表中生成1项。。。事实上，它是每6个元素迭代一次，然后把第7个元素放到一个单独的元素中——我需要每5个元素迭代一次，把第6个元素放到一个单独的元素中。你能修好吗？我试图更改值
（islice（it，5））
，但它无法退出
而
循环。@Xtigyro它似乎对我有用。。。您使用什么值来测试它？@juanpa.arrivillaga:这些值是这种类型的（我不能完全共享）：
“00”、“13”、“00”、“13”、“13，”，”，”他们，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，单词“00”、“12”、“*”、“*”、“*”、“2,4”“一些长单词”、“00”、“07”、“*”、“*”、“*”、“6”、“一些这类长单词”、“00”、“16”、“1”、“*”、“*”、“*”、“*”、“一些长单词”、“00”、“1”