classes_dynamiques.py

import sys

# Classes créée dynamiquement
AutreNomYolo = type('Yolo', (), {'__str__': lambda: 'salut'})
AutreNomYolo2 = type('Yolo', (), {'__str__': lambda: 'degage'})
type('Yolo', (), {'__str__': lambda: 'salut'})  # garbage collector direct ? comment appeler la classe par son __name__
# car je pourrais stocker l'objet dans une liste etc..
list_obj = [None, None]
list_obj[1] = type('Yolo', (), {'__str__': lambda: 'salut'})
print(AutreNomYolo.__str__())
print(AutreNomYolo.__name__)
print('\n')
print(AutreNomYolo2.__str__())
print(AutreNomYolo2.__name__)  # apparement pas grave d'avoir 2 classes avec le mm nom mais pas mm méthodes..


def mere_de_toutes_les_classes():
    return

# faut foutre ca dans un dico
noms_de_classes = ['Bidule', 'Trucmuche', 'Tartarine']
dico_imports = {nom: type(nom, (), {'__str__': lambda: 'ds un dico'})for nom in noms_de_classes}

# mais c'est tjr pas un véritable import, normal
# {nom: type(nom, (), {'__str__': lambda: 'ds un dico'})for nom in noms_de_classes}

current_module = module = sys.modules[__name__]

# La solution finale (achtung!)
[setattr(current_module, nom, type(nom, (), {'fake_str': lambda self: f' methode INSTANCE'})) for nom in noms_de_classes]


setattr(current_module, 'LeNom', type('Yolo', (), {'__str__': lambda self: 'salut'}))
print("ClassLENOM", LeNom)  # pas de surcharge du __str__ de la classe
print("Instance LENOM", LeNom())  # mais de l'instance

# surcharge des méthodes via l'instance
inst_bidul = Bidule()
print(inst_bidul.fake_str())
inst_bidul.fake_str = lambda: f"autre chose"  # pas besoin du self car je suis sur une instance..
inst_bidul.fake_str2 = lambda: f"autre chose2"
print(inst_bidul.fake_str())
print(inst_bidul.fake_str2())

# surcharge des méthode via la classe
Bidule.__str__ = lambda self: f"{self.__class__.__name__}  CLASSE"  # quand tu met self tout court dans la fstring, ca appelle __str__()..
print(Bidule())
print(Bidule().fake_str())

# surcharger le str de la classe: la méthode str appelée sur une classe provient de la metaclasse, donc type
# il faut donc surcharger type, et sa méthode str
class MetaSoeur(type):
    def __str__(self):
        return f"{super().__str__()} Kalash"


class KlassStr(metaclass=MetaSoeur):
    pass

KlassStr2 = MetaSoeur('KlassStr2', (), {})

print(KlassStr)
print(KlassStr2)