我有一个2项元组的列表,我想将它们转换为2个列表,其中第一个包含每个元组中的第一项,第二个包含第二项。
例如:
original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# and I want to become...
result = (['a', 'b', 'c', 'd'], [1, 2, 3, 4])
有内置的功能吗?
我有一个2项元组的列表,我想将它们转换为2个列表,其中第一个包含每个元组中的第一项,第二个包含第二项。
例如:
original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# and I want to become...
result = (['a', 'b', 'c', 'd'], [1, 2, 3, 4])
有内置的功能吗?
Answers:
zip
是它自己的逆!前提是您使用特殊的*运算符。
>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
它的工作方式是通过调用zip
参数:
zip(('a', 1), ('b', 2), ('c', 3), ('d', 4))
…除了参数zip
直接传递(在转换为元组之后)之外,因此不必担心参数数量太大。
zip([], [])
这种方式解压缩不会使您感到困惑[], []
。它让你[]
。如果仅...
zip
除了返回迭代器而不是列表之外,在Python 3中的工作原理完全相同。为了获得与上述相同的输出,您只需要将zip调用包装在一个列表中即可: list(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)]))
将输出[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
list
很好。但是,如果你试图(通过实现完整的结果一下子list
ifying的结果zip
),你可能会使用大量内存(因为所有的tuple
小号必须立即创建)。如果你可以遍历的结果zip
,而不list
ifying,你可以节省大量的内存。唯一需要关注的是输入中是否包含许多元素。这样做的代价是必须将它们全部解压缩为参数,并且zip
需要为所有它们创建和存储迭代器。这是一个非常长的list
s 真正的问题(请考虑成千上万个元素或更多)。
你也可以
result = ([ a for a,b in original ], [ b for a,b in original ])
它应该更好地扩展。特别是如果Python除非需要,否则最好不要扩展列表推导。
(顺便说一句,它会组成一个2元组(一对)的列表,而不是一个元组列表,例如 zip
。)
如果可以使用生成器而不是实际列表,则可以这样做:
result = (( a for a,b in original ), ( b for a,b in original ))
生成器在您请求每个元素之前不会仔细检查列表,但是另一方面,它们会保留对原始列表的引用。
zip(*x)
版本“更好地扩展” 。zip(*x)
只需要通过循环一次,并且不会用完堆栈元素。
zip
如果用例是转置后的数据被立即使用并丢弃,而原始列表在内存中保留的时间更长,则此答案仅比使用更好。
如果列表的长度不同,则可能不希望按照Patricks的答案使用zip。这有效:
>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
但是使用不同的长度列表,zip会将每个项目截断为最短列表的长度:
>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e')]
您可以使用不带功能的map来用None填充空白结果:
>>> map(None, *[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, None)]
zip()稍快一些。
izip_longest
zip_longest
python3用户而闻名。
def transpose_finite_iterable(iterable):
return zip(*iterable) # `itertools.izip` for Python 2 users
对于(潜在无限)可迭代的有限可迭代(例如list
/ tuple
/的序列str
),效果很好
| |a_00| |a_10| ... |a_n0| |
| |a_01| |a_11| ... |a_n1| |
| |... | |... | ... |... | |
| |a_0i| |a_1i| ... |a_ni| |
| |... | |... | ... |... | |
哪里
n in ℕ
,a_ij
对应于-th可迭代的j
-th元素i
,申请后transpose_finite_iterable
我们得到
| |a_00| |a_01| ... |a_0i| ... |
| |a_10| |a_11| ... |a_1i| ... |
| |... | |... | ... |... | ... |
| |a_n0| |a_n1| ... |a_ni| ... |
这种情况的Python示例,其中a_ij == j
,n == 2
>>> from itertools import count
>>> iterable = [count(), count()]
>>> result = transpose_finite_iterable(iterable)
>>> next(result)
(0, 0)
>>> next(result)
(1, 1)
但是我们不能transpose_finite_iterable
再次使用它来返回原始的结构,iterable
因为它result
是有限迭代的无限迭代(tuple
在我们的例子中是s):
>>> transpose_finite_iterable(result)
... hangs ...
Traceback (most recent call last):
File "...", line 1, in ...
File "...", line 2, in transpose_finite_iterable
MemoryError
那么我们该如何处理呢?
deque
看完itertools.tee
function文档后,有一些Python配方可以通过一些修改来帮助解决我们的问题
def transpose_finite_iterables(iterable):
iterator = iter(iterable)
try:
first_elements = next(iterator)
except StopIteration:
return ()
queues = [deque([element])
for element in first_elements]
def coordinate(queue):
while True:
if not queue:
try:
elements = next(iterator)
except StopIteration:
return
for sub_queue, element in zip(queues, elements):
sub_queue.append(element)
yield queue.popleft()
return tuple(map(coordinate, queues))
让我们检查
>>> from itertools import count
>>> iterable = [count(), count()]
>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))
>>> result
(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)
>>> next(result[0])
0
>>> next(result[0])
1
现在我们可以定义通用函数来处理可迭代的可迭代对象,其中一些是有限的,而另一个则可以使用functools.singledispatch
装饰器(例如)
from collections import (abc,
deque)
from functools import singledispatch
@singledispatch
def transpose(object_):
"""
Transposes given object.
"""
raise TypeError('Unsupported object type: {type}.'
.format(type=type))
@transpose.register(abc.Iterable)
def transpose_finite_iterables(object_):
"""
Transposes given iterable of finite iterables.
"""
iterator = iter(object_)
try:
first_elements = next(iterator)
except StopIteration:
return ()
queues = [deque([element])
for element in first_elements]
def coordinate(queue):
while True:
if not queue:
try:
elements = next(iterator)
except StopIteration:
return
for sub_queue, element in zip(queues, elements):
sub_queue.append(element)
yield queue.popleft()
return tuple(map(coordinate, queues))
def transpose_finite_iterable(object_):
"""
Transposes given finite iterable of iterables.
"""
yield from zip(*object_)
try:
transpose.register(abc.Collection, transpose_finite_iterable)
except AttributeError:
# Python3.5-
transpose.register(abc.Mapping, transpose_finite_iterable)
transpose.register(abc.Sequence, transpose_finite_iterable)
transpose.register(abc.Set, transpose_finite_iterable)
在有限非空可迭代项上的二元运算符类中,可以将其视为自身的逆(数学家称这种函数为“对合”)。
作为singledispatch
ing 的奖励,我们可以处理numpy
类似
import numpy as np
...
transpose.register(np.ndarray, np.transpose)
然后像
>>> array = np.arange(4).reshape((2,2))
>>> array
array([[0, 1],
[2, 3]])
>>> transpose(array)
array([[0, 2],
[1, 3]])
由于transpose
返回迭代器,并且如果有人希望在OP中具有的tuple
,list
则可以通过map
内置函数(例如
>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> tuple(map(list, transpose(original)))
(['a', 'b', 'c', 'd'], [1, 2, 3, 4])
我已经添加推广解决方案lz
包从0.5.0
版本,可以像使用
>>> from lz.transposition import transpose
>>> list(map(tuple, transpose(zip(range(10), range(10, 20)))))
[(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (10, 11, 12, 13, 14, 15, 16, 17, 18, 19)]
没有用于处理潜在无限迭代的潜在无限迭代的解决方案(至少很明显),但是这种情况并不常见。
考虑使用more_itertools.unzip:
>>> from more_itertools import unzip
>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> [list(x) for x in unzip(original)]
[['a', 'b', 'c', 'd'], [1, 2, 3, 4]]
因为它返回元组(并且可以使用大量内存),所以zip(*zipped)
对我来说,这个技巧似乎比有用的还要聪明。
这是一个实际上将为您提供zip反函数的函数。
def unzip(zipped):
"""Inverse of built-in zip function.
Args:
zipped: a list of tuples
Returns:
a tuple of lists
Example:
a = [1, 2, 3]
b = [4, 5, 6]
zipped = list(zip(a, b))
assert zipped == [(1, 4), (2, 5), (3, 6)]
unzipped = unzip(zipped)
assert unzipped == ([1, 2, 3], [4, 5, 6])
"""
unzipped = ()
if len(zipped) == 0:
return unzipped
dim = len(zipped[0])
for i in range(dim):
unzipped = unzipped + ([tup[i] for tup in zipped], )
return unzipped
先前的答案都没有有效地提供所需的输出,即列表的元组,而不是元组的列表。对于前者,你可以使用与。区别在于:tuple
map
res1 = list(zip(*original)) # [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
res2 = tuple(map(list, zip(*original))) # (['a', 'b', 'c', 'd'], [1, 2, 3, 4])
此外,大多数以前的解决方案都假定使用Python 2.7,在Python 2.7中zip
返回列表而不是迭代器。
对于Python 3.x,您需要将结果传递给诸如list
或tuple
耗尽迭代器的函数。对于内存高效的迭代器,您可以省略外部list
和外部tuple
调用各自的解决方案。
虽然zip(*seq)
非常有用,但可能不适用于很长的序列,因为它将创建要传递的值的元组。例如,我一直在使用具有超过一百万个条目的坐标系,并且发现创建它的速度明显更快序列直接。
通用方法如下所示:
from collections import deque
seq = ((a1, b1, …), (a2, b2, …), …)
width = len(seq[0])
output = [deque(len(seq))] * width # preallocate memory
for element in seq:
for s, item in zip(output, element):
s.append(item)
但是,根据您要对结果执行的操作,收集的选择可能会产生很大的不同。在我的实际用例中,使用集而不使用内部循环比所有其他方法明显更快。
而且,正如其他人指出的那样,如果您要对数据集执行此操作,则可以改用Numpy或Pandas集合。
虽然numpy数组和熊猫可能是更可取的,但此函数模仿zip(*args)
as时的行为unzip(args)
。
允许在args
迭代值时传递生成器。装饰cls
和/或main_cls
微管理容器初始化。
def unzip(items, cls=list, main_cls=tuple):
"""Zip function in reverse.
:param items: Zipped-like iterable.
:type items: iterable
:param cls: Callable that returns iterable with callable append attribute.
Defaults to `list`.
:type cls: callable, optional
:param main_cls: Callable that returns iterable with callable append
attribute. Defaults to `tuple`.
:type main_cls: callable, optional
:returns: Unzipped items in instances returned from `cls`, in an instance
returned from `main_cls`.
:Example:
assert unzip(zip(["a","b","c"],[1,2,3])) == (["a","b",c"],[1,2,3])
assert unzip([("a",1),("b",2),("c",3)]) == (["a","b","c"],[1,2,3])
assert unzip([("a",1)], deque, list) == [deque(["a"]),deque([1])]
assert unzip((["a"],["b"]), lambda i: deque(i,1)) == (deque(["b"]),)
"""
items = iter(items)
try:
i = next(items)
except StopIteration:
return main_cls()
unzipped = main_cls(cls([v]) for v in i)
for i in items:
for c,v in zip(unzipped,i):
c.append(v)
return unzipped