Bagaimana cara saya memeriksa (saat runtime) jika satu kelas adalah subkelas dari yang lain?

Katakanlah saya memiliki Suit kelas dan empat subclass suit: Heart, Spade, Diamond, Club.

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

Saya memiliki metode yang menerima setelan sebagai parameter, yang merupakan objek kelas, bukan instance. Lebih tepatnya, itu mungkin hanya menerima satu dari empat nilai: Heart, Spade, Diamond, Club. Bagaimana saya bisa membuat pernyataan yang memastikan hal seperti itu? Sesuatu seperti:

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

Saya menggunakan Python 3.

Anda bisa menggunakan issubclass()seperti ini assert issubclass(suit, Suit).

issubclass(class, classinfo)

Kutipan:

Mengembalikan true jika classadalah subclass (langsung, tidak langsung atau virtual) dari classinfo.

Anda dapat menggunakan isinstancejika Anda memiliki instance, atau issubclassjika Anda memiliki kelas. Biasanya berpikir itu ide yang buruk. Biasanya dalam Python Anda bekerja jika suatu objek mampu melakukan sesuatu dengan mencoba melakukan hal itu padanya.

Fungsi issubclass(sub, sup)boolean mengembalikan true jika subclass yang diberikan submemang merupakan subclass dari superclass sup.

issubclass contoh runnable minimal

Berikut adalah contoh yang lebih lengkap dengan beberapa pernyataan:

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

Diuji dalam Python 3.5.2.

Anda bisa menggunakan builtin issubclass. Tetapi pengecekan tipe biasanya dianggap tidak perlu karena Anda bisa menggunakan bebek-mengetik.

Menggunakan issubclass sepertinya cara yang bersih untuk menulis loglevels. Agak terasa aneh menggunakannya ... tapi sepertinya lebih bersih daripada opsi lain.

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)

Menurut dokumen Python , kita juga bisa menggunakan class.__mro__atribut atau class.mro()metode:

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