我对什么是不可变类型感到困惑。我知道float对象被认为是不可变的，我的书中有这样的例子:
class RoundFloat(float):
def __new__(cls, val):
return float.__new__(cls, round(val, 2))
因为类结构/层次结构，这被认为是不可变的吗?，这意味着float位于类的顶部，是它自己的方法调用。类似于这种类型的例子(即使我的书说dict是可变的):
class SortedKeyDict(dict):
def __new__(cls, val):
return dict.__new__(cls, val.clear())
然而，可变的东西在类中有方法，例如:
class SortedKeyDict_a(dict):
def example(self):
return self.keys()
同样，对于最后一个类(SortedKeyDict_a)，如果我将这种类型的set传递给它:
d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))
不调用示例方法，它将返回一个字典。带有__new__的SortedKeyDict将其标记为错误。我尝试用__new__将整数传递给RoundFloat类，它没有标记错误。
在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
太奇怪了。
如果你是从另一种语言(除了一种非常像Python的语言，比如Ruby)学习Python的，并且坚持用另一种语言来理解它，下面是人们通常会感到困惑的地方:
>>> a = 1
>>> a = 2 # I thought int was immutable, but I just changed it?!
在Python中，赋值不是突变。
在c++中，如果你写a = 2，你是在调用a.operator=(2)，这将改变存储在a中的对象(如果a中没有存储对象，这是一个错误)。
在Python中，a = 2对存储在a;它只是意味着2现在存储在a中。(如果a中没有存储对象，也没关系。)
归根结底，这是更深层次区别的一部分。
在c++这样的语言中，变量是内存中的类型化位置。如果a是int型，这意味着它有4个字节，编译器知道它应该被解释为int型。当你令a = 2时，它改变了存储在这4个字节内存中的内容从0,0,0,1变成了0,0,0,2。如果在其他地方有另一个int变量，它有自己的4个字节。
A variable in a language like Python is a name for an object that has a life of its own. There's an object for the number 1, and another object for the number 2. And a isn't 4 bytes of memory that are represented as an int, it's just a name that points at the 1 object. It doesn't make sense for a = 2 to turn the number 1 into the number 2 (that would give any Python programmer way too much power to change the fundamental workings of the universe); what it does instead is just make a forget the 1 object and point at the 2 object instead.
如果赋值不是突变，那么什么是突变呢?
Calling a method that's documented to mutate, like a.append(b). (Note that these methods almost always return None). Immutable types do not have any such methods, mutable types usually do.
Assigning to a part of the object, like a.spam = b or a[0] = b. Immutable types do not allow assignment to attributes or elements, mutable types usually allow one or the other.
Sometimes using augmented assignment, like a += b, sometimes not. Mutable types usually mutate the value; immutable types never do, and give you a copy instead (they calculate a + b, then assign the result to a).
但如果赋值不是突变，那么对象的一部分赋值是如何突变的呢?这就是棘手的地方。a[0] = b不会改变[0](再次，不像c++)，但它会改变a(不像c++，除非是间接的)。
这就是为什么最好不要尝试按照您习惯的语言来理解Python的语义，而是根据Python的语义来学习Python的语义。
可变和不可变对象之间的区别
定义
可变对象:创建后可以更改的对象。
不可变对象:创建后不能更改的对象。
在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
什么?浮点数是不可变的?但我做不到
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]
在我看来，你似乎在争论可变/不可变到底意味着什么。下面是一个简单的解释:
首先，我们需要一个解释的基础。
把你编程的任何东西都想象成一个虚拟对象，一个以二进制数字序列的形式保存在计算机内存中的东西。(不过，不要试图把这个想象得太困难。^^)现在在大多数计算机语言中，你不会直接处理这些二进制数，而是更多地使用二进制数的解释。
例如，你不会想到像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)这个解释当然是不科学的，它是为了帮助你掌握可变和不可变的区别。
