看待差异的一种方式是:

在python中，对不可变对象的赋值可以被认为是深度拷贝， 而对可变对象的赋值是浅的

首先，一个类是否有方法或者它的类结构是什么与可变性无关。

int和float是不可变的。如果我这样做

a = 1
a += 5

它在内存的第一行将名称a指向1。在第二行，它查找1，加5，得到6，然后把a指向内存中的6——它没有以任何方式把1变成6。同样的逻辑适用于下面的例子，使用其他不可变类型:

b = 'some string'
b += 'some other string'
c = ('some', 'tuple')
c += ('some', 'other', 'tuple')

对于可变类型，我可以做一些事情来改变它在内存中存储的值。:

d = [1, 2, 3]

我已经在内存中创建了1、2和3的位置列表。如果我这样做

e = d

我只是把e指向d指向的同一个列表。然后我可以这样做:

e += [4, 5]

e和d所在的列表也会被更新到内存中的位置为4和5。

如果我回到一个不可变类型，用一个元组来做:

f = (1, 2, 3)
g = f
g += (4, 5)

那么f仍然只指向原来的元组——你已经把g指向了一个全新的元组。

现在，用你的例子

class SortedKeyDict(dict):
    def __new__(cls, val):
        return dict.__new__(cls, val.clear())

你经过的地方

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))

(这是一个元组的元组)作为val，你会得到一个错误，因为元组没有.clear()方法-你必须传递dict(d)作为val为它工作，在这种情况下，你会得到一个空的SortedKeyDict作为结果。

常见的不可变类型:

数字:int()， float()， complex() 不可变序列:str()， tuple()， frozenset()， bytes()

通用可变类型(几乎所有其他类型):

可变序列:list()， bytearray() 设置类型:Set () 映射类型:dict() 类，类实例 等。

快速测试类型是否可变的一个技巧是使用id()内置函数。

例如，使用on integer，

>>> i = 1
>>> id(i)
***704
>>> i += 1
>>> i
2
>>> id(i)
***736 (different from ***704)

使用on list，

>>> a = [1]
>>> id(a)
***416
>>> a.append(2)
>>> a
[1, 2]
>>> id(a)
***416 (same with the above id)

对象是否可变取决于它的类型。这与它是否具有某些方法无关，也与类层次结构无关。

用户定义的类型(即类)通常是可变的。有一些例外，比如不可变类型的简单子类。其他不可变类型包括一些内置类型，如int、float、tuple和str，以及一些用C实现的Python类。

《Python语言参考》中“数据模型”一章的一般解释:

The value of some objects can change. Objects whose value can change are said to be mutable; objects whose value is unchangeable once they are created are called immutable. (The value of an immutable container object that contains a reference to a mutable object can change when the latter’s value is changed; however the container is still considered immutable, because the collection of objects it contains cannot be changed. So, immutability is not strictly the same as having an unchangeable value, it is more subtle.) An object’s mutability is determined by its type; for instance, numbers, strings and tuples are immutable, while dictionaries and lists are mutable.

每次我们改变一个不可变变量的值时，它基本上会破坏之前的实例并创建一个变量类的新实例

var = 2 #Immutable data
print(id(var))
var += 4
print(id(var))

list_a = [1,2,3] #Mutable data
print(id(list_a))
list_a[0]= 4
print(id(list_a))

输出:

9789024
9789088
140010877705856
140010877705856

注意:可变变量memory_location在改变值时为change

例如，对于不可变对象，赋值会创建一个新的值副本。

x=7
y=x
print(x,y)
x=10 # so for immutable objects this creates a new copy so that it doesnot 
#effect the value of y
print(x,y)

对于可变对象，赋值操作不会创建值的另一个副本。例如,

x=[1,2,3,4]
print(x)
y=x #for immutable objects assignment doesn't create new copy 
x[2]=5
print(x,y) # both x&y holds the same list