Perché Python non valuta l'aritmetica numerica costante prima di compilarla in bytecode?

Question

Nel codice seguente, perché Python non compila f2 allo stesso bytecode come f1?

C'è un motivo per non farlo?

>>> def f1(x): 
    x*100 

>>> dis.dis(f1) 
    2   0 LOAD_FAST    0 (x) 
       3 LOAD_CONST    1 (100) 
       6 BINARY_MULTIPLY 
       7 POP_TOP 
       8 LOAD_CONST    0 (None) 
      11 RETURN_VALUE 
>>> def f2(x): 
     x*10*10 

>>> dis.dis(f2) 
    2   0 LOAD_FAST    0 (x) 
       3 LOAD_CONST    1 (10) 
       6 BINARY_MULTIPLY 
       7 LOAD_CONST    1 (10) 
      10 BINARY_MULTIPLY 
      11 POP_TOP 
      12 LOAD_CONST    0 (None) 
      15 RETURN_VALUE 

Answer 1

Questo perché x potrebbe avere un metodo __mul__ con effetti collaterali. x * 10 * 10 chiamate __mul__ due volte, mentre x * 100 chiama solo una volta:

>>> class Foo(object): 
...  def __init__ (self): 
...    self.val = 5 
...  def __mul__ (self, other): 
...    print "Called __mul__: %s" % (other) 
...    self.val = self.val * other 
...    return self 
... 
>>> a = Foo() 
>>> a * 10 * 10 
Called __mul__: 10 
Called __mul__: 10 
<__main__.Foo object at 0x1017c4990> 

piegare automaticamente le costanti e solo chiamando __mul__ volta potrebbe cambiare il comportamento.

È possibile ottenere l'ottimizzazione desiderata riordinando l'operazione in modo tale che le costanti vengano moltiplicate per prime (o, come menzionato nei commenti, utilizzando le parentesi per raggrupparle in modo tale che vengano semplicemente utilizzate insieme, indipendentemente dalla posizione), rendendo così esplicito il vostro desiderio per la piegatura avvenga:

>>> def f1(x): 
...  return 10 * 10 * x 
... 
>>> dis.dis(f1) 
    2   0 LOAD_CONST    2 (100) 
       3 LOAD_FAST    0 (x) 
       6 BINARY_MULTIPLY  
       7 RETURN_VALUE 

Answer 2

Python valuta le espressioni da left to right. Per f2(), questo significa che sarà dapprima valutare x*10 e quindi moltiplicare il risultato per 10. Prova:

Prova:

def f2(x): 
    10*10*x 

Questo dovrebbe essere ottimizzata.