blocks|key|1956967|text|y+=+[i[0]+for+i+in+x]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1956968|但是，这只适用于每个元组中的一个元素。|unstyled|1956969|但是，如果每个元组有多个元素，则可以使用稍微复杂一点的列表理解：|1956970|y+=+[i[j]+for+i+in+x+for+j+in+range(len(i))]|1956971|参考：List+Comprehensions|offset|length|1956972|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/2/tutorial/datastructures.html?highlight=list%2520comprehension#list-comprehensions^0|0|0|0|0|3|J|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$B|C]]|$1|K|3|L|5|F|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

<pre><code>y = [i[0] for i in x]
</code></pre>

This only works for one element per tuple, though.

However, if you have multiple elements per tuple, you can use a slightly more complex list comprehension:

<pre><code>y = [i[j] for i in x for j in range(len(i))]
</code></pre>

Reference: <a href="http://docs.python.org/2/tutorial/datastructures.html?highlight=list%20comprehension#list-comprehensions" rel="nofollow">List Comprehensions</a>

blocks|key|4795507|text|只需执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4795508|x+=+[i[0]+for+i+in+x]|code-block|syntax|javascript|4795509|解释：|4795510|>>>+x=[(12,),+(1,),+(3,)]

>>>+x
[(12,),+(1,),+(3,)]

>>>+[i+for+i+in+x]
[(12,),+(1,),+(3,)]

>>>+[i[0]+for+i+in+x]
[12,+1,+3]|4795511|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just do this:

<pre><code>x = [i[0] for i in x]
</code></pre>

Explanation:

<pre><code>&gt;&gt;&gt; x=[(12,), (1,), (3,)]

&gt;&gt;&gt; x
[(12,), (1,), (3,)]

&gt;&gt;&gt; [i for i in x]
[(12,), (1,), (3,)]

&gt;&gt;&gt; [i[0] for i in x]
[12, 1, 3]
</code></pre>

blocks|key|2682581|text|这是最有效的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2682582|x+=+[i+for+i,+in+x]|code-block|syntax|javascript|2682583|或者，等同地|2682584|x+=+[i+for+(i,)+in+x]|2682585|这有点慢：|2682586|x+=+[i[0]+for+i+in+x]|2682587|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This is the most efficient way:

<pre><code>x = [i for i, in x]
</code></pre>

or, equivalently

<pre><code>x = [i for (i,) in x]
</code></pre>

This is a bit slower:

<pre><code>x = [i[0] for i in x]
</code></pre>

blocks|key|2682591|text|你可以使用map函数....|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2682592|map(lambda+y:+y[0],+x)|code-block|syntax|javascript|2682593|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|$]]

you can use map function.... 

<pre><code>map(lambda y: y[0], x)
</code></pre>

blocks|key|50739|text|你没有说你所说的“最好的”是什么意思，但你大概是指“最pythonic的”或“最易读的”或类似的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|50740|F3AR3DLEGEND给出的列表理解可能是最简单的。任何知道如何阅读列表理解的人都会立即知道它的含义。|50741|y+=+[i[0]+for+i+in+x]|code-block|syntax|javascript|50742|然而，通常你并不真正需要一个列表，只需要一些可以迭代一次的东西。如果您在x中有十亿个元素，那么构建一个包含十亿个元素的y来一次迭代一个元素可能不是一个好主意。因此，您可以使用生成器表达式：|offset|length|style|CODE|50743|y+=+(i[0]+for+i+in+x)|50744|如果您更喜欢函数式编程，则可能更喜欢使用map。map的缺点是您必须向它传递一个函数，而不仅仅是一个表达式，这意味着您需要使用lambda函数或itemgetter|50745|y+=+map(operator.itemgetter(0),+x)|50746|在Python3中，这相当于生成器表达式；如果需要list，则将其传递给list。在Python2中，它返回一个list；如果需要迭代器，请使用itertools.imap而不是map。|50747|如果您想要一个更通用的扁平化解决方案，您可以自己编写一个，但这种通用解决方案的itertools总是值得一看的，实际上有一个名为flatten的配方用于“扁平化一级嵌套”。因此，将其复制并粘贴到您的代码(或pip+install+more-itertools)中，您只需执行以下操作：|50748|y+=+flatten(x)|50749|如果您先看看flatten是如何实现的，然后看看chain.from_iterable是如何实现的，然后再看看chain是如何实现的，您就会注意到，您可以在内置方面编写相同的代码。但是，当flatten变得更具可读性和易读性时，为什么还要费心呢？|50750|最后，如果您希望将泛型版本简化为嵌套列表理解(当然是生成器表达式)：|50751|y+=+[j+for+i+in+x+for+j+in+i]|50752|然而，嵌套的列表理解很容易出错，无论是在写还是读。(请注意，第一个给出最简单答案的人F3AR3DLEGEND也给出了嵌套理解，但却错了。如果他做不到，你确定要试一下吗？)对于非常简单的情况，它们不是太差，但我仍然认为flatten更容易阅读。|50753|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/2/library/itertools.html#recipes^0|0|0|0|10|1|1N|1|0|0|K|3|O|3|1R|6|20|A|0|0|P|4|10|4|1K|4|20|E|2H|3|0|13|9|1S|7|2V|Q|13|9|0|0|0|6|7|O|J|1J|5|2M|7|0|0|0|30|7|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1H|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1J|8|@$K|1K|L|1L|M|N]|$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|1O|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1P|8|@$K|1Q|L|1R|M|N]|$K|1S|L|1T|M|N]|$K|1U|L|1V|M|N]|$K|1W|L|1X|M|N]]|9|@]|A|$]]|$1|S|3|T|5|F|7|1Y|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1Z|8|@$K|20|L|21|M|N]|$K|22|L|23|M|N]|$K|24|L|25|M|N]|$K|26|L|27|M|N]|$K|28|L|29|M|N]]|9|@]|A|$]]|$1|W|3|X|5|6|7|2A|8|@$K|2B|L|2C|M|N]|$K|2D|L|2E|M|N]|$K|2F|L|2G|M|N]]|9|@$K|2H|L|2I|1|2J]]|A|$]]|$1|Y|3|Z|5|F|7|2K|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|2L|8|@$K|2M|L|2N|M|N]|$K|2O|L|2P|M|N]|$K|2Q|L|2R|M|N]|$K|2S|L|2T|M|N]]|9|@]|A|$]]|$1|12|3|13|5|6|7|2U|8|@]|9|@]|A|$]]|$1|14|3|15|5|F|7|2V|8|@]|9|@]|A|$G|H]]|$1|16|3|17|5|6|7|2W|8|@$K|2X|L|2Y|M|N]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|2Z|8|@]|9|@]|A|$]]]|19|$1A|$5|1B|1C|1D|A|$1E|1F]]]]

You didn't say what you mean by "best", but presumably you mean "most pythonic" or "most readable" or something like that.

The list comprehension given by F3AR3DLEGEND is probably the simplest. Anyone who knows how to read a list comprehension will immediately know what it means.

<pre><code>y = [i[0] for i in x]
</code></pre>

However, often you don't really need a list, just something that can be iterated over once. If you've got a billion elements in <code>x</code>, building a billion-element <code>y</code> just to iterate over it one element at a time may be a bad idea. So, you can use a generator expression:

<pre><code>y = (i[0] for i in x)
</code></pre>

If you prefer functional programming, you might prefer to use <code>map</code>. The downside of <code>map</code> is that you have to pass it a function, not just an expression, which means you either need to use a <code>lambda</code> function, or <code>itemgetter</code>:

<pre><code>y = map(operator.itemgetter(0), x)
</code></pre>

In Python 3, this is equivalent to the generator expression; if you want a <code>list</code>, pass it to <code>list</code>. In Python 2, it returns a <code>list</code>; if you want an iterator, use <code>itertools.imap</code> instead of <code>map</code>.

If you want a more generic flattening solution, you can write one yourself, but it's always worth looking at <a href="http://docs.python.org/2/library/itertools.html#recipes" rel="noreferrer"><code>itertools</code></a> for generic solutions of this kind, and there is in fact a recipe called <code>flatten</code> that's used to "Flatten one level of nesting". So, copy and paste that into your code (or <code>pip install more-itertools</code>) and you can just do this:

<pre><code>y = flatten(x)
</code></pre>

If you look at how <code>flatten</code> is implemented, and then at how <code>chain.from_iterable</code> is implemented, and then at how <code>chain</code> is implemented, you'll notice that you could write the same thing in terms of builtins. But why bother, when <code>flatten</code> is going to be more readable and obvious?

Finally, if you want to reduce the generic version to a nested list comprehension (or generator expression, of course):

<pre><code>y = [j for i in x for j in i]
</code></pre>

However, nested list comprehensions are very easy to get wrong, both in writing and reading. (Note that F3AR3DLEGEND, the same person who gave the simplest answer first, also gave a nested comprehension and got it wrong. If he can't pull it off, are you sure you want to try?) For really simple cases, they're not too bad, but still, I think <code>flatten</code> is a lot easier to read.

So, I have <code>x=[(12,), (1,), (3,)]</code> (list of tuples) and I want <code>x=[12, 1, 3]</code> (list of integers) in best way possible? Can you please help?

Python list of tuples to list of int

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

所以，我有x=[(12,), (1,), (3,)] (元组列表)，我想要以最好的方式使用x=[12, 1, 3] (整数列表)？你能帮帮忙吗？

问到int列表的元组的Python列表
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问到int列表的元组的Python列表EN