Langage python: coding & programmation orientée objet

Nous parlons dans ce tutoriel la programmation orientée objet.

Python un langage POO

L’un des principaux objectifs de la programmation orientée objet est de permettre pour écrire du code qui est proche de la façon dont vous pensez aux choses que votre code représente. Cela facilitera le raisonnement sur le code et la réflexion, par sa justesse.

Une classe est un type de données. En Python, type et classe sont (pour la plupart) synonymes. Un objet est une instance d’une classe. Par exemple, Python a une classe de liste. Si nous faisons une liste appelée mylist. Alors, maliste est un objet de type liste.

mylist = []
print(type(mylist))
print(isinstance(mylist, list))
print(isinstance(mylist, str))
<class ’list’>
True
False

Il existe toutes sortes de classes intégrées à Python. Certains vous pourriez ne pas

attendre.

def foo():
return 0
print(type(foo))
<class ’function’>

Pour les étudiants avancés, voici un exemple plus exotique appelé un générateur. En Python, vous pouvez céder au lieu de revenir. Si c’est le cas, le résultat sera quelque chose appelé un générateur et non une fonction. Cette idée puissante montre beaucoup en Python, mais nous ne pourrons pas vraiment nous en sortir jusqu’à ce que nous comprenions comment les classes sont capables de regrouper les données et le code.

def mygenerator(n):
for i in range(n):
yield i
print(type(mygenerator))
print(type(mygenerator(5)))
<class ’function’>
<class ’generator’>

Un exemple simple

L’une des premières façons dont nous apprenons à combiner plusieurs éléments de l’information en un seul objet est en calcul ou en algèbre linéaire, avec l’Introduction de vecteurs. Nous pouvons considérer un vecteur bidimensionnel comme une paire de Nombres. Si nous essayons d’écrire du code qui fonctionne avec 2 dimensions vecteurs, nous pouvons simplement utiliser des tuples. 

u = (3,4)
v = (3,6)
def add(a, b):
return (a[0] + b[0], a[1] + b[1])
def subtract(a,b):
return (a[0] - b[0], a[1] - b[1])
def dot(a, b):
return (a[0] * b[0] + a[1] * b[1])
def norm(a):
return (a[0] * a[0] + a[1] * a[1]) ** 0.5
def isvertical(a):
return a[0] == 0
print(norm(u))
print(add(u,v))
print(u + v)
print(isvertical(subtract(v, u)))
 def norm(a):
return (a[0] * a[0] + a[1] * a[1]) ** 0.5
def isvertical(a):
return a[0] == 0
print(norm(u))
print(add(u,v))
print(u + v)
print(isvertical(subtract(v, u)))

Output:

5.0 (6, 10) (3, 4, 3, 6) True

Cela pourrait convenir si c’est tout ce que nous voulions faire, mais au fur et à mesure que nous remplissons le code, les choses commenceront à devenir plus compliquées. Par exemple, supposons que nous voulions assurez-vous que les entrées de ces fonctions sont vraiment des tuples qui contiennent deux nombres. Nous pourrions ajouter du code à chaque méthode pour vérifier cela erreur ou récupérer autrement, mais ce n’est pas génial, car nous voulons vraiment juste opérer sur des vecteurs. De plus, nous pourrions vouloir ajouter d’autres types de choses en plus des vecteurs. Cela nous obligerait probablement à créer la fonction add beaucoup plus compliqué, ou renommez-le quelque chose de plus descriptif tel que vectoradd.

class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def norm(self):
return (self.x ** 2 + self.y ** 2) ** 0.5
u = Vector(3,4)
print(u.norm())
print(Vector(5,12).norm())

Output:

5.0
13.0

Une fonction définie dans une classe est appelée méthode. C’est une convention standard d’utiliser self comme nom du premier paramètre d’une méthode. Ce paramètre est l’objet qui sera généralement exploité par la méthode. 

Au lieu de cela, la notation par points remplit ce paramètre pour vous. C’est u.norm()

est traduit en vector.norm(u).

La méthode init est appelée un initialiseur. Des méthodes comme celle-ci qui

commencer et finir par deux traits de soulignement sont parfois appelés les méthodes magiques ou également les méthodes dunder. Vous ne devriez pas inventer vos propres méthodes commençant et se terminant par deux traits de soulignement. C’est ainsi que Python les définit à part afin que vous n’appeliez pas réellement vos propres méthodes la même chose. Aussi, les méthodes dunder ne sont généralement pas appelées explicitement, mais fournissent à la place d’autres moyens de les appeler. Dans le cas d’un initialiseur, appeler le nom de la classe en tant que fonction appelle l’initialiseur. Vous avez déjà vu cela, comme comme dans float(“3.14159”).

Nous allons utiliser une autre méthode magique pour implémenter l’addition

class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def norm(self):
return (self.x ** 2 + self.y ** 2) ** 0.5
def __add__(self, other):
newx = self.x + other.x
newy = self.y + other.y
return Vector(newx, newy)
u = Vector(3,4)
v = Vector(3,6)
print(u + v)

Cette sortie est assez bizarre. Il nous dit que u + v est un objet vectoriel à une adresse mémoire, mais ne nous disons pas de quel vecteur il s’agit. Nous devons le faire implémenter afin d’imprimer correctement le vecteur. Cette méthode magique est appelée par la fonction d’impression pour convertir ses paramètres en une chaîne. C’est pas évident comment une chaîne doit être imprimée pour une classe donnée. Nous devons le préciser nous-mêmes.

Dans l’exemple ci-dessous, nous avons ajouté une méthode str ainsi qu’un type vérification des entrées. Le résultat garantira qu’un vecteur a deux flotte comme coordonnées.

class Vector:
def __init__(self, x, y):
try:
self.x = float(x)
self.y = float(y)
except ValueError:
self.x = 0.0
self.y = 0.0
def norm(self):
return (self.x ** 2 + self.y ** 2) ** 0.5
def __add__(self, other):
newx = self.x + other.x
newy = self.y + other.y
return Vector(newx, newy)
def __str__(self):
return "(%f, %f)" %(self.x, self.y)
u = Vector(3,4)
v = Vector(3,6)
print(u + v)

(6.000000, 10.000000)