Discussion :

[Aboubakar Ahamda]

Salut à tous !!!

J'ai commencé la POO en python mais il y a une notion qui m'échappe vraiment.je n'arrive pas à comprendre c'est quoi le Polymorphisme en python.J'ai beaucoup cherché sur google,différents tutoriels etc mais je comprends rien (et pourtant j'ai bien compris la notion d'héritage voir héritage multiple) mais avec le polymorphisme je suis mort.

J'ai trouve des tutoriels qui parlent des polymorphismes d'autre parlent "surcharge des méthodes " donc je suis perdu mes amis.

S'il vous s'il y a quelqu'un qui peux m'expliquer bien ,ces trucs je serais ravi et reconnaissant.

Merci d'avance.

[chticricri]

Bonjour

En poo le polymorphisme consiste à offrir une interface commune à des objets de différent type.

En Python, nul besoin de créer cette interface. Imaginons que tu crée une classe dont tu souhaite pouvoir afficher le contenu par un simple print.
En cela tu n'a besoin que d'ajouter dans ta classe la méthode spéciale __str__(self) dans laquelle tu retourne une chaîne représentant son contenu.
Cela fait coin coin, cela flotte sur l'eau : c'est un canard !

En outre toute classe C héritant d'une classe B qui hérite elle-même d'une classe A, se comporte au moins comme une classe B et au moins comme
une classe A. C'est une autre façon de réaliser le polymorphisme.

[Sve@r]

Bonjour

Le polymorphisme c'est "pouvoir appeler la même méthode" sur plusieurs objets différents sans se préoccuper de comment se comportera l'objet dans ce cas.

En Python, ça se fait en redéfinissant la méthode dans la fille quand c'est nécessaire. Et dans ce cas, quand c'est nécessaire d'implémenter un héritage, il faut alors explicitemet le demander.

Exemple

Code python :

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
>>> class base(object):
	def affiche(self):
		print "je suis la base"
 
>>> class filleA(base):
	def affiche(self):
		base.affiche(self)
		print "filleA"
 
>>> class filleB(base):
	def affiche(self):
		print "filleB"
 
>>> class filleC(base):
	pass
 
>>> a=filleA()
>>> a.affiche()
je suis la base
filleA
 
>>> b=filleB()
>>> b.affiche()
filleB
 
>>> c=filleC()
>>> c.affiche()
je suis la base

Les 3 classes filles possèdent toutes 3 la fonction "affiche" récupérée par défaut. Toutefois la première ayant besoin d'avoir le comportement d'origine plus le sien propre est alors obligée d'appeler la fonction de la classe mère de façon explicite. Et la seconde, elle, n'ayant pas besoin de la fonction d'origine, se contente de redéfinir un autre comportement totalement différent.

[wiztricks]

J'ai trouve des tutoriels qui parlent des polymorphismes d'autre parlent "surcharge des méthodes " donc je suis perdu mes amis.

En fait, le "polymorphisme" en POO a de nombreuses variantes. Pire, Python étant un langage dynamique, il a un polymorphisme particulier appelé duck typing.

Effectivement, il y a de quoi s'y perdre, mais çà ne devrait pas trop vous gêner pour coder.

- W

[Laurent 1973]

Pour compléter ce qui a été dit sur le polymorphisme (qui n'est pas propre à Python), je pourrais faire l'exemple des animaux.
C'est parlant parce que c'est assez concret.

un chien remue la queue quand il est content, un chat ronronne et un canari chante.

Supposons que l'on avait 3 classes qui reprend ces 3 animaux.
Sans héritage/polymorphisme, on aurait quelque chose comme cela:

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
class Dog:
 
    def move_tail(self):
        # move its tail
        ....
 
class Cat:
 
    def purr(self)
        # purr
        ....
 
class Canary:
 
    def song(self)
        # song
        ....

Maintenant, tu manipules tes animaux et sur l'un d'entre eux, tu veux lui faire faire l'action d'etre content.
Mais comme il ne font pas l'action de la même façon, tu dois avant analyser le type d'animaux que tu as:

Code :

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

1
2
3
4
5
6
7
8
9
my_pet = get_current_pet()
if isinstance(my_pet,Dog):
     my_pet.move_tail()
elif isinstance(my_pet,Cat):
     my_pet.purr()
elif isinstance(my_pet,Canary):
     my_pet.song()
else:
     raise Exception('???')

On vois alors, que la gestion d'une simple action deviens assez compliquer.
Et si on veux rajouter un hamster, faudra rajouter une nouvelle condition.

Maintenant, si on utilisait l'heritage/polymorphisme en introduisant la notion d'une classe mère:

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
class Animal
 
    def be_happy(self):
          raise Exception('not implemented')
 
class Dog(Animal):
 
    def be_happy(self):
        # move its tail
        ....
 
class Cat(Animal):
 
    def be_happy(self):
        # purr
        ....
 
class Canary(Animal):
 
    def be_happy(self):
        # song
        ....

On ne cherche plus à décrire chaque particularité de chaque animaux, mais de les rassembler dans une notion général.
L'appel à l'action comme précédemment se résumera alors à:

Code :

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

1
2
my_pet = get_current_pet()
my_pet.be_happy()

Et on vois aussi, que l'ajout de l'animal hamster sera aussi grandement simplifier.

Voilà, une illustration de ce que peux t'apporter l’héritage et le polymorphisme.

[fred1599]

Un exemple très simple en python pour exprimer le polymorphisme, c'est la fonction add (ajouter), qui fonctionne avec beaucoup de paramètres de type différent

Code :

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

1
2
def add(param1, param2):
    return param1 + param2

Vous pourrez faire les tests suivants:

Code :

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

1
2
3
4
print(add(12, 5)) # somme
print(add('b', 'onjour')) # concaténation
print(add(3.8, 9)) # somme
print(add([4, 9], [3, 6, 12.5])) # étendre