blocks|key|4271004|text|这是因为当您执行test2+=+test时，您并不是在复制列表的内容，而是简单地向test2分配一个对原始列表的引用。因此，对test2的任何更改也会影响test。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4271005|正确的方法是使用复制模块中的deepcopy()+(如果可以进行浅层复制，则使用copy()。|4271006|import+copy
test2+=+copy.deepcopy(test)+#+deep+copy

test2+=+copy.copy(test))+#+shallow+copy

test2+=+test[:]+#+shallow+copy+using+slices|code-block|syntax|javascript|4271007|有关更深入的解释以及复制列表的其他方法，请参阅this+page。|4271008|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/copy.html#copy.deepcopy|1|http://henry.precheur.org/python/copy_list^0|8|C|15|5|1R|5|25|4|0|E|A|14|6|E|A|0|0|0|N|9|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|H|3|I|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|O|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

It's because when you do <code>test2 = test</code> you are not copying the contents of the list, but simply assigning <code>test2</code> a reference to the original list. Thus, any changes to the <code>test2</code> will also affect <code>test</code>.

The right way to do this is using <a href="http://docs.python.org/library/copy.html#copy.deepcopy" rel="nofollow noreferrer"><code>deepcopy()</code></a> from the copy module (or <code>copy()</code> if you can get away with a shallow copy.

<pre><code>import copy
test2 = copy.deepcopy(test) # deep copy

test2 = copy.copy(test)) # shallow copy

test2 = test[:] # shallow copy using slices
</code></pre>

See <a href="http://henry.precheur.org/python/copy_list" rel="nofollow noreferrer">this page</a> for a more in-depth explanation as well as other methods to copy a list.

blocks|key|950454|text|[1,2]是一个数组，当您将其赋值给test时，您将为该数组分配一个引用以进行测试。因此，当您执行test2=test时，您将引用赋值给另一个变量。对任何变量进行更改，数组都会被更改。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|950455|您的第二个示例可以工作，因为您完全创建了一个新数组。你可以像这样做：|950456|test+=+[1,2]
test2+=+[test[0]-1,+test[1]]|code-block|syntax|javascript|950457|entityMap^0|0|5|I|4|1D|A|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

<code>[1,2]</code> is an array and when you assign it to <code>test</code> you assign a reference to that array to test. So when you do <code>test2=test</code>, you are assigning the reference to yet another variable. Make changes to any variable and the array will get changed.

Your second example works, because you create a new array altogether. You might as well have done it like this:

<pre><code>test = [1,2]
test2 = [test[0]-1, test[1]]
</code></pre>

blocks|key|4271080|text|Python不做赋值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4271081|它实现了名称绑定。|4271082|这是有区别的，here对此进行了精彩而详细的解释。|offset|length|4271083|在第一个示例中:第一行将名称"test“绑定到由"1,2”表达式创建的列表对象。您的第二行代码将名称"test2“绑定到绑定到"test”的同一对象。第三行修改绑定到"test2“的对象，与"test”绑定的对象相同。|4271084|在第二个示例中:第一行将名称"test“绑定到由"1,2”表达式创建的列表对象。您的第二行代码将名称"test2“绑定到绑定到"test”的同一对象。第三行将名称"test2“绑定到一个由表达式"[test2-1，test21]”创建的新对象。|4271085|如果你真的想要两个独立的列表，将相同的值绑定到不同的变量，你需要：|4271086|>>>+test+=+[1,+2]
>>>+test2+=+list(test)
>>>+test2[0]+=+3
>>>+print(test)
[1,+2]
>>>+print(test2)
[3,+2]|code-block|syntax|javascript|4271087|注意，这是一个浅拷贝列表，所以如果在列表中找到相同的对象，那么更改test2中元素的对象状态当然会影响test。|style|CODE|4271088|附注：巨蟒。分号。丑陋。没必要。不要使用。|4271089|entityMap|0|LINK|mutability|MUTABLE|url|http://www.python.net/crew/mwh/hacks/objectthink.html|1^0|0|0|7|4|0|0|0|34|1|1|0|0|0|X|5|1F|4|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|19|8|@]|9|@$F|1A|G|1B|1|1C]]|A|$]]|$1|H|3|I|5|6|7|1D|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1E|8|@]|9|@$F|1F|G|1G|1|1H]]|A|$]]|$1|L|3|M|5|6|7|1I|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1J|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1K|8|@$F|1L|G|1M|U|V]|$F|1N|G|1O|U|V]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1P|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|15]]]]

Python does not do assignment. 

It does name binding. 

There is a difference, and it is explained wonderfully and in detail <a href="http://www.python.net/crew/mwh/hacks/objectthink.html" rel="nofollow noreferrer">here</a>.

In your first example:
Your first line binds the name "test" to a list object created by the "[1,2]" expression.
Your second line binds the name "test2" to the same object that is bounded to "test".
Your third line mutates the object bound to "test2", which is the same as the object bound to by "test".

In your second example: 
Your first line binds the name "test" to a list object created by the "[1,2]" expression.
Your second line binds the name "test2" to the same object that is bounded to "test".
Your third line binds the name "test2" to a new object, created by the expression "[test2[0]-1, test2<a href="http://www.python.net/crew/mwh/hacks/objectthink.html" rel="nofollow noreferrer">1</a>]".

If you really want two independent lists with the same values bound to different variables, you need to:

<pre><code>&gt;&gt;&gt; test = [1, 2]
&gt;&gt;&gt; test2 = list(test)
&gt;&gt;&gt; test2[0] = 3
&gt;&gt;&gt; print(test)
[1, 2]
&gt;&gt;&gt; print(test2)
[3, 2]
</code></pre>

Note that this is a shallow-copy list, so changing the state of the object of an element in <code>test2</code> will, of course, effect <code>test</code> if the the same object is found in that list. 

p.s. Python. Semi-colons. Ugly. Unnecessary. Do not use.

blocks|key|948440|text|在Python语言中，就像在Java语言中一样，赋值本身并不会产生副本--相反，赋值会将另一个引用添加到与=右侧相同的对象中。(参数传递的工作方式与此相同)。奇怪的是，您从来没有听说过这个概念，而Python非常流行，而Java更是如此(许多其他语言也倾向于类似的工作方式，可能会有更复杂或更不同的地方)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|948441|当你想要一个副本时，你需要一个副本(作为右边表达式的一部分，或者用来获取你传递的参数)！在Python语言中，根据您的确切目的，有几种方法--标准库的copy模块是一种流行的方法(使用函数copy，用于“浅层”复制，以及deepcopy+--用于“深层”复制，当然，也就是说，不仅是容器，而且是每个包含的项，也会递归地进行深层复制)。|948442|但是，您通常需要的是“新列表”--无论原始序列是列表、副本还是其他可迭代的内容，您可能并不关心:您想要一个新的list实例，它的项与“其他项”的项相同。表达这一点的完美方法是使用list(somethingelse)+--调用list类型，它总是创建一个新的list实例，并将其作为参数提供给iterable，您希望在新的list中包含它的项。类似地，dict(somemapping)创建一个新的dict，set(someiterable)创建一个新的集合--调用一个类型来创建该类型的新实例是一个非常通用和有用的概念！|948443|entityMap^0|1H|1|0|23|4|2M|4|32|8|0|1J|4|2H|J|35|4|4W|H|5J|4|5O|H|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|K|$]]

In Python, like in Java, assignment per se never makes a copy -- rahter, assignment adds another reference to the same object as the right-hand side of the <code>=</code>. (Argument passing works the same way). Strange that you've never heard of the concept, when Python is quite popular and Java even much more so (and many other languages tend to work similarly, possibly with more complications or distinguos).

When you want a copy, you ask for a copy (as part of the expression that is on the right-hand side, or gets used to get the argument you're passing)! In Python, depending on your exact purposes, there are several ways -- the <code>copy</code> module of the standard library being a popular ones (with functions <code>copy</code>, for "shallow" copies, and <code>deepcopy</code> -- for "deep" copies, of course, i.e., ones where, not just the container, but every contained item, also gets deep copied recursively).

Often, though, what you want is "a new list" -- whether the original sequence is a list, a copy, or something else that's iterable, you may not care: you want a new <code>list</code> instance, whose items are the same as those of "something else". The perfect way to express this is to use <code>list(somethingelse)</code> -- call the <code>list</code> type, which always makes a new instance of list, and give it as an argument the iterable whose items you want in the new list. Similarly, <code>dict(somemapping)</code> makes a new <code>dict</code>, and <code>set(someiterable)</code> makes a new set -- calling a type to make a new instance of that type is a very general and useful concept!

I have just started python and came across something kind of strange.

The following code assigns a co-ordinate of x=1 and y=2 to the variable test. The test2 variable assigns itself the same value as test and then the [x] value for test2 is changed to the old [x] value minus 1. This works fine, however, when the last part is executed, not only does it minus 1 from the [x] value in test2, it does the same to the [x] value in the test variable too.

<pre><code>test = [1,2];
test2 = test;
test2[1] = test2[1] - 1;
</code></pre>

I found doing the following worked fine but I still don't understand why the first method changes the test value as well as the test2 value.

<pre><code>test = [1,2];
test2 = test;
test2 = [test2[0] -1 ,test2[1]];
</code></pre>

Could someone please explain why this happens.

Thank You
TheLorax

Python permanent assignment variables

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我刚开始使用python，遇到了一些奇怪的事情。下面的代码将x=1和y=2的坐标分配给变量test。test2变量为自己分配与TEST值相同的值，然后test2的x值被更改为旧的x值减1。但是，当执行最后一部分时，它不仅从test2中的x值减去1，还对test变量中的x值执行相同的操作。test = [1,2];tes...

问Python永久赋值变量
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python永久赋值变量EN