Comment puis-je vérifier (au moment de l'exécution) si une classe est une sous-classe d'une autre?

Disons que j'ai un costume de classe et quatre sous-classes de costume: Heart, Spade, Diamond, Club.

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

J'ai une méthode qui reçoit un costume comme paramètre, qui est un objet de classe, pas une instance. Plus précisément, il ne peut recevoir qu'une seule des quatre valeurs: Coeur, Bêche, Diamant, Club. Comment puis-je faire une affirmation qui assure une telle chose? Quelque chose comme:

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

J'utilise Python 3.

Vous pouvez utiliser issubclass()comme ça assert issubclass(suit, Suit).

issubclass(class, classinfo)

Extrait:

Renvoie vrai si classest une sous-classe (directe, indirecte ou virtuelle) de classinfo.

Vous pouvez utiliser isinstancesi vous avez une instance ou issubclasssi vous avez une classe. Normalement, je pensais que c'était une mauvaise idée. Normalement, en Python, vous déterminez si un objet est capable de quelque chose en essayant de lui faire cette chose.

La issubclass(sub, sup)fonction booléenne renvoie true si la sous sub- classe donnée est en effet une sous-classe de la superclasse sup.

issubclass exemple exécutable minimal

Voici un exemple plus complet avec quelques assertions:

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

Testé en Python 3.5.2.

Vous pouvez utiliser la sous-classe intégrée. Mais la vérification de type est généralement considérée comme inutile car vous pouvez utiliser la frappe de canard.

Utiliser issubclass semblait être un moyen propre d'écrire des niveaux de journal. Cela semble un peu étrange de l'utiliser ... mais il semble plus propre que les autres options.

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)

Selon le document Python , nous pouvons également utiliser un class.__mro__attribut ou une class.mro()méthode:

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