如何压缩两个不同大小的列表，重复较短的列表？

小开

最佳答案

你可以使用 itertools.cycle:

使用迭代器从迭代器返回元素并保存每个元素的副本。当迭代器耗尽时，从保存的副本中返回元素。无限重复。

例如:

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


from itertools import cycle
zip_list = zip(A, cycle(B)) if len(A) > len(B) else zip(cycle(A), B)

小开

试试这个。

A = [1,2,3,4,5,6,7,8,9]
B = ["A","B","C"]
Z = []
for i, a in enumerate(A):
Z.append((a, B[i % len(B)]))

只要确保较大的列表是在 A。

小开

也许有一个更好的方法，但是你可以创建一个函数来重复你的列表到你想要的长度。

def repeatlist(l,i):
'''give a list and a total length'''
while len(l) < i:
l += l
while len(l) > i:
l.pop()

那就做吧

repeatlist(B,len(A))
zip_list = zip(A,B)

小开

对称，无条件一行

[*zip(A*(len(B)//len(A) + 1), B*(len(A)//len(B) + 1))]

严格回答 如何压缩两个 < strong > 不同大小的列表

需要一个补丁为同等规模的名单是通用的:

[*(zip(A, B) if len(A) == len(B)
else zip(A*(len(B)//len(A) + 1),
B*(len(A)//len(B) + 1)))]

小开

现在有了列举理解

[(i, B[i % 3 - 1]) for i in A]

或者，如果 A的元素不是顺序的，并且不需要考虑列表长度

[(j, B[i % len(B)]) for i, j in enumerate(A)] if len(A) >= len(B) else \
[(A[i % len(A)], j) for i, j in enumerate(B)]

小开

对于以任意顺序处理任意有限数目的潜在无限可迭代程序的版本:

from itertools import cycle, tee, zip_longest


def cyclical_zip(*iterables):
iterables_1, iterables_2 = zip(*map(tee, iterables))  # Allow proper iteration of iterators


for _, x in zip(
zip_longest(*iterables_1),      # Limit             by the length of the longest iterable
zip(*map(cycle, iterables_2))): #       the cycling
yield x


assert list(cyclical_zip([1, 2, 3], 'abcd', 'xy')) == [(1, 'a', 'x'), (2, 'b', 'y'), (3, 'c', 'x'), (1, 'd', 'y')]  # An example and test case

小开

解决任意数量的迭代，你不知道哪一个是最长的(也允许任何空的迭代的默认值) :

from itertools import cycle, zip_longest


def zip_cycle(*iterables, empty_default=None):
cycles = [cycle(i) for i in iterables]
for _ in zip_longest(*iterables):
yield tuple(next(i, empty_default) for i in cycles)


for i in zip_cycle(range(2), range(5), ['a', 'b', 'c'], []):
print(i)

产出:

(0, 0, 'a', None)
(1, 1, 'b', None)
(0, 2, 'c', None)
(1, 3, 'a', None)
(0, 4, 'b', None)

小开

d1=['one','two','three']
d2=[1,2,3,4,5]

什么都没有

zip(d1,d2)
<zip object at 0x05E494B8>

邮政编码清单

list(zip(d1,d2))

拉链清单词典

{'one': 1, 'two': 2, 'three': 3}

注意: Python 3.7 +

小开

你可以使用 itertools.cycle:

from itertools import cycle


my_list = [1, 2, 3, 5, 5, 9]
another_list = ['Yes', 'No']


cyc = cycle(another_list)


print([[i, next(cyc)] for i in my_list])
# [[1, 'Yes'], [2, 'No'], [3, 'Yes'], [5, 'No'], [5, 'Yes'], [9, 'No']]

小开

试试这样:

my_list=[  1,   2,   3, 5,  5,  9]
another_list=['Yes','No']
if type(len(my_list)/2) == float:
ml=int(len(my_list)/2)+1
else:
ml=int(len(my_list)/2)


print([[x,y] for x,y in zip(my_list,another_list*ml)])

本土方式:

尝试计算并取整第一个列表长度的一半，如果是 float，那么也加1
在第二个 YesNo 列表与之前计算的数字相乘之前使用 zip()进行迭代

小开

让我们使用 np.tile和 zip:

my_list = [1, 2, 3, 5, 5, 9]
another_list = ['Yes', 'No']
list(zip(my_list,np.tile(another_list, len(my_list)//len(another_list) + 1)) )

产出:

[(1, 'Yes'), (2, 'No'), (3, 'Yes'), (5, 'No'), (5, 'Yes'), (9, 'No')]

小开

你知道第二份名单比较短吗？

import itertools
list(zip(my_list, itertools.cycle(another_list)))

这实际上会给出一个元组列表，而不是列表列表。

小开

一个非常简单的方法是将短名单相乘，这样短名单就会更长:

my_list = [1, 2, 3, 5, 5, 9]
another_list = ['Yes', 'No']


zip(my_list, another_list*3))
#[(1, 'Yes'), (2, 'No'), (3, 'Yes'), (5, 'No'), (5, 'Yes'), (9, 'No')]

请注意，这里不需要仔细计算乘数，因为 zip只到最短列表的长度(乘数的重点是确保最短列表是 my_list)。也就是说，如果使用 100而不是 3，结果将是相同的。

小开

可以在计数的循环中使用模 %运算符

my_list=[1, 2, 3, 5, 5, 9]
another_list=['Yes','No']


new_list = []
for cur in range(len(my_list)):
new_list.append([my_list[cur], another_list[cur % 2]])
# [[1, 'Yes'], [2, 'No'], [3, 'Yes'], [5, 'No'], [5, 'Yes'], [9, 'No']]

可以用 len(another_list)代替 2

小开

我喜欢易亨利的回答，它的执行速度更快一些，但是这里有一个不使用 itertools 的答案。

my_list = [1, 2, 3, 5, 5, 9]
another_list = ['Yes', 'No']


new_list = []
for i in range(len(my_list)):
new_list.append([my_list[i], another_list[i % len(another_list)]])


new_list


[[1, 'Yes'], [2, 'No'], [3, 'Yes'], [5, 'No'], [5, 'Yes'], [9, 'No']]

小开

这个问题试图用错误的方法解决问题。

您在这里尝试的是获取两个给定列表的元素的所有可能的排列。这可以很容易地实现使用 itertools.product

>>> from itertools import product
>>> list(product(range(2), range(5)))
[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4)]
>>> list(product(range(2), range(2)))
[(0, 0), (0, 1), (1, 0), (1, 1)]
>>> list(product(range(2), range(2), range(3)))
[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 1, 0), (0, 1, 1), (0, 1, 2), (1, 0, 0), (1, 0, 1), (1, 0, 2), (1, 1, 0), (1, 1, 1), (1, 1, 2)]