Python：为列表中的每个类对象创建一个不同的副本

如何制作 Python 类中对象列表的副本，以便每个副本都是所述 Python 类的不同实例？

假设我有一个 Python 类

class myClass():
    def __init__(self, neighbor):
        self.neighbor = neighbor

另外假设 myList = [a,b,c,d,...] 是一个列表 myClass 对象，使得 myList 中的每个条目都有另一个条目 myList 填充其 neighbor 属性。例如，也许

a.neighbor = b
b.neighbor = c
etc.

我想复制 myList 其条目是新 myClass 对象（它们 有 是不同的对象），但具有直接可比较的 myClass 数据。| ||具体地（天真地）我想要一个返回

的函数 newList = [a0,b0,c0,d0,...] 如果我可以实现下面括号中的操作，我就得到了我想要的。

a0.neighbor = b0
b0.neighbor = c0
etc.

我怎样才能实现括号中描述的过程？

def myFunction(myList):
    myDict = {}
    newList = []
    for item in myList:
        
        (create a myClass object called item0)
        newList = newList.append(item0)
        
        myDict{item} = item0

# populate the neighbor data for each new item
    for item in myList
        myDict{item}.neighbor = myDict{item.neighbor}
        
    return newList

我确信这是一个简单的问题，但我无法确定在 StackOverflow 或文档中搜索的正确关键字是什么。

I'm sure this is a simple question, but I haven't been able to determine what the right keywords to search are on StackOverflow or in the documentation.

可以使用字典来跟踪原始对象和克隆对象，然后更新邻居：

from copy import deepcopy

class MyClass:
    def __init__(self, neighbor=None):
        self.neighbor = neighbor

    def __repr__(self):
        # 用于更清晰的表示形式，返回邻居的id
        return f"MyClass(neighbor={id(self.neighbor)})" 

def copy_list_of_objects(original_list):
    """返回一个包含列表中每个对象的浅表副本的新列表。"""

    # 创建原始对象到克隆对象的映射
    object_map = {}
    cloned_list = []

    # 深度复制对象并将它们存储在映射中
    for obj in original_list:
        cloned_list.append(deepcopy(obj))
        object_map[obj] = cloned_list[-1]  # 使用最后一个添加的对象

    # 更新克隆对象的邻居
    for obj in original_list:
        if obj.neighbor:
            cloned_object = object_map[obj]
            cloned_neighbor = object_map[obj.neighbor]
            cloned_object.neighbor = cloned_neighbor

    return cloned_list

# 示例用法：
a = MyClass()
b = MyClass(a)
c = MyClass(b)
my_list = [a, b, c]

cloned_list = copy_list_of_objects(my_list)

# 验证克隆对象和邻居是否是不同的实例
print(f"Original list: {my_list}")
print(f"Cloned list: {cloned_list}")
for i, (original, cloned) in enumerate(zip(my_list, cloned_list)):
    print(f"Object {i+1}: original={id(original)}, cloned={id(cloned)}")
    print(f"  Original neighbor: {id(original.neighbor) if original.neighbor else None}")
    print(f"  Cloned neighbor: {id(cloned.neighbor) if cloned.neighbor else None}")

说明：

1. deepcopy 用于创建对象的独立副本，包括其属性的副本。 这确保了克隆对象的修改不会影响原始对象，反之亦然。
2. object_map 字典 用于跟踪原始对象和相应克隆对象之间的关系。这使得更新克隆对象的 neighbor 属性变得更容易。
3. 在 更新 neighbor 属性 的循环中，我们首先检索克隆对象及其邻居，然后相应地更新 neighbor 属性。

此代码首先创建原始对象及其克隆对象的映射，然后遍历克隆对象，更新其 neighbor 属性以指向克隆的邻居。这确保了克隆列表具有与其原始对应物相同的结构，但是所有对象都是独立的实例。