blocks|key|1827955|text|使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1827956|import+copy
OriginalPixCoords=+copy.deepcopy(pixCoords)|code-block|syntax|javascript|1827957|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|$]]

use 

<pre><code>import copy
OriginalPixCoords= copy.deepcopy(pixCoords)
</code></pre>

blocks|key|1840290|text|您正在使用的是一个浅层副本。这实际上意味着您创建了一个新的列表，并只指向旧的内存空间。这意味着如果这些对象被修改，你的新列表将仍然反映那些更新，因为它们发生在相同的内存空间中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1840291|>>>+#+Shallow+Copy
>>>+mylist+=+[]
>>>+mylist.append({"key":+"original"})
>>>+mynewlist+=+mylist.copy()
>>>+mynewlist
[{'key':+'original'}]
>>>+mylist[0]["key"]+=+"new+value"
>>>+mylist
[{'key':+'new+value'}]
>>>+mynewlist
[{'key':+'new+value'}]

>>>+#+Now+Deep+Copy
>>>+mylist+=+[]
>>>+mylist.append({"key":+"original"})
>>>+from+copy+import+deepcopy
>>>+mynewlist+=+deepcopy(mylist)
>>>+mynewlist
[{'key':+'original'}]
>>>+mylist[0]["key"]+=+"new+value"
>>>+mylist
[{'key':+'new+value'}]
>>>+mynewlist
[{'key':+'original'}]|code-block|syntax|javascript|1840292|另一个类似的问题：What+is+the+difference+between+shallow+copy,+deepcopy+and+normal+assignment+operation?|offset|length|1840293|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/17246693/what-is-the-difference-between-shallow-copy-deepcopy-and-normal-assignment-oper^0|0|0|9|2E|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|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

What you're using is a shallow copy. It effectively means you created a new list and just pointed to the old memory spaces. Meaning if those object got modified, your new list will still reflect those updates since they occurred in the same memory space.

<pre><code>&gt;&gt;&gt; # Shallow Copy
&gt;&gt;&gt; mylist = []
&gt;&gt;&gt; mylist.append({"key": "original"})
&gt;&gt;&gt; mynewlist = mylist.copy()
&gt;&gt;&gt; mynewlist
[{'key': 'original'}]
&gt;&gt;&gt; mylist[0]["key"] = "new value"
&gt;&gt;&gt; mylist
[{'key': 'new value'}]
&gt;&gt;&gt; mynewlist
[{'key': 'new value'}]

&gt;&gt;&gt; # Now Deep Copy
&gt;&gt;&gt; mylist = []
&gt;&gt;&gt; mylist.append({"key": "original"})
&gt;&gt;&gt; from copy import deepcopy
&gt;&gt;&gt; mynewlist = deepcopy(mylist)
&gt;&gt;&gt; mynewlist
[{'key': 'original'}]
&gt;&gt;&gt; mylist[0]["key"] = "new value"
&gt;&gt;&gt; mylist
[{'key': 'new value'}]
&gt;&gt;&gt; mynewlist
[{'key': 'original'}]
</code></pre>

Another similar question: <a href="https://stackoverflow.com/questions/17246693/what-is-the-difference-between-shallow-copy-deepcopy-and-normal-assignment-oper">What is the difference between shallow copy, deepcopy and normal assignment operation?</a>

blocks|key|1827959|text|设置多个变量等于相同的值相当于Python中的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1827960|看看这个|1827961|a+=+b+=+[1,2,3]
a+==+b+#+True
a+is+b++++#+True+(same+memory+location)
b[1]+=+3
print(b)++#+[1,3,3]
print(a)++#[1,3,3]|code-block|syntax|javascript|1827962|现在，您正在创建浅层副本。如果您需要两个副本(具有不同的值和数据历史记录)，则只需按以下方式分配变量：|1827963|import+copy

original+=+data
original_copy+=+copy.deepcopy(data)
original_copy+==+original+==+data+#+True
original_copy+is+original+++#+False
original_copy[0]+=+4
original_copy+==+original++#+False|1827964|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Settings multiple variables equal to the same value is the equivalent of a pointer in Python.

Check this out

<pre><code>a = b = [1,2,3]
a == b # True
a is b # True (same memory location)
b[1] = 3
print(b) # [1,3,3]
print(a) #[1,3,3]
</code></pre>

Right now, you are creating shallow copies. If you need both copies (with different values and data history), you can simply assign the variables in the following manner:

<pre><code>import copy

original = data
original_copy = copy.deepcopy(data)
original_copy == original == data # True
original_copy is original # False
original_copy[0] = 4
original_copy == original # False
</code></pre>

After I apply an operation to a list, I would like to get access to both the modified list and the original one.
Somehow I am not able to. 

In the following code snippet, I define two functions with which I modify the original list.
Afterwards, I get my values from a class and apply the transformation.

<pre><code>def get_min_by_col(li, col): # get minimum from list
 return min(li, key=lambda x: x[col - 1])[col - 1]

def hashCluster(coords): # transform to origin
 min_row = get_min_by_col(coords,0)
 min_col = get_min_by_col(coords,1)
 for pix in coords:
 pix[1] = pix[1] - min_row
 pix[0] = pix[0] - min_col
 return (coords)


pixCoords = hashCoords = originalPixCoords = [] # making sure they are empty
for j in dm.getPixelsForCluster(dm.clusters[i]):
 pixCoords.append([j['m_column'], j['m_row']]) # getting some values from a class -- ex: [[613, 265], [613, 266]] or [[615, 341], [615, 342], [616, 341], [616, 342]] 
originalPixCoords = pixCoords.copy() # just to be safe, I make a copy of the original list
print ('Original : ', originalPixCoords) 
hashCoords = hashCluster(pixCoords) # apply transformation
print ('Modified : ', hashCoords)
print ('Original : ', originalPixCoords) # should get the original list
</code></pre>

Some results [Jupyter Notebook]: 

<pre><code>Original : [[607, 268]]
Modified : [[0, 0]]
Original : [[0, 0]]

Original : [[602, 264], [603, 264]]
Modified : [[0, 0], [1, 0]]
Original : [[0, 0], [1, 0]]

Original : [[613, 265], [613, 266]]
Modified : [[0, 0], [0, 1]]
Original : [[0, 0], [0, 1]]
</code></pre>

Is the function <code>hashCluster</code> able to modify the new list as well? Even after the <code>.copy()</code>?

What am I doing wrong? My goal is to have access to both the original and modified lists, with as less operations and copies of lists as possible (since I am looping over a very large document).

List operation, keeping track of old list

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在对列表应用操作后，我希望同时访问修改后的列表和原始列表。不知何故，我做不到。在下面的代码片段中，我定义了两个用来修改原始列表的函数。然后，我从一个类中获取值并应用转换。def get_min_by_col(li, col):                          # get minimum from li...

问列表操作，跟踪旧列表
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问列表操作，跟踪旧列表EN