关于不变字符串的变化身份

Question

关于类型为str（在python 2.7中）的对象的id的一些东西让我困惑。类型str是不可变的，因此我希望一旦创建它，它将始终具有相同的id。我相信我的词组不太好，所以我将发布一个输入和输出序列的示例。

>>> id('so')
140614155123888
>>> id('so')
140614155123848
>>> id('so')
140614155123808

所以在这期间，它一直在变化。但是，在变量指向该字符串后，情况会发生变化：

>>> so = 'so'
>>> id('so')
140614155123728
>>> so = 'so'
>>> id(so)
140614155123728
>>> not_so = 'so'
>>> id(not_so)
140614155123728

所以看起来，一旦变量保存了这个值，它就会冻结id。实际上，在del so和del not_so之后，id('so')的输出再次开始改变。

这与（小）整数的行为不同。

我知道不变性和拥有相同的id之间没有真正的联系；不过，我仍在试图找出这种行为的根源。我相信熟悉python内部结构的人不会比我惊讶，所以我正试图达到同样的目的。。。

更新

用不同的字符串进行相同的尝试会得到不同的结果。。。

>>> id('hello')
139978087896384
>>> id('hello')
139978087896384
>>> id('hello')
139978087896384

现在它等于。。。

Answer 1

此行为特定于Python交互shell。如果我将以下内容放入.py文件中：

print id('so')
print id('so')
print id('so')

然后执行它，我收到以下输出：

2888960
2888960
2888960

在CPython中，字符串文本被视为常量，我们可以在上面代码片段的字节码中看到：

  2           0 LOAD_GLOBAL              0 (id)
              3 LOAD_CONST               1 ('so')
              6 CALL_FUNCTION            1
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  3          11 LOAD_GLOBAL              0 (id)
             14 LOAD_CONST               1 ('so')
             17 CALL_FUNCTION            1
             20 PRINT_ITEM          
             21 PRINT_NEWLINE       

  4          22 LOAD_GLOBAL              0 (id)
             25 LOAD_CONST               1 ('so')
             28 CALL_FUNCTION            1
             31 PRINT_ITEM          
             32 PRINT_NEWLINE       
             33 LOAD_CONST               0 (None)
             36 RETURN_VALUE  

相同的常量（即相同的字符串对象）加载3次，因此id相同。

Answer 2

默认情况下，CPython并不保证将所有字符串都实习，但实际上，Python代码库中的许多地方确实重用了已经创建的字符串对象。很多Python内部都使用^{} function call来显式地内联Python字符串，但是除非遇到其中一种特殊情况，否则两个相同的Python字符串文本将生成不同的字符串。

Python还可以自由地重用内存位置，并且Python还可以通过在编译时使用代码对象中的字节码存储不可变的文本来优化它们。Python REPL（交互式解释器）还将最新的表达式结果存储在_名称中，这会使事情更加混乱。

因此，您将不时看到相同的id出现。

只运行REPL中的id(<string literal>)行需要几个步骤：

1. 该行已编译，其中包括为字符串对象创建常量：

   >>> compile("id('foo')", '<stdin>', 'single').co_consts
   ('foo', None)
   

   这显示了已编译字节码的存储常量；在本例中是字符串'foo'和None单例。在此阶段，可以优化由产生不可变值的简单表达式组成的表达式，请参见下面关于优化器的说明。

2. 执行时，从代码常量加载字符串，并id()返回内存位置。生成的int值绑定到_，并打印：

   >>> import dis
   >>> dis.dis(compile("id('foo')", '<stdin>', 'single'))
     1           0 LOAD_NAME                0 (id)
                 3 LOAD_CONST               0 ('foo')
                 6 CALL_FUNCTION            1
                 9 PRINT_EXPR          
                10 LOAD_CONST               1 (None)
                13 RETURN_VALUE        
   

3. 代码对象未被任何对象引用，引用计数降至0，代码对象将被删除。因此，string对象也是如此。

然后，如果重新运行相同的代码，Python可以将相同的内存位置用于新的string对象。如果重复此代码，通常会导致打印相同的内存地址。这取决于您对Python内存还做了什么。

ID重用不是可预测的；如果同时垃圾收集器运行以清除循环引用，则可以释放其他内存，您将获得新的内存地址。

接下来，Python编译器还将实习生存储为常量的任何Python字符串，只要它看起来足够像一个有效的标识符。Pythoncode object factory function PyCode_New将通过调用^{}来实习生任何只包含ASCII字母、数字或下划线的字符串对象。此函数在常量结构中递归，对于在其中找到的任何字符串对象v执行：

if (all_name_chars(v)) {
    PyObject *w = v;
    PyUnicode_InternInPlace(&v);
    if (w != v) {
        PyTuple_SET_ITEM(tuple, i, v);
        modified = 1;
    }
}

其中^{}被记录为

/* all_name_chars(s): true iff s matches [a-zA-Z0-9_]* */

因为您创建了符合该条件的字符串，所以它们被保留，这就是为什么您在第二个测试中看到对'so'字符串使用相同的ID的原因：只要保留对保留版本的引用，保留将导致未来的'so'文本重用被保留的字符串对象，即使是在新的代码块和绑定到不同的标识符。在第一个测试中，不保存对字符串的引用，因此在可以重用之前，将丢弃已实习的字符串。

顺便说一下，您的新名称so = 'so'将字符串绑定到包含相同字符的名称。换句话说，您正在创建一个名称和值相等的全局。作为Python的标识符和限定常量的实习生，您最终将对标识符及其值使用相同的字符串对象：

>>> compile("so = 'so'", '<stdin>', 'single').co_names[0] is compile("so = 'so'", '<stdin>', 'single').co_consts[0]
True

如果您创建的字符串不是代码对象常量，或者包含字母+数字+下划线范围以外的字符，您将看到id()值未被重用：

>>> some_var = 'Look ma, spaces and punctuation!'
>>> some_other_var = 'Look ma, spaces and punctuation!'
>>> id(some_var)
4493058384
>>> id(some_other_var)
4493058456
>>> foo = 'Concatenating_' + 'also_helps_if_long_enough'
>>> bar = 'Concatenating_' + 'also_helps_if_long_enough'
>>> foo is bar
False
>>> foo == bar
True

Python编译器要么使用peephole optimizer（Python版本<；3.7）要么使用功能更强大的AST optimizer（3.7及更新版本）来预计算（折叠）包含常量的简单表达式的结果。peepholder将其输出限制为长度小于等于20的序列（以防止代码对象膨胀和内存使用），而AST优化器对4096个字符的字符串使用单独的限制呃。这意味着，如果生成的字符串符合当前Python版本的优化器限制，则仅由名称字符组成的较短字符串的连接仍然会导致字符串被中断。

例如，在Python 3.7上，'foo' * 20将产生一个单独的内部字符串，因为常量折叠将其转换为单个值，而在python3.6或更早版本上，只有'foo' * 6将被折叠：

>>> import dis, sys
>>> sys.version_info
sys.version_info(major=3, minor=7, micro=4, releaselevel='final', serial=0)
>>> dis.dis("'foo' * 20")
  1           0 LOAD_CONST               0 ('foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo')
              2 RETURN_VALUE

以及

>>> dis.dis("'foo' * 6")
  1           0 LOAD_CONST               2 ('foofoofoofoofoofoo')
              2 RETURN_VALUE
>>> dis.dis("'foo' * 7")
  1           0 LOAD_CONST               0 ('foo')
              2 LOAD_CONST               1 (7)
              4 BINARY_MULTIPLY
              6 RETURN_VALUE

Answer 3

在第一个示例中，每次都会创建字符串'so'的新实例，因此会创建不同的id

在第二个示例中，您将字符串绑定到变量，然后Python可以维护字符串的共享副本。