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

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

可变对象必须至少有一个方法能够改变对象。例如，list对象有append方法，它实际上会改变对象:

>>> a = [1,2,3]
>>> a.append('hello') # `a` has mutated but is still the same object
>>> a
[1, 2, 3, 'hello']

但是float类没有改变float对象的方法。你可以:

>>> b = 5.0 
>>> b = b + 0.1
>>> b
5.1

但是=操作数不是一个方法。它只是在变量和它右边的东西之间做了一个绑定，没有别的。它从不改变或创建对象。它声明了变量将指向什么，从现在开始。

当执行b = b + 0.1时，=操作数将变量绑定到一个新的浮点数，其创建结果为5 + 0.1。

当你将一个变量赋值给一个存在的对象时，不管是否是可变的，=操作数将变量绑定到该对象。没有别的事情发生

在任何一种情况下，=都只是进行绑定。它不改变或创建对象。

当执行= 1.0时，=操作数创建的不是浮点数，而是该行的1.0部分。实际上，当您编写1.0时，它是float(1.0)的简写，一个返回float对象的构造函数调用。(这就是为什么如果你输入1.0并按enter键，你会得到下面打印的“echo”1.0;这是你调用的构造函数的返回值)

现在，如果b是一个浮点数，你赋值a = b，两个变量都指向同一个对象，但实际上变量之间不能通信，因为对象是不可变的，如果你做b += 1，现在b指向一个新对象，而a仍然指向旧对象，不知道b指向什么。

但如果c是，假设，一个列表，你赋值a = c，现在a和c可以“通信”，因为list是可变的，如果你执行c.append('msg')，然后检查a，你得到消息。

(顺便说一下，每个对象都有一个唯一的关联id号，你可以通过id(x)获得。所以你可以检查一个对象是否相同，或者不检查它的唯一id是否改变了。)

常见的不可变类型:

数字: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)

一个类是不可变的，如果该类的每个对象在实例化时都有一个固定的值，以后不能更改

换句话说，要么改变变量(名称)的整个值，要么就不管它。

例子:

my_string = "Hello world" 
my_string[0] = "h"
print my_string 

你希望这可以工作并打印hello world，但这将抛出以下错误:

Traceback (most recent call last):
File "test.py", line 4, in <module>
my_string[0] = "h"
TypeError: 'str' object does not support item assignment

解释器说:我不能改变这个字符串的第一个字符

你将不得不改变整个字符串，以使其工作:

my_string = "Hello World" 
my_string = "hello world"
print my_string #hello world

查看这个表格:

源

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

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作为结果。

在Python中，有一种简单的方法可以知道:

不变的:

    >>> s='asd'
    >>> s is 'asd'
    True
    >>> s=None
    >>> s is None
    True
    >>> s=123
    >>> s is 123
    True

可变的:

>>> s={}
>>> s is {}
False
>>> {} is {}
Flase
>>> s=[1,2]
>>> s is [1,2]
False
>>> s=(1,2)
>>> s is (1,2)
False

And:

>>> s=abs
>>> s is abs
True

所以我认为内置函数在Python中也是不可变的。

但我真的不明白float是如何工作的:

>>> s=12.3
>>> s is 12.3
False
>>> 12.3 is 12.3
True
>>> s == 12.3
True
>>> id(12.3)
140241478380112
>>> id(s)
140241478380256
>>> s=12.3
>>> id(s)
140241478380112
>>> id(12.3)
140241478380256
>>> id(12.3)
140241478380256

太奇怪了。