How to detect method overloading in subclasses in python?

You can compare whatever is in the class’s __dict__ with the function inside the method
you can retrieve from the object –
the “detect_overriden” functionbellow does that – the trick is to pass
the “parent class” for its name, just as one does in a call to “super” –
else it is not easy to retrieve attributes from the parentclass itself
instead of those of the subclass:

# -*- coding: utf-8 -*-
from types import FunctionType

def detect_overriden(cls, obj):
    res = []
    for key, value in cls.__dict__.items():
        if isinstance(value, classmethod):
            value = getattr(cls, key).im_func
        if isinstance(value, (FunctionType, classmethod)):
            meth = getattr(obj, key)
            if not meth.im_func is  value:
                res.append(key)
    return res


# Test and example
class A(object):
    def  __init__(self):
        print detect_overriden(A, self)

    def a(self): pass
    @classmethod
    def b(self): pass
    def c(self): pass

class B(A):
    def a(self): pass
    #@classmethod
    def b(self): pass

edit changed code to work fine with classmethods as well:
if it detects a classmethod on the parent class, extracts the underlying function before proceeding.

—
Another way of doing this, without having to hard code the class name, would be to follow the instance’s class ( self.__class__) method resolution order (given by the __mro__ attribute) and search for duplicates of the methods and attributes defined in each class along the inheritance chain.

It seems simplest and sufficient to do this by comparing the common subset of the dictionaries of an instance and the base class itself, e.g.:

def detect_overridden(cls, obj):
  common = cls.__dict__.keys() & obj.__class__.__dict__.keys()
  diff = [m for m in common if cls.__dict__[m] != obj.__class__.__dict__[m]]
  print(diff)

def f1(self):
  pass

class Foo:
  def __init__(self):
    detect_overridden(Foo, self)
  def method1(self):
    print("Hello foo")
  method2=f1

class Bar(Foo):
  def method1(self):
    print("Hello bar")
  method2=f1 # This is pointless but not an override
#  def method2(self):
#    pass

b=Bar()
f=Foo()

Runs and gives:

['method1']
[]

In reply to answer https://stackoverflow.com/a/9437273/1258307, since I don’t have enough credits yet to comment on it, it will not work under python 3 unless you replace im_func with __func__ and will also not work in python 3.4(and most likely onward) since functions no longer have the __func__ attribute, only bound methods.

EDIT: Here’s the solution to the original question(which worked on 2.7 and 3.4, and I assume all other version in between):

    class Super:
        def __init__(self):
            if self.method.__code__ is Super.method.__code__:
                print('same')
            else:
                print('different')

        @classmethod
        def method(cls):
            pass

    class Sub1(Super):
        def method(self):
            print('hi')

    class Sub2(Super):
        pass

    Super() # should be same
    Sub1() # should be different
    Sub2() # should be same

And here’s the output:

same
different
same

Not sure if this is what you’re looking for but it helped me when I was looking for a similar solution.

class A:
    def fuzz(self):
        pass

class B(A):
    def fuzz(self):
        super().fuzz()

assert 'super' in B.__dict__['fuzz'].__code__.co_names

I’m using the following method to determine if a given bound method is overridden or originates from the parent class

class A():
    def bla(self):
        print("Original")


class B(A):
    def bla(self):
        print("Overridden")

class C(A):
    pass


def isOverriddenFunc(func):
    obj = func.__self__
    prntM = getattr(super(type(obj), obj), func.__name__)

    return func.__func__ != prntM.__func__


b = B()
c = C()

b.bla()
c.bla()

print(isOverriddenFunc(b.bla))
print(isOverriddenFunc(c.bla))

Result:

Overridden
Original
True
False

Of course, for this to work, the method must be defined in the base class.

If you want to check for an overridden instance method in Python 3, you can do this using the type of self:

class Base:
    def __init__(self):
        if type(self).method == Base.method:
            print('same')
        else:
            print('different')

    def method(self):
        print('Hello from Base')


class Sub1(Base):
    def method(self):
        print('Hello from Sub1')


class Sub2(Base):
    pass

Now Base() and Sub2() should both print “same” while Sub1() prints “different”. The classmethod decorator causes the first parameter to be bound to the type of self, and since the type of a subclass is by definition different to its base class, the two class methods will compare as not equal. By making the method an instance method and using the type of self, you’re comparing a plain function against another plain function, and assuming functions (or unbound methods in this case if you’re using Python 2) compare equal to themselves (which they do in the C Python implementation), the desired behavior will be produced.

You can check to see if the function has been overridden by seeing if the function handle points to the Super class function or not. The function handler in the subclass object points either to the Super class function or to an overridden function in the Subclass. For example:

class Test:
    def myfunc1(self):
        pass
    def myfunc2(self):
        pass

class TestSub(Test):
    def myfunc1(self):
        print('Hello World')

>>> test = TestSub()
>>> test.myfunc1.__func__ is Test.myfunc1
False
>>> test.myfunc2.__func__ is Test.myfunc2
True

If the function handle does not point to the function in the Super class, then it has been overridden.

You can also check if something is overridden from its parents, without knowing any of the classes involved using super:

class A:
    def fuzz(self):
        pass

class B(A):
    def fuzz(self):
        super().fuzz()

class C(A):
    pass

>>> b = B(); c = C()
>>> b.__class__.fuzz is super(b.__class__, b).fuzz.__func__
False
>>> c.__class__.fuzz is super(c.__class__, c).fuzz.__func__
True

See this question for some more nuggets of information.

A general function:

def overrides(instance, function_name):
    return getattr(instance.__class__, function_name) is not getattr(super(instance.__class__, instance), function_name).__func__

>>> overrides(b, "fuzz")
True
>>> overrides(c, "fuzz")
False

The top-trending answer and several others use some form of Sub.method == Base.method. However, this comparison can return a false negative if Sub and Base do not share the same import syntax. For example, see discussion here explaining a scenario where issubclass(Sub, Base) -> False.

This subtlety is not apparent when running many of the minimal examples here, but can show up in a more complex code base. The more reliable approach is to compare the method defined in the Sub.__bases__ entry corresponding to Base because __bases__ is guaranteed to use the same import path as Sub

import inspect 

def method_overridden(cls, base, method):
   """Determine if class overriddes the implementation of specific base class method

   :param type cls: Subclass inheriting (and potentially overriding) the method
   :param type base: Base class where the method is inherited from
   :param str method: Name of the inherited method
   :return bool: Whether ``cls.method != base.method`` regardless of import
       syntax used to create the two classes
   :raises NameError: If ``base`` is not in the MRO of ``cls``
   :raises AttributeError: If ``base.method`` is undefined
   """

   # Figure out which base class from the MRO to compare against
   base_cls = None
   for parent in inspect.getmro(cls):
       if parent.__name__ == base.__name__:
           base_cls = parent
           break
   if base_cls is None:
       raise NameError(f'{base.__name__} is not in the MRO for {cls}')

   # Compare the method implementations
   return getattr(cls, method) != getattr(base_cls, method)