blocks|key|761150|text|在Python中，变量是“引用”，这意味着可以有两个变量引用同一个对象。在您的第一个例子中，这就是正在发生的事情:同一个列表的两个名称。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|761151|如果您需要第二个实际列表，可以“复制”第一个列表。有关方法，请参见此处：How+to+clone+or+copy+a+list?|offset|length|761152|请注意，这也适用于列表中的项--如果它们是更复杂的对象，您可以选择对列表进行“深度复制”，复制每个元素的每个部分，或者复制一个“浅拷贝”，只复制引用，这样就会有一个包含对原始对象的新引用的新列表。您需要为每个用例选择正确的方法。|761153|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2612802/how-to-clone-or-copy-a-list-in-python^0|0|10|S|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

In Python, variables are "references" meaning that you can have two variables referring to the same object. In your first example that's what is happening: two names for the same list.

If you need a second actual list, you can "copy" the first one. For how, see here: <a href="https://stackoverflow.com/questions/2612802/how-to-clone-or-copy-a-list-in-python">How to clone or copy a list?</a>

Note that this applies to the items within the list too--if they were more complicated objects, you would have the choice to do a "deep copy" of the list, copying every single part of every element, or a "shallow copy", copying just the references, so you'd have a new list containing new references to the original objects. You need to choose the right approach for each use case.

blocks|key|761189|text|将oldvec设置为vec可以使oldvec指向vec。您还没有创建一个新的列表，您只是为它创建了另一个名称。通过使用列表理解，您将显式创建列表的新副本，相当于vec.copy()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|761190|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|$]]

Setting oldvec to vec literally makes oldvec point to vec. You haven't created a new list, you've simply made another name for it. By using a list comprehension you are explicitly creating a new copy of the list, equivalent to vec.copy().

blocks|key|330626|text|您应该将Python看作一个对象:在内存中的某个地方实例化的东西，其中有一个或多个指针存储它的内存地址--也就是说，当您说[]时，您正在内存中的某个地方分配一些新的空间。因此，当您调用vec+=+[0.0,+0.0]时，它会在内存中的某个地方创建一个新的列表，而它的地址存储在vec变量中。因此，当您执行oldvec+=+vec时，只需将地址从vec复制到oldvec。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|330627|让我举一个例子来说明:例如，假设列表[0.0,+0.0]存储在address+0x0800中。当您说vec+=+[0.0,+0.0]时，vec变量现在接收0x0800。当您说oldvec+=+vec时，oldvec会收到相同的0x0800。因此，当您访问oldvec的第一个元素时，您确实是在访问vec所指向的相同的列表。|330628|现在，考虑一下您的新行：oldvec+=+[vv+for+vv+in+vec]。当您执行[]时，它会创建一个新的列表，在内存中的其他地方，对吗？如vec命令所述，这个列表中填充了for的元素。因此，它会在内存中的其他地方创建一个新的列表，存储0.0和0.0+(如果我正确理解您解释的内容，稍后还会创建新的元素)。这就是Python内部处理命令的方式。|330629|希望这能有所帮助。|330630|entityMap^0|1P|2|2K|G|3U|3|48|C|4S|3|4Y|6|3N|4|0|I|A|13|6|1E|G|1W|3|25|6|2F|C|2T|6|35|6|3J|6|44|3|4B|3|0|C|R|18|2|21|3|2H|3|3D|3|3H|3|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]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|D]]|E|@]|F|$]]|$1|I|3|J|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|E|@]|F|$]]|$1|K|3|L|5|6|7|23|8|@]|E|@]|F|$]]|$1|M|3|-4|5|6|7|24|8|@]|E|@]|F|$]]]|N|$]]

You should think on Python list as an object: something instantiated somewhere in the memory, with one or more pointers storing its memory address - ie, when you say <code>[]</code>, you are allocating some new space somewhere in the memory. So, when you call <code>vec = [0.0, 0.0]</code>, it creates a new list somewhere in the memory, and it's address is stored in <code>vec</code> variable. So, when you do <code>oldvec = vec</code>, you're simply copying the address from <code>vec</code> to <code>oldvec</code>.

Let me illustrate with an example: imagine, for instance, that your list <code>[0.0, 0.0]</code> is stored at address <code>0x0800</code>. When you say <code>vec = [0.0, 0.0]</code>, <code>vec</code> variable now receives <code>0x0800</code>. When you say <code>oldvec = vec</code>, <code>oldvec</code> receives the same <code>0x0800</code>. So, when you access the first element of <code>oldvec</code>, you are indeed accessing the same list that <code>vec</code> points to.

Now, think about your new line: <code>oldvec = [vv for vv in vec]</code>. When you do <code>[]</code>, it creates a new list, somewhere else in the memory, right? This list is populated with the elements of <code>vec</code>, as the <code>for</code> command says. So, it creates a new list, somewhere else in the memory, storing <code>0.0</code> and <code>0.0</code> (and new elements later, if I understood correctly what you explained). That's how internally Python handles your command.

Hope that helps.

blocks|key|761290|text|您可以看到下面的情况的一种方法是使用id函数。这显示了对象的内存地址。内存地址是指将对象存储在物理内存中的位置。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|761291|如果我们为这三个命令运行它，并查看不同的地址(这就在我的计算机上，如果您自己运行它，您会得到不同的数字)：|761292|>>>+vec+=+[0.0,+0.0]
>>>+print+id(vec)
4501729936

>>>+oldvec1+=+vec
>>>+print+id(oldvec1)
4501729936

>>>+oldvec2+=+[vv+for+vv+in+vec]
>>>+print+id(oldvec2)
4502046984|code-block|syntax|javascript|761293|我们看到vec和oldvec1引用相同的地址，因此它们是同一个对象的两个不同的标签。在这个框架下，Python在address+4501729936上操作对象:变量名称vec和oldvec1只是我们可以使用的方便标签。它们没有提到“不同的”对象。|761294|相比之下，oldvec2的位置完全不同。当Python运行列表理解时，它不知道这将产生与以前相同的列表，因此它创建了该列表的新副本。|761295|761296|这是一张快速的脏照片来显示正在发生的事情。虽然红色的博客和绿色的博客恰好包含相同的信息，但它们是两个不同的小块。vec和oldvec1都指向同一个红色blob，因此对其中之一的任何操作都会影响底层的红色blob，并反映在另一个红色blob中。相反，oldvec2指向一个完全不同的绿色blob，它恰好是红色blob中信息的副本，但是对绿色blob的更改不会影响红色blob。|761297|​|761298|📷|atomic|761299|761300|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/b4308a1ff59190e626d3474fe00b9b94.png|imageAlt^0|I|2|0|0|0|4|3|8|7|1S|A|2C|3|2G|7|0|5|7|0|0|1K|3|1O|7|3G|7|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|V|3|W|5|X|7|20|8|@]|D|@$9|21|A|22|1|23]]|E|$]]|$1|Y|3|U|5|6|7|24|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|10|$11|$5|12|13|14|E|$15|16|17|-4]]]]

One way you can see what's going under the hood is to use the <code>id</code> function. This shows you the memory address of an object. The memory address refers to where the object is stored in physical memory.

If we run it for these three commands, and look at the different addresses (this is just on my computer; you'll get different numbers if you run it yourself):

<pre><code>&gt;&gt;&gt; vec = [0.0, 0.0]
&gt;&gt;&gt; print id(vec)
4501729936

&gt;&gt;&gt; oldvec1 = vec
&gt;&gt;&gt; print id(oldvec1)
4501729936

&gt;&gt;&gt; oldvec2 = [vv for vv in vec]
&gt;&gt;&gt; print id(oldvec2)
4502046984
</code></pre>

We see that <code>vec</code> and <code>oldvec1</code> refer to the same address, so they're two different labels for the same object. Under the hood, Python is manipulating the object at address <code>4501729936</code>: the variable names <code>vec</code> and <code>oldvec1</code> are just convenient labels for us to use. They don’t refer to “distinct” objects.

By contrast, <code>oldvec2</code> is somewhere completely different. When Python runs the list comprehension, it doesn’t know that this will happen to produce the same list as before, so it creates a new copy of that list.

<hr>

Here's a quick n' dirty picture to show what's going on. Although the red blob and the green blog happen to contain the same information, they are two different blobs. Both <code>vec</code> and <code>oldvec1</code> point to the same red blob, so any operations on either one will affect the underlying red blob, and be reflected in the other. By contrast, <code>oldvec2</code> points to a completely different green blob, which happens to be a copy of information in the red blob, but changes to the green blob don’t affect the red blob.

<img src="https://i.stack.imgur.com/6MJ8Z.png" alt="enter image description here">

i THINK i've solved my own issue already, but i'm seeking a better understanding of why, or to be enlightened/set straight.

i have a list i call vec: 

<pre><code>vec = [0.0, 0.0] 
</code></pre>

which changes values as data are read in. 

in order to compare the current and previous values, i have another list which i call oldvec. 
if i define oldvec as 

<pre><code>oldvec = vec
</code></pre>

then it changes values every time vec changes values, so a comparison is useless -- they're always the same. 

however, if i instead write

<pre><code>oldvec = [vv for vv in vec] 
</code></pre>

i don't have this problem -- oldvec keeps its values even as vec changes, so the comparison between current and previous vectors works as i need it to, i.e. it actually detects repeats and non-repeats! ... WHY?

populating lists -- what is python doing?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想我已经解决了我自己的问题，但我正在寻求更好地理解原因，或者是开悟/开诚布公。我有一份名单叫vec：vec = [0.0, 0.0] 它在读取数据时更改值。为了比较当前和以前的值，我有另一个列表，我称之为oldvec。如果我将oldvec定义为oldvec = vec然后，每当vec改变值时，它就会改变值，所以比较是...

问填充列表--蟒蛇在做什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问填充列表--蟒蛇在做什么？EN