Python 中是否有语句仅当两个复合列表的所有项目具有不同的 id 时才会解析为 True

Question

I recently found out that certain assignments, eg,

list2 = list1*1  
list2 = list1[:]  
list2 = copy.copy(list1)  (need to import copy)  

when used on compound lists (for example lists of lists) produce list2 that has different id from list1 but with components that have the same id's. Thus a subsequent change in a component of list2 will also change the corresponding component of list1. The list2 is list1 statement will resolve as False whether or not some lists components have the same id.

My question:
Is there something like a notTheSame command that resolves True only if list1 and list2 as well as all their components have different ids?

Answer 1

No, you would have to write a function to compare all items by their IDs, but note it only matters if they are "not the same" if the items are mutable, and their is no "ismutable()" function.

If you want your list copies to also copy sub-lists and other mutable items, use:

import copy
list1 = copy.deepcopy(list2)

Note that your hypothetical notTheSame function wouldn't work even with deepcopy, because immutable items do not need to have unique IDs. Python is free to optimize immutable items by re-using the object, since it can't be changed.

Here's an example:

import copy

list1 = [1,2,[3,4,5],6,7,[8,9,10]]

list2 = list1.copy()
list3 = copy.deepcopy(list1)

def ids(x):
    return ' '.join([f'{id(i):08x}' for i in x])

print(ids(list1))
print(ids(list2))
print(ids(list3))

Output:

7ffdff4006a0 7ffdff4006c0 22da8898200 7ffdff400740 7ffdff400760 22da8898a00
7ffdff4006a0 7ffdff4006c0 22da8898200 7ffdff400740 7ffdff400760 22da8898a00
7ffdff4006a0 7ffdff4006c0 22da88aea80 7ffdff400740 7ffdff400760 22da88ae980

Note that the shallow copy (2nd line) IDs are all the same. Only the 3rd and 6th item have a new ID in list3 (3rd line). The integer objects (in CPython's implementation anyway) don't change their IDs. Only the mutable list objects change.

Answer 2

A simple function can be written up to manually do a check:

def all_unique(list1, list2):
    return id(list1) != id(list2) and all(id(x) != id(y) for x, y in zip(list1, list2))

There is no built-in that I know of for this explicit purpose.

This seems like an odd requirement though. Just to clear up "certain assignments" returning elements with the same IDs: all the methods you show (sequence multiplication, slicing, and copy.copy ) all produce shallow copies. All they do is copy the outer structure, while copying references to the underlying objects into the new structure. If you want to ensure that all objects in the copy are unique (or at least unique in the cases that matter), use copy.deepcopy instead. It will recursively go through supporting structures and copy all objects.