Is there a way to compare a Python object with an object generated from a deepcopy?
eg:
import copy
original_object = SomeObject()
cloned_object = copy.deepcopy(original_object)
assertDeepCopy(original_object, cloned_object)
This is what I believe you're asking for:
def deep_compare(left, right):
try:
if not left.__dict__:
return left == right
for key in left.__dict__:
if key not in right.__dict__:
return false
else:
return deep_compare(left[key], right[key])
except (AttributeError, TypeError):
return left == right
However, note that this can go wrong in a number of places: if the objects don't define ==
in a way that you like, you won't get the answer that you want.
I know it is an old answer, but with Python 3 the previous code didn't work for me, so I updated it in this one that works better for me:
import logging
log = logging.getLogger(__name__)
...
def deep_compare(self,left, right, level=0):
if type(left) != type(right):
log.info("Exit 1 - Different types")
return False
elif type(left) is dict:
# Dict comparison
for key in left:
if key not in right:
log.info("Exit 2 - missing {} in right".format(key))
return False
else:
if not deep_compare(left[str(key)], right[str(key)], level +1 ):
log.info("Exit 3 - different children")
return False
return True
elif type(left) is list:
# List comparison
for key in left:
if key not in right:
log.info("Exit 4 - missing {} in right".format(key))
return False
else:
if not deep_compare(left[left.index(key)], right[right.index(key)], level +1 ):
log.info("Exit 5 - different children")
return False
return True
else:
# Other comparison
return left == right
return False
It compares dict, list and any other types that implements the "==" operator by themselves. If you need to compare something else different, you need to add a new branch in the "if tree".
Hope that helps.
This solution allows you to to deep compare objects, dicts, lists and primitives. And it allows you to exclude keys from the comparison.
I thought this might be helpful to some people looking for deep compare with object support :)
def deep_compare(left, right, excluded_keys = []):
# convert left and right to dicts if possible, skip if they can't be converted
try:
left = left.__dict__
right = right.__dict__
except:
pass
# both sides must be of the same type
if type(left) != type(right):
return False
# compare the two objects or dicts key by key
if type(left) == dict:
for key in left:
# make sure that we did not exclude this key
if key not in excluded_keys:
# check if the key is present in the right dict, if not, we are not equals
if key not in right:
return False
else:
# compare the values if the key is present in both sides
if not deep_compare(left[key], right[key], excluded_keys):
return False
# check if any keys are present in right, but not in left
for key in right:
if key not in left and key not in excluded_keys:
return False
return True
# check for each item in lists
if type(left) == list:
# right and left must have the same length
if len(left) != len(right):
return False
# compare each item in the list
for index in range(len(left)):
if not deep_compare(left[index], right[index], excluded_keys):
return False
# do a standard comparison
return left == right
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.