operator - python// division




Perché non ci sono operatori++ e-in Python? (12)

Chiarezza!

Python ha molto a che fare con la chiarezza e nessun programmatore è in grado di indovinare correttamente il significato di --a meno che non abbia imparato una lingua con quel costrutto.

Python si occupa anche di evitare costrutti che invitano errori e gli operatori ++ sono noti per essere ricche fonti di difetti. Queste due ragioni sono sufficienti per non avere quegli operatori in Python.

La decisione secondo cui Python utilizza il rientro per contrassegnare i blocchi piuttosto che i mezzi sintattici come una forma di parentesi iniziale / finale o marcatura di fine obbligatoria si basa in gran parte sulle stesse considerazioni.

Per esempio, cond ? resultif : resultelse un'occhiata alla discussione sull'introduzione di un operatore condizionale (in C: cond ? resultif : resultelse ) in Python nel 2005. Leggete almeno il primo messaggio e il messaggio decisionale di quella discussion (che aveva diversi precursori sullo stesso argomento precedente).

Curiosità: il PEP frequentemente menzionato in esso è la "Proposta di estensione Python" PEP 308 . LC significa comprensione delle liste , GE significa espressione del generatore (e non preoccuparti se ti confondono, non sono nessuno dei pochi punti complicati di Python).

Perché non ci sono operatori ++ e -- in Python?


Certo, potremmo dire "Guido ha deciso in quel modo", ma penso che la domanda riguardi davvero le ragioni di quella decisione. Penso che ci siano diversi motivi:

  • Mescola insieme dichiarazioni ed espressioni, che non è una buona pratica. Vedi http://norvig.com/python-iaq.html
  • Generalmente incoraggia le persone a scrivere codice meno leggibile
  • Extra complessità nell'implementazione del linguaggio, che non è necessaria in Python, come già menzionato

Credo che derivi dal credo di Python che "esplicito è meglio di implicito".


E 'stato appena progettato in questo modo. Gli operatori di incremento e decremento sono solo scorciatoie per x = x + 1 . In genere Python ha adottato una strategia di progettazione che riduce il numero di mezzi alternativi per eseguire un'operazione. L'assegnazione aumentata è la cosa più vicina agli operatori di incremento / decremento in Python e non sono stati aggiunti fino a Python 2.0.


Ho sempre pensato che avesse a che fare con questa linea dello zen di python:

Ci dovrebbe essere uno - e preferibilmente solo uno - modo ovvio per farlo.

x ++ e x + = 1 fanno esattamente la stessa cosa, quindi non c'è motivo di averli entrambi.


L'operatore ++ non è esattamente uguale all'operatore + =. In effetti il ​​risultato di entrambi è lo stesso, ma gli usi hanno qualche differenza. Ad esempio, puoi usare l'operatore ++ in condizionale ternario, per il ciclo, ecc ma non puoi usare + =. In fondo, sentiamo il bisogno ++ e -, per questo motivo.


La mia comprensione del perché Python non ha un operatore ++ sta seguendo: Quando scrivi questo in python a=b=c=1 otterrai tre variabili (etichette) che puntano allo stesso oggetto (il cui valore è 1). Puoi verificarlo usando la funzione id che restituirà un indirizzo di memoria dell'oggetto:

In [19]: id(a)
Out[19]: 34019256

In [20]: id(b)
Out[20]: 34019256

In [21]: id(c)
Out[21]: 34019256

Tutte e tre le variabili (etichette) puntano allo stesso oggetto. Ora incrementa una delle variabili e vedi come influenza gli indirizzi di memoria:

In [22] a = a + 1

In [23]: id(a)
Out[23]: 34019232

In [24]: id(b)
Out[24]: 34019256

In [25]: id(c)
Out[25]: 34019256

Puoi vedere che a variabile ora punta a un altro oggetto come variabili b e c . Perché hai usato a = a + 1 è esplicitamente chiaro. In altre parole, assegni completamente un altro oggetto all'etichetta a . Immagina di poter scrivere a++ ma suggerirebbe di non assegnare alla variabile a nuovo oggetto, ma di aumentare la vecchia. Tutta questa roba è IMHO per minimizzare la confusione. Per una migliore comprensione, vedi come funzionano le variabili python:

In Python, perché una funzione può modificare alcuni argomenti come percepiti dal chiamante, ma non altri?

Python è call-by-value o call-by-reference? Né.

Python passa per valore o per riferimento?

Python passa per riferimento o passa per valore?

Python: come faccio a passare una variabile per riferimento?

Comprensione delle variabili Python e gestione della memoria

Emulazione del comportamento del pass-by-value in python

Le funzioni Python chiamano per riferimento

Code Like a Pythonista: Idiomatic Python


Non è perché non ha senso; ha perfettamente senso definire "x ++" come "x + = 1, valutando il legame precedente di x".

Se vuoi conoscere il motivo originale, dovrai seguire le vecchie mailing list di Python o chiedere a qualcuno che era lì (ad esempio Guido), ma è abbastanza facile giustificare dopo il fatto:

Semplice incremento e decremento non sono necessari tanto quanto in altre lingue. Non scrivi cose come for(int i = 0; i < 10; ++i) in Python molto spesso; invece fai cose come for i in range(0, 10) .

Dato che non è necessario quasi altrettanto spesso, ci sono molte meno ragioni per dargli una propria sintassi speciale; quando hai bisogno di incrementare, += solito va bene.

Non è una decisione se ha senso, o se può essere fatto - lo fa, e può farlo. Si tratta di valutare se il beneficio merita di essere aggiunto alla sintassi principale della lingua. Ricordate, si tratta di quattro operatori: postinc, postdec, preinc, predec e ognuno di questi avrebbe bisogno di avere i propri sovraccarichi di classe; devono tutti essere specificati e testati; aggiungerebbe opcode alla lingua (implicando un motore VM più grande, e quindi più lento); ogni classe che supporta un incremento logico dovrebbe implementarle (sopra += e -= ).

Questo è tutto ridondante con += e -= , quindi diventerebbe una perdita netta.


Perché, in Python, gli interi sono immutabili (int's + = restituisce effettivamente un oggetto diverso).

Inoltre, con ++ / - è necessario preoccuparsi di pre-versus post-incremento / decremento, e ci vuole solo un altro tasto per scrivere x+=1 . In altre parole, evita la potenziale confusione a scapito di guadagni minimi.


Primo, Python è influenzato solo indirettamente da C; è fortemente influenzato dalla ABC , che a quanto pare non ha questi operatori , quindi non dovrebbe essere una grande sorpresa non trovarli neanche in Python.

In secondo luogo, come altri hanno già detto, l'incremento e il decremento sono supportati da += e -= già.

In terzo luogo, il supporto completo per un insieme di operatori ++ e -- include in genere il supporto di entrambe le versioni di prefisso e suffisso. In C e C ++, questo può portare a tutti i tipi di costrutti "adorabili" che sembrano (per me) essere contrari allo spirito di semplicità e rettitudine che Python abbraccia.

Ad esempio, mentre l'istruzione C while(*t++ = *s++); può sembrare semplice ed elegante per un programmatore esperto, per qualcuno che lo apprende, è tutt'altro che semplice. Getta una combinazione di incrementi e decrementi di prefisso e postfix, e anche molti professionisti dovranno fermarsi e pensare un po '.


come ho capito così non penserai che il valore in memoria sia cambiato. in c quando fai x ++ il valore di x nella memoria cambia. ma in python tutti i numeri sono immutabili quindi l'indirizzo che x ha indicato come ancora x non x + 1. quando scrivi x ++ penseresti che x cambi quello che realmente accade è che x refrence è cambiato in una locazione in memoria dove x + 1 è memorizzato o ricrea questa posizione se non esiste.


Questa originale risposta che ho scritto è un mito del folklore dell'informatica : smentito da Dennis Ritchie come "storicamente impossibile" come indicato nelle lettere agli editori di Communications of the ACM luglio 2012 doi:10.1145/2209249.2209251

Gli operatori di incremento / decremento C sono stati inventati in un momento in cui il compilatore C non era molto intelligente e gli autori volevano essere in grado di specificare l'intento diretto di utilizzare un operatore di linguaggio macchina che salvasse una manciata di cicli per un compilatore che potrebbe fare a

load memory
load 1
add
store memory

invece di

inc memory 

e il PDP-11 supportava anche le istruzioni "autoincrement" e "autoincrement deferred" corrispondenti rispettivamente a *++p e *p++ . Vedere la sezione 5.3 del manuale se è orribilmente curioso.

Poiché i compilatori sono abbastanza intelligenti da gestire i trucchi di ottimizzazione di alto livello incorporati nella sintassi di C, ora sono solo una comodità sintattica.

Python non ha trucchi per comunicare le intenzioni all'assemblatore perché non ne usa uno.







operators