Python string interning

Embora essa pergunta não tenha nenhum uso real na prática, estou curioso para saber como o Python faz o estágio de string. Eu percebi o seguinte.

>>> "string" is "string"
True

Isso é o que eu esperava.

Você também pode fazer isso.

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

E isso é muito inteligente!

Mas você não pode fazer isso.

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

Por que o Python não avaliaria s1+"g"e perceberia que é o mesmo s2e apontaria para o mesmo endereço? O que realmente está acontecendo naquele último bloco para que ele volte False?

Isso é específico da implementação, mas seu interpretador provavelmente está internando constantes de tempo de compilação, mas não os resultados de expressões de tempo de execução.

A seguir, uso o CPython 2.7.3.

No segundo exemplo, a expressão "strin"+"g"é avaliada em tempo de compilação e é substituída por "string". Isso faz com que os dois primeiros exemplos tenham o mesmo comportamento.

Se examinarmos os bytecodes, veremos que eles são exatamente os mesmos:

  # 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)

O terceiro exemplo envolve uma concatenação de tempo de execução, o resultado da qual não é automaticamente internado:

  # 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 você fosse manualmente intern()o resultado da terceira expressão, você obteria o mesmo objeto de antes:

>>> 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

Agora, sua pergunta é por que o id é o mesmo no caso 1 e não no caso 2.
No caso 1, você atribuiu um literal de string "123"para xey .

Como a string é imutável, faz sentido para o interpretador armazenar a string literal apenas uma vez e apontar todas as variáveis ​​para o mesmo objeto.
Portanto, você vê o id como idêntico.

No caso 2, você está modificando xusando concatenação. Ambos xe ytêm os mesmos valores, mas não a mesma identidade.
Ambos apontam para objetos diferentes na memória. Portanto, eles têm diferentes ide o isoperador retornouFalse