定期替换列表中的值

Question

假设我在Python中有以下列表:

my_list = [10] * 95

给定n,我想m在列表中替换任何其他元素,同时保留下一个n元素.

例如,如果n = 3和m = 2,我希望我的列表看起来像:

[10, 10, 10, 0, 0, 10, 10, 10 ,0, 0, ..., 10, 10, 10 , 0, 0]

如果它不能完全填补,因为与案件n = 4和m = 2,那么它的确定,如果我的名单看起来是这样的:

[10, 10, 10, 10, 0, 0, ..., 10, 10, 10, 10, 0]

我该如何尝试解决这个问题？

Answer 1

您可以使用itertools.cycle创建无限序列,[10, 10, 10, 0, 0]然后使用以下内容获取该序列的前95个元素itertools.islice:

n = 3
m = 2

pattern = [10] * n + [0] * m
my_list = list(itertools.islice(itertools.cycle(pattern), 95))

Answer 2

my_list = [10] * 95
n = 3
m = 2
for i in range(m):
    my_list[n+i::m+n] = [0] * len(my_list[n+i::m+n])

这只需要m完成工作的任务(m可能很小).

如果你真的只有两个可能的值(例如10和0),你可以做得更简单:

my_list = [ 10 if i % (n+m) < n else 0 for i in range(95) ]

但是在整个95范围内迭代Python,所以可能不是很快.

稍微复杂一些,但可能更有效(尤其是巨大的清单,并为大值n和m)将是这样的:

my_list = (([ 10 ] * n + [ 0 ] * m) * (95 // (n + m) + 1))[:95]

但是它内部构建了许多列表,因此需要通过测试来确定这是否对您的情况有效.(对于大型列表,也应考虑内存消耗.)

如果你可以使用numpy(有点偏离问题,但因为它很普遍):

my_list = (np.arange(95) % (n+m) < n) * 10

Answer 3

另一种可能性,这次是enumerate:

[x * (i % (n + m) < n) for i, x in enumerate(my_list)]

它使用的事实,False并True等于0和1在Python(见这里).

作为奖励,即使列表不是常数,它也能正常工作:

>>> n = 4
>>> m = 2
>>> my_list = range(20)
>>> [x * (i % (n+m) < n) for i, x in enumerate(my_list)]
[0, 1, 2, 3, 0, 0, 6, 7, 8, 9, 0, 0, 12, 13, 14, 15, 0, 0, 18, 19]

如果列表包含字符串,则用空字符串替换它们而不是0:

>>> my_list = 'abcdefghijk'
>>> [x * (i % (n+m) < n) for i, x in enumerate(my_list)]
['a', 'b', 'c', 'd', '', '', 'g', 'h', 'i', 'j', '']

Answer 4

这对我有用:

list = [10] * 95

n = 4
m = 2

amask = np.tile(np.concatenate((np.ones(n),np.zeros(m))),int((len(list)+1)/(n+m)))[:len(list)]

list = np.asarray(list)*amask

哪个输出:

array([10., 10., 10., 10.,  0.,  0., 10., 10., 10., 10.,  0.,  0., 10.,
       10., 10., 10.,  0.,  0., 10., 10., 10., 10.,  0.,  0., 10., 10.,
       10., 10.,  0.,  0., 10., 10., 10., 10.,  0.,  0., 10., 10., 10.,
       10.,  0.,  0., 10., 10., 10., 10.,  0.,  0., 10., 10., 10., 10.,
        0.,  0., 10., 10., 10., 10.,  0.,  0., 10., 10., 10., 10.,  0.,
        0., 10., 10., 10., 10.,  0.,  0., 10., 10., 10., 10.,  0.,  0.,
       10., 10., 10., 10.,  0.,  0., 10., 10., 10., 10.,  0.,  0., 10.,
       10., 10., 10.,  0.])

代码采用n和m构造一个1和0的掩码,其长度与初始匹配list使用该np.tile函数.然后,您只需将掩码乘以列表,并获得您想要的掩码.它也应灵活到列表的不同长度和(几乎)任意选择n和m.

如果需要,可以将数组转换回列表.

Answer 5

这个怎么样？

my_list = [10] * 95
n = 3
m = 2

for i in range(n, len(my_list)-1, n+m):
    my_list[i:i+m] = [0]*m

print(my_list)

编辑

我发现上述代码在某些情况下会更改结果列表的长度。

>>> a = [1,2,3]
>>> a[2:4] = [0] * 2
>>> a
[1, 2, 0, 0]

因此，应以某种方式恢复长度。

my_list = [10] * 95
cp_list = list(my_list)
n = 3
m = 5

for i in range(n, len(my_list)-1, n+m):
    cp_list[i:i+m] = [0]*m

cp_list = cp_list[:len(my_list)]
print(cp_list)