Question

我想知道是否有办法将函数的输出分配给变量，而只需运行一次函数。例如，假设我有这样的函数：

def my_func(x):
    return x+1, x**2, x**3

然后我想将每个输出存储为变量，所以通常我会在之后对其进行编码：

var1 = my_func(2)[0]
var2 = my_func(2)[1]
var3 = my_func(2)[2]

但根据我的理解，上面的每一行都要求函数再次运行。如果我有一个更长的功能，那么同时分配所有功能会更方便，只运行一次功能。有没有办法做到这一点？

Answer 1

是的，您可以通过序列解包来完成此操作：

def my_func(x):
    return x+1, x**2, x**3

var1, var2, var3 = my_func(2)

此功能在文档中进行了描述：Tuples and Sequences

Answer 2

两种可能性：

将函数的返回值（即tuple）赋给变量，并访问其元素：

var = my_func(2)
var1 = var[0]
var2 = var[1]
var3 = var[2]

或使用解包：

var1, var2, var3 = my_func(2)

回复：在大多数情况下哪种方法运行得更快？

让我们比较一下反汇编（我点赞>差异）：

dis.dis('t=my_func(2);d=t[0]+t[1]+t[2]')

  1           0 LOAD_NAME                0 (my_func)
              2 LOAD_CONST               0 (2)
              4 CALL_FUNCTION            1
           >  6 STORE_NAME               1 (t)
              8 LOAD_NAME                1 (t)
           > 10 LOAD_CONST               1 (0)
           > 12 BINARY_SUBSCR
             14 LOAD_NAME                1 (t)
           > 16 LOAD_CONST               2 (1)
           > 18 BINARY_SUBSCR
             20 BINARY_ADD
             22 LOAD_NAME                1 (t)
           > 24 LOAD_CONST               0 (2)
           > 26 BINARY_SUBSCR
             28 BINARY_ADD
             30 STORE_NAME               2 (d)
             32 LOAD_CONST               3 (None)
             34 RETURN_VALUE

dis.dis('a,b,c=my_func(2);d=a+b+c')

  1           0 LOAD_NAME                0 (my_func)
              2 LOAD_CONST               0 (2)
              4 CALL_FUNCTION            1
          >   6 UNPACK_SEQUENCE          3
          >   8 STORE_NAME               1 (a)
          >  10 STORE_NAME               2 (b)
          >  12 STORE_NAME               3 (c)
             14 LOAD_NAME                1 (a)
             16 LOAD_NAME                2 (b)
             18 BINARY_ADD
             20 LOAD_NAME                3 (c)
             22 BINARY_ADD
             24 STORE_NAME               4 (d)
             26 LOAD_CONST               1 (None)
             28 RETURN_VALUE

因此，第一种方法在每次使用变量时都需要两个指令（LOAD_CONST，BINARY_SUBSCR），而第二种方法在创建变量时需要多一条指令。

差异实际上毫无意义。

从函数调用

2 个答案: