Python |如何将值从主列表分组到不同的列表，并为每个索引指定一定的数字范围

所以，我有一个清单。。。我希望OGlist的前5个元素进入_list，第二个5个元素进入_list2，第三个5个元素进入_list，第四个5个元素进入_list2，依此类推

我如何做到这一点

我试过这个：

OGlist = [A, B, C, D, E, 1, 2, 3, 4, 5, F, G, H, I, J, 6, 7, 8, 9, 10]
_list = []
_list2 = []

我应该使用什么条件和逻辑来获得所需的输出

期望输出：

for x in range(1, len(OGlist) + 1):
    _list.append(OGlist[x-1])
    if x%5 == 0:
        y = x
        while True:
            _list2.append(OGlist[x])
            x += 1
            if x == y + 5:
                break

---

如果您正在寻找一行程序，这应该可以

OGlist=[x，y，foo，bar等]
如果i%5==0，则范围（len（OGlist）-5）内的i的列表\u of_list=[OGlist[i:i+5]
##以偶数索引获取列表
_如果i%2==0，则list=[l_0代表i，l_u在枚举（列表的列表）中]
##以奇数索引获取列表
_list2=[l_0代表i，如果i%2==1，则枚举（列表的列表）中的l_0]
##压扁
来自itertools进口链
_列表=列表（链从可编辑（_列表））
_list2=列表（链.自可编辑（_list2））

它在列表中每隔5个元素（使用OGlist[i:i+5]）（由i%5==0强制）迭代一次，直到到达少于5个元素的点（由len（OGlist）-5强制）

测试：

╰─$ python 25ms
Python 3.8.3（默认值，2020年7月2日，11:26:31）
[叮当声10.0.0]：：关于达尔文的巨蟒公司
有关详细信息，请键入“帮助”、“版权”、“信用证”或“许可证”。
>>>OGlist=列表（范围（100））
>>>食人魔名单
[0, 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, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>>如果i%5==0，则范围（len（OGlist）-5）内的i的列表\u of_list=[OGlist[i:i+5]
>>>列表
[[0, 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, 29], [30, 31, 32, 33, 34], [35, 36, 37, 38, 39], [40, 41, 42, 43, 44], [45, 46, 47, 48, 49], [50, 51, 52, 53, 54], [55, 56, 57, 58, 59], [60, 61, 62, 63, 64], [65, 66, 67, 68, 69], [70, 71, 72, 73, 74], [75, 76, 77, 78, 79], [80, 81, 82, 83, 84], [85, 86, 87, 88, 89], [90, 91, 92, 93, 94]]
>>>_list=[val for val in[l_ufor i，l_uin enumerate（列表的列表）如果i%2==0]]
>>>_list2=[val for val in[l_ufor i，l_uin enumerate（列表的列表）如果i%2==1]]
>>>_列表
[[0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44], [50, 51, 52, 53, 54], [60, 61, 62, 63, 64], [70, 71, 72, 73, 74], [80, 81, 82, 83, 84], [90, 91, 92, 93, 94]]
>>>_清单2
[[5, 6, 7, 8, 9], [15, 16, 17, 18, 19], [25, 26, 27, 28, 29], [35, 36, 37, 38, 39], [45, 46, 47, 48, 49], [55, 56, 57, 58, 59], [65, 66, 67, 68, 69], [75, 76, 77, 78, 79], [85, 86, 87, 88, 89]]
>>>来自itertools进口链
>>>_list=list（链从_iterable（_list））
>>>_list2=列表（链从_iterable（_list2））
>>>_列表
[0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32, 33, 34, 40, 41, 42, 43, 44, 50, 51, 52, 53, 54, 60, 61, 62, 63, 64, 70, 71, 72, 73, 74, 80, 81, 82, 83, 84, 90, 91, 92, 93, 94]
>>>_清单2
[5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 25, 26, 27, 28, 29, 35, 36, 37, 38, 39, 45, 46, 47, 48, 49, 55, 56, 57, 58, 59, 65, 66, 67, 68, 69, 75, 76, 77, 78, 79, 85, 86, 87, 88, 89]
>>>

我会这样处理：

_list = [A, B, C, D, E, F, G, H, I, J]
_list2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

OGlist[i:i+5]表示范围（0，len（OGlist），10）内的i

返回一个序列，如

[[0,1,2,3,4]，[10,11,12,13,14]，…]

，

链。from\u iterable

将列表列表连接到一个列表中。

这是我的代码

from itertools import chain

_list = list(chain.from_iterable(OGlist[i:i+5] for i in range(0, len(OGlist), 10)))
_list2 = list(chain.from_iterable(OGlist[i:i+5] for i in range(5, len(OGlist), 10)))

---

我想为这个问题添加一个更动态的解决方案

如果您不知道列表/数组的大小，例如，我们添加一些元素（也不是5的倍数）：

OGlist=['A'，B'，C'，D'，E'，1,2,3,4,5'，F'，G'，H'，I'，J'，6,7,8,9,10'，AB'，BB'，CC'，DD']

看看会发生什么：

groups=list（zip（*（iter（OGlist））*5））
列表=functools.reduce（operator.iconcat，组[1:：2]，]）
list_2=functools.reduce（operator.iconcat，组[：：2]，]）
打印（列表，列表2）

输出

#[1,2,3,4,5,6,7,8,9,10][A'，B'，C'，D'，E'，F'，G'，H'，I'，J']

所有其他元素都消失了

简单解 注意，我的成绩有了很大提高，这只是一个例子

来自itertools导入计数
OGlist=['A'，'B'，'C'，'D'，'E'，1,2,3,4,5'，'F'，'G'，'H'，'I'，'J'，6,7,8,9,10'，AB'，'BB'，'CC'，'DD']
def get_分区（lst、start、stop）：
返回lst[开始：停止]
def交流发电机（lst）：
计数=计数（0，5）#生成迭代器
下一步（计数）
极限=长度（lst）
_列表=[]
_列表2=[]
prev=0
当限制>=0时：
切片器_first=next（计数）#获取前5个元素
切片器_second=下一个（计数）#获取第二个5个元素
#===========#
first_block=获取分区（lst、prev、切片器_first）
第二个\u块=获取分区（lst、切片器\u第一、切片器\u第二）
#=======<将元素添加到列表>=======#
_列表+=第一个\u块
_list2+=第二个_块
prev=切片器\秒
限值-=5
返回_列表，_列表2
对于交流发电机中的r（OGlist）：
打印（“列表=>”，r）
#列表=>['A'，B'，C'，D'，E'，F'，G'，H'，I'，J'，AB'，BB'，CC'，DD']
#列表=>[1,2,3,4,5,6,7,8,9,10]

在这个例子中，我使用了函数

调用

计数

得到5、10等

从函数

get_partition

中，我们得到元素的切片

import numpy as np

size_array = 500 # example
big_list = [x for x in range(size_array)]
half_list1 = []
half_list2 = []


idx = [x for x in range(0,int(size_array/5), 2)]
idx = np.repeat(idx, 5)*5 + np.tile([1, 2, 3, 4, 5], int(size_array/10))

half_list1 = [big_list[i] for i in idx]
half_list2 = [big_list[i+5] for i in idx]

import functools
import operator

OGlist = [A, B, C, D, E, 1, 2, 3, 4, 5, F, G, H, I, J, 6, 7, 8, 9, 10]

groups = list(zip(*(iter(OGlist),)*5))
list_ =  functools.reduce(operator.iconcat, groups[1::2], [])
list_2 = functools.reduce(operator.iconcat, groups[::2], [])