Module : Programmation Orienée Objet.

(POO) 2023 -
2024 Ecole Supérieure en Génie
Electrique
et Energétique d’Oran (ESG2E)

Département de Seconde cycle.

Spécialité: AUTOMATIQUE .

Présentation du module

Programmation Orienée Objet .

(POO)

Présentée par Dr: A. MEKRI

Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Déclaration des Variables

en Python
En Python, une variable est un espace de stockage qui contient une valeur
pouvant être modifiée pendant l'exécution du programme.
Pour déclarer une variable en Python, vous utilisez simplement le nom de la variable suivi du
signe égal (=) et de la valeur que vous souhaitez lui attribuer.
Exemple :
nom = "AHMED"
age= 22
Taille = 1.71
ahmed_est_majeur = True
ahmed_est_mineur= False
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Affichage des Variables

en Python
Utilisation de print() :C'est la méthode la plus simple et la plus
directe pour afficher une variable.
Exemple :

nom = "AHMED"
age= 22
Taille = 1.71
ahmed_est_majeur = True
ahmed_est_mineur= False
print(nom)
print(age)
print(age,Taille)
print("la taille de ahmed est", Taille)
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Entrée des Variables en

Pour entrer des variables en Python, vous pouvez utiliser la fonction input(). Elle
Python
permet de demander à l'utilisateur d'entrer des données via le clavier. Par défaut,
l'entrée est toujours interprétée comme une chaîne de caractères (type str), donc si
vous voulez une autre valeur (comme un nombre entier ou flottant), vous devez
convertir cette entrée.
nom = input("Entrez votre nom : ")
print("je m'appelle ",nom)

age = int(input("Entrez votre âge : "))

print(f"Vous avez {age} ans.")

taille = float(input("Entrez votre taille en mètres : "))

print(f"Votre taille de {nom} est {taille} mètres.")
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.
1. Les entiers (int)
Les entiers (int) sont utilisés pour représenter des nombres entiers, positifs ou négatifs,
sans partie décimale.

Exemple:
x=5
y=-3

Opérations arithmétiques : Vous pouvez effectuer des opérations arithmétiques sur les entiers,
telles que l'addition, la soustraction, la multiplication et la division.
x=5
y=2
somme = x + y
difference = x - y
produit = x * y
quotient = x / y # La division retourne un nombre à virgule flottante en Python 3
division_entiere = x // y # La division entière (ignorant la partie fractionnaire)
reste = x % y # Le reste de la division
puissance = x ** 2 # x élevé à la puissance 2
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Conversion de types :
Vous pouvez convertir d'autres types de données en entiers à l'aide des fonctions int()

Exemple:
gg=int(23.9)
print(gg)

Flottants (float) : Ils représentent les nombres à virgule flottante, c'est-à-dire les nombres
avec une partie décimale.
Exemple : Taille = 1.71
Nb: les opérations sur les int sont identique au float
Chaînes de caractères (str) : Elles représentent du texte, entouré de guillemets simples ou
doubles.
Exemple : nom = "Ahmed" x=5
Booléens (bool) : Ils représentent des valeurs de vérité, y = 10
True ou False. est_superieur = x > y
est_inferieur = x < y
est_egal = x == y
print(est_superieur) # False
print(est_inferieur) # True
print(est_egal) # False
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.
2. LES LISTES
En Python, les listes sont des structures de données très flexibles qui permettent de stocker
une collection ordonnée d'éléments.
Exemple:
semaine=['dimanche', 'lundi', "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
Accès aux éléments de la liste : Les éléments d'une liste peuvent être accédés en utilisant
l'index (position) de l'élément. L'index commence à 0.
#Exemple :
Premier_jour_de_la_semaine=[0]
dernier_jour_de_la_semaine=[6]
Vous pouvez également utiliser des indices négatifs pour accéder aux éléments à partir de
la fin de la liste.
#Exemple :
jourA=[-1]
jourC=[-3]
Modifier les éléments de la liste : Les éléments d'une liste peuvent être modifiés en utilisant
leur indice. #Exemple:
semaine=['dimanche', 'lundi', "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
semaine[0]="SS"
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Ajouter des éléments à une liste :

append : Ajoute un élément à la fin de la liste.
#Exemple :
semaine=['dimanche', 'lundi', "mardi", "mercredi", "jeudi", "vendredi"]
[Link]("samedi")
insert : Insère un élément à une position spécifique.

#Exemple :
semaine=['dimanche', 'lundi', "mercredi", "jeudi", "vendredi", "samedi"]
[Link](2, "mardi") # Insère mardi à la position 2

Supprimer des éléments de la liste :

remove : Supprime la première occurrence d'une valeur spécifique.

#Exemple:
semaine=['dimanche', 'lundi', "mardi", "mercredi", "jeudi", "vendredi", "samedi"]
[Link]("lundi") # supprimer le jours lundi de la liste semaine
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Longueur d'une liste :

La fonction len() renvoie le nombre d'éléments dans une liste.
#Exemple :
semaine=['dimanche', 'lundi', "mardi", "mercredi", "jeudi", "vendredi"]
longeur=len(semaine)
Slicing (découpage) :
Vous pouvez extraire une partie d'une liste en utilisant la notation de découpage.
#Exemple :
semaine=['dimanche', 'lundi', "mercredi", "jeudi", "vendredi", "samedi"]
sous_liste=semaine[2:4] # extraire les élément suivant "mercredi", "jeudi"

Concaténation de listes : Vous pouvez concaténer deux listes avec l'opérateur +.

#Exemple:
jour_de_semaine=['dimanche', 'lundi',"mardi", "mercredi", "jeudi"]
wekend=["vendredi","samedi"]
semaine=jour_de_semaine+wekend
#ou bien
semaine=jour_de_semaine+ ["vendredi","samedi"]
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

3. Tuples (tuple) :
Ils sont similaires aux listes mais sont immuables,
ce qui signifie qu'ils ne peuvent pas être modifiés après leur création.
#Exemple :
semaine=('dimanche', 'lundi', "mercredi", "jeudi", "vendredi", "samedi")
[Link](2, "mardi") # Insère mardi à la position 2
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.
4. Les dictionnaires (dict)
les dictionnaires (dict) sont des collections non ordonnées d'éléments, où chaque élément
est composé d'une paire clé-valeur.
#Exemple :
ahmed_inf = {"nom": "Ahmed", "âge": 22,"taille":1.72, "ville": "Oran","situation
familiale":"célibataire"}
print(ahmed_inf)

Accès aux éléments : Vous pouvez accéder à la valeur d'un élément en utilisant sa clé..
#Exemple :
nom=ahmed_inf["nom"]
age=ahmed_inf["age"]

Modification d'un dictionnaire : Vous pouvez modifier les valeurs des éléments d'un
dictionnaire en utilisant leur clé.

#Exemple:
ahmed_inf["ville"]="alger"
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Ajout d'éléments : Vous pouvez ajouter de nouveaux éléments à un dictionnaire en

spécifiant une nouvelle paire clé-valeur.
#Exemple :
ahmed_inf["profession"]="étudiant"

Suppression d'éléments : Vous pouvez supprimer un élément d'un dictionnaire en

utilisant l'instruction del ou la méthode pop().
#Exemple :
ahmed_inf.pop("nom")
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

4. les comparaisons en python

Avant de passer à une autre sorte des condition et des boucles (les boucles while),
nous abordons tout de suite les comparaisons. Celles-ci seront reprises sur les Tests.
Python est capable d’effectuer toute une série de comparaisons entre le contenu de
deux variables, telles que :

Observez les exemples suivants avec des nombres entiers.

Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

4. les conditions en python

En programmation, les conditions sont utilisées pour effectuer des actions
différentes en fonction de l'évaluation d'une expression booléenne (vraie ou
fausse). En Python, les conditions sont généralement utilisées avec des
instructions de contrôle de flux telles que if, else et elif (abréviation de "else if)

x=int(input("entrez la valeur de x "))

print("x=",x)
if x>0:
print("x est positive")
elif x<0:
print("x est negative")
else:
print("x est nul")

Vous pouvez également combiner plusieurs conditions à l'aide des opérateurs logiques and,
or et not.
and : renvoie True si toutes les conditions sont vraies
or : renvoie True si au moins l'une des conditions est vraie
not : renverse le résultat de la condition.
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Exemple:
x=int(input("entrez la valeur de x "))
if x > 0 and x < 100:
print("x est un nombre positif inférieur à 100")
elif x == 0 or x >= 100:
print("x est soit nul ou n'appartient pas à
l'intervalle (0, 100)")
else:
print("x est négative")

Vous pouvez également combiner plusieurs conditions à l'aide des opérateurs logiques and,
or et not.
and : renvoie True si toutes les conditions sont vraies
or : renvoie True si au moins l'une des conditions est vraie
not : renverse le résultat de la condition.
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

4. Boucles et comparaisons
Boucles for
.1 Principe
En programmation, on est souvent amené à répéter plusieurs fois une
instruction
animaux = [" girafe ", " tigre ", " singe ", " souris "]
print ("animal", animaux)
print ( animaux [0])
print ( animaux [1])
print ( animaux [2])
print ( animaux [3])

Si votre liste ne contient que 4 éléments, ceci est encore faisable mais imaginez
qu’elle en contienne 100 voire 1000! Pour remédier à cela, il faut utiliser les
boucles. Regardez l’exemple suivant :

animaux = [" girafe ", " tigre ", " singe ", " souris "]
for animal in animaux :
print ( animal )
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Dans l’exemple suivant, le corps de la boucle contient deux instructions (ligne

2 et ligne 3) car elles sont indentées par rapport à la ligne débutant par for :

1 for animal in animaux :

2 print ( animal )
3 print ( animal *2)
4 print ("C'est fini ")
La ligne 4 ne fait pas partie du corps de la boucle car elle est au même niveau
que le for (c’est-à-dire non indentée par rapport au for). Notez également
que chaque instruction du corps de la boucle doit être indentée de la même
manière (ici 4 espaces).
Dans les exemples ci-dessus, nous avons exécuté une boucle en itérant
directement sur une liste. Une tranche d’une liste
étant elle même une liste, on peut également itérer dessus :

animaux = [" girafe ", " tigre ", " singe ", " souris "]
for animal in animaux [1:3]:
print ( animal )
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

4.1.2 Fonction range()

Python possède la fonction range() sur les Listes et qui est aussi bien
commode pour faire une boucle sur une liste d’entiers de manière
automatique :
for i in range (4):
print (i)

Toutefois, il se peut qu’au cours d’une boucle vous ayez besoin des indices,
auquel cas vous devrez itérer sur les indices :
animaux = [" girafe ", " tigre ", " singe ", " souris "]
for i in range ( len ( animaux )):
print (f"L' animal {i} est un(e) { animaux [i ]}")

La fonction len(animaux) renvoie la longueur de la liste animaux, c'est-à-dire le nombre

d'éléments dans la liste.

La fonction range() génère une séquence d'entiers de 0 à la longueur de la

liste (exclue). Donc, range(len(animaux)) génère une séquence d'entiers
allant de 0 à la longueur de la liste animaux moins un.
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

La fonction range() est une fonction intégrée de Python qui génère une séquence de nombres.
Elle est souvent utilisée pour contrôler l'itération dans les boucles for et pour créer des
séquences de nombres.
La syntaxe générale de la fonction range() est la suivante :
range(start, stop, step)

où :
•start : Valeur de départ de la séquence (par défaut : 0)

•stop : Valeur de fin de la séquence (exclue)

•step : Pas d'incrémentation entre les valeurs (par défaut : 1)

Exemple:

for i in range(5):
print(i)
for j in range(3,10):
print(j)
for K in range(1,20,2):
print(K)
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Boucle while:
La syntaxe de base d'une boucle while est la suivante :
while condition: # Bloc de code à exécuter tant que la condition est vraie
Exemple:

i=0
while i < 5:
print(i)
i += 1

Dans cet exemple :

La variable i est initialisée à 0.

La boucle while vérifie si i est inférieur à 5 à chaque itération.

Tant que la condition i < 5 est vraie, le bloc de code indenté est exécuté.

À chaque itération, la valeur de i est augmentée de 1 avec i += 1.

Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Utilisation de while True: break

Dans cet exemple, nous utilisons la déclaration break pour sortir de la boucle lorsque
i atteint 5 :

i=0
while True:
print(i)
i += 1
if i == 5:
break

Utilisation de continue
Dans cet exemple, nous utilisons la déclaration continue pour passer à l'itération suivante :
1. si i est pair :
i=0
while i < 5:
i += 1
if i % 2 == 0:
continue
print(i)
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

2. si i est impair :
i=0
while i < 10:
i += 1
if i %2 != 0:
continue
print(i)

Dans le prochain exemple, lorsque i =2 ou bien 3 ou bien 5 ou bien 6, la déclaration continue

est exécutée, ce qui ignore le reste du bloc de code à l'intérieur de la boucle pour cette
itération.

i=0
while i < 10:
i += 1
if i==2 or i==3 or i==5 or i==7:
continue
print(i)
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.
[Link]:
En programmation, une fonction est un bloc réutilisable de code qui effectue une tâche
spécifique.
En Python, les fonctions sont définies à l'aide du mot-clé def.
Voici un exemple simple de fonction

def carre (x):

return x**2
print ( carre (5))

Notez que la syntaxe de def utilise les deux-points comme les boucles for et while
ainsi que les tests if, un bloc d’instructions est donc attendu.
De même que pour les boucles et les tests, l’indentation de ce bloc d’instructions
(qu’on appelle le corps de la fonction) est obligatoire.

Dans l’exemple précédent, nous avons passé un argument à la fonction carre() qui nous a
renvoyé (ou retourné) une valeur que nous avons immédiatement affichée à l’écran avec l
’instruction print(). Que veut dire valeur renvoyée ?
Et bien cela signifie que cette dernière
est récupérable dans une variable :
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

def carre (x):

return x**2
print ( carre (5))

res = carre (5)

print ( res )

Ici, le résultat renvoyé par la fonction est stocké dans la variable res.
Notez qu’une fonction ne prend pas forcément un argument et ne renvoie pas forcément
une valeur, par exemple :
Passage d’arguments:

def fois (x, y):

return x*y
print(fois(4, 3))

def fois (x, y):

return x*y
print(fois("la",3))
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

def fois (x, y):

return x*y
print(fois([3,8,6],3))

def carre_cube2 (x):

return [x**2 , x **3]
print(carre_cube2(5))

3.1Paramètres et arguments :
Les fonctions peuvent accepter des paramètres, qui sont des valeurs que vous
fournissez
à la fonction lors de son appel. Voici un exemple avec des paramètres :

def saluer(nom):
print("Bonjour, " + nom + "!")

saluer("Ali") # Cela affichera "Bonjour, Ali!"

Dans cet exemple, nom est un paramètre de la fonction saluer, et "Ali" est un argument
fourni lors de l'appel de la fonction
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

3.2Arguments par défaut :

Vous pouvez définir des valeurs par défaut pour les paramètres d'une fonction.
Ces valeurs seront utilisées si l'appel de fonction ne fournit pas de valeur pour
ce paramètre. Exemple :
def multiplier(a, b=2):
return a * b

print(multiplier(5)) # Utilise la valeur par défaut de b (2), affiche 10

print(multiplier(5, 3)) # Utilise la valeur fournie pour b (3), affiche 15

3.3Les fonctions lambda:

Les fonctions lambda en Python sont des fonctions anonymes définies en une seule ligne.
Elles sont également appelées "fonctions anonymes" car elles n'ont pas de nom comme
les fonctions définies avec le mot-clé def.
Les fonctions lambda sont souvent utilisées pour des opérations simples et ponctuelles.
La syntaxe générale est la suivante :
lambda arguments: expression
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

Voici un exemple simple qui montre comment créer et utiliser une fonction lambda :
carre = lambda x: x ** 2
print(carre(5)) # Cela affichera 25

Dans cet exemple, lambda x: x ** 2 crée une fonction lambda prenant un argument x et
renvoyant x élevé au carré. Ensuite, nous l'assignons à la variable carre et appelons la fonction
avec carre(5).

Les fonctions lambda peuvent prendre plusieurs arguments, comme illustré ici :

somme = lambda x, y: x + y
print(somme(3, 4)) # Cela affichera 7

Voici un exemple avec map() qui applique la fonction lambda à chaque élément d'une liste :
liste = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x ** 2, liste))
print(carres) # Cela affichera [1, 4, 9, 16, 25]
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

4. L es Caractères spéciaux en python

En Python, plusieurs caractères spéciaux sont utilisés pour représenter des séquences
d'échappement ou des caractères spéciaux dans les chaînes de caractères.
Voici quelques-uns des caractères spéciaux les plus couramment utilisés en Python :
4.1 Séquences d'échappement :
voici quelques exemples d'utilisation des séquences d'échappement en Python :
Nouvelle ligne (\n) :

print("Première ligne\nDeuxième ligne")

Tabulation (\t) :

print("Colonne1\tColonne2\tColonne3")

#Exemple:
for i in range(1, 11):
produit_9 = 9 * i
produit_8 = 8 * i
produit_7 = 7 * i
print(f"{9} x {i} = {produit_9}\t{8} x {i} = {produit_8}\t{7} x {i} = {produit_7}")
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

écrire 2 fonctions :
— pair (nbre), qui renvoie True, si le nombre est Pair
— impair (nbre), qui renvoie True, si le nombre est Impair
Le nombres sera demandé à l’utilisateur. Le résultat attendu est : "La fonction Pair retourne
True pour la valeur 2"
def pair (nbre):
if (nbre % 2 == 0):
return True

def impair (nbre):

if (nbre % 2 == 1):
return True

nombre = int (input ("Votre nombre : "))

if ( pair (nombre) ):
print ("Le nombre est pair")
if ( impair (nombre) ):
print ("Le nombre est impair")
Module: : Programmation Orienée Objet.(POO)
Chapitre I:Python de base.

écrire 2 fonctions :
— mini (a,b) qui renvoie le minimum entre a et b
— maxi (a,b) qui renvoie le maximum entre a et b
Les 2 nombres a et b seront demandés à l’utilisateur.

def mini (a,b):

if ( a < b ):
return a
else:
return b

def maxi (a,b):

if ( a > b ):
return a
else:
return b
premier_nbre=int (input ("1er nombre : "))
second_nbre=int (input ("2nd nombre : "))
print ("Minimum de %d et %d : %d" % (premier_nbre, second_nbre, mini (premier_nbre, second_nbre)))
print ("Maximum de %d et %d : %d" % (premier_nbre, second_nbre, maxi (premier_nbre, second_nbre)))
Module: : Programmation Orienée Objet.(POO)
Chapitre II: Manipulation et l'analyse des données.
A. Les principales bibliothèque utiliser pour les mathématiques en python:
En Python, il existe plusieurs bibliothèques populaires pour effectuer des opérations
mathématiques. Les principales bibliothèques sont :

1. le module math:
Après cette instruction, le module math est importé et vous pouvez utiliser toutes les
fonctions et constantes définies dans ce module. Par exemple, vous pouvez utiliser
[Link]() pour calculer la racine carrée d'un nombre :
import math
x = 16
sqrt_x = [Link](x)
print("Racine carrée de", x, "est", sqrt_x)

Le programme suivant importe la bibliothèque math, puis utilise plusieurs de ses fonctions
pour effectuer différents calculs mathématiques. Il calcule la racine carrée, le sinus et le
cosinus d'un angle, accède à la constante π (pi), arrondit des nombres décimaux, et calcule
l'exponentielle et le logarithme.
import math
racine_carree = [Link](25)
print("Racine carrée de 25:", racine_carree)
Module: : Programmation Orienée Objet.(POO)
Chapitre II: Manipulation et l'analyse des données.
# Calcul du sinus et du cosinus
angle_degres = 45
angle_radian = [Link](angle_degres)
sinus = [Link](angle_radian)
cosinus = [Link](angle_radian)
print("Sinus de", angle_degres, "degrés:", sinus)
print("Cosinus de", angle_degres, "degrés:", cosinus)

# Accès à la constante pi
pi = [Link]
print("La valeur de pi:", pi)

# Arrondi de nombres décimaux

nombre_arrondi_1 = [Link](3.4)
nombre_arrondi_2 = [Link](3.9)
print("Arrondi de 3.4:", nombre_arrondi_1)
print("Arrondi de 3.9:", nombre_arrondi_2)

# Calcul de l'exponentielle et du logarithme

exponentielle = [Link](2)
logarithme = [Link](10)
print("Exponentielle de 2:", exponentielle)
print("Logarithme népérien de 10:", logarithme)
Module: : Programmation Orienée Objet.(POO)
Chapitre II: Manipulation et l'analyse des données.

1. Module NumPy :
NumPy est une bibliothèque de calcul numérique qui fournit un support pour la manipulation
de tableaux (matrices) multidimensionnels (ndarrays) ainsi que pour une vaste collection de
fonctions mathématiques pour effectuer des opérations sur ces tableaux.

Voici des exemples qui illustrent quelques-unes des nombreuses fonctionnalités offertes
par NumPy pour effectuer des opérations sur des tableaux multidimensionnels de manière
efficace en Python.
1. A. Les opération vectoriel:
import numpy as np

# Création de tableaux
vecteur = [Link]([1, 2, 3, 4, 5])
print("Vecteur:", vecteur)

matrice = [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print("Matrice:\n", matrice)

# Accès aux éléments du tableau

print("Élément à l'index 2 du vecteur:", vecteur[2])
print("Élément à la ligne 2 et colonne 0 de la matrice:", matrice[2, 0])
Module: : Programmation Orienée Objet.(POO)
Chapitre II: Manipulation et l'analyse des données.
# Opérations mathématiques sur les tableaux
a = [Link]([1, 2, 3])
b = [Link]([4, 5, 6])
addition = a + b
produit_scalaire = [Link](a, b)
print("Addition de tableaux:", addition)
print("Produit scalaire de deux vecteurs:", produit_scalaire)

# Fonctions mathématiques
moyenne = [Link](vecteur)

print("Moyenne du vecteur:", moyenne)

vecteur_a = [Link]([1, 2, 3])

vecteur_b = [Link]([4, 5, 6])

# Calcul du produit vectoriel

produit_vectoriel = [Link](vecteur_a, vecteur_b)

print("Vecteur a:", vecteur_a)

print("Vecteur b:", vecteur_b)
print("Produit vectoriel de a et b:", produit_vectoriel)
1. C -La fonction linspace:
La fonction linspace est une fonction de la bibliothèque NumPy qui permet de créer un
tableau de valeurs réparties uniformément sur un intervalle donné. Elle est souvent utilisée
pour générer des valeurs d'entrée pour les tracés graphiques ou pour effectuer des calculs
numériques sur des plages spécifiques. Voici sa syntaxe :

[Link](start, stop, num=50)

start : Valeur de départ de la séquence.
stop : Valeur de fin de la séquence.
num : Nombre de valeurs à générer, par défaut 50
Exemple: Créer un tableau de 100 valeurs réparties uniformément entre -5 et 5 :
import numpy as np
valeurs = [Link](-5, 5, num=10)
print(valeurs)
 import numpy as np
# Création d'un tableau x de valeurs de -5 à 5
x = [Link](-5, 5, 100)

# Calcul des valeurs de la fonction pour chaque valeur de x

y = x**2
print("la valeur du y=",y)

3. La bibliothèque Matplotlib :
Matplotlib est une bibliothèque de traçage en Python qui permet de créer une grande
variété graphiques, y compris des graphes linéaires, des diagrammes à barres, des
graphe en nuage de points, des histogrammes, des graphiques en boîte, des graphiques
en secteurs, etc.
Elle offre une flexibilité et une personnalisation élevées pour créer des graphiques de qualité
professionnelle.
Voici un exemple simple de création d'un graphique linéaire avec Matplotlib :
import [Link] as plt

# Données à tracer
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
# Tracer le graphique linéaire
[Link](x, y)
# Ajouter des étiquettes d'axe et un titre
[Link]('X')
[Link]('Y')
[Link]('Graphique linéaire')

# Afficher le graphique
[Link]()

Voici un exemple simple montrant comment utiliser Matplotlib pour tracer une fonction
mathématique :
import numpy as np
import [Link] as plt
# Créer un tableau x de valeurs de -5 à 5
x = [Link](-5, 5, 100)
# Calculer les valeurs de la fonction pour chaque valeur de x
y = [Link](x)
# Tracer la fonction
[Link](x, y)
[Link]('x')
[Link]('sin(x)')
[Link]('Tracé de la fonction sin(x)')
[Link](True)
[Link]()
import numpy as np
import [Link] as plt
import math

# Définition de la fonction mathématique complexe

def fonction_complex(x):
return [Link](x) * [Link](-x**2)

# Définir l'intervalle sur lequel tracer la fonction

intervalle = [Link](-2, 3, 1000)

# Calculer les valeurs de la fonction sur l'intervalle

valeurs = fonction_complex(intervalle)

# Tracer la fonction
[Link](intervalle, valeurs, label='f(x) = sin(x) * exp(-x^2)')
[Link]('x')
[Link]('f(x)')
[Link]('Tracé d\'une fonction mathématique complexe')
[Link]()
[Link]()
[Link]()
import numpy as np
import [Link] as plt

# Définir la fonction mathématique complexe

def f(x):
return [Link](x) * [Link](-x**2)

# Générer un ensemble de valeurs de x sur un intervalle donné

intervalle = [Link](-2, 2, 1000)
valeurs = f(intervalle)

# Tracer la fonction
[Link](intervalle, valeurs, label='f(x) = sin(x) * exp(-x^2)')
[Link]('x')
[Link]('f(x)')
[Link]('Tracé d\'une fonction mathématique complexe')
[Link]()
[Link]()
[Link]()
[Link](intervalle, valeurs, label='f(x) = sin(x) * exp(-x^2)') :
Cette instruction trace la fonction mathématique complexe en utilisant les valeurs de
l'intervalle x sur l'axe des abscisses et les valeurs de la fonction f(x) sur l'axe des
ordonnées.
L'argument label est utilisé pour définir une étiquette pour cette courbe, qui sera utilisée
dans la légende du graphique.
[Link]('x') : Cette instruction définit le label de l'axe des abscisses, c'est-à-dire l'axe
horizontal, comme "x". Cela indique quelle variable est représentée sur cet axe.
[Link]('f(x)') : Cette instruction définit le label de l'axe des ordonnées, c'est-à-dire
l'axe vertical, comme "f(x)". Cela indique quelle fonction ou quelle quantité est représentée
sur cet axe.
[Link]('Tracé d\'une fonction mathématique complexe') :
Cette instruction définit le titre du graphique comme "Tracé d'une fonction mathématique
complexe". Cela fournit une description ou un titre pour le graphe,
aidant ainsi à interpréter son contenu.
[Link]() : Cette instruction ajoute une légende au graphe, basée sur les étiquettes
définies dans la fonction [Link]. Dans cet exemple, la légende affichera
f(x) = sin(x) * exp(-x^2) .
[Link]() : Cette instruction ajoute une grille au graphe pour une meilleure visibilité.
La grille est composée de lignes horizontales et verticales qui traversent le graphe,
facilitant ainsi l'estimation des valeurs des données.
[Link]() : Cette instruction affiche le graphe à l'écran.
Et pour tracer plusieurs graphe dans un seul fichier mes ensemble en utilise les
instruction représenter dans le programme suivant :
import numpy as np
import [Link] as plt

# Définir les fonctions f1(x), f2(x) et f3(x)

def f1(x):
return 5 * x**3 - 3 * x**2 + 10

def f2(x):
return 300 * [Link](x**2) - 10 * [Link](x**3)

def f3(x):
return 200 * [Link](0.5 * x**2) + [Link]((3 * x)**2 + 10) - 2 * [Link](x)

# Générer un ensemble de valeurs de x

x_i = [Link](-5, 5, 1000)

# Calculer les valeurs des fonctions pour chaque valeur de x_i

y1 = f1(x_i)
y2 = f2(x_i)
y3 = f3(x_i)
 # Tracer les courbes
[Link](figsize=(10, 6))

[Link](x_i, y1, label='f1(x)=5x^3-3x^2+10')

[Link](x_i, y2, label='f2(x)=300sin(x^2)-10cos(x^3)')
[Link](x_i, y3, label='f3(x)=200cos(0.5x^2)+log((3x)^2+10)-2e^x')

[Link]('x')
[Link]('y')
[Link]('Graphique des fonctions f1(x), f2(x) et f3(x)')
[Link]()

[Link](True)
[Link]()

[Link](figsize=(10, 6)) : Cette instruction crée une nouvelle figure avec une taille de 10
pouces de largeur et 6 pouces de hauteur. Cela permet de définir les dimensions de la figure
dans laquelle les courbes seront tracées.
[Link](x_i, y1, label='f1(x)=5x^3-3x^2+10') : Cette instruction trace la première courbe en
utilisant les valeurs de xi et les valeurs correspondantes de yi
comme ordonnées. L'argument label est utilisé pour définir une étiquette pour cette courbe,
qui sera utilisée dans la légende du graphe.
Et pour tracer plusieurs graphe indépendamment en utilise les instruction représenter dans
le programme suivant :

# Tracer la fonction f1(x)

[Link](figsize=(10, 6))
[Link](x_i, y1, label='f1(x)=5x^3-3x^2+10')
[Link]('x')
[Link]('f1(x)')
[Link]('Tracé de la fonction f1(x)')
[Link]()
[Link](True)
[Link]()

# Tracer la fonction f2(x)

[Link](figsize=(10, 6))
[Link](x_i, y2, label='f2(x)=300sin(x^2)-10cos(x^3)')
[Link]('x')
[Link]('f2(x)')
[Link]('Tracé de la fonction f2(x)')
[Link]()
[Link](True)
[Link]()
[Link](figsize=(12, 8))

[Link](3, 2, 1)
[Link](x_values, f1_prime_values, label="f1'(x)")
[Link]('x')
[Link]("f1'(x)")
[Link]("Dérivée première de f1(x)")
[Link]()

[Link](3, 2, 2)
[Link](x_values, f1_double_prime_values, label="f1''(x)")
[Link]('x')
[Link]("f1''(x)")
[Link]("Dérivée seconde de f1(x)")
[Link]()

[Link](3, 2, 3)
[Link](x_values, f2_prime_values, label="f2'(x)")
[Link]('x')
[Link]("f2'(x)")
[Link]("Dérivée première de f2(x)")
[Link]()
Et pour tracer plusieurs graphe indépendamment dans un seul fichier en utilise les instruction
représenter dans le programme suivant :
# Tracer la fonction f1(x)
[Link](figsize=(12, 8))

[Link](2, 2, 1)
[Link](x_i, y1, label="f1(x)")
[Link]('x')
[Link]("f1'(x)")
[Link]("Tracé de la fonction f1(x)")
[Link]()

[Link](2, 2, 2)
[Link](x_i, y2, label="f2(x)")
[Link]('x')
[Link]("f2'(x)")
[Link]("Tracé de la fonction f2(x)")
[Link]()
[Link](2, 2, 3)
[Link](x_i, y3, label="f3(x)")
[Link]('x')
[Link]("f3'(x)")
[Link]("Tracé de la fonction f3(x)")
[Link]()
3. La bibliothéque Sympy:
SymPy est une bibliothèque Python très utile pour le calcul symbolique. Elle offre une large
gamme de fonctionnalités pour effectuer des opérations symboliques telles que
la simplification d'expressions, le calcul de dérivées, d'intégrales, de limites, la résolution
d'équations, et bien plus encore.
Exemple suivant illustre comment SymPy peut être utilisé pour effectuer des calculs
symboliques simples, tels que la simplification d'expressions et le calcul de dérivées.
import sympy as sp

# Définir les symboles

x = [Link]('x')

# Définir l'expression mathématique complexe

expression = x**3 + 2*x**2 + x + 1 + 5*x**2+3*(x**2+8*x+9)+9*x**3

# Simplifier l'expression
expression_simplifiee = [Link](expression)

# Calculer la dérivée première

derivee_premiere = [Link](expression, x)

# Calculer la dérivée seconde

derivee_seconde = [Link](derivee_premiere, x)

# Afficher les résultats

print("Expression originale:", expression)
print("Expression simplifiée:", expression_simplifiee)
print("Dérivée première:", derivee_premiere)
print("Dérivée seconde:", derivee_seconde)
Cet exemple illustre comment utiliser la bibliothèque SymPy pour effectuer des calculs
bidimensionnels de dérivées partielles et d'intégrales doubles.
import sympy as sp
# Définir les symboles
x, y = [Link]('x y')

# Définir la fonction bidimensionnelle

f = x**2 * y + [Link](x*y)

# Calculer la dérivée partielle par rapport à x

derivee_x = [Link](f, x)

# Calculer la dérivée partielle par rapport à y

derivee_y = [Link](f, y)

# Calculer l'intégrale double sur un rectangle [-1, 1]x[-1, 2]

integrale_double = [Link]([Link](f, (x, -1, 1)), (y, -1, 2))

# Afficher les résultats

print("Fonction bidimensionnelle f(x, y):", f)
print("Dérivée partielle par rapport à x:", derivee_x)
print("Dérivée partielle par rapport à y:", derivee_y)
print("Intégrale double sur [-1, 1]x[-1, 1]:", integrale_double)
Cet exemple illustre comment SymPy peut être utilisé pour effectuer des calculs différentiels
(dériver) , les intégral analytique à la fois sur des fonctions simples et compliqué et même
sur des Intervalles donnés.
import sympy as sp

# Définir le symbole et la fonction

x = [Link]('x')
f = x**2 + 3*x + 2

# Calculer la dérivée première

derivee_premiere = [Link](f, x)

# Calculer l'intégrale indéfinie

integrale_indefinie = [Link](f, x)

# Calculer l'intégrale définitive sur l'intervalle [-1, 1]

integrale_definie = [Link](f, (x, -1, 1))

# Afficher les résultats

print("Fonction originale f(x):", f)
print("Dérivée première:", derivee_premiere)
print("Intégrale indéfinie:", integrale_indefinie)
print("Intégrale définitive sur [-1, 1]:", integrale_definie)
 Chapitre 4 : programmation orientée
objet

1. Les classes
2. l'Encapsulation
3. l'Héritage en Programmation Orientée Objet (POO)
4. Héritage Multiple en Python
5. Exemples d’explication
 II. La programmation orientée objet
(POO)

Introduction: Historiquement, la solution aux problèmes logiciels, consistait à

diviser une tâche complexe en plusieurs sous-taches (procédures ou fonctions)
et à diviser ces sous- tâches en d’autres sous-tâches encore plus petites (d’autres
procédures ou fonctions). En utilisant des méthodes séquentiels.
Cette approche présente certains inconvénients. Si nous voulons en réutiliser une partie, nous
remarquons que les fonctions sont liées à des données partagées avec d’autres fonctions. Il
est donc difficile d’isoler une partie du programme ou de le faire évoluer. Dans ce cas de
figure, lorsqu’un programme devient important, il peut s’avérer difficile de s’y retrouver.

La POO (programmation Orienté Objet) permet de traiter ce problème en offrant une

programmation modulaire extrêmement structurée, très lisible et surtout réutilisable.

La programmation orientée objet, ou POO, est un modèle de programmation qui repose sur le
concept de classes et d'objets. Elle est utilisée pour structurer un programme logiciel en
éléments de code simples et réutilisables, généralement appelés classes, qui sont utilisés pour
créer des instances individuelles d'objets. Il existe de nombreux langages de programmation
orientés objet, notamment JavaScript, C++, Java et Python
En programmation orientée objet (POO), les objets et les classes sont des concepts
fondamentaux. Voici une explication plus détaillée de ces deux notions :

[Link] :
Une classe est un modèle ou un plan qui définit les caractéristiques communes et le
comportement des objets.

Elle agit comme un schéma à partir duquel des objets spécifiques (instances) peuvent
être créés.

Elle encapsule les données (attributs) et les méthodes (fonctions) qui opèrent sur ces
données.

Une classe est une abstraction qui représente un concept ou une entité du monde réel.

En Python, la syntaxe pour définir une classe est relativement simple.

Voici un exemple basique de création d'une classe "Voiture" avec des attributs et des
méthodes
 La commande def en Python est utilisée pour définir des fonctions,
y compris les méthodes dans la programmation orientée objet (POO).
En POO, une méthode est essentiellement une fonction qui est définie à l'intérieur d'une
classe et agit sur une instance de cette classe.
La syntaxe générale de la déclaration d'une méthode en POO avec def est la suivante :
class Etudiant:
def __init__(self, nom, age, matricule):

Les méthodes __init__ et self sont des concepts fondamentaux en programmation orientée
objet en Python.
La méthode __init__ est un constructeur spécifique en Python. Elle est appelée
automatiquement lors de la création d'une nouvelle instance de classe.
Son rôle principal est d'initialiser les attributs de l'objet.
Elle peut prendre plusieurs paramètres en plus de self (qui est une référence à l'instance
en cours).
Voici un exemple :
Dans cet exemple, lorsque vous créez une instance de la classe Etudiant,
la méthode __init__ est automatiquement appelée et initialise les attributs nom, age
et matricule avec les valeurs fournies en tant que paramètres
self est une convention en Python pour désigner la première variable des méthodes
d'une classe. Elle représente l'instance de la classe elle-même.
L'utilisation de self permet d'accéder aux attributs et aux méthodes de l'objet à
l'intérieur de la classe. Voici un exemple :
class Etudiant:
def __init__(self, nom, age, matricule, situation_familiale):
[Link] = nom
[Link] = age
[Link] =matricule

En résumé,
__init__ est utilisée pour initialiser les attributs lors de la création d'une
instance, et self est utilisé pour faire référence à l'instance elle-même à l'intérieur
des méthodes de la classe.
Pour définir une méthode, il faut :
 Indiquer son nom
 Indiquer les arguments entre des parenthèses.
 Le premier argument d'une méthode doit être self.
1. 2 Représentation d’un objet
Pour accéder aux méthodes d'un objet, on indique :
 le nom de la variable qui fait référence à cet objet
 un point
 le nom de la méthode
Exemple :
# Définition de la classe Voiture
class Voiture:
# Le constructeur (__init__) initialise les attributs de l'objet
def __init__(self, marque, modele, annee):
[Link] = marque Dans cet exemple, la classe Voiture a un constructeur
[Link] = modele __init__ qui est appelé lors de la création d'un nouvel objet.
[Link] = annee Ce constructeur initialise les attributs de l'objet
(marque, modele, annee).La classe a également une méthode
# Méthode pour démarrer la voituredemarrer qui affiche un message indiquant que la voiture démarre
def demarrer(self):
print(f"La voiture {[Link]} {[Link]} démarre.")

# Instanciation d'un objet de la classe Voiture

ma_voiture = Voiture(marque= "chevroler", modele= "sparck", annee=2012)

# Utilisation des attributs et méthodes de l'objet

print(f"Année de la voiture : {ma_voiture.annee}")
ma_voiture.demarrer()

Ensuite, un objet ma_voiture est créé en représenté la classe Voiture avec des valeurs
spécifiques pour les attributs.
Enfin, on accède aux attributs de l'objet (annee) et on appelle sa méthode (demarrer)
Vous pouvez ajouter d'autres méthodes et attributs selon les besoins de votre application.
La POO en Python permet également l'héritage, l'encapsulation et le polymorphisme,
offrant ainsi des fonctionnalités avancées pour la modélisation de systèmes complexes

Exemple 02:
Supposons que nous voulions modéliser des étudiants et leurs cours;
voici un exemple simple d'un programme orienté objet en Python:
class Etudiant:
def __init__(self, nom, age, matricule):
[Link] = nom La classe Etudiant a un constructeur
[Link] = age __init__
[Link] = matricule pour initialiser les attributs de l'étudiant
self.cours_inscrits = [] (nom, âge, matricule) et une liste vide pour
les cours auxquels il est inscrit.
def s_inscrire_au_cours(self, cours):
self.cours_inscrits.append(cours)
print(f"{[Link]} s'est inscrit au cours de {cours}")

def afficher_informations(self):
print(f"Nom: {[Link]}, Age: {[Link]}, Matricule: {[Link]}")
print("Cours inscrits:") La méthode s_inscrire_au_cours permet à un
for cours in self.cours_inscrits: étudiant de s'inscrire à un cours
print(f"- {cours}") en ajoutant le cours à sa liste de cours inscrits.

La méthode afficher_informations affiche

les informations de l'étudiant,
y compris la liste des cours inscrits.
# Création d'objets étudiants
etudiant1 = Etudiant("Ahmed", 20, "12345")
etudiant2 = Etudiant(« ali", 22, "67890")

# Création d'objets cours Nous créons ensuite deux objets étudiants

cours1 = "Mathématiques" (etudiant1 et etudiant2) et deux objets cours
cours2 = "Informatique" (cours1 et cours2).
Les étudiants s'inscrivent à des cours,
# Inscription d'étudiants aux cours et nous affichons ensuite leurs informations.
etudiant1.s_inscrire_au_cours(cours1)
etudiant2.s_inscrire_au_cours(cours1)
etudiant2.s_inscrire_au_cours(cours2)

# Affichage des informations des étudiants

etudiant1.afficher_informations()
etudiant2.afficher_informations()
 4. l'Héritage en Programmation Orientée Objet (POO)

4.1. Introduction à l'Héritage :

L'héritage est l'un des principes fondamentaux de la programmation orientée objet (POO).
Il permet de créer une nouvelle classe en réutilisant les caractéristiques (attributs et
méthodes) d'une classe existante, appelée classe parente ou classe de base.
4.2. Classe Parente (ou Classe de Base) :
La classe dont on hérite est appelée classe parente.
Elle définit les caractéristiques générales que les classes dérivées vont hériter

4.3. Classe Dérivée (ou Sous-classe) :

La classe qui hérite d'une classe parente est appelée classe dérivée.
Elle hérite des attributs et méthodes de la classe parente et peut également en ajouter ou
en modifier
4.4. Syntaxe de l'Héritage en Python :
class ClasseParente:
# Définition des attributs et méthodes de la classe parente

class ClasseDerivee(ClasseParente):
# Définition des attributs et méthodes spécifiques à la classe dérivée
4. 5. Accès aux Attributs et Méthodes Hérités :
Les attributs et méthodes de la classe parente peuvent être accédés directement depuis
la classe dérivée.
Utilisation de la fonction super() pour appeler les méthodes de la classe parente.
4.6. Exemple concret d'Héritage :
class Vehicule:
def __init__(self, marque, annee,couleur, moteur):
[Link] = marque
[Link] = annee
[Link]=couleur
[Link]=moteur

def afficher_info(self):
print(f"Véhicule de {[Link]}, année {[Link]},couleur {[Link]}, moteur
{[Link]}")

class carburant(Vehicule):
def __init__(self, marque, annee, couleur, moteur, modele,option):
super().__init__(marque, annee, couleur, moteur)
[Link] = modele
[Link]=option
 def afficher_info(self):
super().afficher_info()
print(f"Modèle: {[Link]}")
print(f"cette voiture ce dispose des option suivant:{[Link]}")

class électrique(Vehicule):
def __init__(self, marque, annee,couleur,moteur,modele, énergie):
super().__init__(marque, annee, couleur, moteur)
[Link] = modele
self.énergie=énergie
def afficher_info(self):
super().afficher_info()
print(f"Modèle: {[Link]},énergie:{self.énergie}")

class hybrid(Vehicule):
def __init__(self, marque, annee,couleur,moteur, modele, systémme_de_controle,
protection):
super().__init__(marque, annee, couleur, moteur)
[Link] = modele
[Link]émme_de_controle=systémme_de_controle
[Link]=protection
def afficher_info(self):
super().afficher_info()
print(f"Modèle: {[Link]},systémme de controle:{[Link]émme_de_controle}")
print(f"elle est renforcée par un systéme de protection type:{[Link]}")

# Création d'une instance de la classe Voiture

ma_voiture = carburant("chevrolet", 2010, "gris", 1.2 , "sparck","jante en alliage,vitre
électrique,systeme anti pollution ")
amin_voiture=électrique("tesla",2023,"rouge", " « Tri-Motor »", " readster","électrique")
ali_voiture=hybrid("toyota",2022, "gris","1.4-éssance avec un moteur électrique y","yaris",«
électrique","A-V-P-W")

# Appel de la méthode afficher_info de la classe Voiture

print("ma est une:")
ma_voiture.afficher_info()
#print("la voiture de ali est une:")
#ali_voiture.afficher_info()
#print ("la voiture de amin est une:")
#amin_voiture.afficher_info()
4.7 Utilisation de la fonction super() en Héritage en Python

La fonction super() est une fonction intégrée en Python qui est couramment utilisée dans
le contexte de l'héritage en programmation orientée objet.
Elle permet d'appeler une méthode de la classe parente (classe mère) dans la classe enfant
(classe dérivée).
Cela facilite l'accès et la manipulation des attributs et méthodes de la classe parente dans la
classe enfant, comme il est représenter dans l’exemple précédant
Avantages de la fonction super()
Accès aux Méthodes Parentes : La fonction super() permet d'accéder facilement aux méthodes
de la classe parente depuis la classe enfant
Facilite les Changements : En cas de modification de la méthode dans la classe parente, la mise
à jour se propage automatiquement à toutes les classes dérivées.
Conclusion
La fonction super() en Python est un outil puissant qui facilite l'héritage et la création de
hiérarchies de classes.
Elle contribue à la lisibilité et à la maintenance du code en facilitant l'accès aux fonctionnalités
de la classe parente.
En l'utilisant correctement, vous pouvez créer une structure d'héritage bien organisée et
cohérente dans vos programmes orientés objet.
 4.8. Avantages de l'héritage:

Réutilisation du Code : L'héritage permet de réutiliser le code existant, ce qui contribue à une
meilleure organisation du programme.
Hiérarchie Logique : La structure d'héritage permet de créer une hiérarchie logique entre les
classes, rendant le code plus compréhensible.

Maintenance Facile : Les modifications apportées à la classe mère se reflètent automatiquement

dans toutes les classes dérivées, simplifiant la maintenance.

5. Héritage Multiple en Python

L'héritage multiple est une fonctionnalité en programmation orientée objet (POO) qui permet
à une classe d'hériter des attributs et des méthodes de plusieurs classes parentes.

Bien que Python supporte l'héritage multiple, il faut l'utiliser avec prudence pour éviter des
conflits potentiels. Dans cet article, nous explorerons l'héritage multiple en Python, ses
avantages, ses challenges, et comment les surmonter.
5.1Syntaxe de l'Héritage Multiple

La syntaxe de l'héritage multiple en Python est relativement simple. Vous pouvez déclarer
une classe qui hérite de plusieurs classes parentes comme suit :

class ClasseA:
# Attributs et méthodes de la classe A

class ClasseB:
# Attributs et méthodes de la classe B

class ClasseC(ClasseA, ClasseB):

# Attributs et méthodes de la classe C

Dans cet exemple, la classe Classe C hérite à la fois des attributs et des méthodes de Classe A
et ClasseB.

5.2Résolution des Conflits avec la fonction super()

Lorsque vous utilisez l'héritage multiple, il peut y avoir des conflits si les classes parentes
ont des méthodes ou des attributs avec le même nom. La fonction super() peut être utilisée
pour résoudre ces conflits. Voici un exemple
class ClasseA:
def methode(self):
print("Méthode de ClasseA")

class ClasseB:
def methode(self):
print("Méthode de ClasseB")

class ClasseC(ClasseA, ClasseB):

def methode(self):
super(ClasseB, self).methode()
super(ClasseA, self).methode()
print("Méthode de ClasseC")

Dans cet exemple, la classe ClasseC utilise super() pour appeler les méthodes des classes
parentes ClasseA et ClasseB. Cela permet de gérer les conflits de manière plus contrôlée
6. Exemples d’explication
Dans le prochain exemple on va Créez une classe Projet avec les attributs nom et
description.
Ensuite, créez des classes dérivées Tache et Risque.
Enfin, créez une classe Projet Avec Risque qui peut hériter à la fois de Projet et Risque
pour gérer un projet avec des éléments de risque.

class Projet:
def __init__(self, nom, description):
[Link] = nom
[Link] = description

def afficher_info(self):
print(f"Projet: {[Link]}")
print(f"Description: {[Link]}")

class Tache(Projet):
def __init__(self, nom, description, duree):
super().__init__(nom, description)
[Link] = duree
def afficher_info(self):
super().afficher_info()
print(f"Duree de la tâche: {[Link]} jours")

class Risque:
def __init__(self, description_risque, niveau):
self.description_risque = description_risque
[Link] = niveau

def afficher_risque(self):
print(f"Description du risque: {self.description_risque}")
print(f"Niveau de risque: {[Link]}")

class ProjetAvecRisque(Projet, Risque):

def __init__(self, nom, description, description_risque, niveau):
# Utilisation de super() pour appeler les constructeurs de Projet et Risque
super().__init__(nom, description)
Risque.__init__(self, description_risque, niveau)

def afficher_info(self):
super().afficher_info()
self.afficher_risque()
# Exemple d'utilisation
projet_risque = ProjetAvecRisque("Projet ABC", "Un projet avec des risques",
"Problèmes de budget", "Élevé")
projet_risque.afficher_info()

Dans cet exemple, la classe Projet est la classe de base, les classes Tache et Risque en sont
les classes dérivées.
La classe ProjetAvecRisque hérite à la fois de Projet et Risque pour gérer un projet qui peut
avoir des éléments de risque.
Vous pouvez créer des instances de cette classe et utiliser les méthodes pour afficher
les informations du projet et les risques associés.

Exemple 02
Ecrire un programme en python pour criée une classe parant (Personne) avec les attribues
(nom, âge) ; en suite deux classe (Etudiant) et (Enseignant) héritent de la classe de base
Personne avec les attribue suivant (nom, âge, matricule) pour la classe (Etudiant) et (nom,
âge, matière) pour la classe (Enseignant). Déclarée pour chaque classe une méthode
afficher_info qui affiche des informations spécifiques à la classe, avec des informations
générales héritées de la classe Personne.
class Personne:
def __init__(self, nom, age):
[Link] = nom
[Link] = age

def afficher_info(self):
print(f"Nom: {[Link]}, Age: {[Link]}")

class Etudiant(Personne):
def __init__(self, nom, age, matricule):
super().__init__(nom, age)
[Link] = matricule

def afficher_info(self):
super().afficher_info()
print(f"Matricule: {[Link]}")
class Enseignant(Personne):
def __init__(self, nom, age, matiere):
super().__init__(nom, age)
[Link] = matiere

def afficher_info(self):
super().afficher_info()
print(f"Matière enseignée: {[Link]}")

# Exemple d'utilisation
personne1 = Personne("Ali", 30)
etudiant1 = Etudiant("ahmed", 20, "E12345")
enseignant1 = Enseignant("amel", 40, "Mathématiques")

personne1.afficher_info()
etudiant1.afficher_info()
enseignant1.afficher_info()
 Exemple 03:
Créez une classe Livre avec les attributs suivants : titre, auteur, annee_publication.
Ensuite, créez une classe Bibliothèque qui peut stocker plusieurs livres.
Ajoutez des méthodes pour ajouter un livre, supprimer un livre et afficher tous les livres
de la bibliothèque.
class Livre:
def __init__(self, titre, auteur, annee_publication):
[Link] = titre
[Link] = auteur
self.annee_publication = annee_publication

def __str__(self):
return f"{[Link]} par {[Link]}, publié en {self.annee_publication}"

class Bibliotheque:
def __init__(self):
[Link] = []

def ajouter_livre(self, livre):

[Link](livre)
print(f"{[Link]} a été ajouté à la bibliothèque.")
def supprimer_livre(self, titre):
for livre in [Link]:
if [Link] == titre:
[Link](livre)
print(f"{[Link]} a été supprimé de la bibliothèque.")
return
print(f"Aucun livre avec le titre {titre} n'a été trouvé dans la bibliothèque.")

def afficher_livres(self):
print("Livres dans la bibliothèque:")
for livre in [Link]:
print(livre)

# Exemple d'utilisation
livre1 = Livre("la derniére nuit du rais", "yasmina khadra", 2016)
livre2 = Livre("nedjma", "kateb yacine", 2004)
livre3 = Livre("Le sommeil du juste", "Mouloud Mammeri", 1976)

biblio = Bibliotheque()
biblio.ajouter_livre(livre1)
biblio.ajouter_livre(livre2)
biblio.ajouter_livre(livre3)

biblio.afficher_livres()

biblio.supprimer_livre("nedjma")

biblio.afficher_livres()
1.3. Attributs en Python :
Les attributs sont des variables liées à une classe ou à une instance.
Ils définissent les caractéristiques d'un objet.
En Python, les attributs peuvent être publics ,privés ou protégés

3. l'Encapsulation :
L'encapsulation est le fait de regrouper les données (attributs) et les méthodes qui les
manipulent au sein d'une même unité (la classe).
Elle permet de cacher l'implémentation interne d'un objet et de ne montrer que ce qui
est nécessaire à l'utilisateur.

3.1 Encapsulation des Attributs :

Les attributs privés commencent généralement par un double underscore (__).
Exemple : __attribut_prive.
Les attributs privés ne sont pas accessibles directement depuis l'extérieur de la classe.
3.2 Méthodes d'Accès :
Pour accéder aux attributs privés, on utilise généralement des méthodes d'accès
(getters et setters).
Un getter permet de récupérer la valeur d'un attribut privé.
Un setter permet de modifier la valeur d'un attribut privé.
class Personne: # Définition de la classe Personne :
def __init__(self, nom, age):
[Link] = nom
self.__age = age # Attribut privé

def afficher_informations(self):
print(f"Nom: {[Link]}, Âge: {self.__age}")

def anniversaire(self):
self.__age += 1
print(f"Joyeux anniversaire ! Nouvel âge : {self.__age}")

# Utilisation de la classe
personne1 = Personne("Ali", 30)

# Tentative d'accéder à l'attribut privé directement (ce qui générera une erreur)
# print(personne1.__age)

# Utilisation des méthodes publiques pour accéder à l'attribut privé

personne1.afficher_informations()
[Link]()
personne1.afficher_informations()
class CompteBancaire:
def __init__(self, titulaire, solde=0):
self.__titulaire = titulaire
self.__solde = solde

def get_titulaire(self):
return self.__titulaire

def get_solde(self):
return self.__solde

def deposer(self, montant):

if montant > 0:
self.__solde += montant
print(f"{montant} dinars déposés. Nouveau solde : {self.__solde} dinars.")
else:
print("Le montant doit être supérieur à 0.")
def retirer(self, montant):
if 0 < montant <= self.__solde:
self.__solde -= montant
print(f"{montant} dinars retirés. Nouveau solde : {self.__solde} dinars.")
else:
print("Montant invalide ou solde insuffisant.")

# Utilisation de la classe
compte1 = CompteBancaire("Ali", 100000)
print(compte1.get_titulaire())
print(compte1.get_solde())
[Link](50000)
[Link](20000)