Jak sprawdzić (w czasie wykonywania), czy jedna klasa jest podklasą innej?

Powiedzmy, że mam garnitur klasy i cztery podklasy garnituru: Serce, Szpadel, Diament, Klub.

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

Mam metodę, która odbiera kolor jako parametr, który jest obiektem klasy, a nie instancją. Dokładniej, może otrzymać tylko jedną z czterech wartości: Serce, Szpadel, Diament, Klub. Jak mogę złożyć twierdzenie, które zapewni takie rozwiązanie? Coś jak:

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

Używam Python 3.

Możesz użyć w issubclass()ten sposób assert issubclass(suit, Suit).

issubclass(class, classinfo)

Fragment:

Zwraca true, jeśli classjest podklasą (bezpośrednią, pośrednią lub wirtualną) dla classinfo.

Możesz użyć, isinstancejeśli masz instancję lub issubclassklasę. Zwykle uważał to za zły pomysł. Zwykle w Pythonie sprawdzasz, czy obiekt jest zdolny do czegoś, próbując to zrobić.

Funkcja issubclass(sub, sup)boolowska zwraca true, jeśli podklasa subjest rzeczywiście podklasą nadklasy sup.

issubclass minimalny możliwy do uruchomienia przykład

Oto bardziej kompletny przykład z pewnymi twierdzeniami:

#!/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 w górę .

Testowane w języku Python 3.5.2.

Możesz użyć wbudowanej podklasy. Ale sprawdzanie typu jest zwykle postrzegane jako niepotrzebne, ponieważ można używać pisania kaczego.

Korzystanie z Issubclass wydawało się czystym sposobem pisania loglevels. To trochę dziwne, używając go ... ale wydaje się czystsze niż inne opcje.

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)

Zgodnie z dokumentacją Pythona możemy również użyć class.__mro__atrybutu lub class.mro()metody:

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