Игнорировать множественное возвращаемое значение python

StackOverflow https://stackoverflow.com/questions/431866

  •  08-07-2019
  •  | 
  •  

Вопрос

Допустим, у меня есть функция 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)

Мне кажется, это лучший выбор: 

val1, val2, ignored1, ignored2 = some_function()

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

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

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

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

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

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

latitude = func()['lat']
print(latitude)

Вы даже можете использовать namedtuple , если вы хотите добавить дополнительную информацию о том, что вы возвращаете: 

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

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

latitude = func().lat
print(latitude)

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

Если это функция, которую вы используете все время, но всегда отбрасываете второй аргумент, я бы сказал, что создать псевдоним для функции без второго возвращаемого значения будет менее грязно, используя 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]]

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

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top