Python: эффективный вызов подмножества переменных функции множественного возврата

Question

Я хочу знать, смогу ли я запретить моей функции работать через все ее процедуры, если меня интересует только одна (или меньше, чем сумма) переменных, которые она возвращает.

Чтобы выяснить, предположим, что у меня есть функция с (кортеж) множественных возвратов:

def func_123(n):
    x=n+1
    y=n+2
    z=n+3
    return x,y,z

Если меня интересуют только третьи значения, я могу просто сделать:

_,_,three = func_123(0)

Но я хочу знать, как это работает в функции.

Выполняет ли моя функция три вычисления и только затем выбирает "отбросить" первые два и дает мне тот, который я хочу, или он распознает, что может выполнять намного меньше работы, если выполняет только подпрограммы, необходимые для возврата значения, которое я хочу? Если первое, есть ли способ обойти это (кроме, конечно, создания функций для каждого вычисления и отпускания уникальной функции для организации всех подпрограмм)?

Answer 1

Он вычислит и вернет все значения. Например

def foo(x):
    return x+1, x+2

Когда я вызываю эту функцию

>>> foo(1)
(2, 3)
>>> _, a = foo(1)
>>> a
3
>>> _
2

Обратите внимание, что _ является вполне допустимым и пригодным для использования именем переменной. Это просто используется соглашением, чтобы подразумевать, что вы не хотите использовать эту переменную.

Самое близкое к тому, что вы описываете, - написать свою функцию в качестве генератора. Например

def func_123(n):
    for i in range(1,4):
        yield n + i

>>> a = func_123(1)
>>> next(a)
2
>>> next(a)
3
>>> next(a)
4

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

Answer 2

Он ничего не "выбирает" и не "бросает". То, что вы используете, это присвоение кортежей; в частности, вы присваиваете кортежу возвращаемое значение (_,_,three), _ Переменная - это просто соглашение для переменной "выбросить".

Answer 3

Я хотел бы попробовать что-то другое, используя встроенный модуль functools (это может быть не совсем то, что вы ищете, но вы можете переосмыслить то, что вы делаете.)

>>> import functools
>>> def func_123(n, m):
...     return n + m
...
>>> func_dict = dict()
>>> for r in [1,2,3]:
...     func_dict[r] = functools.partial(func_123, r)
...
>>> for k in [1,2,3]:
...     func_dict[k](10)
...
11
12
13
>>> func_dict[3](20)
23
>>>

ИЛИ ЖЕ

>>> func_1 = functools.partial(func_123, 1)
>>> func_2 = functools.partial(func_123, 2)
>>> func_3 = functools.partial(func_123, 3)

>>> func_1(5)
6
>>> func_2(5)
7
>>> func_3(5)
8
>>> func_3(3)
6
>>>

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

Answer 4

Это только соглашение использовать _ для неиспользуемых переменных. Таким образом, все операторы в функции оцениваются.