[Article] Héritage simple, héritage multiple et métaclasse

Version imprimable

10/10/2015, 19h37
deusyss

[Article] Héritage simple, héritage multiple et métaclasse

Bonjour à tous,

Je vous propose un article concernant l'héritage simple, l'héritage multiple et les métaclasses en Python.

Bonne lecture a tous :D
11/10/2015, 07h45
tyrtamos

Bonjour,

Très intéressant, merci!
11/10/2015, 09h13
deusyss

De rien, heureux que ça plaise :)
11/10/2015, 11h12
cervo

:salut:

Merci ! super doc
12/10/2015, 07h43
deusyss

Un heureux de plus :ccool:

Amélioration du cour sur les héritages et classes Python

Bonjour :-)

J'ai un complément à demander pour intégration au cour «Concepts avancés Python» qui me semble important dans la section «Héritage simple, héritage multiple et métaclasses».

En effet il manque une partie sur les classes proxy Python.
Genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class A:
def __init__(self, mon_paramètreA):
    self.ma_propriétéA = mon_paramètreA
 
    def maMéthodeA(self):
        pass
 
 
class B:
   def __init__(self, mon_paramètreB):
         self.ma_propriétéB = mon_paramètreB
 
        def maMéthodeB(self):
         pass 
 
 
class Proxy:
     def __new__(cls, mon_paramètre):
         if mon_paramètre == 'valeur1':
             return A(mon_paramètre)
        if mon_paramètre == 'valeur2':
             return B(mon_paramètre)

Et sur l'héritage conditionnel.
Genre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class A:
     def __init__(self, mon_paramètreA):
         self.ma_propriétéA = mon_paramètreA 
 
    def maMéthodeA(self):
         pass 
 
 
class ProxyHeritage:
     def __new__(cls, mon_paramètre):
         class B(A if mon_paramètre == 'Valeur' else object):
             def __init__(self, mon_paramètreB):
                 self.ma_propriétéB = mon_paramètreB 
 
            def maMéthodeB(self):
                 pass 
 
        return B(mon_paramètre)

Je construis moi même un cours open source dédié à la programmation Python pour l'administrateur systèmes.
voir mon site du cour,
Avec le site source en cour de rédaction.

13/10/2021, 18h08
wiztricks

Salut,

Héritage simple, multiple et metaclass sont mis en œuvre spécifiquement avec Python (on fait un peu autrement avec les autres langage).
Ce que vous appelez "proxy" ressemble étrangement au pattern factory de la POO. Et les patterns sont indépendant du langage objet utilisé (il n'y a rien de spécifique à Python là dedans).

- W
13/10/2021, 18h20
sefran007

Citation:

Envoyé par wiztricks

Salut,

Héritage simple, multiple et metaclass sont mis en œuvre spécifiquement avec Python (on fait un peu autrement avec les autres langage).
Ce que vous appelez "proxy" ressemble étrangement au pattern factory de la POO. Et les patterns sont indépendant du langage objet utilisé (il n'y a rien de spécifique à Python là dedans).

- W

Bonjour :-)

C'est juste une demande pour aider les programmeurs.
Parce que personnellement j'ai été confronté à ces difficultés il y a quelques années après avoir suivi ce cour sur Python, et je pense que ces deux concept sont important pour le développement objets avec Python :-)

Ils ne sont que trop rarement dans les cours objets sur Python…
13/10/2021, 18h46
wiztricks

Citation:

Envoyé par sefran007

Ils ne sont que trop rarement dans les cours objets sur Python…

Je ne vois pas l'intérêt de faire un cours sur les patterns de la POO avec Python.
Il est préférable de comprendre les "patterns" et voir combien nombre d'entre eux sont inutiles avec Python (et il y a déjà des tutos. à ce sujet mais il faut avoir fait l'étape POO/Patterns avant).

- W

Bon j'ai trouvé une solution encore plus élégante pour faire des héritages conditionnels, avec en plus la possibilité de filtrer les méthodes de classe à l'héritage (la méthode super() permettant de filtrer les propriétés de classes).

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
class Base(object):
    def bad_function(self):
        print("OK pour la fonction bad_function dans la classe %s" % self.__class__)
    def good_function(self):
        print("OK pour la fonction good_fonction dans la classe %s" % self.__class__)
 
class Child(Base):
    def __init__(self, paramètreChild=False, banieméthodes=[]):
        parent = Base
        class new_parent(parent.__base__):
            pass
        parent_list = dir(parent)
        new_parent_list = dir(new_parent)
        candidates = set(parent_list) - set(new_parent_list)
        if paramètreChild:
            for candidate in candidates:
                if candidate not in banieméthodes:
                    setattr(new_parent, candidate, parent.__getattribute__(parent, candidate))
        Child.__bases__ = (new_parent, )
 
 
class Finale(Child):
    def __init__(self, paramètreFinal=False, options=[]):
        if paramètreFinal:
            if options == []:
                super().__init__(paramètreFinal)
            else:
                super().__init__(paramètreFinal, options)
        elif options != []:
            super().__init__(True, banieméthodes=options)
        else:
            super().__init__()
 
 
print('Finale()')
c = Finale()
try:
    c.bad_function()
except AttributeError:
    print("fonction bad_function supprimée!")
try:
    c.good_function()
except AttributeError:
    print("fonction good_function supprimée!")
print('Finale(True)')
c = Finale(True)
try:
    c.bad_function()
except AttributeError:
    print("fonction bad_function supprimée!")
try:
    c.good_function()
except AttributeError:
    print("fonction good_function supprimée!")
print('Finale(options=[\'bad_function\'])')
c = Finale(options=['bad_function'])
try:
    c.bad_function()
except AttributeError:
    print("fonction bad_function supprimée!")
try:
    c.good_function()
except AttributeError:
    print("fonction good_function supprimée!")
b = Base()
b.bad_function()

Voilà un code plus propre pour l'héritage conditionnel de classes, qui ne perturbe plus les héritages en cascade conditionnels et la syntaxe normale des classes Python.

J'espère que ces commentaires pourront aider un développeur débutant, ou plus ingénieur systèmes comme moi :D

14/10/2021, 12h08
wiztricks

Citation:

Envoyé par sefran007

J'espère que ces commentaires pourront aider un développeur débutant, ou plus ingénieur systèmes comme moi :D

A priori, une classe sert à fabriquer des objets semblables (qui ont les mêmes attributs).
Ce que vous faites est juste un bricolage infâme: vous feriez mieux d'ouvrir une discussion pour décrire le problème que vous cherchez à résoudre.

- W
15/10/2021, 12h52
popo

Citation:

Envoyé par wiztricks

A priori, une classe sert à fabriquer des objets semblables (qui ont les mêmes attributs).
Ce que vous faites est juste un bricolage infâme: vous feriez mieux d'ouvrir une discussion pour décrire le problème que vous cherchez à résoudre.

- W

Bonjour,

Etant novice en Python, et plutôt habitué à des langages comme .Net, c'est la première fois je je croise la notion d'héritage conditionnel.

J'ai vu que le dernier code posté sefran007 ne vous plait pas du tout.
De ce que j'en comprends, je suis plutôt d'accord

Mais quid de la forme suivante que j'ai également pu voir ailleurs ?
class B(A if mon_paramètre == 'Valeur' else object)

Comme je l'ai dit cette notion est totalement nouvelle pour moi et j'ai énormément de mal à comprendre en quelle occasion il faudrait l'utiliser.
Est-ce que c'est une pratique courante ?
Dans quel cas de figure doit-on l'utiliser ?
15/10/2021, 14h18
wiztricks

Salut,

Citation:

Envoyé par popo

Mais quid de la forme suivante que j'ai également pu voir ailleurs ?
class B(A if mon_paramètre == 'Valeur' else object)

Ici, la classe B hérite conditionnellement de A ou d'object.

Reste à voir la motivation qu'il y a derrière... et en quoi çà va être utile d'avoir un b (= B()) qui soit ou pas instance de A. C'est pas parce qu'on peut que ça à plus de sens que de le faire autrement de façon "plus orthodoxe".

Mais ça demande de connaître le problème qu'on cherche à résoudre et faire un arbitrage des avantages/inconvénients entre différentes solutions... en allant un peu plus loin que l'aspect fonctionnel (çà marche) pour intégrer des critères non-techniques.

Normalement, un code devrait être revu par un pair qui va poser des questions, maintenu par d'autres personnes que le développeur qui auront de la peine à toucher un code qu'ils ne comprennent pas, sans parler de documenter, tester...

C'est vrai que dans la vraie vie, le programmeur Python est plutôt solitaire et peut programmer correctement ou fabriquer un code qui ne sera pas maintenable lorsqu'il changera de boulot. C'est dommage pour la boîte qui l'emploie mais "logique" dans une société où on veut aller vite au résultat en minimisant l'effort à faire pour l'obtenir.

- W