Python

1
 Présentation de Python
Développé en 1989 par Guido van
RossumOpen sourcePortable (Windows,
linux Mac OS)Orienté
objetDynamiqueExtensibleSupport pour
l'intégration d'autre langage

2
Présentation de Python
Présentation de Python

Il existe 2 techniques pour effectuer la
traduction en langage machine mon code
source:
 Interprétation: inconvénient lent!!!
 Compilation: Rapide, inconvénient compilation

3
Présentation de Python

  Et Python ???

 Avantages:Interpréteur permettant de
tester n'importe quel petit bout de code
 Compilation transparente
 Inconvénients:Peut être lent

4
Présentation de Python
 Que peut-on faire avec Python?
Web:
Django, Zope, Plone,...
Bases de données:
MySQL, PostgrSQL,Oracle,...
Gui:
Gtk+,Qt, Tcl/Tk, WxWidgets…
Représentation graphique:
gnuplot,matplotlib,VTK
Calcul scientifique:
numpy, scipy, sage,... 5
 Présentation de Python
 Pourquoi Python pour le calcul ?
 Peut être appris en quelques jours
 Permet de faire des tests rapides
 Alternative à Matlab, Octave, Scilab
 Parallélisation
 Multiplateforme
 Facilement interfaçable avec des
librairies(Fortran, C/C++) de calcul
scientifique
6
Les types et les opérations de
base
 Entiers(32 bits)
 Entiers longs
 Réels (64 bits)
 Complexe: 3+4j, ou 3+5J
 Booléens ( True, False)

7
Les types et les opérations
de base

Affectation:
 >>> i=3 # i vaut 3
 >>>a, pi=True,
 >>>k=r=2.15
 Affichage dans l'interpréteur
 >>> I
3
 >>> print (i)

8
Les types et opérations de
base
 Opérateurs +,-,*,/,%,//
 Puissance **
 Comparaison: ==, is, !=, is not, >,<,>=,<=
 Opérateurs bitwise: & ,|,<<,>>
 Opérateurs logique: or,and, not

9
 Les types et les opérations
de base

Les listes
 Initialisation: [ ],list(),[1, 2,3,4], ['point','triangle',6],
range(10), range(2,10,2) Concaténation
 In [18]: sept_zeros=[0]*7;sept_zeros
 Out[18]: [0, 0, 0, 0, 0, 0, 0]
 In [20]: L1,L2=[1,2,3],[4,5]
 In [21]: L1+L2
 Out[21]: [1, 2, 3, 4, 5]
 Une liste est une séquence comme pour une chaîne de
caractère
10
Les types et les opérations de base
 ATTENTION !!!!!
 In [22]: L=['Dans','python','tout','est','objet’]
 In [23]: T=L
 In [24]: T[4] ='bon’
 In [25]: T
 Out[25]: ['Dans', 'python', 'tout', 'est', 'bon’]
 In [26]: L
 Out[26]: ['Dans', 'python', 'tout', 'est','bon’]
 In [27]: L=T[:]
 In [28]: L[4]='objet’
 In [29]: T;L
 Out[29]: ['Dans', 'python', 'tout', 'est', 'bon’]
 Out[29]: ['Dans', 'python', 'tout', 'est', 'objet'] 11
 Les types et les opérations de base

Une liste à ses propres méthodes help(list)
len(L) : taille de la liste
L.sort() : trier la liste
L.append() ajout element en fin de,liste
L.reverse(): inversion de la liste
L.index() recher elt dans L
L.remove(): retirer element
L.pop() ajout en fin de liste
12
Les types et les opérations
de base
 Les tuples
 Initialisation:(),tuple(),(1,) 'a','b','c’, ('a','b','c’)
 Concaténation
 >>>(1,2)*3
 >>> (1,2,1,2,1,2)
 In [1]: t1,t2=(1,2,3),(4,5)
 In [2]: t1+t2
 Out[2]: (1, 2, 3, 4, 5)
 Un tuple est aussi une séquence.

13
Les types et les opérations de base
 Opération sur un tuple
 Un tuple n'est pas modifiable
 In [3]: t='a','b','c','d’
 In [4]: t[0]='alpha’
 TypeError Traceback (most recent call last)
 TypeError: 'tuple' object does not support item assignment
 In [6]: t=('alpha',)+t[1:]
 In [7]: t
 Out[7]: ('alpha', 'b', 'c', 'd’)
 Mais un objet modifiable dans un tuple peut l'être
 In[8]: t=(1,2,[3,4],6)
 In[9]:t[2][0]=1;t
 Out[9]: (1,2,[1,4],6) 14
 Les types ete les opérations de base
 Les dictionnaires:
 Initialisation {}, dict(), {'point':1,'ligne’:2}
 Un dictionnaire est constitué de clés et de valeurs
 Pas de concaténation possible
 Ajout d une clé ou modif d'une valeur
 >>> dic['triangle’]=3
 >>> dic
 {'ligne': 2, 'triangle': 3, 'point': 1}
 >>> dic['point’]=3
 {'ligne': 2, 'triangle': 3, 'point': 3}

15
 Les types et ls opérations de base
 Dictionnaire a ses propres méthodes:
 len(dic): taille du dictionnaire
 Dico.keys renvoie les clés
 Dic.value renvoie les valeurs
 Dic.has_key renvoie True si clé presente
 Dic.get donne valeur de la clé si elle existe
sinon une valeur par défaut

16
Structure de contrôle
Structure if
 a = 200
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")
17
 L’iNDENTATION:
 Python s'appuie sur l'indentation (espace
blanc au début d'une ligne) pour
RECONNAITRE les blocs dans le code.
D'autres langages de programmation
utilisent souvent des accolades à cette fin.

18
 Exemple
 l’instruction “if”, sans indentation (générera
une erreur):

a = 33
b = 200
if b> a:
print ("b is greater than a") # vous obtiendrez
une erreur

19
 Elif :
 Le mot-clé elif est une façon python de dire "si
les conditions précédentes n'étaient pas vraies,
alors essayez cette condition".
 Exemple:

a = 33
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
20
 Else: Le mot-clé else attrape tout ce qui n'est pas
intercepté par les conditions précédentes.
 Example:
 a = 200
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")

21
 Vous pouvez également avoir un else sans
elif: Exemple
 a = 200
 b = 33
 if b > a:
 print("b is greater than a")
 else:
 print("b is not greater than a")

22
 Si vous n'avez qu'une seule instruction à
exécuter, vous pouvez la placer sur la
même ligne que l'instruction if.
 Exemple:
 if a > b: print("a is greater than b")

23
 Si vous n'avez qu'une seule instruction à
exécuter, une pour if et une pour else, vous
pouvez tout mettre sur la même ligne:
Exemple:

 a = 2
b = 330
print("A") if a > b else print("B")

24
 Vous pouvez également avoir plusieurs instructions
 else sur la même ligne.

 Exemple:
 a = 330
b = 330
print("A") if a > b else print("=") if a == b else print("B")

25
Structure iterative: while
 Avec la boucle while, nous pouvons
exécuter un ensemble d'instructions tant
qu'une condition est vraie.
 Exemple: afficher i tant que i est inférieur à
6:
i=1
 while i < 6:
 print(i)
 i += 1
26
 La boucle while nécessite que les
variables pertinentes soient prêtes, dans
cet exemple, nous devons définir une
variable d'indexation, i, que nous
initialisons à 1.

27
L’instruction break:
 Avec l'instruction break, nous pouvons arrêter la
boucle même si la condition while est vraie:
 Exemple Quittez la boucle lorsque i est 3:
 i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  i += 1
28
L’instruction continue:
 Avec l'instruction continue, nous pouvons arrêter
l'itération en cours et continuer avec la suivante:
Exemple Passez à l'itération suivante si i vaut 3:
 i = 0
while i < 6:
  i += 1 
  if i == 3:
    continue
  print(i)

29
L’instruction else:
 Avec l'instruction else, nous pouvons exécuter
un bloc de code une fois lorsque la condition
n'est plus vraie: Exemple Afficher un message
une fois que la condition est fausse:
 i = 1
while i < 6:
  print(i)
  i += 1
else:
  print("i is no longer less than 6")
30
 Structure repetitive: boucle for
 Une boucle « for » est utilisée pour itérer
sur une séquence (c'est-à-dire une liste, un
tuple, un dictionnaire, un ensemble ou une
chaîne).
 Cela ressemble moins au mot-clé « for »
dans d'autres langages de programmation,
et fonctionne plus comme une méthode
d'itération que l'on trouve dans d'autres
langages de programmation orientés objet.

31
 Avec la boucle for, nous pouvons exécuter
un ensemble d'instructions, une fois pour
chaque élément d'une liste, d'un tuple, d'un
ensemble, etc.
 Exemple: Afficher chaque fruit dans une
liste de fruits.

 fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)
32
 La boucle for ne nécessite pas de variable
d'indexation à définir au préalable.
 Boucle sur une chaîne:
 Même les chaînes sont des objets itérables,
elles contiennent une séquence de
caractères:
 Exemple Parcourez les lettres du mot
«banane»:
 for x in "banana":
  print(x)

33
 L’instruction break:
 Avec l'instruction break, nous pouvons
arrêter la boucle avant qu'elle n'ait parcouru
tous les éléments: Exemple Quittez la
boucle lorsque x est "banane":

 fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x) 
  if x == "banana":
    break
34
 Exemple: Quittez la boucle lorsque x est
"banana", mais cette fois la pause vient
avant l’affichage:
 fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    break
  print(x)

35
L’instructon continue :
Avec l'instruction continue, nous pouvons
arrêter l'itération actuelle de la boucle et
continuer avec la suivante:
Exemple: N’afficher pas “banana”:

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    continue
  print(x)
36
La fonction range ():
 Pour parcourir un ensemble de code un
certain nombre de fois, nous pouvons
utiliser la fonction range (), La fonction
range () renvoie une séquence de
nombres, commençant par 0 par défaut et
incrémentée de 1 (par défaut), et se
termine à un nombre spécifié.

37
 Example
 Utiliser la fonction range() :
 for x in range(6):
  print(x)
Notez que range (6) ne correspond pas aux
valeurs de 0 à 6, mais aux valeurs de 0 à 5.
La fonction range () par défaut à 0 comme
valeur de départ, cependant il est possible
de spécifier la valeur de départ en ajoutant
un paramètre: range (2, 6), ce qui signifie
des valeurs de 2 à 6 (mais pas 6):
38
 Exemple:
 Utilisation du paramètre de démarrage:
 for x in range(2, 6):
  print(x)

La fonction range () incrémente par défaut la

séquence de 1, mais il est possible de
spécifier la valeur d'incrément en ajoutant un
troisième paramètre: range (2, 30, 3):
Exemple Incrémentez la séquence de 3 (la
valeur par défaut est 1):
39
 for x in range(2, 30, 3):
  print(x)

 Else dans la boucle For :

 Le mot clé else dans une boucle for spécifie
un bloc de code à exécuter lorsque la
boucle est terminée: Exemple afficher tous
les nombres de 0 à 5 et aficcher un
message lorsque la boucle est terminée:

40
 for x in range(6):
  print(x)
else:
  print("Finally finished!")

 Remarque: Le bloc else ne sera PAS

exécuté si la boucle est arrêtée par une
instruction break.

41
 Exemple: Sortez de la boucle lorsque x vaut
3 et voyez ce qui se passe avec le bloc else:

 for x in range(6):
  if x == 3: break
  print(x)
else:
  print("Finally finished!")

42
Boucles imbriquées
 Une boucle imbriquée est une boucle à
l'intérieur d'une boucle. La "boucle interne"
sera exécutée une fois pour chaque itération
de la "boucle externe": Exemple Affichez
chaque adjectif pour chaque fruit:

 adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]
for x in adj:
  for y in fruits:
    print(x, y)
43
Fonction python
 Une fonction est un bloc de code qui ne
s'exécute que lorsqu'elle est appelée.
Vous pouvez transmettre des données,
appelées paramètres, à une fonction. Une
fonction peut renvoyer des données en
conséquence.

44
 Créer une fonction En Python:
 une fonction est définie à l'aide du mot-clé
def: Exemple
 def my_function():
  print("Hello from a function") 

 Pour appeler une fonction, utilisez le nom de

la fonction suivi de parenthèses: Exemple
 def my_function():
  print("Hello from a function")

my_function() 45
 Arguments :
 Les informations peuvent être transmises
aux fonctions en tant qu'arguments. Les
arguments sont spécifiés après le nom de
la fonction, entre parenthèses. Vous
pouvez ajouter autant d'arguments que
vous le souhaitez, séparez-les simplement
par une virgule. L'exemple suivant a une
fonction avec un argument (fname).
Lorsque la fonction est appelée, nous
transmettons un prénom, qui est utilisé à
l'intérieur de la fonction pour afficher le nom
complet: Exemple 46
 def my_function(fname):
  print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus")

47
 Nombre d'arguments

 Par défaut, une fonction doit être appelée
avec le nombre correct d'arguments. Cela
signifie que si votre fonction attend 2
arguments, vous devez appeler la fonction
avec 2 arguments, pas plus, ni moins.

48
 Exemple Cette fonction attend 2
arguments et obtient 2 arguments:

 def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil", "Refsnes")

49
 Si vous essayez d'appeler la fonction avec
1 ou 3 arguments, vous obtiendrez une
erreur: Exemple Cette fonction attend 2
arguments, mais n'en obtient que 1:

 def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil")

50
Nombre arbitraire d’Arguments, *
args
 Si vous ne savez pas combien d'arguments
seront passés à votre fonction, ajoutez un *
avant le nom du paramètre dans la
définition de la fonction. De cette façon, la
fonction recevra un tuple d'arguments et
pourra accéder aux éléments en
conséquence: Exemple Si le nombre
d'arguments est inconnu, ajoutez un * avant
le nom du paramètre:
51
 def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus")

52
 Les arguments arbitraires sont souvent
raccourcis en * args dans les
documentations Python.
 Vous pouvez également envoyer des
arguments avec la syntaxe
 clé = valeur.

 De cette façon, l'ordre des arguments n'a

pas d'importance.

53
 Exemple:
 def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Emil", child2

= "Tobias", child3 = "Linus")

 L’expression Arguments clés est souvent

abrégée en kwargs dans les
documentations Python.

54
 Nombre arbitraire d’Arguments
clés, ** kwargs
 Si vous ne savez pas combien d'arguments
clés seront passés à votre fonction, ajoutez
deux astérisques: ** avant le nom du
paramètre dans la définition de la fonction. De
cette façon, la fonction recevra un dictionnaire
d'arguments et pourra accéder aux éléments
en conséquence:
55
 Exemple Si le nombre d'arguments clés est
inconnu, ajoutez un double ** avant le nom du
paramètre:

 def my_function(**kid):
  print("His last name is " + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes")

56
Valeur de paramètre par défaut
 L'exemple suivant montre comment utiliser
une valeur de paramètre par défaut. Si
nous appelons la fonction sans argument,
elle utilise la valeur par défaut:

57
 Exemple
 def my_function(country = "Norway"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

58
Passer une liste comme
argument
 Vous pouvez envoyer n'importe quel type
d'argument de données à une fonction
(chaîne, nombre, liste, dictionnaire, etc.), et
il sera traité comme le même type de
données à l'intérieur de la fonction. Par
exemple. si vous envoyez une liste en
argument, ce sera toujours une liste
lorsqu'elle atteindra la fonction

59
 Exemple:

 def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

60
Valeurs de retour
 Pour laisser une fonction renvoyer une valeur,
utilisez l'instruction return:
 Exemple:
 def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))

61
récursivité
Python accepte également la récursivité des
fonctions, ce qui signifie qu'une fonction
définie peut s'appeler elle-même. La
récursivité est un concept mathématique et de
programmation courant. Cela signifie qu'une
fonction s'appelle elle-même. Cela a
l'avantage de signifier que vous pouvez
parcourir les données pour atteindre un
résultat..

62
 Le développeur doit être très prudent avec
la récursivité car il peut être assez facile
de glisser dans l'écriture d'une fonction qui
ne se termine jamais, ou qui utilise des
quantités excessives de mémoire ou de
puissance de processeur. Cependant,
lorsqu'elle est écrite correctement, la
récursivité peut être une approche très
efficace et mathématiquement élégante de
la programmation.

63
 Dans cet exemple, somme_recursive ()
est une fonction que nous avons définie
pour s'appeler elle-même. Nous utilisons
la variable n comme données, qui
décrémente (-1) après chaque étape. La
récursivité se termine lorsque la condition
n'est pas supérieure à 0 (c'est-à-dire
lorsqu'elle vaut 0).

64
 Pour un nouveau développeur, cela peut
prendre un certain temps pour
comprendre comment cela fonctionne
exactement, le meilleur moyen de le
savoir est de le tester et de le modifier.

65
 Exemple:
 def somme_recursive(n):
  if(n > 0):
    resultat = n + somme_recursive(n - 1)
    print(resultat)
  else:
    resultat = 0
  return resultat

print("\n\n Resultas Exemple Recursivite ")

somme_recursive(6)
66
 Python Lambda
 Une fonction lambda est une petite fonction
anonyme.

 Une fonction lambda peut prendre n'importe

quel nombre d'arguments, mais ne peut
avoir qu'une seule expression.

67
 Syntaxe:
 lambda arguments : expression
 L'expression est exécutée et le résultat
est retourné:
 Exemple
 Ajoutez 10 à l'argument a et renvoyez le
résultat:
 x = lambda a : a + 10
print(x(5))

68
 Les fonctions Lambda peuvent accepter
n'importe quel nombre d'arguments:
 Exemple
 Multipliez l'argument a par l'argument b et
renvoyez le résultat:
 x = lambda a, b : a * b
print(x(5, 6))

 Exemple :Additionner les arguments a, b et c et

renvoyez le résultat:
 x = lambda a, b, c : a + b + c
print(x(5, 6, 2)) 69
Pourquoi utiliser les fonctions
Lambda?
 La puissance des fonctions lambda est
mieux exploitée lorsque vous les utilisez
comme fonction anonyme dans une autre
fonction.
 Supposons que vous ayez une définition de
fonction qui prend un argument, et cet
argument sera multiplié par un nombre
inconnu:
 def myfunc(n):
  return lambda a : a * n
70
 Utilisez cette définition de fonction pour
créer une fonction qui double toujours le
nombre que vous envoyez:

 Exemple
 def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))
71
Classes et objets Python

 Python est un langage de programmation

orienté objet.

 Presque tout en Python est un objet, avec

ses propriétés et ses méthodes.

 Une classe est comme un constructeur

d'objet, ou un "plan" pour créer des objets.
72
 Créer une classe
 Pour créer une classe, utilisez le mot clé
class:
 Exemple
 Créez une classe nommée MyClass, avec
une propriété nommée x:
 class MyClass:
  x = 5

73
Créer un objet
 Nous pouvons maintenant utiliser la classe
nommée MyClass pour créer des objets:
 Exemple
 Créez un objet nommé p1 et affichez la
valeur de x:
 p1 = MyClass()
print(p1.x)

74
La fonction __init __ ()
 Les exemples ci-dessus sont des classes
et des objets dans leur forme la plus
simple et ne sont pas vraiment utiles dans
les applications réelles.

 Pour comprendre la signification des

classes, nous devons comprendre la
fonction intégrée __init __ ().

75
 Toutes les classes ont une fonction appelée
__init __ (), qui est toujours exécutée
lorsque la classe est lancée.

 Utilisez la fonction __init __ () pour attribuer

des valeurs aux propriétés de l'objet ou à
d'autres opérations nécessaires lors de la
création de l'objet:

76
 Exemple
 Créez une classe nommée Person,
utilisez la fonction __init __ () pour
attribuer des valeurs pour le nom et l'âge:
 class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age) 77
 Remarque: Le paramètre self est une
référence à l'instance actuelle de la classe
et est utilisé pour accéder aux variables
appartenant à la classe.

 Il n'a pas besoin d'être nommé self, vous

pouvez l'appeler comme vous le souhaitez,
mais il doit être le premier paramètre de
toute fonction de la classe:

78
 Exemple:
 Utilisez les mots nomobjet et abc au lieu de
self:
 class Person:
  def __init__(nomobject, name, age):
   nomobject.name = name
    nomobject.age = age

  def myfunc(abc):
    print("Hello my name is " + abc.name)

p1 = Person("John", 36)
p1.myfunc() 79
Modifier les propriétés de l'objet

 Vous pouvez modifier les propriétés

d'objets comme celui-ci:

 Exemple
 Définissez l'âge de p1 sur 40:
 p1.age = 40

80
Supprimer les propriétés de
l'objet
 Vous pouvez supprimer les propriétés des
objets à l'aide du mot-clé del:

 Exemple
 Supprimez la propriété age de l'objet p1:
 del p1.age

81
Supprimer des objets

 Vous pouvez supprimer des objets en

utilisant le mot-clé del:

 Exemple
 Supprimez l'objet p1:
 del p1

82
 Héritage
 L'héritage nous permet de définir une classe qui
hérite de toutes les méthodes et propriétés d'une
autre classe.

 La classe parente est la classe héritée,

également appelée classe de base.

 La classe enfant est la classe qui hérite d'une

autre classe, également appelée classe dérivée.

83
 Créer une classe parent
 N'importe quelle classe peut être une classe
parente, donc la syntaxe est la même que
pour créer n'importe quelle autre classe:
 Exemple
 Créez une classe nommée Person, avec les
propriétés firstname et lastname, et une
méthode printname:

84
 class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

#Use the Person class to create an object,

and then execute the printname method:

x = Person("John", "Doe")
x.printname() 85
 Créer une classe enfant
 Pour créer une classe qui hérite de la
fonctionnalité d'une autre classe, envoyez la
classe parente en tant que paramètre lors de
la création de la classe enfant:

 Exemple
 Créez une classe nommée Student, qui
héritera des propriétés et méthodes de la
classe Person:

86
 class Student(Person):
  pass

 Remarque: utilisez le mot-clé pass lorsque

vous ne souhaitez pas ajouter d'autres
propriétés ou méthodes à la classe.

 Désormais, la classe Student a les mêmes

propriétés et méthodes que la classe
Person.

87
 Exemple
 Utilisez la classe Student pour créer un
objet, puis exécutez la méthode printname:
 x = Student("Mike", "Olsen")
x.printname()

88
 Ajouter la fonction __init __ ()
 Jusqu'à présent, nous avons créé une
classe enfant qui hérite des propriétés et des
méthodes de son parent.

 Nous voulons ajouter la fonction __init __ ()

à la classe enfant (au lieu du mot-clé pass).

 Remarque: La fonction __init __ () est

appelée automatiquement chaque fois que la
classe est utilisée pour créer un nouvel objet
89
 Exemple
 Ajoutez la fonction __init __ () à la classe
Student:
 class Student(Person):
  def __init__(self, fname, lname):
    #add properties etc.

90
 Lorsque vous ajoutez la fonction __init __ (),
la classe enfant n'héritera plus de la fonction
__init __ () du parent.

 Remarque: la fonction __init __ () de l'enfant

remplace l'héritage de la fonction __init __ ()
du parent.

 Pour conserver l'héritage de la fonction __init

__ () du parent, ajoutez un appel à la fonction
__init __ () du parent:
91
 Exemple:
 class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname)

 Nous avons maintenant ajouté avec succès la

fonction __init __ (), et conservé l'héritage de la
classe parente, et nous sommes prêts à ajouter
des fonctionnalités dans la fonction __init __ ().

92
 Utilisez la fonction super ()
 Python a également une fonction super () qui
fera en sorte que la classe enfant hérite de
toutes les méthodes et propriétés de son
parent:

 Exemple:
 class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)

93
 En utilisant la fonction super (), vous n'avez pas à
utiliser le nom de l'élément parent, il héritera
automatiquement des méthodes et propriétés de son
parent.

 Ajouter des propriétés:

Exemple
 Ajoutez une propriété appelée graduationyear à la
classe Student:
 class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)
    self.graduationyear = 2019 94
 Dans l'exemple ci-dessous, l'année 2019
doit être une variable et passée dans la
classe Student lors de la création d'objets
Student. Pour ce faire, ajoutez un autre
paramètre dans la fonction __init __ ():

 Exemple
 Ajoutez un paramètre d'année et passez
l'année correcte lors de la création d'objets:

95
 class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

x = Student("Mike", "Olsen", 2019)

96
 Ajouter des méthodes
 Exemple
 Ajoutez une méthode appelée bienvenue dans la
classe Student:
 class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

  def welcome(self):
    print("Welcome", self.firstname, self.lastname, "to
the class of” , self.graduationyear)

97
 Si vous ajoutez une méthode dans la
classe enfant avec le même nom qu'une
fonction de la classe parent, l'héritage de la
méthode parent sera remplacé.

98