检查 Python 中的可变性？

Question

考虑这个代码：

a = {...} # a is an dict with arbitrary contents
b = a.copy()

1. 可变性在键和值中扮演什么角色字典？
2. 如何确保一个字典的键或值的更改不会反映在另一个字典中？
3. 这与 dict 键的可散列 约束 有什么关系？
4. Python 2.x 和 Python 3.x 之间的行为有什么差异吗？

如何检查 Python 中的类型是否可变？

Answer 1

1. 密钥必须是可散列的 - 这就是强加给你的一切。特别是，您可以拥有一个用户定义的类，其实例是可散列的，但也是可变的 - 但是这通常是一个坏主意。

2. 通过不在两个字典之间共享值。共享密钥通常是可以的，因为它们应该是不可变的（对于内置类型来说也是如此）。从copy标准库模块的意义上来说，复制字典是绝对安全的。在这里调用 dict 构造函数也可以：b = dict(a)。您还可以使用不可变值。

3. 所有内置不可变类型都是可哈希的。所有内置可变类型都不可散列。对 dict 键的约束只需要内置的 hash 函数作用于键，这又要求其类实现 __hash__ 魔术方法。

   但是，如果对象的哈希值在其生命周期内可能发生更改，则代码可能会巧妙地或意外地中断。举一个病理学的例子：

   <前><代码>>>>随机导入
   >>>>> X 类：
   ... def __hash__(self): 返回 random.randint(0, 100)
   ...
   >>>>> a, b = x(), x()
   >>>>> c = {a:1, b:2}
   >>>>> c[a]
   回溯（最近一次调用最后一次）：
   文件“”，第 1 行，在中
   KeyError: <__main__.x 对象位于...>

   这就是为什么尝试创建可变的、可散列的类型是不明智的：散列应该不会改变，但也应该反映对象的状态。

4. 没有。

如果类型不是不可变的，那么它就是可变的。如果类型是内置不可变类型，则该类型是不可变的：str、int、long、bool、 float、tuple，可能还有其他几个我忘记了。用户定义的类型始终是可变的。

如果一个对象不是不可变的，那么它就是可变的。如果一个对象递归地仅由不可变类型的子对象组成，则该对象是不可变的。因此，列表元组是可变的；您无法替换元组的元素，但可以通过列表接口修改它们，从而更改整体数据。

Answer 2

Python 中的语言级别实际上不存在诸如可变性或不变性之类的东西。有些对象无法提供更改它们的方法（例如字符串和元组），因此实际上是不可变的，但这纯粹是概念性的；无论是你的代码还是 Python 本身，都没有语言级别的属性表明这一点。

不变性实际上与 dict 无关；使用可变值作为键是完全可以的。重要的是比较和散列：对象必须始终保持等于自身。例如：

class example(object):
    def __init__(self, a):
        self.value = a
    def __eq__(self, rhs):
        return self.value == rhs.value
    def __hash__(self):
        return hash(self.value)

a = example(1)
d = {a: "first"}
a.data = 2
print d[example(1)]

这里，example 不是不可变的；我们使用 a.data = 2 修改它。然而，我们将它用作哈希的键，没有任何问题。为什么？我们正在更改的属性对相等性没有影响：哈希值保持不变，并且 example(1) 始终等于 example(1)，忽略任何其他属性。

最常见的用途是缓存和记忆：缓存或不缓存属性在逻辑上不会更改对象，并且通常对相等性没有影响。

（我要在这里停下来——请不要一次问五个问题。）

Answer 3

模块集合中有MutableSequence、MutableSet、MutableMapping。它可用于检查预制类型的可变性。

issubclass(TYPE, (MutableSequence, MutableSet, MutableMapping))

如果要在用户定义的类型上使用此类型，则该类型必须从其中之一继承或注册为虚拟子类。

class x(MutableSequence):
    ...

或者

class x:
    ...

abc.ABCMeta.register(MutableSequence,x)

Answer 4

实际上并不能保证可哈希的类型也是不可变的，但至少，正确实现 __hash__ 要求该类型相对于其自身的哈希而言是不可变的，并达到平等。这不是以任何特定方式强制执行的。

然而，我们都是成年人了。除非你真的这么想，否则实现__hash__是不明智的。粗略地说，这归结为如果一个类型实际上可以用作字典键，那么它就应该以这种方式使用。

如果您正在寻找类似于字典但又不可变的东西，那么namedtuple 可能是标准库中的最佳选择。诚然，这不是一个很好的近似，但它是一个开始。

Answer 5

1. 字典键必须是可散列的，这意味着它们具有不可变的散列值。 dict 值可能是可变的，也可能不是可变的；但是，如果它们是可变的，这会影响您的第二个问题。

2. “对键的更改”不会反映在两个字典之间。对不可变值（例如字符串）的更改也不会得到反映。对可变对象（例如用户定义的类）的更改将得到反映，因为对象是按 id（即引用）存储的。

   类 T（对象）：
     def __init__(self, v):
       自我.v = v
   
   
   t1 = T(5)
   
   
   d1 = {'a': t1}
   d2 = d1.copy()
   
   
   d2['a'].v = 7
   d1['a'].v # = 7
   
   
   d2['a'] = T(2)
   d2['a'].v # = 2
   d1['a'].v # = 7
   
   
   导入副本
   d3 = copy.deepcopy(d2) # 执行“深层复制”
   d3['a'].v = 12
   d3['a'].v # = 12
   d2['a'].v # = 2
   

3. 我认为前两个答案可以解释这一点。

4. 据我所知，这方面没有。

一些额外的想法：

要理解键的行为，需要了解两件主要事情：键必须是hashable （这意味着它们实现了 object.__hash__(self)）并且它们还必须是“可比较的”（这意味着它们实现了类似 object.__cmp__(self))。从文档中得到的一个重要信息：默认情况下，用户定义对象的哈希函数返回 <代码>id()。

考虑这个例子：

class K(object):
  def __init__(self, x, y):
     self.x = x
     self.y = y
  def __hash__(self):
     return self.x + self.y

k1 = K(1, 2)
d1 = {k1: 3}
d1[k1] # outputs 3
k1.x = 5
d1[k1] # KeyError!  The key's hash has changed!
k2 = K(2, 1)
d1[k2] # KeyError!  The key's hash is right, but the keys aren't equal.
k1.x = 1
d1[k1] # outputs 3

class NewK(object):
  def __init__(self, x, y):
     self.x = x
     self.y = y
  def __hash__(self):
     return self.x + self.y
  def __cmp__(self, other):
     return self.x - other.x

nk1 = NewK(3, 4)
nd1 = {nk1: 5}
nd1[nk1] # outputs 5
nk2 = NewK(3, 7)
nk1 == nk2 # True!
nd1[nk2] # KeyError! The keys' hashes differ.
hash(nk1) == hash(nk2) # False
nk2.y = 4
nd1[nk2] # outputs 5

# Where this can cause issues:
nd1.keys()[0].x = 5
nd1[nk1] # KeyError! nk1 is no longer in the dict!
id(nd1.keys()[0]) == id(nk1)  # Yikes. True?!
nd1.keys()[0].x = 3
nd1[nk1]  # outputs 5
id(nd1.keys()[0]) == id(nk1)  # True!

值更容易理解，字典存储对对象的引用。阅读有关 hashable 的部分。像字符串这样的东西是不可变的，如果你“改变”它们，你改变它的字典现在引用一个新对象。可变的对象可以“就地更改”，因此两个字典的值都会改变。

d1 = {1: 'a'}
d2 = d1.copy()
id(d1[1]) == id(d2[1]) # True
d2[1] = 'z'
id(d1[1]) == id(d2[1]) # False

# the examples in section 2 above have more examples of this.

无论如何，这一切的要点如下：

• 对于键，您关心的可能不是可变性，而是散列性和可比性关于。
• 您关心值的可变性，因为根据定义，可以更改可变对象的值而不更改对其的引用。

我认为没有通用的方法来测试这两点。适用性测试取决于您的用例。例如，检查对象是否实现 __hash__ 和比较（__eq__ 或 __cmp__）函数可能就足够了。同样，您可以通过某种方式“检查”对象的 __setattr__ 方法来确定它是否可变。

Answer 6

您可以通过打印 id 或该数据类型的内存位置地址轻松检查数据类型是可变还是不可变如果数据类型是不可变的，则内存位置的地址将在您更新变量时发生变化，例如：

stn = 'Hello'
print(id(stn)) 

您将获取该变量stn的内存位置的地址，但是当您将该变量与某个值连接起来，然后继续print内存位置的地址时，您将得到与第一个不同的输出同样，

stn += ' world'
print(id(stn))

您肯定会从第一个地址获得另一个内存位置地址，但是当您对可变数据类型执行此操作时，内存位置的地址将保持不变，例如

lists = [1, 2, 3]
print(id(lists))

在这里您将获得内存位置的地址，并且如果您去向前并在该列表中附加一些数字，内存位置的地址将继续相同

lists.append(4)
print(id(lists))

，并且您已经注意到内存位置的地址对于所有计算机而言并不相同
所以你无法在不同的计算机上检查相同的数据类型并得到相同的结果

Answer 7

字典是无序的键：值对集合。键必须是不可变的，因此是可散列的。要确定对象是否可散列，您可以使用 hash() 函数：

>>> hash(1)
1
>>> hash('a')
12416037344
>>> hash([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash((1,2,3))
2528502973977326415
>>> hash({1: 1})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'

另一方面，值可以是任何对象。如果您需要检查对象是否不可变，那么我会使用hash()。