常见的不可变类型:

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

什么?浮点数是不可变的?但我做不到

x = 5.0
x += 7.0
print x # 12.0

那不是"mut" x吗?

你同意字符串是不可变的，对吧?但你可以做同样的事情。

s = 'foo'
s += 'bar'
print s # foobar

变量的值会改变，但改变的方式是改变变量所指向的对象。可变类型可以这样改变，也可以“就地”改变。

区别就在这里。

x = something # immutable type
print x
func(x)
print x # prints the same thing

x = something # mutable type
print x
func(x)
print x # might print something different

x = something # immutable type
y = x
print x
# some statement that operates on y
print x # prints the same thing

x = something # mutable type
y = x
print x
# some statement that operates on y
print x # might print something different

具体的例子

x = 'foo'
y = x
print x # foo
y += 'bar'
print x # foo

x = [1, 2, 3]
y = x
print x # [1, 2, 3]
y += [3, 2, 1]
print x # [1, 2, 3, 3, 2, 1]

def func(val):
    val += 'bar'

x = 'foo'
print x # foo
func(x)
print x # foo

def func(val):
    val += [3, 2, 1]

x = [1, 2, 3]
print x # [1, 2, 3]
func(x)
print x # [1, 2, 3, 3, 2, 1]

我没有阅读所有的答案，但所选的答案是不正确的，我认为作者有一个想法，即能够重新分配变量意味着任何数据类型都是可变的。事实并非如此。可变性与通过引用传递而不是通过值传递有关。

假设您创建了一个List

a = [1,2]

如果你说:

b = a
b[1] = 3

即使你在B上重新分配了一个值，它也会重新分配a上的值。这是因为当你分配“B = a”时。您传递给对象的是“Reference”，而不是值的副本。而字符串、浮点数等则不是这样。这使得列表、字典和类似的东西是可变的，但是布尔值、浮点数等是不可变的。

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

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

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

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

例子:

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

查看这个表格:

源

在我看来，你似乎在争论可变/不可变到底意味着什么。下面是一个简单的解释:

首先，我们需要一个解释的基础。

把你编程的任何东西都想象成一个虚拟对象，一个以二进制数字序列的形式保存在计算机内存中的东西。(不过，不要试图把这个想象得太困难。^^)现在在大多数计算机语言中，你不会直接处理这些二进制数，而是更多地使用二进制数的解释。

例如，你不会想到像0x110, 0xaf0278297319或类似的数字，而是你会想到像6这样的数字或像“Hello, world”这样的字符串。然而，这些数字或字符串是计算机内存中二进制数的一种解释。对于变量的任何值都是如此。

简而言之:我们不是用实际值编程，而是用实际二进制值的解释编程。

Now we do have interpretations that must not be changed for the sake of logic and other "neat stuff" while there are interpretations that may well be changed. For example think of the simulation of a city, in other words a program where there are many virtual objects and some of these are houses. Now may these virtual objects (the houses) be changed and can they still be considered to be the same houses? Well of course they can. Thus they are mutable: They can be changed without becoming a "completely" different object.

现在想想整数:它们也是虚拟对象(计算机内存中的二进制数序列)。如果我们改变其中一个，比如把6的值加1，它还是6吗?当然不是。因此任何整数都是不可变的。

所以:如果虚拟对象的任何变化意味着它实际上变成了另一个虚拟对象，那么它就被称为不可变的。

最后的话:

(1)永远不要把你在现实世界中可变和不可变的经验与某种语言的编程混淆在一起:

每种编程语言都有自己的定义，哪些对象可以静音，哪些对象不可以静音。

因此，虽然您现在可能理解了含义上的差异，但仍然需要学习每种编程语言的实际实现. ...的确，一种语言可能有一个目的，即6可能被削弱为7。然后，这将是相当疯狂或有趣的东西，就像平行宇宙的模拟

(2)这个解释当然是不科学的，它是为了帮助你掌握可变和不可变的区别。