2013-05-22 13 views
6

sto attraversando alcune attività Python ed è stato dato codice di esempio con questo operatore: y *= -1Che cosa è questo operatore * = -1

ho dato un'occhiata attraverso il relevant Python docs, senza alcun risultato.

Lo so y += 1, ad esempio, è l'abbreviazione di y = y + 1. Quindi questo è y = y * -1 y uguale a volte -1 forse?

Cosa più vicina nei documenti Python che ho trovato è questo: x * y: prodotto di xey

È questo vero?

+3

Per trovare i documenti importanti si avrebbe bisogno di cercare * incarico aumentato *. –

+0

Ahh ok grazie amico. – BenniMcBeno

risposta

12

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 
+0

Puoi spiegare perché è interpretato come' y = y .__ imul __ () 'e non solo' y .__ imul __ () '? – wim

+0

Vedere [i documenti] (http://docs.python.org/3.3/reference/datamodel.html#object.__iadd__): "Questi metodi dovrebbero tentare di eseguire l'operazione sul posto (modifica di sé) e restituire il risultato (che potrebbe essere, ma non deve essere, auto). " – shx2

+2

@wim c'è il famigerato caso di modifica delle tuple 'x = ([],)', 'x [0] + = ['a']' 'x' – jamylak

3

Sì, è corretto. Significa semplicemente moltiplicare il valore della mano sinistra per il valore negativo della mano destra. Sono entrambi operatori aritmetici che differiscono semplicemente per il funzionamento e il binding di espressioni, quindi credo che +/* siano paralleli ovunque negli overload.

y = y * -1 
+3

Non è identico al 100%, se 'y' ha effetti collaterali quando viene valutato (come la stampa o lo stato di modifica). In 'y * = -1',' y' viene valutato una volta. In 'y = y * -1',' y' è viene valutato due volte. – Patashu

+0

Vuoi dire il secondo valutato dall'operatore uguale? Nvm, hai detto stato di modifica. È più evidente quando si tratta di elementi: 'k [chiave] * = -1' – chaz

Problemi correlati