Bir sınıfın diğerinin alt sınıfı olup olmadığını nasıl kontrol edebilirim (çalışma zamanında)?

Diyelim ki bir takım elbisem ve dört takım elbisem var: Heart, Spade, Diamond, Club.

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

Bir örnek, bir sınıf nesnesi olan bir parametre olarak bir takım alır bir yöntem var. Daha doğrusu, dört değerden sadece birini alabilir: Kalp, Maça, Elmas, Kulüp. Böyle bir şeyi sağlayan bir iddiayı nasıl yapabilirim? Gibi bir şey:

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

Python 3 kullanıyorum.

Sen kullanabilirsiniz issubclass()böyle assert issubclass(suit, Suit).

issubclass(class, classinfo)

Alıntı:

Öğesinin classalt sınıfı (doğrudan, dolaylı veya sanal) ise true döndür classinfo.

Sen kullanabilirsiniz isinstanceEğer bir örneğini varsa ya issubclasssen bir sınıf varsa. Normalde bunun kötü bir fikir olduğunu düşündüm. Normalde Python'da, bir nesne bu şeyi yapmaya çalışarak bir şey yapabiliyorsa çalışırsınız.

issubclass(sub, sup)Verilen alt sınıf ise boole fonksiyonu true döndürür subgerçekten üst sınıf bir alt sınıfıdır sup.

issubclass minimal çalıştırılabilir örnek

İşte bazı iddialarla daha eksiksiz bir örnek:

#!/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 akış yukarı .

Python 3.5.2'de test edilmiştir.

Yerleşik issubclass'ı kullanabilirsiniz. Ancak yazım denetimini kullanabileceğiniz için tür denetimi genellikle gereksiz olarak görülür.

İssubclass kullanmak loglevels yazmak için temiz bir yol gibi görünüyordu. Bunu kullanmak biraz garip geliyor ... ama diğer seçeneklerden daha temiz görünüyor.

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)

Göre Python doc , biz de kullanabilir class.__mro__Özellik veya class.mro()yöntem:

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