¿Cómo verifico (en tiempo de ejecución) si una clase es una subclase de otra?

Digamos que tengo un traje de clase y cuatro subclases de traje: Corazón, Espada, Diamante, Club.

class Suit:
   ...
class Heart(Suit):
   ...
class Spade(Suit):
   ...
class Diamond(Suit):
   ...
class Club(Suit):
   ...

Tengo un método que recibe un traje como parámetro, que es un objeto de clase, no una instancia. Más precisamente, puede recibir solo uno de los cuatro valores: Corazón, Espada, Diamante, Club. ¿Cómo puedo hacer una afirmación que garantice tal cosa? Algo como:

def my_method(suit):
   assert(suit subclass of Suit)
   ...

Estoy usando Python 3.

Puedes usar issubclass()así assert issubclass(suit, Suit).

issubclass(class, classinfo)

Extracto:

Devuelve verdadero si classes una subclase (directa, indirecta o virtual) de classinfo.

Puede usar isinstancesi tiene una instancia, o issubclasssi tiene una clase. Normalmente pensé que era una mala idea. Normalmente, en Python se determina si un objeto es capaz de hacer algo al intentar hacerle eso.

La issubclass(sub, sup)función booleana devuelve verdadero si la subclase dada subes de hecho una subclase de la superclase sup.

issubclass ejemplo ejecutable mínimo

Aquí hay un ejemplo más completo con algunas afirmaciones:

#!/usr/bin/env python3

class Base:
    pass

class Derived(Base):
    pass

base = Base()
derived = Derived()

# Basic usage.
assert issubclass(Derived, Base)
assert not issubclass(Base, Derived)

# True for same object.
assert issubclass(Base, Base)

# Cannot use object of class.
try:
    issubclass(derived, Base)
except TypeError:
    pass
else:
    assert False

# Do this instead.
assert isinstance(derived, Base)

GitHub aguas arriba .

Probado en Python 3.5.2.

Puede usar la subclase incorporada. Pero la verificación de tipos generalmente se considera innecesaria porque puede usar la escritura de pato.

Usar issubclass parecía una forma limpia de escribir loglevels. Se siente un poco extraño usarlo ... pero parece más limpio que otras opciones.

class Error(object): pass
class Warn(Error): pass
class Info(Warn): pass
class Debug(Info): pass

class Logger():
    LEVEL = Info

    @staticmethod
    def log(text,level):
        if issubclass(Logger.LEVEL,level):
            print(text)
    @staticmethod
    def debug(text):
        Logger.log(text,Debug)   
    @staticmethod
    def info(text):
        Logger.log(text,Info)
    @staticmethod
    def warn(text):
        Logger.log(text,Warn)
    @staticmethod
    def error(text):
        Logger.log(text,Error)

Según el documento de Python , también podemos usar el class.__mro__atributo o el class.mro()método:

class Suit:
    pass
class Heart(Suit):
    pass
class Spade(Suit):
    pass
class Diamond(Suit):
    pass
class Club(Suit):
    pass

>>> Heart.mro()
[<class '__main__.Heart'>, <class '__main__.Suit'>, <class 'object'>]
>>> Heart.__mro__
(<class '__main__.Heart'>, <class '__main__.Suit'>, <class 'object'>)

Suit in Heart.mro()  # True
object in Heart.__mro__  # True
Spade in Heart.mro()  # False

#issubclass(child,parent)

class a:
    pass
class b(a):
    pass
class c(b):
    pass

print(issubclass(c,b))#it returns true