[Python] incremento variabile

[gila75]

Dopo tantissimo tempo cerco di rimettermi con la programmazione.
Stavo "attaccando" il python per l'ennesima volta...speriamo che sia quella buona.
ho una semplicissima domanda, mi era già stato spiegato, ma non ricordo dove.
mi era stato detto che in Python l'incremento variabile si fa (preferibilmente) con:
a=1
a=+=1

e non a=a+1
ma non capisco, viene comunque creato sempre un nuovo oggetto di nome "a":

Codice: Seleziona tutto

>>> a=1
>>> id (a)
21717336
>>> a+=1
>>> a
2
>>> id(a)
21717312
>>> 

metodo non "pythonico"

Codice: Seleziona tutto

>>> id(a)
21717336
>>> a=a+1
>>> a
2
>>> id(a)
21717312
>>> 

in ogni caso viene creato un oggetto nuovo con un diverso indirizzo di memoria.
Dove sta l'inghippo che non capisco?

[nuzzopippo]

Ciao @gila ... sempre domande "particolari" le Tue, roba per utenti ben più ferrati di me che spero intervengano, canicola permettendo.

Intanto, una "correzione" al volo : l'operatore unario canonicamente NON utilizza la notazione "x = += 1", bensì la notazione "x += 1", come da Te ben utilizzato nel codice ma erratamente espresso nel testo, la prima notazione causa un errore di sintassi.

Ora, in attesa di meglio, una risposta più che altro "intuitiva" da parte mia ... così mi verifico un po' con pareri più competenti
Se ricordo bene le "lezioni" del buon @ClaudioF (i suoi non sono semplici post) è un argomento cui ha gentilmente accennato ed in parte trattato più volte, è lunga rintracciare tali interventi ma "serve".

Da quegli interventi e da altre letture mi sono formato questa approssimativa idea : il "particolare" indirizzamento in memoria delle variabili in python ed il "cambio" di indirizzo alla modifica della variabile è legato al fatto che in python "tutto è un oggetto" (anche i valori) e l'assegnazione di un valore ad una variabile non è altro che un collegamento di quel valore ad un nome, cambiando il "valore" cambia di conseguenza l'indirizzo in memoria riferito dato che si parla di un diverso "oggetto".

Lo so che tale "idea" è approssimativa ma si lega bene alla tipizzazione "non obbligata" delle variabili python ed agli scarni concetti da me letti sulla allocazione dinamica della memoria del "C" sottostante ... ovvio, spero in migliori indicazioni

Ciao e buon "rientro"

[Edit] ... ho dovuto cercare ma leggi il punto 8.10 di questa pagina e guarda qua:

Codice: Seleziona tutto

>>> a = "banana"
>>> b = "banana"
>>> id(a), id(b)
(140426923608024, 140426923608024)
>>> 

L'indirizzo in memoria delle due variabili è lo stesso

[gila75]

Ciao Nuzzo, che piacere "rivederti".
In effetti sono sempre domande un po' strane, ma io sono fatto cosi', se non ho chiaro mi blocco.
Clsudio_F aveva spiegato, ma dovrei ricercare bene.
Il fatto che :
a=a+1 e a+=1 creino tutti e due due oggetti diversi mi spiazza, non capisco le differenze, ma se non ricordo male ci sono.
Claudio aveva postato il codice disassemblato, ma non lo sapevo interpretare.
Con calma rileggo bene il tuo post, ora sono in giro.
Intanto grazie !!!

[gila75]

Ecco, trovato:
viewtopic.php?f=33&t=626951

Codice: Seleziona tutto

>>> import dis
>>> def f():
...     a += 1
... 
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_CONST               1 (1)
              6 INPLACE_ADD         
              7 STORE_FAST               0 (a)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE        
>>> def f():
...     a = a + 1
... 
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_CONST               1 (1)
              6 BINARY_ADD          
              7 STORE_FAST               0 (a)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE        
>>> 

ma non so interpretare. Ad ogni modo è solo una curiosità, io adotto la scrittura a+=1

[gila75]

Rieccomi dopo un po'. Proseguendo lo studio, mi sono imbattuto sulle differenze tra a=a+1 e a+=1
In poche parole, cambia solo il fatto che in a=a+1 a viene calcolata inutilmente 2 volte peggiorando le prestazioni.
Facilmente verificabile comparando i tempi.
Entrambi i modi, creano un nuovo oggetto, essendo i numeri al pari di stringhe e tuple oggetti immutabili.
Cosa tira cosa, mi sono imbattuto in un caso interessante per me neofita, sempre inerente ad a+=a o a=a+a
questa volta però riguarda oggetti mutevoli come le liste per esempio:
Supponiamo:

Codice: Seleziona tutto

l=[1,2]
m=l #ora m è uguale l, punta stessa area memoria
l=l+[3,4]
print (l,m)

output:

Codice: Seleziona tutto

[1, 2, 3, 4] [1, 2]

come si può notare, a è uguale a m, ma nella riga:

Codice: Seleziona tutto

l=l+[3,4]

l, diventa un oggetto nuovo, quindi m non viene modificato.
Discorso opposto con:

Codice: Seleziona tutto

l=[1,2]
m=l
l+=[3,4]
print (l,m)

Output:

Codice: Seleziona tutto

[1, 2, 3, 4] [1, 2, 3, 4]

in questo caso, non creiamo un oggetto nuovo, ma [3,4], viene aggiunto sul posto, quindi m che condivideva la
stessa area di memoria viene modificato.
Lo stesso risultato lo avremmo ottenuto con l.extend()
Sono banalità, ma penso siano importanti per un neofita, potrebbero generare bug difficili da scovare.
Penso oltretutto che siano i concetti base del python che è meglio avere ben chiari

PS: solo una curiosità: ho provato a scrivere in C alcune funzioni di "libreria" delle stringhe, per esempio maketrans().
Ora io non sono un programmatore esperto e professionista del C, ma devo dire che risulta particolarmente ostico battere le funzioni python
che saranno scritte sicuramente in C. Nel caso di maketrans, sono riuscito a eguagliare i tempi...o quasi.
Quindi deduco che siano altamente ottimizzate

[nuzzopippo]

Concordo sulla utilità dei concetti esposti, che ritengo notevole.

Nel link che avevo postato prima, sezioni 8.11 ed 8.12, si tocca l'argomento degli "alias", indicando la necessità di porci attenzione ... ma non ci si arriva mica facilmente che utilizzando l'incremento unario si tocca un alias.
Interessanti ed ottime verifiche queste @gila, me le annoto.

Niente da dire sulla ottimizzazione delle librerie ... anche se penso che chi le scrive ed esamina sia un bel po' "avanti"

[gila75]

Interessanti ed ottime verifiche queste @gila, me le annoto.

Grazie Nuzzo. Ci spendo un po' di tempo e vado a rilento, ma io se non ho chiaro mi blocco.

Niente da dire sulla ottimizzazione delle librerie ... anche se penso che chi le scrive ed esamina sia un bel po' "avanti"

Sicuramente sarà un team super preparato e chissà quante verifiche dovrà passare lo script.
La mia è solo una curiosità principalmente, ma anche un modo per vedere se sto usando in modo corretto gli strumenti Python.
Il discorso che facevamo con lo script sui numeri primi: usando append( se non ricordo male) 2 righe e si scriveva, ma era pessimo.
Ecco oltre alla curiosità cerco di non abusare delle comodità. é un po' difficile spiegare cosa intendo, ma credo avrai capito