Ytukyg

def check_classes(cls):

    if len(cls.__bases__) == 0:

        return 

    else:

        test_list = 

        for x in range(len(cls.__bases__)):

            test_list += [cls] + check_classes(cls.__bases__[x])

        for x in cls.__bases__:

            return test_list + [x]

I currently have a recursive function that takes a class as its parameter and returns a list of all base classes. This works fine, but it has many duplicate classes in the list. I want to return a set instead of a list and was wondering how I could go about changing the code to do so.

Python has a builtin set type that eliminates duplicates:

def get_bases(obj):

   bases = {obj}  # new set including only obj

   if not(obj.__bases__):  # technically redundant - iter is a noop on empty collections

      return bases

   else:

      for x in obj.__bases__:

          bases.update(get_bases(x))  # update set - automatically eliminates duplicates

      return bases

This code already avoids adding many duplicates in the first place. However, the set still eliminates duplicates in case of multiple inheritance.

class A: ...

class B1(A): ...

class B2(A): ...

class C(B1, B2): ...

print(get_bases(C))

# {<class '__main__.C'>, <class '__main__.B1'>, <class 'object'>, <class '__main__.B2'>, <class '__main__.A'>}

Python being Python, there is already something that does this:

>>> C.__mro__

(__main__.C, __main__.B1, __main__.B2, __main__.A, object)

If you just care about the bases, use __mro__. Its order also expresses how lookup is performed with multiple bases.

A slightly different approach for such searches is to use a set to track duplicates, but a list to store elements:

def get_bases(obj, _dupes=None):

   _dupes = _dupes if _dupes is not None else set()

   bases = [obj]  # new list including only obj

   _dupes.add(obj)

   for x in obj.__bases__:

       if x not in _dupes:

           bases.extend(get_bases(x, _dupes))  # update set - automatically eliminates duplicates

   return bases

This uses a _dupes: set to check whether you already visited a class. Instead of eliminating classes you added twice, it only adds them once in the first place. A set is faster for this check than a list, given many elements. However, you need the list to preserve order.

Your function is redundant in that it can be replaced with cls.__mro__:

>>> class Base: pass

...

>>> class Foo(Base): pass

...

>>> class Bar(Base): pass

...

>>> class Baz(Foo, Bar): pass

...



>>> Baz.__mro__

(<class '__main__.Baz'>, <class '__main__.Foo'>, <class '__main__.Bar'>, <class '__main__.Base'>, <class 'object'>)

Your biggest issue is that your implementation adds classes to the list twice, once in the recursive call, then again in the current call. Only add the current class to the list. Checking for the __bases__ list as empty is redundant too, as the for loop already not do anything if the sequence is empty.

So this is enough:

def check_classes(cls):

    result = [cls]

    for base in cls.__bases__:

        result += check_classes(base)

    return result

But this will still repeat base classes that have been included in the hierarchy more than once:

>>> check_classes(Baz)

[<class '__main__.Baz'>, <class '__main__.Foo'>, <class '__main__.Base'>, <class 'object'>, <class '__main__.Bar'>, <class '__main__.Base'>, <class 'object'>]

Note that Base and object appear twice, due to multiple inheritance. You could use a set to avoid this:

def check_classes(cls):

    result = set([cls])

    for base in cls.__bases__:

        result.update(check_classes(base))

    return result

at which point we lose ordering, but that may be sufficient for your needs:

>>> check_classes(Baz)

{<class '__main__.Bar'>, <class '__main__.Foo'>, <class '__main__.Base'>, <class 'object'>, <class '__main__.Baz'>}

However, then you could just use set(cls.__mro__) and be done with it:

>>> check_classes(Baz) == set(Baz.__mro__)

True