Nella grande maggioranza dei casi
y *= <expr>
è uguale
y = y * <expr>
ma nel caso generale, viene interpretato come:
y = imul(y, <expr>)
che è quindi equivalente a:
y = y.__imul__(<expr>)
se il tipo di y
s' ignora __imul__
.
Questo significa che se il tipo y
s' sostituisce il inplace operatore di moltiplicazione, y*=<expr>
viene eseguita inplace, mentre y=y*<expr>
non è.
EDIT
Potrebbe non essere immediatamente chiaro perché è necessaria l'assegnazione, cioè perché è intrepreted come y = imul(y, <expr>)
, e non solo imul(y, <expr>)
.
La ragione è che fa un sacco di senso per i due scenari seguenti per dare lo stesso risultato:
c = a * b
e
c = a
c *= b
Ora, questo naturalmente funziona se a
e b
sono dello stesso tipo (ad esempio float, array numpy, ecc.), ma se non lo sono, è possibile che il risultato dell'operazione abbia il tipo di b
, nel qual caso l'operazione non può essere un'operazione interna di a
, quindi il risultato deve essere assegnato a a
, al fine di ottenere il comportamento corretto.
Per esempio, questo funziona, grazie alla cessione:
from numpy import arange
a = 2
a *= arange(3)
a
=> array([0, 2, 4])
Mentre se l'assegnazione è sceso, a
rimane invariato:
a = 2
imul(a, arange(3))
=> array([0, 2, 4])
a
=> 2
Per trovare i documenti importanti si avrebbe bisogno di cercare * incarico aumentato *. –
Ahh ok grazie amico. – BenniMcBeno