python - 如何证明参数评估在 Python 中是“从左到右”的？

Question

例如，在 JavaScript 中，我们可以编写如下程序：

var a = 1;
testFunction(++a, ++a, a);
function testFunction(x, y, z){
      document.writeln("<br />x = " + x);
      document.writeln("<br />y = " + y);
      document.writeln("<br />z = " + z);
}

我们会得到一个输出：

x = 2
y = 3
z = 3

这意味着在 JavaScript 中参数是真正从左到右计算的。在 C 中我们会得到输出

x = 3
y = 3
z = 3

我想知道我们是否可以在 Python 中做同样的事情，或者因为它是按值传递参考语言，所以这是不可能的？

我制作了一个简单的程序，但我认为这并不能证明什么：

x = 2
def f(x, y, z):
    print(x, y, z)

f(x*2, x*2, x**2)
print(x)

4 4 4
2

当我调用它时，Python 不会让我在函数参数中做任何新的赋值（例如f(x=4, x, x)或类似的东西）。

Answer 1

>>> def f(x, y): pass
...
>>> f(print(1), print(2))
1
2

Answer 2

反汇编函数调用。

>>> def foo():
...   bar(x+1, x+2, x+3)
... 
>>> dis.dis(foo)
  2           0 LOAD_GLOBAL              0 (bar)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_CONST               1 (1)
              9 BINARY_ADD          
             10 LOAD_GLOBAL              1 (x)
             13 LOAD_CONST               2 (2)
             16 BINARY_ADD          
             17 LOAD_GLOBAL              1 (x)
             20 LOAD_CONST               3 (3)
             23 BINARY_ADD          
             24 CALL_FUNCTION            3
             27 POP_TOP             
             28 LOAD_CONST               0 (None)
             31 RETURN_VALUE        

Answer 3

使用 Python 3：

>>> a = []
>>> f = print(
    a.append(1), a[:],
    a.append(2), a[:],
    a.append(3), a[:]
)
None [1] None [1, 2] None [1, 2, 3]

---

档案：

>>> a = []
>>> f = print(a.append(1), a, a.append(2), a, a.append(3), a)

奇怪的是（起初），这段代码产生了：

None [1, 2, 3] None [1, 2, 3] None [1, 2, 3]

但是，dis(f)使这一点更清楚：

>>> dis(f)

  1           0 LOAD_NAME                0 (print) #Loads the value of 'print' into memory. Precisely, the value is pushed to the TOS (Top of Stack)
    -->       3 LOAD_NAME                1 (a) #Loads the value of object 'a' 
              6 LOAD_ATTR                2 (append) #Loads the append attribute (in this case method)
              9 LOAD_CONST               0 (1) #Loads the constant 1
             12 CALL_FUNCTION            1 #a.append(1) is called
             15 LOAD_NAME                1 (a) #for print(...,a,...)
             18 LOAD_NAME                1 (a) #for the next a.append()
             21 LOAD_ATTR                2 (append) 
             24 LOAD_CONST               1 (2) 
             27 CALL_FUNCTION            1 #a.append(2)
             30 LOAD_NAME                1 (a) 
             33 LOAD_NAME                1 (a) 
             36 LOAD_ATTR                2 (append) 
             39 LOAD_CONST               2 (3) 
             42 CALL_FUNCTION            1 #a.append(3)
             45 LOAD_NAME                1 (a) #loads a to be used thrice by print
             48 CALL_FUNCTION            6 #calls print
             51 PRINT_EXPR                 #prints TOS and clears it
             52 LOAD_CONST               3 (None) #Loads None
             55 RETURN_VALUE             #Returns None

的输出dis(f)是我们所期望的——从左到右的评估。本质上，这种“差异”是print()最后评估的结果。到那时， 的值a已更改为[1, 2, 3]并且相同的最终对象被打印三次。

如果我们用 替换a，a[:]我们会得到预期的结果。

Answer 4

恕我直言，这也表明了这一点：

>>> '{} {} {}'.format(x,x+1,x+2)
'1 2 3'

编辑：

>>> def f(t):   return time.time()-t 
...         

>>> t1=time.time(); '{:.4} {:.4} {:.4}'.format(f(t1),f(t1),f(t1))
'5.007e-06 7.868e-06 9.06e-06'

Answer 5

自定义类可以在这里提供帮助：

class Tester(object):
    "test object to reveal left to right evaluation"
    def __init__(self, value):
        self.value = value
    def __add__(self, value):
        print("adding ", value)
        return Tester(self.value + value)
    def __repr__(self):
        return repr(self.value)

运行时：

--> t = Tester(7)
--> t
7
--> t = t + 7
adding  7
--> t
14
--> def blah(a, b, c):
...   print(a, b, c)
... 
--> blah(t+1, t+2, t+3)
adding  1
adding  2
adding  3
15 16 17

Answer 6

简答：从左到右

示例：由于这是一个在我进行算术运算时总是在我脑海中浮现的问题（我应该转换为浮点数以及哪个数字），因此提供了一个来自该方面的示例：

>>> a = 1/2/3/4/5/4/3
>>> a
0

当我们除以整数时，不足为奇的是它会变得更低四舍五入。

>>> a = 1/2/3/4/5/4/float(3)
>>> a
0.0

如果我们将最后一个整数类型转换为浮点数，我们仍然会得到零，因为当我们的数字除以浮点数时，由于整数除法，我们已经变成了 0。

>>> a = 1/2/3/float(4)/5/4/3
>>> a
0.0

与上面相同的场景，但将浮点类型转换移动到更靠近左侧的位置。

>>> a = float(1)/2/3/4/5/4/3
>>> a
0.0006944444444444445

最后，当我们将第一个整数类型转换为浮点数时，结果就是所需的整数，因为从第一个除法开始，即最左边的除法，我们使用浮点数。

额外1：如果您试图回答这个问题以提高算术评估，您应该检查这个

额外2：请注意以下情况：

>>> a = float(1/2/3/4/5/4/3)
>>> a
0.0