Interning di stringhe Python

Sebbene questa domanda non abbia alcun reale utilizzo nella pratica, sono curioso di sapere come Python esegue l'internamento delle stringhe. Ho notato quanto segue.

>>> "string" is "string"
True

Questo è come mi aspettavo.

Puoi anche farlo.

>>> "strin"+"g" is "string"
True

E questo è abbastanza intelligente!

Ma non puoi farlo.

>>> s1 = "strin"
>>> s2 = "string"
>>> s1+"g" is s2
False

Perché Python non valuta s1+"g"e si rende conto che è la stessa cosa s2e lo punta allo stesso indirizzo? Cosa sta effettivamente succedendo in quell'ultimo blocco per riaverlo False?

Questo è specifico dell'implementazione, ma il tuo interprete probabilmente sta internando costanti in fase di compilazione ma non i risultati delle espressioni in fase di esecuzione.

In quanto segue utilizzo CPython 2.7.3.

Nel secondo esempio, l'espressione "strin"+"g"viene valutata in fase di compilazione e viene sostituita con "string". Ciò fa sì che i primi due esempi si comportino allo stesso modo.

Se esaminiamo i bytecode, vedremo che sono esattamente gli stessi:

  # s1 = "string"
  2           0 LOAD_CONST               1 ('string')
              3 STORE_FAST               0 (s1)

  # s2 = "strin" + "g"
  3           6 LOAD_CONST               4 ('string')
              9 STORE_FAST               1 (s2)

Il terzo esempio prevede una concatenazione run-time, il cui risultato non viene automaticamente internato:

  # s3a = "strin"
  # s3 = s3a + "g"
  4          12 LOAD_CONST               2 ('strin')
             15 STORE_FAST               2 (s3a)

  5          18 LOAD_FAST                2 (s3a)
             21 LOAD_CONST               3 ('g')
             24 BINARY_ADD          
             25 STORE_FAST               3 (s3)
             28 LOAD_CONST               0 (None)
             31 RETURN_VALUE        

Se dovessi manualmente intern()il risultato della terza espressione, otterrai lo stesso oggetto di prima:

>>> s3a = "strin"
>>> s3 = s3a + "g"
>>> s3 is "string"
False
>>> intern(s3) is "string"
True

Caso 1

>>> x = "123"  
>>> y = "123"  
>>> x == y  
True  
>>> x is y  
True  
>>> id(x)  
50986112  
>>> id(y)  
50986112  

Caso 2

>>> x = "12"
>>> y = "123"
>>> x = x + "3"
>>> x is y
False
>>> x == y
True

Ora, la tua domanda è perché l'id è lo stesso nel caso 1 e non nel caso 2.
Nel caso 1, hai assegnato una stringa letterale "123"a xe y.

Poiché le stringhe sono immutabili, ha senso che l'interprete memorizzi la stringa letterale solo una volta e punti tutte le variabili allo stesso oggetto.
Quindi vedi l'id come identico.

Nel caso 2, stai modificando xusando la concatenazione. Entrambi xe yhanno gli stessi valori, ma non la stessa identità.
Entrambi puntano a oggetti diversi in memoria. Quindi hanno diversi ide l' isoperatore è tornatoFalse