可变对象必须至少有一个方法能够改变对象。例如，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是否改变了。)

最简单的答案:

可变变量的值可能会在某个位置发生变化，而不可变变量的值不会在某个位置发生变化。修改不可变变量将重新构建相同的变量。

例子:

>>>x = 5

是否会创建一个由x引用的值5

X ->

>>>y = x

这个表述使y = 5 (x

X -------------> 5 <-----------y

>>>x = x + y

由于x是一个整数(不可变类型)已重新构建。

在语句中，RHS上的表达式将得到值10，当它被赋值给LHS (x)时，x将重新构造为10。所以现在

x ---------> 10

y ---------> 5

这个答案的目标是创建一个单独的地方来找到所有关于如何判断您正在处理的是突变/非突变(不可变/可变)的好想法，以及在可能的情况下如何处理它?有些时候，突变是不受欢迎的，python在这方面的行为可能会让来自其他语言的编码人员感到违反直觉。

根据@mina-gabriel的一篇有用的文章:

可能会有帮助的书籍:《Python中的数据结构和算法》 摘自那本书，列出了可变/不可变类型: 可变/不可变类型图像

分析以上并结合@arrakëën的文章:

什么不会意外改变?

标量(存储单个值的变量类型)不会意外变化 数值示例:int()， float()， complex() 有一些“可变序列”: Str ()， tuple()， frozenset()， bytes()

可以什么?

类似对象的列表(lists, dictionary, sets, bytearray()) 这里的一篇文章也提到了类和类实例，但这可能取决于类继承了什么和/或它是如何构建的。

我所说的“意外”是指来自其他语言的程序员可能没有预料到这种行为(除了Ruby和其他一些“类似Python”的语言)。

在这个讨论中补充:

这种行为是一种优势，因为它可以防止您意外地用多个占用内存的大型数据结构的副本填充代码。但当这种情况不受欢迎时，我们该如何解决呢?

对于列表，简单的解决方案是构建一个新的列表，如下所示:

列表 2 = 列表（列表 1）

对于其他结构……解决方案可能更加棘手。一种方法是遍历元素并将它们添加到新的空数据结构(相同类型)。

当传入可变结构时，函数可以改变原始值。如何分辨?

There are some tests given on other comments on this thread but then there are comments indicating these tests are not full proof object.function() is a method of the original object but only some of these mutate. If they return nothing, they probably do. One would expect .append() to mutate without testing it given its name. .union() returns the union of set1.union(set2) and does not mutate. When in doubt, the function can be checked for a return value. If return = None, it does not mutate. sorted() might be a workaround in some cases. Since it returns a sorted version of the original, it can allow you to store a non-mutated copy before you start working on the original in other ways. However, this option assumes you don't care about the order of the original elements (if you do, you need to find another way). In contrast .sort() mutates the original (as one might expect).

非标准方法(以防有用): 在github上发现了这个，在MIT许可下发布:

Github仓库下:tobgu命名为:pyrsistent 它是什么:Python持久化数据结构代码，用于在不希望发生变化时代替核心数据结构

对于自定义类，@分号建议检查是否有__hash__函数，因为可变对象通常不应该有__hash__()函数。

这就是我目前在这个话题上所收集到的全部信息。欢迎提出其他意见、纠正意见等。谢谢。

可变和不可变对象之间的区别

定义

可变对象:创建后可以更改的对象。 不可变对象:创建后不能更改的对象。

在Python中，如果你改变了不可变对象的值，它会创建一个新对象。

可变的对象

下面是Python中可变类型的对象:

列表 字典 集 中bytearray 用户定义的类

不可变对象

以下是Python中不可变类型的对象:

int 浮动 小数 复杂的 保龄球 字符串 元组 范围 frozenset 字节

一些悬而未决的问题

问:字符串是不可变类型吗? 回答:是的，但你能解释一下吗? 证据1:

a = "Hello"
a +=" World"
print a

输出

"Hello World"

在上面的例子中，字符串被创建为“Hello”，然后更改为“Hello World”。这意味着字符串是可变类型的。但当我们检查它的标识，看它是否为可变类型时，就不是这样了。

a = "Hello"
identity_a = id(a)
a += " World"
new_identity_a = id(a)
if identity_a != new_identity_a:
    print "String is Immutable"

输出

String is Immutable

证据2:

a = "Hello World"
a[0] = "M"

输出

TypeError 'str' object does not support item assignment

问:元组是不可变类型吗? 答案:是的。 证据1:

tuple_a = (1,)
tuple_a[0] = (2,)
print a

输出

'tuple' object does not support item assignment

你必须理解Python将所有数据表示为对象。其中一些对象(如列表和字典)是可变的，这意味着您可以在不改变其标识的情况下更改其内容。其他对象，如整数、浮点数、字符串和元组是不能更改的对象。 一个简单的理解方法是看一下对象ID。

下面是一个不可变的字符串。你不能改变它的内容。如果您试图更改它，它将引发TypeError。同样，如果我们分配新内容，则创建一个新对象，而不是修改内容。

>>> s = "abc"
>>> id(s)
4702124
>>> s[0] 
'a'
>>> s[0] = "o"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s = "xyz"
>>> id(s)
4800100
>>> s += "uvw"
>>> id(s)
4800500

你可以用一个列表这样做，它不会改变对象的身份

>>> i = [1,2,3]
>>> id(i)
2146718700
>>> i[0] 
1
>>> i[0] = 7
>>> id(i)
2146718700

要阅读更多关于Python的数据模型，你可以看看Python语言参考:

双重指控 斑马3套指控模型

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

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