Precisione operatore Python

Question

I documenti Python dicono che * e/hanno la stessa precedenza.
So che le espressioni in python vengono valutate da sinistra a destra.

posso usufruire in questo ed assumere che j j/m è sempre uguale a (j j)/m evitando le parentesi?
Se questo è il caso, posso supporre che ciò valga per gli operatori con la stessa precedenza in generale?

---

ps: La questione è bene per i miei scopi, sono venuto ad esso durante la lettura interi solo il codice (come nell'esempio sopra) senza parentesi, che all'epoca sembrava molto sospetto per me .

Answer 1

Sì - diversi operatori con la stessa precedenza sono associati a sinistra; cioè, verranno utilizzati i due elementi più a sinistra, quindi il risultato e il terzo elemento, e così via.

Un'eccezione è l'operatore di **:

>>> 2 ** 2 ** 3 
256 

Inoltre, gli operatori di confronto (==, >, eccetera) non si comportano in maniera associativa, ma invece di tradurre in x [cmp] y [cmp] z(x [cmp] y) and (y [cmp] z).

Answer 2

Risposta breve: sì.

Gli Operatori Python documentation says the following:

nella stessa casella hanno la stessa precedenza. A meno che la sintassi non sia esplicitamente data, gli operatori sono binari. Gli operatori nello stesso gruppo si spostano da sinistra a destra (tranne per i confronti, inclusi i test, che hanno tutti la stessa precedenza e catena da sinistra a destra ... e l'esponenziazione, quali gruppi da destra a sinistra).

Quindi, in altre parole la risposta alla tua domanda è sì, gli operatori con la stessa priorità verranno gruppo da sinistra a destra a parte Comparisions which chain rather than group:

>>> x = 0 
>>> y = 0 
>>> x == y == True 
False 
>>> (x == y) == True 
True 
>>> x == (y == True) 
True 

e Exponentation:

>>> 2 ** 2 ** 3 
256 
>>> (2 ** 2) ** 3 
64 
>>> 2 ** (2 ** 3) 
256 

anche , in assegnazione il lato destro viene valutato prima sul lato sinistro:

>>> x = 1 
>>> y = x = 2 
>>> y 
2 

Answer 3

Ma, se è ambiguo per voi - il programmatore - e deve essere perché dovete chiedere, allora aspettatevi che sia almeno altrettanto ambiguo per il lettore e sprecate un paio di ottetti per chiarezza.

Affidarsi alle regole di precedenza è ottimo se si è un compilatore.

aggiunto risposte alle osservazioni:

Per la persona che legge il codice che incontra un'ambiguità che richiede la consultazione di fuori per la garanzia, si deve supporre che il prossimo lettore sarà meno esperti di te e salvare loro la fatica e errore umano evitabile di analizzare lo stesso costrutto e aggiungere la parentesi per loro.

In questo caso, anche la risposta accettata era errata (in logica, non in effetto, si veda il suo primo commento) di cui non ero a conoscenza e nemmeno una frazione di coloro che l'avevano svalutato.

Per quanto riguarda la descrizione dell'algebra di base, l'esempio particolare utilizzato nell'OP è istruttivo. Indipendentemente dalla precedenza dell'operatore, l'espressione j * (j/m) è algebricamente identica a (j * j)/m. Sfortunatamente, l'algebra di Python è solo un'approssimazione dell'algebra "platonica ideale" che potrebbe dare risposte sbagliate per entrambe le forme a seconda della magnitudine di j e m. Per esempio:

>>> m = 1e306 
>>> m 
1e+306 
>>> j = 1e307 
>>> j 
9.9999999999999999e+306 
>>> j/m 
10.0 
>>> j*j 
inf 
>>> j * (j/m) 
1e+308 
>>> (j * j)/m 
inf 
>>> ((j * j)/m) == (j * (j/m)) 
False 

così effettivamente la proprietà dell'identità di Python (e il mio FPU) quasi-algebra non regge. E questo può essere diverso sulla vostra macchina per le documentation notes: numeri in virgola

galleggianti sono implementati utilizzo di un doppio in C. Tutte le scommesse sul loro precisione sono fuori a meno che non vi capita di conoscere la macchina si sta lavorando .

si potrebbe affermare che non si ha affari di lavoro sul bordo pelosa di troppo pieno, e questo è vero in una certa misura, ma rimosso dal contesto l'espressione è indeterminato in un ordine delle operazioni e "corretta" sotto un'altra.