Wie überprüfe ich (zur Laufzeit), ob eine Klasse eine Unterklasse einer anderen ist?

Nehmen wir an, ich habe einen Klassenanzug und vier Unterklassen von Anzügen: Herz, Spaten, Diamant, Verein.

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

Ich habe eine Methode, die eine Farbe als Parameter erhält, die ein Klassenobjekt ist, keine Instanz. Genauer gesagt kann es nur einen der vier Werte erhalten: Herz, Spaten, Diamant, Verein. Wie kann ich eine Aussage machen, die so etwas gewährleistet? Etwas wie:

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

Ich benutze Python 3.

Sie können verwendet werden, issubclass()wie diese assert issubclass(suit, Suit).

issubclass(class, classinfo)

Auszug:

Geben Sie true zurück, wenn classes sich um eine Unterklasse (direkt, indirekt oder virtuell) von handelt classinfo.

Sie können verwenden, isinstancewenn Sie eine Instanz haben oder issubclasswenn Sie eine Klasse haben. Normalerweise dachte es ist eine schlechte Idee. Normalerweise ermitteln Sie in Python, ob ein Objekt zu etwas fähig ist, indem Sie versuchen, das zu tun.

Die issubclass(sub, sup)boolesche Funktion gibt true zurück, wenn die angegebene Unterklasse subtatsächlich eine Unterklasse der Oberklasse ist sup.

issubclass minimales lauffähiges Beispiel

Hier ist ein vollständigeres Beispiel mit einigen Behauptungen:

#!/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 stromaufwärts .

Getestet in Python 3.5.2.

Sie können die integrierte issubclass verwenden. Die Typprüfung wird jedoch normalerweise als unnötig angesehen, da Sie die Ententypisierung verwenden können.

Die Verwendung von issubclass schien eine saubere Möglichkeit zu sein, Googlevels zu schreiben. Es fühlt sich irgendwie seltsam an, es zu benutzen ... aber es scheint sauberer als andere Optionen.

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)

Laut Python-Dokument können wir auch class.__mro__Attribute oder class.mro()Methoden verwenden:

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