blocks|key|662357|text|字符串对象本身是不可变的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|662358|指向字符串的变量a是可变的。|offset|length|style|CODE|662359|考虑一下：|662360|a+=+"Foo"
#+a+now+points+to+"Foo"
b+=+a
#+b+points+to+the+same+"Foo"+that+a+points+to
a+=+a+%2B+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.|code-block|syntax|javascript|662361|entityMap^0|0|8|1|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The string objects themselves are immutable.

The variable, <code>a</code>, which points to the string, is mutable.

Consider:

<pre><code>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.
</code></pre>

blocks|key|662390|text|变量只是一个指向对象的标签。该对象是不可变的，但如果愿意，您可以使标签指向完全不同的对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|662391|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A variable is just a label pointing to an object. The object is immutable, but you can make the label point to a completely different object if you want to.

blocks|key|448032|text|第一个a指向字符串“狗”。然后，您更改了变量a以指向新字符串"Dog+eats+treats“。你实际上并没有改变“狗”这个字符串。字符串是不可变的，变量可以指向任何它们想要的东西。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|448033|entityMap^0|3|1|M|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

First <code>a</code> pointed to the string "Dog". Then you changed the variable <code>a</code> to point at a new string "Dog eats treats". You didn't actually mutate the string "Dog". Strings are immutable, variables can point at whatever they want.

blocks|key|448094|text|Python字符串是不可变的。但是，a不是字符串:它是一个具有字符串值的变量。您不能改变字符串，但可以将变量的值更改为新的字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|448095|entityMap^0|I|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Python strings are immutable. However, <code>a</code> is not a string: it is a variable with a string value. You can't mutate the string, but can change what value of the variable to a new string.

blocks|key|448258|text|数据与其关联的标签之间存在差异。例如，当你这样做的时候|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448259|a+=+"dog"|code-block|syntax|javascript|448260|将创建数据"dog"并将其置于标签a下。标签可以更改，但内存中的内容不会更改。执行此操作后，数据"dog"仍将存在内存中(直到垃圾收集器将其删除|offset|length|style|CODE|448261|a+=+"cat"|448262|在您的程序中，a+now+%5E指向%5E+"cat"，但字符串"dog"没有更改。|448263|entityMap^0|0|0|5|5|H|1|1C|5|0|0|7|1|I|5|S|5|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|R|$]]

There is a difference between data and the label it is associated with. For example when you do 

<pre><code>a = "dog"
</code></pre>

the data <code>"dog"</code> is created and put under the label <code>a</code>. The label can change but what is in the memory won't. The data <code>"dog"</code> will still exist in memory (until the garbage collector deletes it) after you do 

<pre><code>a = "cat"
</code></pre>

In your programm <code>a</code> now ^points to^ <code>"cat"</code> but the string <code>"dog"</code> hasn't changed.

blocks|key|662653|text|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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|662654|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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
</code></pre>

blocks|key|662726|text|语句a+=+a+%2B+"+"+%2B+b+%2B+"+"+%2B+c可以根据指针进行分解。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|662727|a+%2B+"+"说给我a指向的东西，这是不能改变的，并将"+"添加到我当前的工作集中。|662728|内存：|662729|working_set+=+"Dog+"
a+=+"Dog"+
b+=+"eats"
c+=+"treats"|code-block|syntax|javascript|662730|%2B+b说给我b所指向的，不能改变的，并将其添加到当前工作集中。|662731|662732|working_set+=+"Dog+eats"
a+=+"Dog"+
b+=+"eats"
c+=+"treats"|662733|%2B+"+"+%2B+c说将"+"添加到当前集合中。然后给我c指向的，不能改变的，并将其添加到当前工作集中。内存：|662734|working_set+=+"Dog+eats+treats"
a+=+"Dog"+
b+=+"eats"
c+=+"treats"|662735|最后，a+=要求将指针设置为指向结果集。|662736|662737|a+=+"Dog+eats+treats"
b+=+"eats"
c+=+"treats"|662738|"Dog"被回收，因为不再有指针连接到它的内存块。我们从未修改过"Dog"所在的内存段，这就是不可变的含义。但是，我们可以更改哪些标签(如果有的话)指向该内存部分。|662739|entityMap^0|2|P|0|0|7|A|1|R|3|0|0|0|0|3|6|1|0|0|0|0|9|B|3|R|1|0|0|3|3|0|0|0|0|5|W|5|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1G|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1H|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|I|5|6|7|1N|8|@]|D|@]|E|$]]|$1|R|3|S|5|L|7|1O|8|@]|D|@]|E|$M|N]]|$1|T|3|U|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|V|3|W|5|L|7|1W|8|@]|D|@]|E|$M|N]]|$1|X|3|Y|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|Z|3|I|5|6|7|20|8|@]|D|@]|E|$]]|$1|10|3|11|5|L|7|21|8|@]|D|@]|E|$M|N]]|$1|12|3|13|5|6|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]]|D|@]|E|$]]|$1|14|3|-4|5|6|7|27|8|@]|D|@]|E|$]]]|15|$]]

The statement <code>a = a + " " + b + " " + c</code> can be broken down based upon pointers.

<code>a + " "</code> says give me what <code>a</code> points to, which can't be changed, and add <code>" "</code> to my current working set.

memory:

<pre><code>working_set = "Dog "
a = "Dog" 
b = "eats"
c = "treats"
</code></pre>

<code>+ b</code> says give me what <code>b</code> points to, which can't be changed, and add it to current working set.

memory:

<pre><code>working_set = "Dog eats"
a = "Dog" 
b = "eats"
c = "treats"
</code></pre>

<code>+ " " + c</code> says add <code>" "</code> to the current set. Then give me what <code>c</code> points to, which can't be changed, and add it to current working set. 
memory:

<pre><code>working_set = "Dog eats treats"
a = "Dog" 
b = "eats"
c = "treats"
</code></pre>

Finally, <code>a =</code> says set my pointer to point to the resulting set.

memory:

<pre><code>a = "Dog eats treats"
b = "eats"
c = "treats"
</code></pre>

<code>"Dog"</code> is reclaimed, because no more pointers connect to it's chunk of memory. We never modified the memory section <code>"Dog"</code> resided in, which is what is meant by immutable. However, we can change which labels, if any, point to that section of memory.

blocks|key|448444|text|总结：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448445|a+=+3
b+=+a
a+=+3%2B2
print+b
#+5|code-block|syntax|javascript|448446|不是不变的：|448447|a+=+'OOP'
b+=+a
a+=+'p'%2Ba
print+b
#+OOP|448448|不可变的：|448449|a+=+[1,2,3]
b+=+range(len(a))
for+i+in+range(len(a)):
++++b[i]+=+a[i]%2B1|448450|这是Python+3中的一个错误，因为它是不可变的。而不是Python+2中的错误，因为很明显，它不是不可变的。|448451|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Summarizing:

<pre><code>a = 3
b = a
a = 3+2
print b
# 5
</code></pre>

Not immutable:

<pre><code>a = 'OOP'
b = a
a = 'p'+a
print b
# OOP
</code></pre>

Immutable:

<pre><code>a = [1,2,3]
b = range(len(a))
for i in range(len(a)):
 b[i] = a[i]+1
</code></pre>

This is an error in Python 3 because it is immutable. And not an error in Python 2 because clearly it is not immutable.

blocks|key|448490|text|>>>+a+=+'dogs'|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|448491|>>>+a.replace('dogs',+'dogs+eat+treats')|448492|'dogs+eat+treats'|448493|>>>+print+a|448494|'dogs'|448495|不可变，不是吗？！|448496|变量更改部分已经讨论过了。|448497|entityMap^0|0|E|0|0|14|0|0|H|0|0|B|0|0|6|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|18|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|19|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|S|$]]

<code>&gt;&gt;&gt; a = 'dogs'</code>

<code>&gt;&gt;&gt; a.replace('dogs', 'dogs eat treats')</code>

<code>'dogs eat treats'</code>

<code>&gt;&gt;&gt; print a</code>

<code>'dogs'</code>

Immutable, isn't it?!

The variable change part has already been discussed.

blocks|key|448557|text|考虑一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448558|>>>+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>|code-block|syntax|javascript|448559|请注意，当我在变量中存储相同的值两次时，十六进制内存位置没有改变。当我存储一个不同的值时，它确实发生了变化。字符串是不可变的。不是因为狂热，而是因为你在内存中创建了一个新的对象而付出了性能损失。变量a只是一个指向该内存地址的标签。它可以被修改为指向任何东西。|offset|length|style|CODE|448560|entityMap^0|0|0|2R|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Consider:

<pre><code>&gt;&gt;&gt; a='asdf'
&gt;&gt;&gt; a.__repr__
&lt;method-wrapper '__repr__' of str object at 0x1091aab90&gt;
&gt;&gt;&gt; a='asdf'
&gt;&gt;&gt; a.__repr__
&lt;method-wrapper '__repr__' of str object at 0x1091aab90&gt;
&gt;&gt;&gt; a='qwer'
&gt;&gt;&gt; a.__repr__
&lt;method-wrapper '__repr__' of str object at 0x109198490&gt;
</code></pre>

Notice that the hex memory location did not change when I stored the same value in the variable twice. It did change when I stored a different value. The string is immutable. Not because of zealotry, but because you pay the performance penalty of creating a new object in memory. The variable <code>a</code> is just a label pointing to that memory address. It can be altered to point to anything.

blocks|key|448603|text|变量可以指向他们想要的任何地方。如果您执行以下操作，将抛出错误：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448604|a+=+"dog"
print+a+++++++++++++++++++#dog
a[1]+=+"g"++++++++++++++++#ERROR!!!!!!+STRINGS+ARE+IMMUTABLE|code-block|syntax|javascript|448605|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Variables can point to anywhere they want..
An error will be thrown if you do the following:

<pre><code>a = "dog"
print a #dog
a[1] = "g" #ERROR!!!!!! STRINGS ARE IMMUTABLE
</code></pre>

blocks|key|448653|text|您可以将numpy数组设置为不可变的，并使用第一个元素：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448654|numpyarrayname[0]+=+"write+once"|code-block|syntax|javascript|448655|然后：|448656|numpyarrayname.setflags(write=False)|448657|或|448658|numpyarrayname.flags.writeable+=+False|448659|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You can make a numpy array immutable and use the first element:

<pre><code>numpyarrayname[0] = "write once"
</code></pre>

then:

<pre><code>numpyarrayname.setflags(write=False)
</code></pre>

or

<pre><code>numpyarrayname.flags.writeable = False
</code></pre>

blocks|key|448724|text|Python字符串对象是不可变的。示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|448725|>>>+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'|code-block|syntax|javascript|448726|在这个例子中，我们可以看到，当我们在a中分配不同的值时，它不会修改。一个新的对象会被创建。|448727|而且它不能被修改。示例：|448728|++>>>+a[0]+=+'c'
++++Traceback+(most+recent+call+last):
++++++File+"<stdin>",+line+1,+in+<module>
++++**TypeError**:+'str'+object+does+not+support+item+assignment|448729|出现错误。|448730|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Python string objects are immutable.
Example:

<pre><code>&gt;&gt;&gt; a = 'tanim'
&gt;&gt;&gt; 'Address of a is:{}'.format(id(a))
'Address of a is:64281536'
&gt;&gt;&gt; a = 'ahmed'
&gt;&gt;&gt; 'Address of a is:{}'.format(id(a))
'Address of a is:64281600'
</code></pre>

In this example we can see that when we assign different value in a it doesn't modify.A new object is created. 
And it can't be modified.
Example: 

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

A error occurs.

blocks|key|663426|text|‘'mutable’意味着我们可以更改字符串的内容，'immutable‘意味着我们不能添加额外的字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|663427|​|663428|📷|atomic|offset|length|663429|663430|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/27fdba8962a2a41c165f5a37acd5462e.png|imageAlt^0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@$G|V|H|W|1|X]]|A|$]]|$1|I|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q|R|-4]]]]

'mutable' means that we can change the content of the string,
'immutable' means that we can't add an extra string.

<img src="https://i.stack.imgur.com/tpmaF.png" alt="click for photo proof">

blocks|key|663515|text|这张图片给出了答案。请读一读。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|663516|​|663517|📷|atomic|offset|length|663518|663519|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/0a510f62ac8a61192997c619f7e7557b.png|imageAlt^0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@$G|V|H|W|1|X]]|A|$]]|$1|I|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q|R|-4]]]]

This image gives the answer. Please read it.

<a href="https://i.stack.imgur.com/GuxcU.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/GuxcU.png" alt="enter image description here"></a>

blocks|key|449346|text|内置函数id()以整数形式返回对象的标识。这个整数通常对应于对象在内存中的位置。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|449347|\>>a='dog'
\>>print(id(a))

139831803293008

\>>a=a%2B'cat'
\>>print(id(a))

139831803293120|code-block|syntax|javascript|449348|最初，'a‘存储在139831803293008内存位置，因为字符串对象在python中是不可变的，如果您尝试修改和重新分配引用将被移除，并将成为指向新内存位置的指针(139831803293120)。|449349|entityMap^0|4|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

The built-in function <code>id()</code> returns the identity of an object as an integer. This integer usually corresponds to the object’s location in memory.

<pre><code>\&gt;&gt;a='dog'
\&gt;&gt;print(id(a))

139831803293008

\&gt;&gt;a=a+'cat'
\&gt;&gt;print(id(a))

139831803293120
</code></pre>

Initially, 'a' is stored in 139831803293008 memory location, as the string object is immutable in python if you try to modify and reassign the reference will be removed and will be a pointer to a new memory location(139831803293120).

blocks|key|663667|text|我们只是将这两个字符串值连接起来。我们从不改变(a)的值。刚才(a)表示另一个具有"dogdog“值的内存块。因为在后台，一个变量永远不会同时代表两个内存块。连接前(a)的值是"dog“。但在那之后(a)代表"dogdog"，因为现在(a)在后端表示。具有"dogdog“值的块。“狗”是代表。被(b)和"dog“计算为垃圾值，直到(b)表示"dog”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|663668|令人困惑的是，我们表示内存块(包含数据或信息)。在后端使用相同的变量名。|663669|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

We r just concatenate the two string values. We never change the value of (a). Just now (a) represent another memory block that has "dogdog" value. Because in the backend, one variable never represent two memory blocks at same time. The value of (a) before concatenation was "dog". But after that (a) represent the "dogdog", because now (a) in backend rep. the block that has "dogdog" value. And "dog" is rep. by (b) and "dog" isn't counted as garbage value until (b) represent the "dog". 

The confusion is we represent the memory blocks(that contain data or info.) in backend with same variable name.

blocks|key|663681|text|a+=+'dog'
address+=+id(a)
print(id(a))

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

import+ctypes
ctypes.cast(address,+ctypes.py_object).value++++#value+at+old+address+is+intact|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|663682|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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
</code></pre>

My understanding was that Python strings are immutable.

I tried the following code:

<pre><code>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
# !!!
</code></pre>

Shouldn't Python have prevented the assignment? I am probably missing something.

Any idea?

Aren't Python strings immutable? Then why does a + " " + b work?

Python

我的理解是Python字符串是不可变的。我尝试了以下代码：a = "Dog"b = "eats"c = "treats"print a, b, c# Dog eats treatsprint a + " " + b + " " + c# Dog eats treatsprint a# Doga = a + " " + ...

问Python字符串不是不可变的吗？那么为什么a+“”+b可以工作呢？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python字符串不是不可变的吗？那么为什么a+“”+b可以工作呢？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python字符串不是不可变的吗？那么为什么a+“”+b可以工作呢？
EN