Quelle méthode est appelée lors du print d'une classe ?

Version imprimable

22/04/2020, 11h55
lg_53

Quelle méthode est appelée lors du print d'une classe ?
Bonjour à tous

Petite question (j'ère sur la toile depuis pas mal de temps et je ne trouve pas la moindre piste ...) : Lorsque j'ai une classe, quelle méthode est appelée lorsque je print cette classe ? Je dit bien la classe (et pas une instance de cette classe).

Le but serait de faire qqch comme ceci :
Code:

1 2 3 4 5 6 7 8 def MakeClass(clsname): class Class(): name = clsname return Class X = MakeClass('X') print(X)
mais où print(X) me renverrai qqch contenant le nom donné en paramètre de la factory (ici 'X'), plutôt que :

Code:

<class '__main__.MakeClass.<locals>.Class'>

qui ne permet pas de faire la différence entre 2 classes différentes fabriquées avec cette même factory.

J'ai vu des choses comme ca aussi sur la toile :
Code:

1 2 3 4 5 6 7 8 def MakeClass(clsname): class Class(): pass Class.__name__ = clsname return Class X = MakeClass('X') print(X)
mais bon à part définir un nouvel attribut (que ce soit name ou __name__) ça ne change manifestement pas grand chose puisque lorsqu'on fait print(X) ces attributs ne semblent pas utilisés.

Merci

Bonne journée
22/04/2020, 13h10
Sve@r
Bonjour
Citation:
Envoyé par lg_53

J'ai vu des choses comme ca aussi sur la toile :

Code:

1 2 3 4 5 6 7 8 def MakeClass(clsname): class Class(): pass Class.__name__ = clsname return Class X = MakeClass('X') print(X)

mais bon à part définir un nouvel attribut (que ce soit name ou __name__) ça ne change manifestement pas grand chose puisque lorsqu'on fait print(X) ces attributs ne semblent pas utilisés.
En utilisant cet exemple, ça marche si tu fais print(X.__name__). Sinon moi non plus je n'y arrive pas.
22/04/2020, 14h12
lg_53

Citation:

Envoyé par Sve@r

ça marche si tu fais print(X.__name__)

Ca c'est sûr ! Mais ça ne répond pas forcément au besoin.
Moi je me dis qu'il doit bien avoir une méthode, à la manière de __str__ mais pour la classe, méthode que je pourrais surcharger... mais impossible de savoir ce qu'il y a derrière ça :(

Il y a str et repr:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> class A:
	def __str__(self): return "str"
	def __repr__(self): return "repr"
 
 
>>> A() # retourne le rep
repr
>>> print(A()) # retourne le str
str
>>> f"{A()}" # retourne str
'str'
>>> f"{A()!r}" # retourne repr
'repr'

edit: lu un peu vite la question :aie:
tu peux toujours utiliser qualname

Code:

1
2
3
4
5
>>> class B: pass
 
>>> B.__qualname__ = "foo"
>>> B
<class '__main__.foo'>

22/04/2020, 14h57
wiztricks

Salut,

Citation:

Envoyé par lg_53

Lorsque j'ai une classe, quelle méthode est appelée lorsque je print cette classe ?

Lorsqu'il s'agit d'une instance, c'est la méthode __str__ qui est appelée (si elle existe).
Lorsqu'il s'agit d'une classe, ce sera la méthode __str__ de la metaclass (qui par défaut est "type"). Et pour changer çà, il faut fabriquer la class à partir d'une metaclass ou on définit son __str__.

- W

Merci les gars !

Citation:

Envoyé par flapili

edit: lu un peu vite la question :aie:
tu peux toujours utiliser qualname

Oui je m'en doutais que qqn tomberait dans ce panneau :aie:, c'est pour ça que dans mon 1er post j'ai bien précisé

Citation:

Envoyé par lg_53

Je dit bien la classe (et pas une instance de cette classe)

mais bon t'es entièrement pardonné puisque __qualname__ fournit une solution.

Ceci dit je ne sais pas si c'est très bon de toucher à ça, donc j'examine aussi la solution de Wiztricks.

Premier script auquel j'aboutis après des lectures sur les métaclasses qui m'ont bien instruites.
Je regarde aussi ce que donne la __mro__, ainsi que la représentation d'une instance pour voir.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MetaType(type):
    def __repr__(self):
        return super().__repr__().replace('NewClass',self.name)
 
def MakeClass(clsname):
    class NewClass(metaclass=MetaType):
        name = clsname
 
        def __repr__(self):  ### For instance of X
            return super().__repr__().replace('NewClass',self.name)
 
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK

Là je tape sur un attribut "maison" nommé name. Je me dis du coup, pourquoi ne pas redéfinir __name__ de la même manière ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MetaType(type):
    def __repr__(self):
        return super().__repr__().replace('NewClass',self.__name__)
 
def MakeClass(clsname): 
    class NewClass(metaclass=MetaType):
        __name__ = clsname
 
        def __repr__(self):  ### For instance of X
            return super().__repr__().replace('NewClass',self.__name__)
 
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### KO
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### KO

Là ça ne fonctionne plus. Mais j'avais trouvé des personnes qui avait mis cette définition en dehors de la classe, après coup, peut être que ça change qqch :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MetaType(type):
    def __repr__(self):
        return super().__repr__().replace('NewClass',self.__name__)
 
def MakeClass(clsname): 
    class NewClass(metaclass=MetaType):
        def __repr__(self):  ### For instance of X
            return super().__repr__().replace('NewClass',self.__class__.__name__)
 
    NewClass.__name__ = clsname
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK

Alors oui ça change qqch, car là ça produit le résultat escompté ! Là je ne comprends pas pourquoi ...
Par contre si je tape sur __qualname__, là je peux le définir où je veux ça ne change rien :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def MakeClass(clsname): 
    class NewClass():
        pass
 
#    NewClass.__qualname__ = clsname
    NewClass.__qualname__ = NewClass.__qualname__.replace('NewClass',clsname)
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK
 
def MakeClass(clsname): 
    class NewClass():
#        __qualname__ = clsname
        __qualname__ = __qualname__.replace('NewClass',clsname)
 
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK

et je peux même au passage m'affranchir de la définition de __repr__ pour les instances de NewClass.

Pour essayer de voir ce qui se passe de différent entre __name__ et __qualname__, j'essaie d'intercepter les attributs de classer demandés :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MetaType(type):
    def __getattribute__(self, name):
        if name != '__class__' :
            print('Get... ', name)
        return super().__getattribute__(name)
 
def MakeClass(clsname): 
    class Class(metaclass=MetaType7):
          pass
 
    return Class
 
 
X = MakeClass('X')
print(X)
print(X())
print('qualname : ',X.__qualname__)
print(X.__mro__)

Là on voit que printer X appelle __qualname__ !
De même printer on voit que printer X.__mro__ appelle __qualname__ !
Et l'affichage d'uns instance de X, elle tire sur la __mro__, donc ça expliquerait pourquoi je n'ai plus besoin de surcharger __repr__ pour les instances, lorsque je modifie directement __qualname__.

Donc ça explique une partie de mes interrogations. Par contre reste en suspend :
Pourquoi mettre __name__ = ... dans la classe ne fait pas pareil que de le définir après coup en dehors de la classe ?

Modifier __qualname__ me parait être la solution la plus simple et efficace, je ne parviens pas à trouve d'avantages à ta solution Wiztricks. Si tu en as, je suis preneur.

Merci les gars pour ce bon aprem de réflexion sur le sujet que vous m'avez donné.

Pour ceux qui veulent tester, je vous met tout les bout de code présentés ici en 1 seul bloc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
print('==========(1)===========')
class MetaType(type):
    def __repr__(self):
        return super().__repr__().replace('NewClass',self.name)
 
def MakeClass(clsname):
    class NewClass(metaclass=MetaType):
        name = clsname
 
        def __repr__(self):  ### For instance of X
            return super().__repr__().replace('NewClass',self.name)
 
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK
 
print('==========(2)===========')
class MetaType(type):
    def __repr__(self):
        return super().__repr__().replace('NewClass',self.__name__)
 
def MakeClass(clsname): 
    class NewClass(metaclass=MetaType):
        __name__ = clsname
 
        def __repr__(self):  ### For instance of X
            return super().__repr__().replace('NewClass',self.__name__)
 
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### KO
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### KO
 
 
print('==========(3)===========')
class MetaType(type):
    def __repr__(self):
        return super().__repr__().replace('NewClass',self.__name__)
 
def MakeClass(clsname): 
    class NewClass(metaclass=MetaType):
        def __repr__(self):  ### For instance of X
            return super().__repr__().replace('NewClass',self.__class__.__name__)
 
    NewClass.__name__ = clsname
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK
 
 
 
print('==========(4)===========')
def MakeClass(clsname): 
    class NewClass():
        pass
 
#    NewClass.__qualname__ = clsname
    NewClass.__qualname__ = NewClass.__qualname__.replace('NewClass',clsname)
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK
 
print('==========(5)===========')
def MakeClass(clsname): 
    class NewClass():
#        __qualname__ = clsname
        __qualname__ = __qualname__.replace('NewClass',clsname)
 
    return NewClass
 
X = MakeClass('XXXX')
print(X)    ### OK
print(X())  ### OK
print('qualname : ',X.__qualname__)
print(X.__mro__)  ### OK

22/04/2020, 19h39
wiztricks
Salut,

Citation:

Envoyé par lg_53

Ceci dit je ne sais pas si c'est très bon de toucher à ça, donc j'examine aussi la solution de Wiztricks.

J'ai proposé une solution à la question initiale:

Citation:

Lorsque j'ai une classe, quelle méthode est appelée lorsque je print cette classe ?

Mais j'ai l'impression que la question est devenu comment fabriquer "dynamiquement" une classe avec le __name__ qu'on veut.
Ma suggestion est: si on fabrique la classe "dynamiquement", on passe par type et pas par "class" machin qu'on rame à bricoler:
Code:

1 2 3 4 5 def MakeClass(name): return type(name, (), {}) X = MakeClass('X') print(X)
- W