不可变与可变类型

我对什么是不可变类型感到困惑。我知道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中，如果你改变了不可变对象的值，它会创建一个新对象。

可变的对象

下面是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

2017-11-13 12:30:00

其他回答

你必须理解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套指控模型

2011-11-08 20:19:56

在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

太奇怪了。

2016-07-03 17:32:48

常见的不可变类型:

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

2014-05-17 20:38:40

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

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

2011-11-08 19:48:20