Surcharger une méthode spéciale d'une class créée dynamiquement

Version imprimable

Bonjour,

J'essaie de créer une classe dynamiquement à l'aide de la class type

Code:

1
2
 
Test = type("Personne",(),method

code de la class

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
"""
@author: Battant
 
"""
 
 
 
from Personne import *
 
def créer_personne (personne, nom, prenom, age) :
    personne.nom = nom
    personne.prenom = prenom
    personne.age = age
 
def présenter_personne (personne) :
    print ("prénom : {} \n prénom : {} \n âge : []" \
           .format(personne.prenom,personne.nom,personne.age))
 
method = {
            "__init__" :"créer,personne",
            "__repr__":"présenter_personne",

Class Personne :

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
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: Battant
 
"""
 
class Personne :
    """ claase représentant une personne issus du cours 
    """
    def __new__ (cls, nom, prénom, age) :
        print ("Appel de la méthode __new__ de la classe".format(cls))
        return object.__new__(cls)	
 
 
    def __init__ (self, nom,prénom, age) :
        self.nom = nom
        self.prénom = prénom
        self.age = age
        self._lieu = "orbe"
 
 
    def __repr__(self):
        """Quand on entre notre objet dans l'interpréteur
                affiche les information sur l'objet sous forme de chaine de caractèree 
  """
        return "Personne : nom : nom( {} ), prénome : prénom ( {} ), age : age( {} ) lieu : lieu( {} )" \
.format (self.nom,self.prénom,self.age,self.lieu)
 
    def __str__(self):
        """Quand on entre notre objet dans l'interpréteur
        affiche les information sur l'objet sous forme de chaine de caractère
            """
            #return "Personne: nom({}), prénom({}), âge({})".format(
         #       self.nom, self.prenom, self.age)
        return ("Personne : nom : nom({}), prénome : prénom({}), age : age({}) lieu : lieu({})" \
		 .format (
				self.nom,self.prénom,self.age,self.lieu))
 
 
    def _get_lieu (self) :
      return self._lieu
 
    def _set_lieu (self,nouveauLieu) :
        print ("Il semble que : {} déménage à {}".format(self.prénom,nouveauLieu))
        self._lieu = nouveauLieu
 
 
    lieu = property(_get_lieu,_set_lieu)

Problème : malgré la surcharge de la méthode spéciale __repr__ dans la définition de la class instanciée dynamiquement, la méthode __repr__ définie n'est pas appelée a la place il y a :

Code:

1
2
3
4
5
6
 
from test_personne import *
>>> test = type("Personne ",(object,),method)
>>> test
<class '__main__.Personne '>
>>>

Question :

1. Est-ce que les clas créée dynamiquement à l'aide de type ne se comporte pas la même chose que les clas normal et si oui pourqoi ?
2. Y'a-il vune façon de surcharger les méthode spécial ou nom avec des classe créée de cette manière

Merci pour votre support

Meilleures salutations

13/06/2017, 13h54
wiztricks
Salut,

Il faut faire les choses proprement et commencer par simplifier, car l'enfer est dans les détails:
Code:

1 2 3 4 5 6 7 >>> class A: ... def __repr__(self): ... return 'coucou' ... >>> A() coucou >>>
Maintenant on définit la "méthode":
Code:

1 2 >>> def foo(self): return 'foo' ...
Puis l'espace de noms associé à la future classe:

Code:

>>> ns = {'__repr__': foo }

Et on vérifie que çà fonctionne:
Code:

1 2 3 >>> B = type('B', (A,), ns) >>> B() foo
- W

Bonjour,

ça n'a pas l'air de marcher chez moi

J'ai mis :
Code:

1 2 3 4 5 6 7 8 def reprtest (): return "test réussit methode = { "__init__" :"créer,personne", '__repr__': "reprtest" }
et pour tester :
Code:

1 2 3 test = type("Personne ",(object,),methode) test
Le résultat est ;
Code:

1 2 3 test <class '__main__.Personne '>
Avez-vous une idée pourquoi ça ne marche pas ?

Merci pour votre support

Salutations

13/06/2017, 22h20
wiztricks
Citation:

Envoyé par Battant

Avez-vous une idée pourquoi ça ne marche pas ?

Si vous écrivez:
Code:

1 2 3 4 5 from test_personne import * >>> test = type("Personne ",(object,),method) >>> test <class '__main__.Personne '> >>>
vous confondez la classe "test" avec une instance de cette classe (qui s'écrit "test()"). Et le __repr__ appelé sera celui correspondant à la classe et non celui que vous avez défini.
Vous pouvez le vérifiez avec une construction plus simple:
Code:

1 2 3 4 5 6 7 8 9 >>> class A: ... def __repr__(self): ... return "coucou" ... >>> A <class '__main__.A'> >>> A() coucou >>>
Cela corrigé, çà va se vautrer un peu plus loin...

Je vous ai proposé une construction qui fonctionne, à vous de l'étudiez pour essayer de comprendre ce qui cloche dans votre code.

- W