Compare object instances for equality by their attributes

Question

I have a class MyClass  which contains two member variables foo and bar   class MyClass      def   init   self  foo  bar           self foo   foo         self bar   bar   I have two instances of this class  each of which has identical values for foo and bar   x   MyClass  foo    bar   y   MyClass  foo    bar     However  when I compare them for equality  Python returns False    gt  gt  gt  x    y False   How can I make python consider these two objects equal

User · Answer

With Dataclasses in Python 3 7  and above   a comparison of object instances for equality is an inbuilt feature   A backport for Dataclasses is available for Python 3 6    Py37  nsc nsc-vbox    python Python 3 7 5  default  Nov  7 2019  10 50 52    GCC 8 3 0  on linux Type  help    copyright    credits  or  license  for more information   gt  gt  gt  from dataclasses import dataclass  gt  gt  gt   dataclass     class MyClass            foo  str         bar  str       gt  gt  gt  x   MyClass foo  foo   bar  bar    gt  gt  gt  y   MyClass foo  foo   bar  bar    gt  gt  gt  x    y True

User · Answer

If you want to get an attribute-by-attribute comparison  and see if and where it fails  you can use the following list comprehension    i for i j in   zip  getattr obj 1  attr  for attr in dir obj 1          getattr obj 2  attr  for attr in dir obj 2      if not i  j    The extra advantage here is that you can squeeze it one line and enter in the  Evaluate Expression  window when debugging in PyCharm

User · Answer

Below works  in my limited testing  by doing deep compare between two object hierarchies  In handles various cases including the cases when objects themselves or their attributes are dictionaries    def deep comp o1 Any  o2 Any - gt bool        NOTE  dict don t have   dict       o1d   getattr o1     dict     None      o2d   getattr o2     dict     None         if both are objects     if o1d is not None and o2d is not None            we will compare their dictionaries         o1  o2   o1   dict    o2   dict        if o1 is not None and o2 is not None            if both are dictionaries  we will compare each key         if isinstance o1  dict  and isinstance o2  dict               for k in set   union o1 keys    o2 keys                     if k in o1 and k in o2                      if not deep comp o1 k   o2 k                            return False                 else                      return False   some key missing             return True       mismatched object types or both are scalers  or one or both None     return o1    o2   This is a very tricky code so please add any cases that might not work for you in comments

User · Answer

Instance of a class when compared with    comes to non-equal  The best way is to ass the cmp function to your class which will do the stuff    If you want to do comparison by the content you can simply use cmp obj1 obj2   In your case cmp doc1 doc2  It will return -1 if the content wise they are same

User · Answer

You should implement the method   eq      class MyClass        def   init   self  foo  bar  name              self foo   foo            self bar   bar            self name   name        def   eq   self other              if not isinstance other MyClass                   return NotImplemented            else                   string lists of all method names and properties of each of these objects                 prop names1   list self   dict                    prop names2   list other   dict                     n   len prop names1   number of properties                 for i in range n                        if getattr self prop names1 i      getattr other prop names2 i                              return False                  return True

User · Answer

class Node      def   init   self  value           self value   value         self next   None      def   repr   self           return str self value       def   eq   self other           return self value    other value  node1   Node 1  node2   Node 1   print f node1 id  id node1     print f node2 id  id node2     print node1    node2     gt  gt  gt  node1 id 4396696848  gt  gt  gt  node2 id 4396698000  gt  gt  gt  True

User · Answer

If you re dealing with one or more classes which you can t change from the inside  there are generic and simple ways to do this that also don t depend on a diff-specific library  Easiest  unsafe-for-very-complex-objects method pickle dumps a     pickle dumps b   pickle is a very common serialization lib for Python objects  and will thus be able to serialize pretty much anything  really  In the above snippet I m comparing the str from serialized a with the one from b  Unlike the next method  this one has the advantage of also type checking custom classes  The biggest hassle  due to specific ordering and  de en coding methods  pickle may not yield the same result for equal objects  specially when dealing with more complex ones  e g  lists of nested custom-class instances  like you ll frequently find in some third-party libs  For those cases  I d recommend a different approach  Thorough  safe-for-any-object method You could write a recursive reflection that ll give you serializable objects  and then compare results from collections abc import Iterable  BASE TYPES    str  int  float  bool  type None     def base typed obj        quot  quot  quot Recursive reflection method to convert any object property into a comparable form       quot  quot  quot      T   type obj      from numpy   T   module       numpy       if T in BASE TYPES or callable obj  or  from numpy and not isinstance T  Iterable            return obj      if isinstance obj  Iterable           base items    base typed item  for item in obj          return base items if from numpy else T base items       d   obj if T is dict else obj   dict        return  k  base typed v  for k  v in d items      def deep equals  args       return all base typed args 0      base typed other  for other in args 1     Now it doesn t matter what your objects are  deep equality is assured to work  gt  gt  gt  from sklearn ensemble import RandomForestClassifier  gt  gt  gt   gt  gt  gt  a   RandomForestClassifier max depth 2  random state 42   gt  gt  gt  b   RandomForestClassifier max depth 2  random state 42   gt  gt  gt    gt  gt  gt  deep equals a  b  True  The number of comparables doesn t matter as well  gt  gt  gt  c   RandomForestClassifier max depth 2  random state 1000   gt  gt  gt  deep equals a  b  c  False  My use case for this was checking deep equality among a diverse set of already trained Machine Learning models inside BDD tests  The models belonged to a diverse set of third-party libs  Certainly implementing   eq   like other answers here suggest wasn t an option for me  Covering all the bases You may be in a scenario where one or more of the custom classes being compared do not have a   dict   implementation  That s not common by any means  but it is the case of a subtype within sklearn s Random Forest classifier   lt type  sklearn tree  tree Tree  gt   Treat these situations in a case by case basis - e g  specifically  I decided to replace the content of the afflicted type with the content of a method that gives me representative information on the instance  in this case  the   getstate   method   For such  the second-to-last row in base typed became d   obj if T is dict else obj   dict   if    dict    in dir obj  else obj   getstate       Edit  for the sake of organization  I replaced the hideous oneliner above with return dict from obj   Here  dict from is a really generic reflection made to accommodate more obscure libs  I m looking at you  Doc2Vec  def isproperty prop  obj       return not callable getattr obj  prop   and not prop startswith        def dict from obj        quot  quot  quot Converts dict-like objects into dicts      quot  quot  quot      if isinstance obj  dict             Dict and subtypes are directly converted         d   dict obj       elif    dict    in dir obj             Use standard dict representation when available         d   obj   dict        elif str type obj       sklearn tree  tree Tree             Replaces sklearn trees with their state metadata         d   obj   getstate          else            Extract non-callable  non-private attributes with reflection         kv     p  getattr obj  p   for p in dir obj  if isproperty p  obj           d    k  v for k  v in kv       return  k  base typed v  for k  v in d items      Do mind none of the above methods yield True for objects with the same key-value pairs in differing order  as in  gt  gt  gt  a     foo       bar       gt  gt  gt  b     bar       foo       gt  gt  gt  pickle dumps a     pickle dumps b  False  But if you want that you could use Python s built-in sorted method beforehand anyway

User · Answer

You should implement the method   eq     class MyClass      def   init   self  foo  bar           self foo   foo         self bar   bar      def   eq   self  other            if not isinstance other  MyClass                 don t attempt to compare against unrelated types             return NotImplemented          return self foo    other foo and self bar    other bar   Now it outputs    gt  gt  gt  x    y True   Note that implementing   eq   will automatically make instances of your class unhashable  which means they can t be stored in sets and dicts  If you re not modelling an immutable type  i e  if the attributes foo and bar may change value within the lifetime of your object   then it s recommend to just leave your instances as unhashable   If you are modelling an immutable type  you should also implement the datamodel hook   hash     class MyClass               def   hash   self             necessary for instances to behave sanely in dicts and sets          return hash  self foo  self bar     A general solution  like the idea of looping through   dict   and comparing values  is not advisable - it can never be truly general because the   dict   may have uncomparable or unhashable types contained within   N B   be aware that before Python 3  you may need to use   cmp   instead of   eq     Python 2 users may also want to implement   ne    since a sensible default behaviour for inequality  i e  inverting the equality result  will not be automatically created in Python 2

User · Answer

I tried the initial example  see 7 above  and it did not work in ipython  Note that cmp obj1 obj2  returns a  1  when implemented using two identical object instances  Oddly enough when I modify one of the attribute values and recompare  using  cmp obj1 obj2  the object continues to return a  1     sigh      Ok  so what you need to do is iterate two objects and compare each attribute using the    sign

User · Answer

Depending on your specific case  you could do    gt  gt  gt  vars x     vars y  True   See Python dictionary from an object  39 s fields

User · Answer

You override the rich comparison operators in your object   class MyClass   def   lt   self  other           return comparison  def   le   self  other           return comparison  def   eq   self  other           return comparison  def   ne   self  other           return comparison  def   gt   self  other           return comparison  def   ge   self  other           return comparison   Like this       def   eq   self  other           return self  id    other  id

User · Answer

I wrote this and placed it in a test utils module in my project  For cases when its not a class  just plan ol  dict  this will traverse both objects and ensure   every attribute is equal to its counterpart No dangling attributes exist  attrs that only exist on one object    Its big    its not sexy    but oh boi does it work   def assertObjectsEqual obj a  obj b        def  assert a  b           if a    b              return         raise AssertionError f  a       b  inside assertObjectsEqual        def  check a  b           if a is None or b is None               assert a  b          for k v in a items                if isinstance v  dict                   assertObjectsEqual v  b k               else                   assert v  b k          Asserting both directions is more work       but it ensures no dangling values on       on either object      check obj a  obj b       check obj b  obj a    You can clean it up a little by removing the  assert and just using plain ol  assert but then the message you get when it fails is very unhelpful

User · Answer

As a summary      It s advised to implement   eq   rather than   cmp    except if you run python  lt   2 0    eq   has been added in 2 1  Don t forget to also implement   ne    should be something like return not self   eq   other  or return not self    other except very special case  Don t forget that the operator must be implemented in each custom class you want to compare  see example below   If you want to compare with object that can be None  you must implement it  The interpreter cannot guess it      see example below   class B object     def   init   self       self name    toto    def   eq   self  other       if other is None        return False     return self name    other name  class A object     def   init   self       self toto    titi      self b inst   B     def   eq   self  other       if other is None        return False     return  self toto  self b inst      other toto  other b inst

User · Answer

When comparing instances of objects  the   cmp   function is called   If the    operator is not working for you by default  you can always redefine the   cmp   function for the object   Edit   As has been pointed out  the   cmp   function is deprecated since 3 0  Instead you should use the    rich comparison    methods

User · Answer

Implement the   eq   method in your class  something like this   def   eq   self  other       return self path    other path and self title    other title   Edit  if you want your objects to compare equal if and only if they have equal instance dictionaries   def   eq   self  other       return self   dict      other   dict

[python] Compare object instances for equality by their attributes

Examples related to python

Examples related to equality