忽略python多个返回值

Mat*_*Mat 253 python tuples function

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

def func():
    return 1, 2
Run Code Online (Sandbox Code Playgroud)

是否有一种很好的方法可以忽略其中一个结果,而不仅仅是分配给一个临时变量?如果我只对第一个值感兴趣,是否有比这更好的方法:

x, temp = func()
Run Code Online (Sandbox Code Playgroud)

Luk*_*ard 553

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

如果您想一次获得多个值,请使用类似的内容x, y = func()[2:4].

  • 这应该是公认的答案.你也可以使用`func()[2:4]之类的东西,如果你只需要***的返回值. (88认同)
  • @TylerLong:我认为`_,_,_,_,_,_,_,_,_,_,_,_,_,a,_,_,_,_,_,_,_,_, _,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_, _, _, _, _, _, _, _, _, _, _, _, C, _, _, _, _, _, _, _, _, _, _, _, _, _, _,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,d,_,_,_,_,_,_,_, _,e,_ = func()`不如多次调用函数那么明确,但这只是我的观点.如果你的函数返回那么多项,我认为使用numpy会更好:`a,b,c,d,e = func()[[13,25,58,89,98]]` (28认同)
  • @endolith我认为这样更好,不需要numpy,也不需要多次调用func():`result = func()``a = result [13]``b = result [25]`... (22认同)
  • 它不会多次调用该函数:>>> def test():... print"here"...返回1,2,3 ... >>> a,b = test()[:2这里[编辑:抱歉,代码没有通过,显然你只在评论中得到一行.对于那些不熟悉的>>>和...是python shell中新行的开头] (11认同)
  • 这种风格是不是很好时,要忽略一个或之间的一些值,比如'X,__,Y = FUNC()` (3认同)
  • 这应该是一个例外的答案。 (2认同)

Bri*_*per 215

一个常见的约定是使用"_"作为要忽略的元组元素的变量名.例如:

def f():
    return 1, 2, 3

_, _, x = f()
Run Code Online (Sandbox Code Playgroud)

  • -1:当你将gettext功能添加到其他人的代码(定义一个名为'_'的函数)时,这种"约定"很糟糕,所以它应该被禁止 (87认同)
  • -1:_表示IPython中的"最后输出".我永远不会给它分配一些东西. (25认同)
  • 好点 - 尽管gettext是否坚持安装一个名为"_"的函数是一个好主意,但这是有争议的.就个人而言,我发现它有点难看.无论如何,使用"_"作为一次性变量是很普遍的. (24认同)
  • 好的,我没有注意到"我" - 感谢参考.恕我直言,你不能指望别人不使用变量只是因为一个Python应用程序定义了它自己的神奇用途. (19认同)
  • 一些像PyDev这样的IDE会给你一个警告,因为你有未使用的变量. (8认同)
  • 我已经在各种代码中看到了它.如果你在标准Python库中执行grep -w'_,'*.py,你会发现它的一些实例.例如,UserDict.py有几个实例.我也在像Pygments和Django这样的软件包中看过它. (5认同)
  • 这种约定在Haskell中也很常见.谁知道它起源于哪里? (4认同)
  • 据我所知,原点是ML.功能语言中的相同用法支持这一点,特别是ML-derived/-inspired语言,如OCaml,F#,Nemerle等. (3认同)
  • @Draemon:到目前为止,有两个例子有下划线有其他用途.它不是一次性变量,不应该被视为一个变量.该函数输出一个元组; 像元组一样使用它. (3认同)
  • @endolith就是重点.python已经分配给`_`.明确地分配给`_`相当于分配给任何东西,这是目标.(即,通常将`_`和新变量分配给 - 这会遗漏新变量.) (3认同)
  • @nosklo当然,任何不符合非Python软件的Python约定都应该被禁止.地狱,当我们在它的时候,让我们禁止Python.也许编写`gettext`的人可以推荐别的东西. (3认同)
  • 非常有趣的概念,但不是非常Pythonic.但是,我提交的解决方案都不是.:-P请问,你在哪里听说过这个会议?我想知道它有多受欢迎. (2认同)
  • @Evan我实际上发现这是非常Python的,特别是考虑到python使用下划线的倾向。(int .__ mul __,__ iter __,__ builtins__等) (2认同)
  • @Draemon:http://ipython.scipy.org/doc/manual/html/interactive/tutorial.html#use-the-output-cache (2认同)
  • 无论哪个特定模块想要使用`_`,为什么要使用任何名称并完全丢弃它,当名称可以被其他东西使用时?例如,为什么不直接执行 `x, print = func()`?`func()[0]` 显然要好得多,真正丢弃元组中不需要的部分并且不会污染命名空间。 (2认同)
  • 分配给“_”(或任何变量名)的另一个缺点是,与该名称关联的引用将持续存在,直到当前函数结束,或者直到您显式“del _”。但由于对象是不需要的,因此尽快对其进行垃圾收集通常更有意义。 (2认同)

小智 84

如果您使用的是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]
Run Code Online (Sandbox Code Playgroud)

  • 您还可以使用 `a, *_ = f()` 来忽略 `a` 之后的任意数量的返回值。 (13认同)
  • 如果有人想知道,这也适用于元组。 (5认同)

Eva*_*ark 18

记住,当你返回多个项目时,你真的会返回一个元组.所以你可以做这样的事情:

def func():
    return 1, 2

print func()[0] # prints 1
print func()[1] # prints 2
Run Code Online (Sandbox Code Playgroud)


lac*_*cal 17

通常的做法是使用虚拟变量_(单个下划线),正如之前许多人所说的那样.

但是,为了避免与该变量名称的其他用法发生冲突(请参阅响应),使用__(双下划线)作为一个一次性变量可能是更好的做法,正如ncoghlan所指出的那样.例如:

x, __ = func()
Run Code Online (Sandbox Code Playgroud)

  • 一点也不坏主意。但随后 '__ ' 会在命名空间中声明一个变量。而“_”不会声明,除非像上面那样在赋值语句的左侧专门使用(例如:“a, _, _ = 1,8,9”)。在那之前,它存储最后执行的语句的结果,如果您想捕获该结果,通常会使用变量来存储该值。这就是为什么“_”是建议的变量名称来捕获垃圾值。执行另一个语句后,“_”值很快就会被覆盖。如果是“_ _”,值将保留在那里,直到 GC 将其清除。 (2认同)

S.L*_*ott 16

三个简单的选择.

明显

x, _ = func()

x, junk = func()
Run Code Online (Sandbox Code Playgroud)

可怕

x = func()[0]
Run Code Online (Sandbox Code Playgroud)

并且有一些方法可以用装饰器来做到这一点.

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

func0= val0(func)
Run Code Online (Sandbox Code Playgroud)

  • 你的例子是倒退的.`x,_ = func()`是可怕的,`x = func()[0]`很明显.分配给变量然后不使用它?该函数返回一个元组; 将它作为一个元组索引. (20认同)
  • 在模式匹配语言中,Python派生出这种模式,"显而易见"的方法确实是显而易见的,不是可怕的,也不是规范的.虽然,在这种语言中,通配符是一种受支持的语言功能,而在Python中,它是一个真正的变量并受到约束,这有点令人不快. (5认同)
  • 我更喜欢`_`变量.很明显,你忽略了一个价值 (4认同)
  • 对于列表处理语言,Python派生自`;)`,列出访问器,如`a [0]`,`a [:]`(列表副本),`a [:: 2]`(每两个元素)和`a [i:] + a [:i]`(旋转列表)确实也很明显和规范. (4认同)

kme*_*lvn 6

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

val1, val2, ignored1, ignored2 = some_function()
Run Code Online (Sandbox Code Playgroud)

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


Chr*_*igi 6

如果这是一个您一直使用但总是丢弃第二个参数的函数,我认为在没有第二个返回值的情况下使用lambda.

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 
Run Code Online (Sandbox Code Playgroud)


1-i*_*ijk 5

这不是问题的直接答案。相反,它回答了这个问题:“如何从许多可能的选项中选择特定的函数输出?”。

如果您能够编写该函数(即它不在您无法修改的库中),则添加一个输入参数来指示您想要从该函数中获得什么。使其成为具有默认值的命名参数,因此在“常见情况”下您甚至不必指定它。

    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 )
Run Code Online (Sandbox Code Playgroud)

此方法提供有关所需输出的“高级警告”功能。因此,它可以跳过不需要的处理,只做获得所需输出所需的工作。另外,由于 Python 执行动态类型,因此返回类型可以更改。请注意该示例如何返回标量、列表或元组......无论您喜欢什么!


cgl*_*cet 5

最好的解决方案可能是命名事物,而不是返回无意义的元组。除非返回的项目的顺序后面有逻辑。

def func():
    return {'lat':1, 'lng':2}

latitude = func()['lat']
print(latitude)
Run Code Online (Sandbox Code Playgroud)

如果要添加有关返回内容的其他信息,甚至可以使用namedtuple

from collections import namedtuple 
Coordinates = namedtuple('Coordinates', ['lat', 'lng'])

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

latitude = func().lat
print(latitude)
Run Code Online (Sandbox Code Playgroud)

如果您返回的东西经常在一起,那么甚至最好为其定义一个类。

  • 这是这个问题中隐藏的问题核心的唯一答案。如果您尝试选择函数的元组输出之一,它们可能不应该位于元组中。元组用于以有序方式“组合在一起”的事物。在OP的情况下,它们(可能)是“性质不同”的输出,并且确实应该以某种方式命名。当没有自然顺序时,要求读者理解第一个和第二个输出指的是什么,会带来麻烦。 (2认同)