blocks|key|3274583|text|内置函数zip()几乎可以执行您想要的操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3274584|>>>+list(zip(*[(1,+2),+(3,+4),+(5,+6)]))
[(1,+3,+5),+(2,+4,+6)]|code-block|syntax|javascript|3274585|唯一的区别是你得到的是元组而不是列表。您可以使用以下命令将它们转换为列表|3274586|list(map(list,+zip(*[(1,+2),+(3,+4),+(5,+6)])))|3274587|entityMap^0|4|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

The built-in function <code>zip()</code> will almost do what you want:
<pre><code>&gt;&gt;&gt; list(zip(*[(1, 2), (3, 4), (5, 6)]))
[(1, 3, 5), (2, 4, 6)]
</code></pre>
The only difference is that you get tuples instead of lists. You can convert them to lists using
<pre><code>list(map(list, zip(*[(1, 2), (3, 4), (5, 6)])))
</code></pre>

blocks|key|5172106|text|从python+docs|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5172107|可以将|5172108|+zip()与*运算符一起用于解压缩列表：|blockquote|5172109|5172110|5172111|具体示例：|5172112|>>>+zip((1,3,5),(2,4,6))
[(1,+2),+(3,+4),+(5,+6)]
>>>+zip(*[(1,+2),+(3,+4),+(5,+6)])
[(1,+3,+5),+(2,+4,+6)]|code-block|syntax|javascript|5172113|或者，如果你真的想要列表：|5172114|>>>+map(list,+zip(*[(1,+2),+(3,+4),+(5,+6)]))
[[1,+3,+5],+[2,+4,+6]]|5172115|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/functions.html^0|1|B|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|18|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|19|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1B|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|1C|8|@]|9|@]|C|$P|Q]]|$1|R|3|S|5|6|7|1D|8|@]|9|@]|C|$]]|$1|T|3|U|5|O|7|1E|8|@]|9|@]|C|$P|Q]]|$1|V|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]]]

From the <a href="http://docs.python.org/library/functions.html">python docs</a>:

<blockquote>
 zip() in conjunction with the * operator can be used to unzip a list:
</blockquote>

Specific example:

<pre><code>&gt;&gt;&gt; zip((1,3,5),(2,4,6))
[(1, 2), (3, 4), (5, 6)]
&gt;&gt;&gt; zip(*[(1, 2), (3, 4), (5, 6)])
[(1, 3, 5), (2, 4, 6)]
</code></pre>

Or, if you really want lists:

<pre><code>&gt;&gt;&gt; map(list, zip(*[(1, 2), (3, 4), (5, 6)]))
[[1, 3, 5], [2, 4, 6]]
</code></pre>

blocks|key|5172121|text|使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5172122|a+=+[(1,2),(3,4),(5,6),]++++
b+=+zip(*a)
>>>+[(1,+3,+5),+(2,+4,+6)]|code-block|syntax|javascript|5172123|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use:

<pre><code>a = [(1,2),(3,4),(5,6),] 
b = zip(*a)
&gt;&gt;&gt; [(1, 3, 5), (2, 4, 6)]
</code></pre>

blocks|key|5172268|text|franklsf95在他的答案中追求性能，并选择了list.append()，但它们并不是最优的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5172269|添加列表理解后，我得到了以下结论：|5172270|def+t1(zs):
++++xs,+ys+=+zip(*zs)
++++return+xs,+ys

def+t2(zs):
++++xs,+ys+=+[],+[]
++++for+x,+y+in+zs:
++++++++xs.append(x)
++++++++ys.append(y)
++++return+xs,+ys

def+t3(zs):
++++xs,+ys+=+[x+for+x,+y+in+zs],+[y+for+x,+y+in+zs]
++++return+xs,+ys

if+__name__+==+'__main__':
++++from+timeit+import+timeit
++++setup_string='''\
N+=+2000000
xs+=+list(range(1,+N))
ys+=+list(range(N%2B1,+N*2))
zs+=+list(zip(xs,+ys))
from+__main__+import+t1,+t2,+t3
'''
++++print(f'zip:\t\t{timeit('t1(zs)',+setup=setup_string,+number=1000)}')
++++print(f'append:\t\t{timeit('t2(zs)',+setup=setup_string,+number=1000)}')
++++print(f'list+comp:\t{timeit('t3(zs)',+setup=setup_string,+number=1000)}')|code-block|syntax|javascript|5172271|这就给出了结果：|5172272|zip:++++++++++++122.11585397789766
append:+++++++++356.44876132614047
list+comp:++++++144.637765085659|5172273|因此，如果您追求的是性能，那么您可能应该使用zip()，尽管列表理解并不落后太多。相比之下，append的性能实际上相当差。|5172274|entityMap^0|P|D|0|0|0|0|0|M|5|1A|6|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

franklsf95 goes for performance in his answer and opts for <code>list.append()</code>, but they are not optimal.

Adding list comprehensions, I ended up with the following:

<pre><code>def t1(zs):
 xs, ys = zip(*zs)
 return xs, ys

def t2(zs):
 xs, ys = [], []
 for x, y in zs:
 xs.append(x)
 ys.append(y)
 return xs, ys

def t3(zs):
 xs, ys = [x for x, y in zs], [y for x, y in zs]
 return xs, ys

if __name__ == '__main__':
 from timeit import timeit
 setup_string='''\
N = 2000000
xs = list(range(1, N))
ys = list(range(N+1, N*2))
zs = list(zip(xs, ys))
from __main__ import t1, t2, t3
'''
 print(f'zip:\t\t{timeit('t1(zs)', setup=setup_string, number=1000)}')
 print(f'append:\t\t{timeit('t2(zs)', setup=setup_string, number=1000)}')
 print(f'list comp:\t{timeit('t3(zs)', setup=setup_string, number=1000)}')
</code></pre>

This gave the result:

<pre><code>zip: 122.11585397789766
append: 356.44876132614047
list comp: 144.637765085659
</code></pre>

So if you are after performance, you should probably use <code>zip()</code> although list comprehensions are not too far behind. The performance of <code>append</code> is actually pretty poor in comparison.

blocks|key|5172225|text|尽管*zip更具Pythonic风格，但以下代码的性能要好得多：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5172226|xs,+ys+=+[],+[]
for+x,+y+in+zs:
++++xs.append(x)
++++ys.append(y)|code-block|syntax|javascript|5172227|此外，当原始列表zs为空时，*zip将引发，但此代码可以正确处理。|5172228|我只是运行了一个快速实验，结果如下：|5172229|Using+*zip:+++++1.54701614s
Using+append:+++0.52687597s|5172230|运行多次，append比zip快3到4倍！测试脚本如下：|5172231|#!/usr/bin/env+python3
import+time

N+=+2000000
xs+=+list(range(1,+N))
ys+=+list(range(N%2B1,+N*2))
zs+=+list(zip(xs,+ys))

t1+=+time.time()

xs_,+ys_+=+zip(*zs)
print(len(xs_),+len(ys_))

t2+=+time.time()

xs_,+ys_+=+[],+[]
for+x,+y+in+zs:
++++xs_.append(x)
++++ys_.append(y)
print(len(xs_),+len(ys_))

t3+=+time.time()

print('Using+*zip:\t{:.8f}s'.format(t2+-+t1))
print('Using+append:\t{:.8f}s'.format(t3+-+t2))|5172232|我的Python版本：|5172233|Python+3.6.3+(default,+Oct+24+2017,+12:18:40)
[GCC+4.2.1+Compatible+Apple+LLVM+8.1.0+(clang-802.0.42)]+on+darwin
Type+"help",+"copyright",+"credits"+or+"license"+for+more+information.|5172234|entityMap^0|2|4|0|0|8|2|E|4|0|0|0|5|6|C|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|19|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1H|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1I|8|@]|D|@]|E|$I|J]]|$1|Y|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|Z|$]]

Despite <code>*zip</code> being more Pythonic, the following code has much better performance:

<pre><code>xs, ys = [], []
for x, y in zs:
 xs.append(x)
 ys.append(y)
</code></pre>

Also, when the original list <code>zs</code> is empty, <code>*zip</code> will raise, but this code can properly handle.

I just ran a quick experiment, and here is the result:

<pre><code>Using *zip: 1.54701614s
Using append: 0.52687597s
</code></pre>

Running it multiple times, <code>append</code> is 3x - 4x faster than <code>zip</code>! The test script is here:

<pre><code>#!/usr/bin/env python3
import time

N = 2000000
xs = list(range(1, N))
ys = list(range(N+1, N*2))
zs = list(zip(xs, ys))

t1 = time.time()

xs_, ys_ = zip(*zs)
print(len(xs_), len(ys_))

t2 = time.time()

xs_, ys_ = [], []
for x, y in zs:
 xs_.append(x)
 ys_.append(y)
print(len(xs_), len(ys_))

t3 = time.time()

print('Using *zip:\t{:.8f}s'.format(t2 - t1))
print('Using append:\t{:.8f}s'.format(t3 - t2))
</code></pre>

My Python Version:

<pre><code>Python 3.6.3 (default, Oct 24 2017, 12:18:40)
[GCC 4.2.1 Compatible Apple LLVM 8.1.0 (clang-802.0.42)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
</code></pre>

blocks|key|866325|text|除了克劳迪奥的答案之外，你还可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866326|>>>a,+b+=+map(list,+zip(*[(1,+2),+(3,+4),+(5,+6)]))
>>>a
[1,3,5]
>>>b
[2,4,6]|code-block|syntax|javascript|866327|根据@Peyman+mohseni+kiasari编辑|866328|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In addition to Claudiu's answer, you can use:

<pre><code>&gt;&gt;&gt;a, b = map(list, zip(*[(1, 2), (3, 4), (5, 6)]))
&gt;&gt;&gt;a
[1,3,5]
&gt;&gt;&gt;b
[2,4,6]
</code></pre>

Edited according to @Peyman mohseni kiasari

blocks|key|3274651|text|除了克劳迪奥和克劳迪奥的回答之外，由于地图需要从python+3中的itertools导入，因此您还可以使用如下列表理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3274652|[[*x]+for+x+in+zip(*[(1,2),(3,4),(5,6)])]
>>>+[[1,+3,+5],+[2,+4,+6]]|code-block|syntax|javascript|3274653|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Adding to Claudiu's and Claudiu's answer and since map needs to be imported from itertools in python 3, you also use a list comprehension like:

<pre><code>[[*x] for x in zip(*[(1,2),(3,4),(5,6)])]
&gt;&gt;&gt; [[1, 3, 5], [2, 4, 6]]
</code></pre>

Suppose I have a list of tuples and I want to convert to multiple lists.

For example, the list of tuples is 

<pre><code>[(1,2),(3,4),(5,6),]
</code></pre>

Is there any built-in function in Python that convert it to:

<pre><code>[1,3,5],[2,4,6]
</code></pre>

This can be a simple program. But I am just curious about the existence of such built-in function in Python.

How to convert list of tuples to multiple lists?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设我有一个元组列表，并且我想转换成多个列表。例如，元组列表为[(1,2),(3,4),(5,6),]Python中有没有内置函数可以将其转换为：[1,3,5],[2,4,6]这可以是一个简单的程序。但我只是对Python中是否存在这样的内置函数感到好奇。

问如何将元组列表转换为多个列表？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将元组列表转换为多个列表？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将元组列表转换为多个列表？
EN