blocks|key|1654050|text|可以使用x+=+func()[0]返回第一个值，使用x+=+func()[1]返回第二个值，依此类推。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1654051|如果你想一次获得多个值，可以使用x,+y+=+func()[2:4]这样的东西。|1654052|entityMap^0|4|D|Q|D|0|G|I|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

You can use <code>x = func()[0]</code> to return the first value, <code>x = func()[1]</code> to return the second, and so on.

If you want to get multiple values at a time, use something like <code>x, y = func()[2:4]</code>.

blocks|key|1439410|text|一种常见的约定是使用"_“作为要忽略的元组元素的变量名。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1439411|def+f():
++++return+1,+2,+3

_,+_,+x+=+f()|code-block|syntax|javascript|1439412|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|$]]

One common convention is to use a "_" as a variable name for the elements of the tuple you wish to ignore. For instance:

<pre><code>def f():
 return 1, 2, 3

_, _, x = f()
</code></pre>

blocks|key|1654159|text|三个简单的选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1654160|显而易见|1654161|x,+_+=+func()

x,+junk+=+func()|code-block|syntax|javascript|1654162|丑陋|1654163|x+=+func()[0]|1654164|有一些方法可以通过装饰器来实现这一点。|1654165|def+val0(+aFunc+):
++++def+pick0(+*args,+**kw+):
++++++++return+aFunc(*args,**kw)[0]
++++return+pick0

func0=+val0(func)|1654166|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Three simple choices.

Obvious

<pre><code>x, _ = func()

x, junk = func()
</code></pre>

Hideous

<pre><code>x = func()[0]
</code></pre>

And there are ways to do this with a decorator.

<pre><code>def val0( aFunc ):
 def pick0( *args, **kw ):
 return aFunc(*args,**kw)[0]
 return pick0

func0= val0(func)
</code></pre>

blocks|key|1654210|text|请记住，当您返回多个项时，您实际上是在返回一个元组。所以你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1654211|def+func():
++++return+1,+2

print+func()[0]+#+prints+1
print+func()[1]+#+prints+2|code-block|syntax|javascript|1654212|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|$]]

Remember, when you return more than one item, you're really returning a tuple. So you can do things like this:

<pre><code>def func():
 return 1, 2

print func()[0] # prints 1
print func()[1] # prints 2
</code></pre>

blocks|key|1439503|text|这对我来说似乎是最好的选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1439504|val1,+val2,+ignored1,+ignored2+=+some_function()|code-block|syntax|javascript|1439505|它既不神秘也不丑陋(就像func()index方法一样)，并且清楚地说明了您的目的。|1439506|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|$]]

This seems like the best choice to me:

<pre><code>val1, val2, ignored1, ignored2 = some_function()
</code></pre>

It's not cryptic or ugly (like the func()[index] method), and clearly states your purpose.

blocks|key|1439543|text|如果你使用的是Python3，你可以在变量前面使用星号(在赋值的左边)，让它成为解包中的一个列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1439544|#+Example+1:+a+is+1+and+b+is+[2,+3]

a,+*b+=+[1,+2,+3]

#+Example+2:+a+is+1,+b+is+[2,+3],+and+c+is+4

a,+*b,+c+=+[1,+2,+3,+4]

#+Example+3:+b+is+[1,+2]+and+c+is+3

*b,+c+=+[1,+2,+3]+++++++

#+Example+4:+a+is+1+and+b+is+[]

a,+*b+=+[1]|code-block|syntax|javascript|1439545|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|$]]

If you're using Python 3, you can you use the star before a variable (on the left side of an assignment) to have it be a list in unpacking.

<pre><code># Example 1: a is 1 and b is [2, 3]

a, *b = [1, 2, 3]

# Example 2: a is 1, b is [2, 3], and c is 4

a, *b, c = [1, 2, 3, 4]

# Example 3: b is [1, 2] and c is 3

*b, c = [1, 2, 3] 

# Example 4: a is 1 and b is []

a, *b = [1]
</code></pre>

blocks|key|1439628|text|这不是对这个问题的直接回答。相反，它回答了这个问题：“我如何从许多可能的选项中选择一个特定的函数输出？”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1439629|如果你能够编写函数(例如，它不在你不能修改的库中)，那么添加一个输入参数，表明你想要从函数中得到什么。让它成为一个具有默认值的命名参数，这样在“常见情况”中，你甚至不需要指定它。|1439630|++++def+fancy_function(+arg1,+arg2,+return_type=1+):
++++++++ret_val+=+None
++++++++if(+1+==+return_type+):
++++++++++++ret_val+=+arg1+%2B+arg2
++++++++elif(+2+==+return_type+):
++++++++++++ret_val+=+[+arg1,+arg2,+arg1+*+arg2+]
++++++++else:
++++++++++++ret_val+=+(+arg1,+arg2,+arg1+%2B+arg2,+arg1+*+arg2+)+
++++++++return(+ret_val+)|code-block|syntax|javascript|1439631|此方法向函数提供有关所需输出的“高级警告”。因此，它可以跳过不需要的处理，只做必要的工作来获得您想要的输出。另外，因为Python执行动态类型，所以返回类型可以更改。请注意示例如何返回标量、列表或元组...你喜欢什么都行！|1439632|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is not a direct answer to the question. Rather it answers this question: "How do I choose a specific function output from many possible options?".

If you are able to write the function (ie, it is not in a library you cannot modify), then add an input argument that indicates what you want out of the function. Make it a named argument with a default value so in the "common case" you don't even have to specify it.

<pre><code> def fancy_function( arg1, arg2, return_type=1 ):
 ret_val = None
 if( 1 == return_type ):
 ret_val = arg1 + arg2
 elif( 2 == return_type ):
 ret_val = [ arg1, arg2, arg1 * arg2 ]
 else:
 ret_val = ( arg1, arg2, arg1 + arg2, arg1 * arg2 ) 
 return( ret_val )
</code></pre>

This method gives the function "advanced warning" regarding the desired output. Consequently it can skip unneeded processing and only do the work necessary to get your desired output. Also because Python does dynamic typing, the return type can change. Notice how the example returns a scalar, a list or a tuple... whatever you like!

blocks|key|1439685|text|通常的做法是使用虚拟变量_+(单下划线)，正如许多人在这里所指出的那样。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1439686|但是，为了避免与该变量名称的其他使用冲突(请参阅this响应)，更好的做法可能是使用__+(双下划线)，而不是ncoghlan所指出的一次性变量。例如：|1439687|x,+__+=+func()|code-block|syntax|javascript|1439688|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/5893946/3511304|1|https://stackoverflow.com/users/597742/ncoghlan^0|C|1|0|16|2|O|4|0|1J|8|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]|$9|15|A|16|1|17]]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

The common practice is to use the dummy variable <code>_</code> (single underscore), as many have indicated here before.

However, to avoid collisions with other uses of that variable name (see <a href="https://stackoverflow.com/a/5893946/3511304">this</a> response) it might be a better practice to use <code>__</code> (double underscore) instead as a throwaway variable, as pointed by <a href="https://stackoverflow.com/users/597742/ncoghlan">ncoghlan</a>. E.g.:

<pre><code>x, __ = func()
</code></pre>

blocks|key|1439717|text|如果这是一个您一直在使用但总是丢弃第二个参数的函数，我认为使用lambda为该函数创建一个没有第二个返回值的别名不会那么麻烦。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1439718|def+func():
++++return+1,+2

func_+=+lambda:+func()[0]+

func_()++#+Prints+1+|code-block|syntax|javascript|1439719|entityMap^0|V|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If this is a function that you use all the time but always discard the second argument, I would argue that it is less messy to create an alias for the function without the second return value using <code>lambda</code>. 

<pre><code>def func():
 return 1, 2

func_ = lambda: func()[0] 

func_() # Prints 1 
</code></pre>

blocks|key|1654486|text|当一个函数有很多输出，并且你不想多次调用它时，我认为选择结果的最清晰的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1654487|results+=+fct()
a,b+=+[results[i]+for+i+in+list_of_index]|code-block|syntax|javascript|1654488|作为最小的工作示例，还演示了该函数只被调用一次：|1654489|def+fct(a):
++++b=a*2
++++c=a%2B2
++++d=a%2Bb
++++e=b*2
++++f=a*a
++++print("fct+called")
++++return[a,b,c,d,e,f]

results=fct(3)
>+fct+called

x,y+=+[results[i]+for+i+in+[1,4]]|1654490|并且这些值与预期一致：|1654491|results
>+[3,6,5,9,12,9]
x
>+6
y
>+12|1654492|为方便起见，还可以使用Python列表索引：|1654493|x,y+=+[results[i]+for+i+in+[0,-2]]|1654494|返回:a=3和b=+12|1654495|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

When you have many output from a function and you don't want to call it multiple times, I think the clearest way for selecting the results would be :

<pre><code>results = fct()
a,b = [results[i] for i in list_of_index]
</code></pre>

As a minimum working example, also demonstrating that the function is called only once :

<pre><code>def fct(a):
 b=a*2
 c=a+2
 d=a+b
 e=b*2
 f=a*a
 print("fct called")
 return[a,b,c,d,e,f]

results=fct(3)
&gt; fct called

x,y = [results[i] for i in [1,4]]
</code></pre>

And the values are as expected :

<pre><code>results
&gt; [3,6,5,9,12,9]
x
&gt; 6
y
&gt; 12
</code></pre>

For convenience, Python list indexes can also be used :

<pre><code>x,y = [results[i] for i in [0,-2]]
</code></pre>

Returns : a = 3 and b = 12

blocks|key|1654575|text|最好的解决方案可能是命名对象，而不是返回无意义的元组(除非返回项的顺序背后有某种逻辑)。例如，您可以使用字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1654576|def+func():
++++return+{'lat':+1,+'lng':+2}
++++
latitude+=+func()['lat']|code-block|syntax|javascript|1654577|如果您想要添加有关所返回内容的额外信息，甚至可以使用namedtuple+(它不仅仅是一个字典，它是一对坐标)：|offset|length|1654578|from+collections+import+namedtuple+

Coordinates+=+namedtuple('Coordinates',+['lat',+'lng'])

def+func():
++++return+Coordinates(lat=1,+lng=2)

latitude+=+func().lat|1654579|如果您的字典/元组中的对象紧密绑定在一起，那么甚至为其定义一个类可能是一个好主意。这样，您还可以定义更复杂的操作。接下来的一个自然问题是：When+should+I+be+using+classes+in+Python?|1654580|大多数最新版本的python+(≥3.7)都有dataclasses，您可以使用它来定义只需很少代码行的类：|1654581|from+dataclasses+import+dataclass

@dataclass
class+Coordinates:
++++lat:+float+=+0
++++lng:+float+=+0

def+func():
++++return+Coordinates(lat=1,+lng=2)

latitude+=+func().lat|1654582|与命名元组相比，数据类的主要优势是它更容易扩展，但也有other+differences。请注意，默认情况下，数据类是可变的，但您可以使用@dataclass(frozen=True)而不是@dataclass来强制它们不可变。|style|CODE|1654583|Here+is+a+video，它可能会帮助您为您的用例选择正确的数据类。|1654584|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/collections.html#namedtuple-factory-function-for-tuples-with-named-fields|1|https://stackoverflow.com/q/33072570/1720199|2|https://docs.python.org/3/library/dataclasses.html|3|https://stackoverflow.com/q/51671699/1720199|4|https://youtu.be/vCLetdhswMg^0|0|0|Q|A|0|0|0|1X|15|1|0|N|B|2|0|0|1X|N|2N|A|R|H|3|0|0|F|4|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1G|8|@]|9|@$I|1H|J|1I|1|1J]]|A|$]]|$1|K|3|L|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|1L|8|@]|9|@$I|1M|J|1N|1|1O]]|A|$]]|$1|O|3|P|5|6|7|1P|8|@]|9|@$I|1Q|J|1R|1|1S]]|A|$]]|$1|Q|3|R|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1U|8|@$I|1V|J|1W|U|V]|$I|1X|J|1Y|U|V]]|9|@$I|1Z|J|20|1|21]]|A|$]]|$1|W|3|X|5|6|7|22|8|@]|9|@$I|23|J|24|1|25]]|A|$]]|$1|Y|3|-4|5|6|7|26|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]|18|$5|11|12|13|A|$14|19]]|1A|$5|11|12|13|A|$14|1B]]|1C|$5|11|12|13|A|$14|1D]]]]

The best solution probably is to name things instead of returning meaningless tuples (unless there is some logic behind the order of the returned items). You can for example use a dictionary:
<pre class="lang-py prettyprint-override"><code>def func():
 return {'lat': 1, 'lng': 2}
 
latitude = func()['lat']
</code></pre>
You could even use <a href="https://docs.python.org/3/library/collections.html#namedtuple-factory-function-for-tuples-with-named-fields" rel="nofollow noreferrer">namedtuple</a> if you want to add extra information about what you are returning (it's not just a dictionary, it's a pair of coordinates):
<pre class="lang-py prettyprint-override"><code>from collections import namedtuple 

Coordinates = namedtuple('Coordinates', ['lat', 'lng'])

def func():
 return Coordinates(lat=1, lng=2)

latitude = func().lat
</code></pre>
If the objects within your dictionary/tuple are strongly tied together then it may be a good idea to even define a class for it. That way you'll also be able to define more complex operations. A natural question that follows is: <a href="https://stackoverflow.com/q/33072570/1720199">When should I be using classes in Python?</a>
Most recent versions of python (≥ 3.7) have <a href="https://docs.python.org/3/library/dataclasses.html" rel="nofollow noreferrer">dataclasses</a> which you can use to define classes with very few lines of code:
<pre class="lang-py prettyprint-override"><code>from dataclasses import dataclass

@dataclass
class Coordinates:
 lat: float = 0
 lng: float = 0

def func():
 return Coordinates(lat=1, lng=2)

latitude = func().lat
</code></pre>
The primary advantage of dataclasses over namedtuple is that its easier to extend, but there are <a href="https://stackoverflow.com/q/51671699/1720199">other differences</a>. Note that by default, dataclasses are mutable, but you can use <code>@dataclass(frozen=True)</code> instead of <code>@dataclass</code> to force them being immutable.
<a href="https://youtu.be/vCLetdhswMg" rel="nofollow noreferrer">Here is a video</a> that might help you pick the right data class for your use case.

Say I have a Python function that returns multiple values in a tuple:

<pre><code>def func():
 return 1, 2
</code></pre>

Is there a nice way to ignore one of the results rather than just assigning to a temporary variable? Say if I was only interested in the first value, is there a better way than this:

<pre><code>x, temp = func()
</code></pre>

Ignore python multiple return value

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

假设我有一个Python函数，它在一个元组中返回多个值：def func():    return 1, 2有没有一种好的方法可以忽略其中一个结果，而不是只给一个临时变量赋值？假设我只对第一个值感兴趣，有没有比这更好的方法：x, temp = func()

问忽略python多个返回值
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问忽略python多个返回值EN