Discussion :

[areuh_fr]

Bonsoir,

En Java, il existe les classes abstraites. Une classe abstraite est une classe qui déclare des attributs et des methodes. Les classes enfants qui héritent de cette classe abstraite doivent obligatoirement posséder ces attributs et méthodes (en plus des leurs propres).
C'est le concept des classes abstraites >> vous confirmez? (j'ai pas fait de prog depuis des lustres).

ce concept de classes abstraites existe t il en Python? Quels st ses avantages.

je souhaite programmer une appli avec certains objets: des sous-marins et des torpilles qui ont exactement les mêmes caractéristiques (vitesse, braquage, sonar, etc, etc).
Dans mon cas les classes abstraites st elles réellement avantageuses?

Avez vous des liens qui en parlent svp?

Merci bien.
a+
areuh

[pacificator]

bonjour,

je te renvoie vers un HOWTO python ch III.3.3 :

III.3.3 Duck typing

L'idée du duck typing est que “If it looks like a duck and quacks like a duck, it must be a duck”, («si ça ressemble à un canard et que ça fait le bruit d'un canard, c'est sans doute un canard»). Le principe est qu'il suffit qu'un objet implémente les méthodes nécessaires à la réalisation d'une tâche (une interface au sens de Java) pour pouvoir les appeler. Il n'a pas besoin de dériver d'une classe de base qui matérialise cette interface. Concrètement, en programmation à la C++ ou à la Java, on ferait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class Shape:             # classe "abstraite" spécifiant une interface
    def area(self):
        raise NotImplementedError
 
class Rectangle(Shape):
    [...]
    def area(self):
        return self.width * self. height
 
class Circle(Shape):
    [...]
    def area(self):
        return self.radius * self.radius * 3.1416

Alors qu'en Python on peut simplement faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
>>> class Rectangle:
...     def area(self): return "rectangle area"
... 
>>> class Circle:
...     def area(self): return "cirle area"
... 
>>> for shape in [Rectangle(), Circle()]:
...     print shape.area()                 # appel polymorphe
... 
rectangle area
cirle area

Bonne continuation, bon python.

[areuh_fr]

Salut tlmd, Pacificator,

je viens de voir l'exemple. Je te le "traduis" afin que tu me dises si j'ai bien compris

2 classes définissent la même methode (area())

Grâce à une boucle for...in avec la clé shape (car shape est bien une clé?) tu fais appel à la méthode area() définie dans chacune des classes.

C'est bien ça?


En ce qui concerne ma question, j'ai dû mal m'exprimer.
Je donne un exemple concret

class soum01 avec un attribut: braquage= 45°
class soum02 avec un attribut: braquage= 90°
class torpille01 avec un attribut: braquage= 150°

Ces 3 classes ont un attribut identique mais avec des valeurs différentes: je définis dc 3 classes.
Ces 3 classes ont une méthode commune:
virage= vitesse/ braquage

Question: est ce que je dois définir la methode dans chaque classe ou y'a t il moyen de déclarer la methode 1 seule fois (dans une 4° classe, un simple script) et l'appeller à partir de là ou je veux?

Merci.
a+
areuh

[pacificator]

Dans l'exemple, shape represente a la premiere iteration un objet rectangle puis un objet cercle à la deuxieme, a chaque fois est appellée la methode area des objets.
Les objets ne sont pas des instances des mêmes classes mais grâce au duck typing, il est possible d'iterer sur eux, en appelant la methode qui porte le même nom dans les deux classes.
Je ne sais pas si je suis très clair..

Concernant ton problème, tu peux utiliser l'heritage, par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class Engin(object):
 
    def __init__(self, braquage=90):
 
        self.vitesse = 0
        self.braquage = braquage
 
    def virage(self):
        return 1. * self.vitesse / self.braquage
 
    def __repr__(self):
        retour = []
        retour.append("engin: %s" % self.__class__.__name__)
        [retour.append("%s: %s" % (k, v)) for k, v in self.__dict__.items()
		 if not k.startswith("_")]
        return "\n".join(retour)
 
 
class Sous_marin_alpha(Engin):
 
    def __init__(self, braquage):
        Engin.__init__(self, braquage)
 
class Sous_marin_bravo(Engin):
 
    def __init__(self, braquage):
        Engin.__init__(self, braquage)
 
    def lance_une_bombe_nucleaire(self):
        print "boum"
 
class Torpille(Engin):
 
    def __init__(self, braquage):
        Engin.__init__(self, braquage)
 
    def explose(self):
        print "Explosion !!!!!!"
 
if __name__ == "__main__":
 
    ssm1 = Sous_marin_alpha(braquage=45)
    ssm2 = Sous_marin_bravo(90)
    torp1 = Torpille(150)
    for vitesse in range(60, 121, 30):
        for engin in [ssm1, ssm2, torp1]:
            engin.vitesse = vitesse
            print 
            print engin
            print "virage: %f" % engin.virage()

si ton besoin est simple, tu peux directement créer des instances de Engin:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
ssm1 = Engin(braquage = 45)
ssm2 = Engin(90)
torp1 = Engin(150)

Tu peux aussi créer une classe Sous-marin qui herite de Engin dont heritent Sous_marin_alpha et Sous_marin_bravo.

- Engin
|
|-- Sous_marin
| |
| |-- Sous_marin_alpha
| |
| |-- Sous_marin_bravo
|
|-- Torpille

[mchk0123]

C'est le concept des classes abstraites >> vous confirmez? (j'ai pas fait de prog depuis des lustres).

Si je ne me trompes pas c'est plutôt la notion d'interface JAVA dans ton cas.

De toutes façon, sous Python, la question ne se pose pas dans ces termes.
(Si tu as des notions en templates C++, ça pourrait aider à comprendre).

Donc, sous JAVA, si tes classes filles oublient d'implémenter une méthode de ta classe d'interface, tu aura un message à la compilation.
Sous Python, la compilation passera, par contre à l'exécution, quand tu appellera par polymorphisme ta méthode, tu aura un joli message d'erreur.

Voilà pour les différences.

Maintenant si vraiment tu as besoin une vérification plus fine, sous Python tu peux trés bien recréer de toutes pieces un concept équivalent à la notion d'interface (via les AST ou un introspection) : tout est possible sous Python.

[areuh_fr]

Bonjour les gens,

Pacificator,
En ce qui concerne le duck typing, oui tu es clair. Ma traduction allait dans ton sens (un peu dans le brouillard et le vocabulaire en moins)

Ton bout de code par rapport aux sous-marins>>> faut que je ke potasse, je vais aller lire qques lignes sur la notion d'héritage.

mchk0123,
Oui, je me suis rendu compte de cette notion d'interface que je nommais classe abstraite. ça fait un sacré moment que j'avais pas touché à des classes et de tte manière lorsque j'etais dessus, j'en étais même pas à ce niveau là. Sans doute que j'essaye de brûler les étapes... ça va me jouer des tours.

Non je n'ai pas besoin d'une vérification plus fine. De toute manière je suis encore bien incapable d'ecrire une telle chose.

Je vais aller explorer l'héritage.

Sujet Résolu

a+ et merci.
Bonne continuation
areuh