忽略python的多个返回值

问题描述：

假设我有一个 Python 函数，它在一个元组中返回多个值：

def func():
    return 1, 2

有没有一种很好的方法来忽略其中一个结果，而不仅仅是分配给临时变量？如果我只对第一个值感兴趣，有没有比这更好的方法：

x, temp = func()

解决方案 1：

您可以使用x = func()[0]返回第一个值，x = func()[1]返回第二个值，依此类推。

如果您想一次获取多个值，请使用类似的东西x, y = func()[2:4]。

解决方案 2：

一个常见的惯例是使用“_”作为要忽略的元组元素的变量名。例如：

def f():
    return 1, 2, 3

_, _, x = f()

解决方案 3：

如果您使用的是 Python 3，则可以在变量前（在赋值的左侧）使用星号，使其成为解包时的列表。

# 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]

解决方案 4：

常见的做法是使用虚拟变量_（单下划线），正如许多人之前所指出的那样。

但是，为了避免与该变量名的其他用法发生冲突（请参阅此回复），更好的做法可能是使用__（双下划线）作为一次性变量，正如ncoghlan所指出的那样。例如：

x, __ = func()

解决方案 5：

请记住，当您返回多个项目时，您实际上是在返回一个元组。因此，您可以执行以下操作：

def func():
    return 1, 2

print func()[0] # prints 1
print func()[1] # prints 2

解决方案 6：

最好的解决方案可能是命名事物，而不是返回无意义的元组（除非返回项目的顺序背后有某种逻辑）。例如，您可以使用字典：

def func():
    return {'lat': 1, 'lng': 2}
    
latitude = func()['lat']

如果您想要添加有关返回内容的额外信息，您甚至可以使用namedtuple（它不仅仅是一本字典，它是一对坐标）：

from collections import namedtuple 

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

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

latitude = func().lat

如果字典/元组中的对象紧密相关，那么为其定义一个类可能是一个好主意。这样，您还可以定义更复杂的操作。接下来自然会有一个问题：我应该何时在 Python 中使用类？

最新版本的 python（≥ 3.7）都有数据类，您可以使用它用很少几行代码来定义类：

from dataclasses import dataclass

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

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

latitude = func().lat

与命名元组相比，数据类的主要优势在于它更易于扩展，但还有其他区别。请注意，默认情况下，数据类是可变的，但您可以使用@dataclass(frozen=True)而不是@dataclass来强制它们不可变。

这个视频可能会帮助您为您的用例选择正确的数据类。另一个关于attrs 与 dataclass的视频揭示了一些有趣的细节，说明为什么attrs可能很有趣。

解决方案 7：

三个简单的选择。

明显的

x, _ = func()

x, junk = func()

可怕

x = func()[0]

并且有方法可以使用装饰器来实现这一点。

def val0( aFunc ):
    def pick0( *args, **kw ):
        return aFunc(*args,**kw)[0]
    return pick0

func0= val0(func)

解决方案 8：

对我来说这似乎是最好的选择：

val1, val2, ignored1, ignored2 = some_function()

它不是神秘的或者丑陋的（比如 func()[index] 方法），并且清楚地说明了您的目的。

解决方案 9：

这不是对问题的直接回答。而是回答了这个问题：“如何从众多可能的选项中选择一个特定的函数输出？”。

如果您能够编写该函数（即，它不在无法修改的库中），则添加一个输入参数，指示您希望从该函数中得到什么。使其成为具有默认值的命名参数，以便在“常见情况”下您甚至不必指定它。

    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 )

此方法为函数提供了有关所需输出的“提前警告”。因此，它可以跳过不必要的处理，只执行获得所需输出所需的工作。此外，由于 Python 具有动态类型，因此返回类型可以更改。请注意示例如何返回标量、列表或元组... 无论您喜欢什么！

解决方案 10：

如果这是一个您经常使用但总是丢弃第二个参数的函数，我认为使用为该函数创建没有第二个返回值的别名会更简洁lambda。

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

解决方案 11：

当一个函数有许多输出并且你不想多次调用它时，我认为选择结果最清晰的方法是：

results = fct()
a,b = [results[i] for i in list_of_index]

作为一个最小工作示例，还演示了该函数只被调用一次：

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)
> fct called

x,y = [results[i] for i in [1,4]]

并且值符合预期：

results
> [3,6,5,9,12,9]
x
> 6
y
> 12

为了方便起见，也可以使用 Python 列表索引：

x,y = [results[i] for i in [0,-2]]

返回：a = 3 和 b = 12

解决方案 12：

如果你愿意，可以忽略除第一个变量之外的所有变量，语法更少。如果我们以你的例子为例，

# The function you are calling.
def func():
    return 1, 2

# You seem to only be interested in the first output.
x, temp = func()

我发现以下方法有效，

x, *_ = func()

这种方法将*所有其他变量“解包”为一个“一次性”变量_。这样做的好处是分配所需的一个变量并忽略其后面的所有变量。

但是，在许多情况下，您可能希望输出不是函数的第一个输出。在这些情况下，最好使用您想要的输出的索引位置来指示这一点。在您的例子中func()[i]，i

# i == 0 because of zero-index.
x = func()[0]

附注一下，如果你想在 Python 3 中有所突破，你可以这样做，

# This works the other way around.
*_, y = func()

你的函数只输出两个潜在变量，所以除非你遇到这样的情况，否则它看起来不太强大，

def func():
    return 1, 2, 3, 4

# I only want the first and last.
x, *_, d = func()