Python 何时为相同的字符串分配新内存？-IT科技

摘要：问题描述：两个具有相同字符的 Python 字符串 a == b 可能共享内存，id(a) == id(b)，或者可能在内存中两次，id(a) != id(b)。尝试ab = "ab" print id( ab ), id( "a"+"b" ) 这里...

问题描述：

两个具有相同字符的 Python 字符串 a == b 可能共享内存，id(a) == id(b)，或者可能在内存中两次，id(a) != id(b)。尝试

ab = "ab"
print id( ab ), id( "a"+"b" )

这里 Python 识别出新创建的“a”+“b”与内存中已有的“ab”相同——不错。

现在考虑一个长度为 N 的州名列表 [“Arizona”、“Alaska”、“Alaska”、“California”... ]（在我的例子中，N 约为 500000）。

我看到 50 个不同的 id() ⇒ 每个字符串“Arizona”... 只存储一次，很好。

但是将列表写入磁盘并再次读回：“相同”列表现在有 N 个不同的 id()，占用更多内存，见下文。

怎么会这样——有人能解释一下 Python 字符串的内存分配吗？

""" when does Python allocate new memory for identical strings ?
    ab = "ab"
    print id( ab ), id( "a"+"b" )  # same !
    list of N names from 50 states: 50 ids, mem ~ 4N + 50S, each string once
    but list > file > mem again: N ids, mem ~ N * (4 + S)
"""

from __future__ import division
from collections import defaultdict
from copy import copy
import cPickle
import random
import sys

states = dict(
AL = "Alabama",
AK = "Alaska",
AZ = "Arizona",
AR = "Arkansas",
CA = "California",
CO = "Colorado",
CT = "Connecticut",
DE = "Delaware",
FL = "Florida",
GA = "Georgia",
)

def nid(alist):
    """ nr distinct ids """
    return "%d ids  %d pickle len" % (
        len( set( map( id, alist ))),
        len( cPickle.dumps( alist, 0 )))  # rough est ?
# cf http://stackoverflow.com/questions/2117255/python-deep-getsizeof-list-with-contents

N = 10000
exec( "
".join( sys.argv[1:] ))  # var=val ...
random.seed(1)

    # big list of random names of states --
names = []
for j in xrange(N):
    name = copy( random.choice( states.values() ))
    names.append(name)
print "%d strings in mem:  %s" % (N, nid(names) )  # 10 ids, even with copy()

    # list to a file, back again -- each string is allocated anew
joinsplit = "
".join(names).split()  # same as > file > mem again
assert joinsplit == names
print "%d strings from a file:  %s" % (N, nid(joinsplit) )

# 10000 strings in mem:  10 ids  42149 pickle len  
# 10000 strings from a file:  10000 ids  188080 pickle len
# Python 2.6.4 mac ppc

添加于 1 月 25 日：

Python 内存中（或任何程序的内存中）有两种字符串：

Ustrings，在唯一字符串的 Ucache 中：这些节省内存，并且如果两者都在 Ucache 中，则使 a == b 变得快速
Ostrings，其他的，可以存储任意次数。

intern(astring)将字符串放入 Ucache（Alex +1）；除此之外，我们完全不知道 Python 如何将 Ostrings 移动到 Ucache 中 —— “a”+“b” 是如何在 “ab” 之后进入的？（“来自文件的字符串”毫无意义 —— 没有办法知道。）

简而言之，Ucaches（可能有多个）仍然很模糊。

历史注脚：
SPITBOL
于 1970 年左右将所有字符串唯一化。

解决方案 1：

Python 语言的每种实现都可以自由地在分配不可变对象（例如字符串）时做出自己的权衡——从语言的角度来看，要么创建一个新的对象，要么找到一个现有的相等对象并使用对它的一个引用，这都是可以的。当然，在实践中，现实世界的实现会达成合理的妥协：当找到这样的对象既便宜又容易时，对合适的现有对象再多一个引用，如果找到合适的现有对象（可能存在也可能不存在）的任务看起来可能需要很长时间搜索，那么只需创建一个新对象即可。

因此，例如，在单个函数中多次出现相同的字符串文字（在我所知道的所有实现中）将使用“对同一对象的新引用”策略，因为在构建该函数的常量池时，避免重复非常快速且容易；但是在不同的函数中执行此操作可能是一个非常耗时的任务，因此现实世界的实现要么根本不这样做，要么只在某些启发式识别的子集中执行此操作，在这些子集中，人们可以希望在编译时间（通过搜索相同的现有常量而减慢速度）与内存消耗（如果不断生成常量的新副本则会增加）之间取得合理的权衡。

我不知道 Python 的任何实现（或者其他具有常量字符串的语言，例如 Java）会在从文件读取数据时费力地识别可能的重复项（通过多个引用重用单个对象）——这似乎不是一个有希望的权衡（在这里你要付出的是运行时，而不是编译时间，所以这种权衡就更没有吸引力了）。当然，如果您知道（由于应用程序级别的考虑）这样的不可变对象很大并且很容易出现许多重复，您可以很容易地实现自己的“常量池”策略（intern可以帮助您为字符串做到这一点，但对于例如具有不可变项的元组、巨大的长整数等，自己实现并不难）。

解决方案 2：

我强烈怀疑 Python 的行为与许多其他语言类似 - 识别源代码中的字符串常量并使用通用表，但在动态创建字符串时不应用相同的规则。这是有道理的，因为源代码中只有一组有限的字符串（当然，Python 允许您动态评估代码），而更有可能的是，您将在程序运行过程中创建大量字符串。

该过程通常称为实习—— 事实上，从本页来看，它在 Python 中也被称为实习。

解决方案 3：

附注：了解 Python 中对象的生命周期非常重要。请注意以下会话：

Python 2.6.4 (r264:75706, Dec 26 2009, 01:03:10) 
[GCC 4.3.4] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a="a"
>>> b="b"
>>> print id(a+b), id(b+a)
134898720 134898720
>>> print (a+b) is (b+a)
False

您认为通过打印两个独立表达式的 ID并指出“它们相等，因此这两个表达式必须相等/等价/相同”的想法是错误的。单行输出并不一定意味着其所有内容都是在同一时刻创建和/或共存的。

如果想知道两个对象是否是同一个对象，直接询问 Python（使用is运算符）。

解决方案 4：

x = 42
y = 42
x == y #True
x is y #True

在此交互中，X 和 Y 应该是 ==（相同值），但不是 is（相同对象），因为我们运行了两个不同的文字表达式。但是，由于小整数和字符串被缓存和重用，因此 is 告诉我们它们引用的是同一个对象。
事实上，如果您真的想深入了解，您可以随时使用标准 sys 模块中的getrefcount
函数询问 Python 对象有多少个引用，该函数返回对象的引用计数。此行为反映了 Python 优化其模型以提高执行速度的众多方式之一。

学习 Python