Игнорировать многократное возвращаемое значение Python

Скажем, у меня есть функция Python, которая возвращает несколько значений в кортеже:

def func():
    return 1, 2

Есть ли хороший способ игнорировать один из результатов, а не просто присваивать временную переменную? Скажите, если бы меня интересовало только первое значение, есть ли лучший способ, чем этот:

x, temp = func()

Одно общее соглашение заключается в использовании «_» в качестве имени переменной для элементов кортежа, которые вы хотите игнорировать. Например:

def f():
    return 1, 2, 3

_, _, x = f()

Вы можете использовать, x = func()[0]чтобы вернуть первое значение, x = func()[1]вернуть второе и так далее.

Если вы хотите получить несколько значений одновременно, используйте что-то вроде x, y = func()[2:4].

Если вы используете 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]

Помните, что когда вы возвращаете более одного предмета, вы действительно возвращаете кортеж. Так что вы можете делать такие вещи:

def func():
    return 1, 2

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

Обычная практика - использовать фиктивную переменную _(одиночное подчеркивание), как многие указывали здесь ранее.

Однако, чтобы избежать коллизий с другими использованиями этого имени переменной (см. Этот ответ), было бы лучше использовать __вместо этого (двойное подчеркивание) в качестве одноразовой переменной, как указано ncoghlan . Например:

x, __ = func()

Три простых варианта

очевидный

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)

Лучшее решение, вероятно, состоит в том, чтобы называть вещи, а не возвращать бессмысленные кортежи. Если за порядком возвращенных товаров нет логики.

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

Если объекты в вашем словаре / кортеже сильно связаны друг с другом, то было бы неплохо даже определить класс для него. Таким образом, вы также сможете определить взаимодействие между объектами этого типа и дать API о том, как с ними работать. Естественный вопрос: когда мне следует использовать классы в Python? ,

Это кажется лучшим выбором для меня:

val1, val2, ignored1, ignored2 = some_function()

Он не загадочный и не уродливый (как метод func () [index]), и в нем четко указана ваша цель.

Это не прямой ответ на вопрос. Скорее, он отвечает на этот вопрос: «Как выбрать вывод конкретной функции из множества возможных вариантов?».

Если вы можете написать функцию (т. Е. Ее нет в библиотеке, которую вы не можете изменить), то добавьте входной аргумент, который указывает, что вы хотите от функции. Сделайте его именованным аргументом со значением по умолчанию, чтобы в «общем случае» вам даже не приходилось его указывать.

    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 выполняет динамическую типизацию, тип возвращаемого значения может измениться. Обратите внимание, как пример возвращает скаляр, список или кортеж ... что угодно!

Если это функция, которую вы используете все время, но всегда отбрасываете второй аргумент, я бы сказал, что создавать псевдоним для функции без использования второго возвращаемого значения не так уж и сложно lambda.

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

Если у вас много выходных данных из функции, и вы не хотите вызывать ее несколько раз, я думаю, что самый простой способ выбрать результаты:

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

Возвращает: а = 3 и б = 12