Internals per tuple di pitone

Question

>>> a=1 
>>> b=1 
>>> id(a) 
140472563599848 
>>> id(b) 
140472563599848 
>>> x=() 
>>> y=() 
>>> id(x) 
4298207312 
>>> id(y) 
4298207312 
>>> x1=(1) 
>>> x2=(1) 
>>> id(x1) 
140472563599848 
>>> id(x2) 
140472563599848 

fino a questo punto, stavo pensando che ci sarà solo una copia di oggetto immutabile e che sarà condivisa (puntata) da tutte le variabili.

Ma quando ho provato, i passaggi seguenti ho capito che avevo torto.

>>> x1=(1,5) 
>>> y1=(1,5) 
>>> id(x1) 
4299267248 
>>> id(y1) 
4299267320 

qualcuno può spiegarmi gli interni?

Answer 1

>>> x1=(1) 
>>> x2=(1) 

è in realtà lo stesso

>>> x1=1 
>>> x2=1 

In Python, smaller numbers are internally cached. Quindi non verranno creati più volte nella memoria. Ecco perché id s di x1 e x2 sono gli stessi fino a questo punto.

Un un elemento tupla dovrebbe avere una virgola alla fine, come questo

>>> x1=(1,) 
>>> x2=(1,) 

Quando si esegue questa operazione, ci sono due nuovi tuple essere costruite con un solo elemento in esso. Anche se gli elementi all'interno delle tuple sono uguali, entrambi sono diverse tuple. Questo è il motivo per cui entrambi hanno diversi id s.

Consente di eseguire l'ultimo esempio e di disassemblare il codice.

compiled_code = compile("x1 = (1, 5); y1 = (1, 5)", "string", "exec") 

Ora,

import dis 
dis.dis(compiled_code) 

produrrebbe qualcosa come questo

1   0 LOAD_CONST    3 ((1, 5)) 
       3 STORE_NAME    0 (x1) 
       6 LOAD_CONST    4 ((1, 5)) 
       9 STORE_NAME    1 (y1) 
      12 LOAD_CONST    2 (None) 
      15 RETURN_VALUE 

Si carica un valore costante, di cui dall'indice 3, che è (1, 5) e poi lo memorizza in x1. Allo stesso modo, carica un altro valore costante, all'indice 4 e lo memorizza in y1. Se guardiamo l'elenco delle costanti nel codice oggetto,

print(compiled_code.co_consts) 

darà

(1, 5, None, (1, 5), (1, 5)) 

Gli elementi in posizioni 3 e 4 sono le tuple che abbiamo creato nel codice vero e proprio. Quindi, Python non crea solo un'istanza per ogni oggetto immutabile, sempre. È un dettaglio di implementazione di cui non dobbiamo preoccuparci molto.

Nota: Se si vuole avere una sola istanza di un oggetto immutabile, si può fare manualmente in questo modo

x1 = (1, 5) 
x2 = x1 

Ora, sia x2 e x1 farà riferimento allo stesso oggetto tupla.