Python 字符串不是不可变的吗？那么为什么 + ” ” +工作？

Question

我的理解是 Python 字符串是不可变的。

我尝试了以下代码：

a = "Dog"
b = "eats"
c = "treats"

print a, b, c
# Dog eats treats

print a + " " + b + " " + c
# Dog eats treats

print a
# Dog

a = a + " " + b + " " + c
print a
# Dog eats treats
# !!!

Python 不应该阻止分配吗？我可能错过了一些东西。

有什么想法吗？

Answer 1

首先a指向字符串“Dog”。然后，您将变量 a 更改为指向新字符串“Dog eats treats”。您实际上并没有改变字符串“Dog”。字符串是不可变的，变量可以指向它们想要的任何内容。

Answer 2

字符串对象本身是不可变的。

指向字符串的变量 a 是可变的。

考虑：

a = "Foo"
# a now points to "Foo"
b = a
# b points to the same "Foo" that a points to
a = a + a
# a points to the new string "FooFoo", but b still points to the old "Foo"

print a
print b
# Outputs:

# FooFoo
# Foo

# Observe that b hasn't changed, even though a has.

Answer 3

变量 a 指向对象“Dog”。最好将 Python 中的变量视为标签。您可以将标签移动到不同的对象，这就是您将 a = "dog" 更改为 a = "dog eats treats" 时所做的操作。

然而，不变性是指对象，而不是标签。

---

如果您尝试 a[1] = 'z' 将 "dog" 转换为 "dzg"，您会收到错误：

TypeError: 'str' object does not support item assignment" 

因为字符串不支持项目分配，因此它们是不可变的。

Answer 4

仅当我们能够更改内存位置中保存的值而不更改内存位置本身时，某些东西才是可变的。

诀窍是：如果发现改变前后的内存位置相同，则它是可变的。

例如，列表是可变的。如何？

>> a = ['hello']
>> id(a)
139767295067632

# Now let's modify
#1
>> a[0] = "hello new"
>> a
['hello new']
Now that we have changed "a", let's see the location of a
>> id(a)
139767295067632
so it is the same as before. So we mutated a. So list is mutable.

字符串是不可变的。我们如何证明这一点？

> a = "hello"
> a[0]
'h'
# Now let's modify it
> a[0] = 'n'
----------------------------------------------------------------------

我们得到

TypeError：“str”对象不支持项目分配

因此我们未能改变字符串。这意味着字符串是不可变的。

在重新分配时，您将变量更改为指向新位置本身。这里你没有改变字符串，而是改变变量本身。以下是您正在做的事情。

>> a = "hello"
>> id(a)
139767308749440
>> a ="world"
>> id(a)
139767293625808

重新分配前后的id是不同的，所以这证明你实际上没有改变，而是将变量指向新的位置。这不是改变该字符串，而是改变该变量。

Answer 5

考虑：

>>> a='asdf'
>>> a.__repr__
<method-wrapper '__repr__' of str object at 0x1091aab90>
>>> a='asdf'
>>> a.__repr__
<method-wrapper '__repr__' of str object at 0x1091aab90>
>>> a='qwer'
>>> a.__repr__
<method-wrapper '__repr__' of str object at 0x109198490>

请注意，当我在变量中存储相同的值两次时，十六进制内存位置没有改变。当我存储不同的值时它确实发生了变化。该字符串是不可变的。不是因为狂热，而是因为您付出了在内存中创建新对象的性能损失。变量a只是指向该内存地址的标签。它可以改变为指向任何东西。

Answer 6

变量只是指向对象的标签。该对象是不可变的，但如果您愿意，您可以使标签指向完全不同的对象。

Answer 7

语句a = a + " " + b + " " + c 可以根据指针进行分解。

a + " " 表示给我 a 指向的内容，该内容无法更改，并将 " " 添加到我当前的工作集。

memory:

working_set = "Dog "
a = "Dog" 
b = "eats"
c = "treats"

+ b 表示给我 b 指向的内容，该内容无法更改，并将其添加到当前工作集中。

memory:

working_set = "Dog eats"
a = "Dog" 
b = "eats"
c = "treats"

+ " " + c 表示将 " " 添加到当前集合。然后给我 c 指向的内容，该内容无法更改，并将其添加到当前工作集中。
内存：

working_set = "Dog eats treats"
a = "Dog" 
b = "eats"
c = "treats"

最后，a = 表示将我的指针设置为指向结果集。

内存：

a = "Dog eats treats"
b = "eats"
c = "treats"

"Dog" 被回收，因为不再有指针连接到它的内存块。我们从未修改过“Dog”所在的内存部分，这就是不可变的含义。但是，我们可以更改哪些标签（如果有）指向该内存部分。

Answer 8

数据和与其关联的标签之间存在差异。例如，当您执行此操作时，

a = "dog"

将创建数据“dog”并将其放置在标签a下。标签可以改变，但内存中的内容不会改变。在您执行此操作后，数据“dog”仍将存在于内存中（直到垃圾收集器将其删除）。

a = "cat"

在您的程序a中，现在^指向^“cat” 但字符串 "dog" 没有改变。

Answer 9

l = [1,2,3]
print id(l)
l.append(4)
print id(l) #object l is the same

a = "dog"
print id(a)
a = "cat"
print id(a) #object a is a new object, previous one is deleted

Answer 10

Python 字符串对象是不可变的。
示例：

>>> a = 'tanim'
>>> 'Address of a is:{}'.format(id(a))
'Address of a is:64281536'
>>> a = 'ahmed'
>>> 'Address of a is:{}'.format(id(a))
'Address of a is:64281600'

在此示例中，我们可以看到，当我们在 a 中分配不同的值时，它不会修改。创建一个新对象。
并且无法修改。
示例：

  >>> a[0] = 'c'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    **TypeError**: 'str' object does not support item assignment

发生错误。

Answer 11

Python 字符串是不可变的。但是，a 不是字符串：它是具有字符串值的变量。您无法更改字符串，但可以将变量的值更改为新字符串。

Answer 12

变量可以指向任何他们想要的地方。
如果执行以下操作，将会引发错误：

a = "dog"
print a                   #dog
a[1] = "g"                #ERROR!!!!!! STRINGS ARE IMMUTABLE

Answer 13

'mutable' 意味着我们可以改变字符串的内容，
“不可变”意味着我们不能添加额外的字符串。

Answer 14

a = 'dog'
address = id(a)
print(id(a))

a = a + 'cat'
print(id(a))      #Address changes

import ctypes
ctypes.cast(address, ctypes.py_object).value    #value at old address is intact

Answer 15

<代码>>> a = '狗'

>>>>> a.replace('狗', '狗吃零食')

'狗吃零食'

>>> print a

'dogs'

不可变的，不是吗？！

变量改变部分已经讨论过了。

Answer 16

考虑在您的示例中添加此内容

 a = "Dog"
 b = "eats"
 c = "treats"
 print (a,b,c)
 #Dog eats treats
 d = a + " " + b + " " + c
 print (a)
 #Dog
 print (d)
 #Dog eats treats

我在博客中找到的更准确的解释之一是：

在Python中，（几乎）一切都是对象。我们在 Python 中通常所说的“变量”更恰当地称为名称。同样，“赋值”实际上是将名称绑定到对象。每个绑定都有一个定义其可见性的范围，通常是名称起源的块。

例如：

some_guy = 'Fred'
# ...
some_guy = 'George'

当我们稍后说 some_guy = 'George' 时，包含 'Fred' 的字符串对象不受影响。我们刚刚更改了名称 some_guy 的绑定。但是，我们还没有更改“Fred”或“George”字符串对象。就我们而言，它们可能会无限期地存在。

博客链接： https://jeffknupp .com/blog/2012/11/13/is-python-callbyvalue-or-callbyreference-neither/

Answer 17

在上述答案的基础上再补充一点。

变量的id在重新分配时会发生变化。

>>> a = 'initial_string'
>>> id(a)
139982120425648
>>> a = 'new_string'
>>> id(a)
139982120425776

这意味着我们已经改变了变量a以指向一个新字符串。现在存在两个 string(str) 对象：

'initial_string'，id = 139982120425648

和

' new_string' with id = 139982120425776

考虑下面的代码：

>>> b = 'intitial_string'
>>> id(b)
139982120425648

现在，b 指向'initial_string' 与重新分配之前的 a 具有相同的 id。

因此，'intial_string' 尚未发生突变。

Answer 18

内置函数id()以整数形式返回对象的标识。该整数通常对应于对象在内存中的位置。

\>>a='dog'
\>>print(id(a))

139831803293008

\>>a=a+'cat'
\>>print(id(a))

139831803293120

最初，“a”存储在 139831803293008 内存位置，因为字符串对象在 python 中是不可变的，如果您尝试修改和重新分配，引用将被删除，并将成为指向新内存位置的指针（139831803293120）。

Answer 19

总结：

a = 3
b = a
a = 3+2
print b
# 5

不是不可变的：

a = 'OOP'
b = a
a = 'p'+a
print b
# OOP

不可变的：

a = [1,2,3]
b = range(len(a))
for i in range(len(a)):
    b[i] = a[i]+1

这是 Python 3 中的一个错误，因为它是不可变的。在 Python 2 中这不是一个错误，因为显然它不是不可变的。

Answer 20

我们只是连接两个字符串值。我们永远不会改变 (a) 的值。刚才（a）代表另一个具有“dogdog”值的内存块。因为在后端，一个变量永远不会同时代表两个内存块。连接前(a)的值为“dog”。但之后 (a) 代表“dogdog”，因为现在 (a) 在后端代表中。具有“dogdog”值的块。而“狗”是代表。在 (b) 代表“dog”之前，(b) 和“dog”不会被算作垃圾值。

令人困惑的是我们在后端用相同的变量名表示内存块（包含数据或信息）。

Answer 21

您可以使 numpy 数组不可变并使用第一个元素：

numpyarrayname[0] = "write once"

then:

numpyarrayname.setflags(write=False)

或

numpyarrayname.flags.writeable = False

Answer 22

这张图给出了答案。请阅读它。