Come posso verificare (in fase di esecuzione) se una classe è una sottoclasse di un'altra?

Diciamo che ho un seme di classe e quattro sottoclassi di seme: Heart, Spade, Diamond, Club.

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

Ho un metodo che riceve un seme come parametro, che è un oggetto di classe, non un'istanza. Più precisamente, può ricevere solo uno dei quattro valori: Heart, Spade, Diamond, Club. Come posso fare un'affermazione che garantisca una cosa del genere? Qualcosa di simile a:

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

Sto usando Python 3.

Puoi usare issubclass()così assert issubclass(suit, Suit).

issubclass(class, classinfo)

Estratto:

Restituisce vero se classè una sottoclasse (diretta, indiretta o virtuale) di classinfo.

Puoi usare isinstancese hai un'istanza o issubclassse hai una classe. Normalmente ho pensato che fosse una cattiva idea. Normalmente in Python si capisce se un oggetto è capace di qualcosa tentando di fargli quella cosa.

La issubclass(sub, sup)funzione booleana ritorna vera se la sottoclasse data subè effettivamente una sottoclasse della superclasse sup.

issubclass esempio minimo eseguibile

Ecco un esempio più completo con alcune asserzioni:

#!/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 a monte .

Testato in Python 3.5.2.

È possibile utilizzare la issubclass integrata. Ma il controllo del tipo è di solito visto come inutile perché puoi usare la tipizzazione anatra.

L'uso di issubclass sembrava un modo chiaro per scrivere i livelli di Google. Sembra strano usarlo ... ma sembra più pulito di altre opzioni.

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)

Secondo il documento Python , possiamo anche usare l' class.__mro__attributo o il class.mro()metodo:

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