Enseignante : Pr.

Houda ANOUN
[email protected]
Participation & discipline
Présence
Mini-projet
Quizs à l’improviste
Examen final
 Maitrise de la syntaxe du langage Python
 Compréhension d’un code Python et exécution pas à pas sur papier
 Développement de l’art de la programmation en python :
 Apprendre à penser de manière algorithmique pour résoudre un problème
 Encourager l’utilisation de bonnes pratiques de programmation : lisibilité, modularité
réutilisabilité de code
 Promouvoir la recherche de solutions élégantes et efficaces
 Favoriser la créativité dans la résolution de problèmes (interdiction d’utiliser les modèles de
langage de type ChatGPT pour résoudre les exercices)
 Favoriser l’expérimentation et l’esprit critique : explorer différents algorithmes et identifier
le plus performant
 Mini-projet : mettre en pratique les compétences acquises et encourager le travail en équipe
 Eléments de base du langage Python
 Variables
 Types élémentaires et opérateurs
 Entrées /sorties
 Structures conditionnelles et itératives
 Fonctions
 Modules
 Structures de données prédéfinies : listes, tuples, strings, ensembles et dictionnaires
 Manipulation des fichiers
 Classes et objets
 Python est un langage de programmation interprété : chaque ligne de
code est lue puis interprétée pour être exécutée par l’ordinateur
 Atouts :
 Multiplateforme : il fonctionne sur de nombreux systèmes
d'exploitation :Windows, Mac OS X, Linux, Android, iOS
 Facile à appréhender
 C'est un langage de haut niveau. Il demande relativement peu de
connaissances sur le fonctionnement d'un ordinateur pour être utilisé
 Riche : types de données, branchements conditionnels, boucles,
organisation du code en procédures et fonctions, objets et classes
 Il dispose de plusieurs librairies très performantes, notamment pour le
calcul scientifique et IA(Numpy, Pandas, Scikit-learn, Keras etc)
 Dans un interpréteur de
commandes, le symbole >>>
correspond au signal d’invite,
(prompt principal), il indique que
Python est prêt à exécuter une
commande.
 Les lignes non précédées de ce
symbole correspondent à l’affichage
d’un résultat.
 Après avoir saisi chaque instruction,
il suffit de taper sur la touche Entrer
pour que la commande soit
exécutée (interprétée)
 Une variable est une zone de la mémoire de l’ordinateur dans laquelle une valeur est stockée
 En Python, la déclaration d’une variable et son initialisation se font en même temps.
 Les variables en Python sont dynamiquement typées, ce qui signifie que le type d'une variable
peut changer au cours de l'exécution du programme.
 Exemple :

 x est l’identifiant de la variable

 Python va automatiquement « deviner » que
x est de type float : typage dynamique
 = est l’opérateur d’affectation
 La fonction type(x) permet de déterminer
le type de la variable x
 Le nom des variables (identifiant) en Python peut être constitué de
lettres minuscules (a à z), de lettres majuscules (A à Z), de chiffres (0 à
9) ou du caractère souligné (_). Il est interdit d’utiliser l’espace dans un
nom de variable.
 Un nom de variable ne doit pas débuter par un chiffre et il n’est pas
recommandé de le faire débuter par le caractère _
 De plus, il faut absolument éviter d’utiliser un mot « réservé » par
Python comme nom de variable (par exemple : print, for, from, etc.).
 Python est sensible à la casse, ce qui signifie que les variables TesT,
test ou TEST sont différentes
 L’opération d’affectation est représentée par le signe =
 L’affectation établit un lien entre le nom de la variable et sa valeur (son contenu).
 Exemples :
>>> n = 7 # définir la variable n et lui donner la valeur 7
>>> msg = "Quoi de neuf ?" # affecter la valeur "Quoi de neuf ?" à msg
>>> pi = 3.14159 # assigner la valeur 3.14159 à la variable pi
 Sous Python, on peut assigner une valeur à plusieurs variables simultanément.
 Exemple :
>>> x = y = 7
>>> print(x, y)
77
 On peut aussi effectuer des affectations parallèles a l’aide d’un seul opérateur :
 Exemple :
>>> a, b = 4, 8.33
>>> print(a, b)
4 8.33
 Numérique : int (entiers), float (réels)
 Opérations applicables : + , - , *, / (division réelle), ** (puissance), % (modulo), // (division entière)
 Exemples : ((1 + 2)**2)/2 = 4.5, 7%3=1, (3*5)//7=2
 Remarque : La taille des entiers n'est limitée que par la mémoire de la machine

 bool : correspond au type booléen, il prend deux valeurs possibles True et False
 Opérations applicables : not (négation logique), and (ET logique), or (OU logique), ^ (ou exclusif)
 Exemples : not (False) and True = True, not(False or True)=False

 str : désigne les chaînes de caractères. Une constante chaîne de caractères doit être délimitée par
des guillemets (ou des quotes)
 Opérations applicables :
 + : concatène (assemble) deux chaînes de caractères.
 * : l’opération s * n (où n est un nombre entier) duplique (répète) la chaine s, n fois.
 Exemples : "A" + "B" = "AB", ("A" + "B")*3 = "ABABAB"
 Conversion en numérique :
 s= "2023.5" #s est de type chaîne de caractères
 a= float(s) #a est de type float, sa valeur est 2023.5
 b= int(a) #b est de type int, sa valeur est 2023
 Remarque : Si la conversion n’est pas possible, ex. float("toto"), Python renvoie une erreur

 Conversion en booléen :
 a= bool("TRUE") #a est de type bool, elle contient la valeur True
 a= bool(1) #la valeur de a est True également

 Conversion en chaîne de caractères :

 a= str(15) # a est de type chaîne et contient "15"
 Pour rendre un script plus lisible pour les autres programmeurs qui voudraient comprendre
son fonctionnement, on peut rajouter des explications (commentaires).
 Les commentaires sont ignorés par l’interpréteur Python
 Syntaxe :
 Sur une seule ligne :
age = 20 #initialisation de la variable age
 Sur plusieurs lignes :
"""
Auteur : Houda ANOUN
Date : Septembre 2023
Objectif : le programme permet de calculer la somme des chiffres d’un entier n saisi au clavier
"""
 Prédire le résultat de chacune des instructions suivantes, puis vérifiez-le dans
l’interpréteur Python :
 (1+2)**3
 "HI" * 4
 "HI" + 3
 ("Py"+"thon") * 2
 ("HI"*4) / 2
 5/2
 5 // 2
5%2
 int("3") + float("3.2")
 float("3") + int("3.2")
 str(3) * float("3.2")
 La fonction print() est une fonction intégrée en Python utilisée pour afficher des
messages à la console
 La syntaxe de base de print() est la suivante :

 Les objets sont les éléments qu’on souhaite afficher. Ils peuvent être des variables, des
constantes ou des expressions.
 sep est un paramètre optionnel qui spécifie le séparateur entre les objets à afficher. Par
défaut, il est égal à l’espace (sep =' ')
 end est un autre paramètre optionnel qui spécifie le caractère de fin de ligne à afficher
après les objets. Par défaut, il est égal au saut de ligne (end ='\n').
 Les littéraux de chaînes de caractères formatées, également appelés f-strings, sont
introduits à partir de la version Python 3.6
 Ils permettent d'insérer des expressions Python à l'intérieur des chaînes de caractères
en utilisant des accolades { }.
 Exemples :
 La fonction input() permet de demander à l'utilisateur de saisir une valeur à partir du
clavier. Elle peut récupérer en paramètre un message d’invite qui sera affiché
 Elle renvoie la valeur saisie sous forme de chaîne de caractères.
 Exemple :

 Remarque : La fonction input() renvoie toujours une chaîne, il faut la convertir en cas de
besoin
Instructions conditionnelles et itératives
 Syntaxe Organigramme

if condition :
Bloc Instructions A

 La condition est une expression booléenne qui prend pour valeur

True (vrai) ou False (faux)

 L’instruction if permet de tester la validité de la condition :

 si la condition est vraie alors le bloc d’instructions A que nous avons indenté
après le : est exécuté.
 si la condition est fausse, le bloc d’instructions A est ignoré.
 Exemples :

Avec condition vraie Avec condition Fausse

x = 15 x=3
if x > 10: if x > 10:
print("Youpi!") print("Youpi")
print(x, "est plus grand que 10") print(x, "est plus grand que 10")
print("Fin") print("Fin")
Affichage après l’exécution : Affichage après l’exécution :
Youpi! Fin
15 est plus grand que 10
Fin
 Un bloc est défini par une indentation obtenue en décalant le début des
instructions vers la droite grâce à des espaces en début de ligne
(habituellement 4 espaces mais ce n’est pas obligatoire).
 Toutes les instructions d’un même bloc doivent être indentées exactement
au même niveau (c’est-à-dire décalées à droite d’un même nombre
d’espaces).
 Exemple :
if(9 > 5) :
print("9 est plus grand que 5")
print("5 est plus petit que 9")
IndentationError !!
 Syntaxe Organigramme

if condition :
Bloc d’Instructions A
else :
Bloc d’Instructions B
 Avec conditions vraie Avec condition fausse
x=5 x = -5
if x > 0: if x > 0:
print(x, "est positif") print(x, "est positif")
else: else:
print(x, "est négatif ou nul") print(x, "est négatif ou nul")
print("Fin") print("Fin")

Affichage après l’exécution : Affichage après l’exécution :

5 est positif -5 est négatif ou nul
Fin Fin
 Les opérateurs de comparaison servent à comparer des valeurs de même type et renvoient
un résultat de type booléen.
 On les utilise pour former les conditions des instructions conditionnelles et itératives

 Exemples :
>>> 12==13
False
>>> not(12 >= 13) and (6 != 7)
True
 Syntaxe Organigramme

if condition 1 :
Bloc d’Instructions 1
elif condition 2 :
Bloc d’Instructions 2
….
elif condition n-1 :
Bloc d’Instructions n-1
else :
Bloc d’Instructions n
 Exemple 1 Exemple 2
a = 16 a = 20
if ( a <= 17 ) : if ( a <= 17 ) :
print ("Vous êtes mineur") print ("Vous êtes mineur")
elif ( a == 18 ) : elif ( a == 18 ) :
print("Vous venez d'atteindre la majorité") print("Vous venez d'atteindre la majorité")
else : else :
print ("Vous êtes majeur") print ("Vous êtes majeur")

Affichage après l’exécution : Affichage après l’exécution :

Vous êtes mineur Vous êtes majeur

 Ecrire un programme qui affiche en fonction d’une
valeur saisie au clavier, l’un des messages suivants :
Ce nombre est pair
Ce nombre est impair, mais est multiple de 3
Ce nombre n’est ni pair ni multiple de 3
 Voici un scénario d’exécution :
Nombre? 7
Ce nombre n’est ni pair ni multiple de 3
 Les boucles s’utilisent pour répéter plusieurs fois
l’exécution d’un bloc d’instructions
 2 catégories de boucles :
 Boucle bornée : quand on connait à l’avance le nombre
d’itérations, on utilise généralement une boucle for.
 Boucle non bornée : si on ne connait pas à l’avance le
nombre d’itérations, on utilise une boucle while
 La boucle for permet de parcourir les éléments d’une séquence telle que une liste
ou une chaîne de caractères

Exemple 1 Exemple 2 Exemple 3

for i in [0, 1, 2, 3]: for i in range(4): chaine = "Hello"
print("i = ", i) print("i = ", i) for i in chaine :
print(i)
Affichage : Affichage : Affichage :
i=0 i=0 H
i=1 i=1 e
i=2 i=2 l
i=3 i=3 l
o
 La fonction range() permet de générer une suite arithmétique d’entiers
 Il existe trois façons d’appeler range() :
 range(stop) : la suite générée contient les entiers de 0 à stop - 1
 range(start, stop) : la suite générée contient les entiers de start à stop - 1
 range(start, stop, step) : step détermine le pas entre deux entiers de la séquence

 Exemples :
 range(4) = [0, 1, 2, 3]
 range(1, 3) = [1, 2]
 range(1, 6, 2) = [1, 3, 5]
 Qu’affiche le programme suivant ?
 La boucle while répète l’exécution d’un bloc d’instruction tant qu’une condition est
vraie

Syntaxe Organigramme

while condition :
Bloc Instructions A
 Exemple : calcul de n! (n!= 1* 2* 3* …*n)
n =int(input("Saisir la valeur de n : "))
i =1
f =1
while(i<=n):
f=f * i
i=i +1
print("La factorielle de ", n, "est : ", f)
Scénario d’exécution :
Saisir la valeur de n : 4
La factorielle de 4 est : 24
 Ecrire un programme qui lit un entier naturel n et qui calcule puis affiche la somme
de ses chiffres.
 Voici un scénario d’exécution :
Votre entier ? 2023
La somme des chiffres de 2023 est 7
Indication :
Utiliser les opérateurs arithmétiques % et // :
n%10 est le chiffre des unités de n
n//10 : n privé de son chiffre des unités
 L’instruction break permet de « casser » l’exécution d’une boucle while ou for
Exemple
while True:
n = int(input("donnez un entier > 0 : "))
print("vous avez fourni", n)
if n > 0:
break
print("reponse correcte")
Scénario d’exécution :
donnez un entier > 0 : -5
vous avez fourni -5
donnez un entier > 0 : -2
vous avez fourni -2
donnez un entier > 0 : 1
vous avez fourni 1
reponse correcte
 L’instruction continue permet de passer prématurément au tour suivant de la boucle

Exemple Affichage

debut iteration 0
bonjour
for i in range(4): debut iteration 1
print("debut iteration", i) bonjour
print("bonjour") debut iteration 2
if i < 2: bonjour
continue fin iteration 2
print("fin iteration", i) debut iteration 3
print("apres la boucle") bonjour
fin iteration 3
apres la boucle
  Dans plusieurs langages, il existe une instruction do…while (Répèter … jusqu’à) qui permet
de créer une boucle non bornée mais qui doit s’exécuter au moins une fois.
 Cette instruction n’existe pas en Python, mais on peut facilement simuler son fonctionnement
comme suit :
import random Scénario d’exécution:
# Génération d'un nombre secret entre 1 et 10
nombre_secret = random.randint(1, 10) Devinez le nombre secret entre 1 et 10 : 5
while True: Essaie encore
# Demander à l'utilisateur de deviner le nombre Devinez le nombre secret entre 1 et 10 : 2
guess = int(input("Devinez le nombre secret entre 1 et 10 : ")) Essaie encore
if guess == nombre_secret: Devinez le nombre secret entre 1 et 10 : 3
print("Félicitations, vous avez deviné le nombre secret !") Félicitations, vous avez deviné le nombre
break # Sortir de la boucle si l’utilisateur devine le nombre secret !
else: Fin du jeu.
print("Essaie encore. ")
print("Fin du jeu.")
 Il est possible de créer des boucles imbriquées en Python (des boucles qui contiennent
une ou plusieurs autres boucles).
 La forme la plus courante est une boucle for imbriquée dans une autre boucle for, mais on
peut également avoir n’importe quelles combinaisons de boucles imbriquées

Exemple Affichage

*
for i in range(7) : **
for j in range(i) : ***
print('*', end=" ") ****
print() #pour effectuer un retour à la ligne *****
******
Ecrire un programme qui lit un entier n et qui affiche sur des lignes séparées, n
suites d’entiers où la ième suite contient les entiers de 1 jusqu’à i.
Scénario d’exécution :
Pour n = 5, on obtiendra l’affichage suivant :
1
12
123
1234
12345
 Une fonction Python est une suite d’instructions, regroupées dans un bloc de code
nommé, qui sera exécuté à la demande
 Avantages :
 La réutilisation du code : éviter de répéter les mêmes séries d’instructions à plusieurs endroits
d’un programme ;
 La modularité : découper une tâche complexe en plusieurs sous-tâches plus simples.
 Amélioration de la lisibilité

 Nous avons déjà utilisé diverses fonctions prédéfinies :

 print()
 input()
 range()
 Syntaxe générale Exemple
def nomDeLaFonction(liste de paramètres): def table(base):
... n=1
bloc d'instructions while n <=10 :
... print(n * base, end =' ')
n = n +1

 La fonction table(base) affiche les dix premiers termes de la table de

multiplication de l’entier base passé en paramètre
 Lors de l’utilisation de cette fonction, on lui passe une valeur concrète
(un argument) pour ce paramètre :
>>> table (5)
5 10 15 20 25 30 35 40 45 50
 Algorithmiquement parlant : on distingue les fonctions des
procédures
 Une fonction f renvoie une valeur. Lors de l’appel, on peut stocker
la valeur renvoyée dans une variable : x=f( ) (par ex., x=max(1, 5))
 Une procédure effectue des actions (par ex., affichage) et ne
renvoie pas de valeur
Exemple de fonction Exemple de procédure
def cube(w): def afficheCube(w):
return w*w*w print(''Le cube de '', w, '' est '', w*w*w)

Utilisation : Utilisation :
n=int(input(''Saisir un entier'')) n=int(input(''Saisir un entier''))
x=cube(n) afficheCube(n)
print(''Le cube de '', n, '' est '', x)
 En python, les fonctions peuvent renvoyer une valeur unique ou plusieurs valeurs
séparées par des virgules (représentées par un tuple)
 Les valeurs renvoyées peuvent être attribuées à des variables individuelles lors de
l'appel de la fonction.

Définition Appel
def divmod(a, b): q, r = divmod(15, 4)
quotient = a // b print("Le quotient est :", q)
reste = a % b print("Le reste est :", r)
return quotient, reste
 Une docstring est une chaîne de caractères avec trois doubles quotes """ situées au début d’une
fonction.
 Elle explique ce que fait le code et donne éventuellement des informations sur les paramètres de la
fonction et ses valeurs de retour .
 Exemple :

 La docstring sera utilisée lorsqu'on demande de l'aide sur la fonction : help(inverse_chiffres)

 Lorsqu’on définit une fonction def f(x, y): les paramètres x et y sont appelés paramètres positionnels.
 Il est strictement obligatoire de leur associer des arguments (valeurs concrètes) lors de l’appel de la
fonction. De plus, il est nécessaire de respecter le même ordre lors de l’appel que dans la définition
de la fonction.
 Exemple :
>>> def fois (x , y ):
… return x * y
>>> fois (3 , 8)
24
>>> fois (2)
Traceback ( most recent call last ):
File " < stdin >" , line 1 , in < module >
TypeError : fois () missing 1 required positional argument : 'y’
 Un paramètre par défaut d’une fonction admet une valeur assignée par défaut dans la
définition de la fonction.
 On le définit avec la syntaxe def f(x, y, p=val)
 Lors de l’appel de la fonction f, si on attribue pas de valeur à p, c’est la valeur par défaut
qui sera utilisée
 Exemple :
>>>def politesse(nom, titre ="Monsieur"):
print("Veuillez agréer,", titre, nom, ", mes salutations distinguées.")
>>>politesse("Momo") #l’argument titre reçoit sa valeur par défaut
Veuillez agréer, Monsieur Momo, mes salutations distinguées
>>>politesse("Bennani", "Madame")
Veuillez agréer, Madame Bennani, mes salutations distinguées
Remarque : Il est important de noter que les paramètres par défaut doivent être définis
après les paramètres positionnels dans la définition de la fonction
 Une variable déclarée à l'intérieur d'une fonction a une portée locale. Elle est accessible uniquement
à l'intérieur de cette fonction.
 Les variables locales sont créées lorsque la fonction est appelée et détruites lorsque la fonction se
termine.
 Les variables locales ne sont pas accessibles en dehors de la fonction
 Exemple :
>>>def nbVoyelles(chaine):
voyelles={'a', 'e', 'i', 'o', 'u', 'y'} #variable locale qui disparait à la fin de la fonction
n=0 #variable locale qui disparait à la fin de la fonction
for c in chaine :
if (c in voyelles):
n=n+1
return n

>>>print(n)
NameError : name ‘n’ is not defined
Un nombre Armstrong est un nombre qui est égal à la somme de ses chiffres élevés
à la puissance du nombre total de chiffres.
Par exemple, 153 est un nombre Armstrong car 1^3 + 5^3 + 3^3 = 153.
1. Écrire une fonction en Python est_armstrong(n) qui renvoie True si n est un
nombre Armstong et False sinon
2. Ecrire une procédure afficher_armstrong() qui affiche tous les nombres
Armstrong à trois chiffres.
 En Python, les modules sont des fichiers qui contiennent des fonctions et/ou des
classes que l'on est amené à réutiliser souvent (on les appelle aussi bibliothèques ou
libraries).
 Les modules permettent d'organiser et de réutiliser efficacement du code en le
regroupant par fonctionnalité ou par thème.
 Pour utiliser un module dans votre programme, vous devez l'importer. L'importation
d'un module rend toutes ses fonctionnalités disponibles dans votre programme.

import nom_module from nom_module import nom_fonction

import random from random import randint
nb = random.randint(0, 10) nb=randint(0, 10)
 Exemple de création de module Exemple d’utilisation du module créé

# mon_module.py #mon_programme.py

def bonjour(nom): import mon_module

print("Bonjour "+nom) mon_module.bonjour("Les GI2")
print(mon_module.message)
def byebye(nom): mon_module.bybye("Les GI2")
print("Au-revoir "+nom)

message="Bienvenue dans mon module! "

Remarque : il faut s’assurer que les deux fichiers mon_module.py et mon_programme.py

se trouvent dans le même répertoire
Les listes, les tuples, les chaînes de caractères, les ensembles et les dictionnaires
On ne peut pas les modifier On peut les modifier après leur
après leur création création
 Une séquence est un type de données qui représente une collection ordonnée
d’éléments
 En Python, il y’a plusieurs types de séquences intégrés : listes, tuples et chaines de
caractères
 Opérations communes :

 Indexation : on accède aux éléments en utilisant des indices (e.g., chaine[2], tuple[0])
 Tranches : on peut extraire une sous-séquence en utilisant la notation de découpage, e.g.,
chaine[1:3]
 Opérateurs de concaténation (+) et répétition (*) : e.g., [1, 2]*3=[1, 2, 1, 2, 1, 2]
 Longueur : e.g., len([1, 2, 3])=3, len("Maroc")=5
 Une liste est une structure de données qui permet de stocker une collection
ordonnée et modifiable d’éléments
 Python autorise la construction de listes contenant des valeurs de types
différents
 Exemples de création de listes :
animaux = ["girafe", "tigre", "singe", "souris"] #liste de chaines de caractères
tailles = [5, 2.5, 1.75, 0.15] #liste de réels
mixte = ["girafe", 5, "souris", 0.15] # liste mixte d’éléments de types différents
type(mixte)
<class ‘list’>
 On accède aux éléments d’une liste en utilisant leur indice, il commence à partir de
0 et se termine à n-1 (n = taille de la liste)
 Exemples :
 >>>animaux = ["girafe", "tigre", "singe", "souris"]
 indices : 0 1 2 3
 >>> animaux[0]
'girafe'
>>> animaux[1]
'tigre'
>>> animaux[3]
'souris'
 On peut également utiliser des indices négatifs pour accéder aux éléments d’une
liste en partant de la fin. L'indice -1 correspond au dernier élément de la liste
 >>>animaux= ["girafe", "tigre", "singe", "souris"]
 indice positif : 0 1 2 3
 indice négatif : -4 -3 -2 -1
>>> animaux[-1]
'souris'
>>> animaux[-2]
'singe'
 Avantage : on peut accéder au dernier élément d’une liste avec l’indice -1 sans
connaitre la taille de la liste
 Soit k >0, pour une liste li de taille n, on a li[-k]=li[n-k]
 Les éléments d'une liste peuvent être modifiés en utilisant leur indice.
 Les listes supportent l’opérateur + (concaténation) et l’opérateur * (duplication)
 Exemples :
>>> ani1 = ["girafe", "tigre"]
>>> ani2 = ["singe", "souris"]
>>>print(ani1 + ani2)
['girafe', 'tigre', 'singe', 'souris']
>>>print(ani1 * 3)
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']
 Les tranches ("slicing" en anglais), permettent d'extraire une partie spécifique d'une liste
en Python.
 La syntaxe générale pour les tranches est la suivante :
liste[début: fin: pas]
où :
• début : l'indice (inclus) à partir duquel la tranche doit commencer (par défaut, le premier
élément).
• fin : l'indice (exclus) jusqu'auquel la tranche doit aller (par défaut, jusqu'à la fin de la liste).
• pas : l'incrément entre les indices de la tranche (par défaut, 1).
 Exemples :

 Question : Que vaut animaux[-2: -5: -1]? Et animaux[: :-1]?

 On peut utiliser une boucle for pour parcourir les éléments d’une liste.

Exemples de parcours d’une liste

li = [1, 2, 9, 7, 6, 4, 10, 7, 9] li = [1, 2, 9, 7, 6, 4, 10, 7, 9]
n= 0 n= 0
for i in range(len(li)): for e in li:
if (li[i]%2==0): if (e%2==0):
n = n +1 n = n +1
print(''Il y’a '', n, '' nombres pairs '') print(''Il y’a '', n, '' nombres pairs '')

Affichage : Affichage :

Il y’a 4 nombres pairs Il y’a 4 nombres pairs

 Fonctions Rôles
len(liste) renvoie la taille de la liste passée en paramètre (le nombre
d’éléments)
max(liste) renvoie le maximum d’une liste
min(liste) renvoie le minimum d’une liste
sum(liste) renvoie la somme des éléments d’une liste de nombres
sorted(liste) renvoie une nouvelle liste contenant les éléments de la liste
passée en paramètre triés dans l'ordre croissant
 Méthodes Rôles
liste.append(elt) Procédure qui ajoute l’élément elt à la fin de la liste
liste.insert(ind, elt) Procédure qui insère l’élément elt à l’indice ind de la liste
liste.index(val) Renvoie l’indice de la première occurrence de val dans la liste
liste.remove(val) Procédure qui supprime la première occurrence de val dans la liste
liste.pop(ind) Supprime et renvoie l’élément à l’indice ind de la liste
liste.sort() Procédure qui trie la liste dans l’ordre croissant
liste.reverse() Procédure qui inverse l’ordre des éléments dans la liste
 Objectif : fournir un moyen de construire une liste de
manière très concise en appliquant une expression sur
chaque élément d'une autre séquence
 Exemples :
>>>carres = [x**2 for x in range(5)] #carres=[0, 1, 4, 9, 16]
>>>vec=[-1, -5, -4, 3, 7]
>>>pos=[abs(x) for x in vec] #pos=[1, 5, 4, 3, 7]
>>>filtre=[x for x in vec if x<0] #filtre=[-1, -5, -4]
 Qu’affiche le programme suivant?
 Recherche d’un entier dans une liste triée d’entiers

Solution 1 Solution 2
def recherche2(l, e):
debut = 0
fin=len(l) -1
def recherche1(l, e): while debut<=fin:
for i in l: milieu= (fin + debut)//2
if i==e: if l[milieu] == e :
return True return True
return False elif l[milieu] < e:
debut = milieu + 1
else :
fin = milieu -1
return False
Complexité linéaire : au pire des cas, Complexité logarithmique : à
toute la liste sera parcourue quand chaque étape, on élimine la moitié
l’élément n’existe pas des éléments à examiner
Un entier est dit distinct s’il est composé de chiffres distincts (différents).
Ecrire une procédure est_distinct(nb) qui permet d’afficher si nb est distinct ou non.

Scénarios d’exécution :
>>> est_distinct(21456)
21456 est un entier distinct!
>>> est_distinct(2022)
2022 n’est pas un entier distinct, le chiffre 2 apparait 3 fois!!
 Ecrire une procédure supprimer_doublons(liste) qui prend en paramètre
une liste d’entiers et supprime tous ses doublons (les éléments qui se
répètent). La procédure doit modifier la liste d'origine pour qu'elle ne
contienne que des éléments uniques, en conservant leur ordre
d'apparition.
 Exemple d’utilisation :
>>>liste = [1, 2, 3, 2, 4, 3, 5, 4]
>>>supprimer_doublons(liste)
>>>print(liste)
[1, 2, 3, 4, 5]
 En Python, les matrices sont représentées par des listes
multidimensionnelles où chaque élément de la liste est lui-même une
liste imbriquée.
 Exemple de création & manipulation de matrice :
#creation d’une matrice 2 x 3 (2 lignes/3 colonnes)
matrice =[[1, 4, 8],
[7, 10, 6]]
print(matrice[0][1]) #affiche 4
matrice[1][1]=3
print(matrice) #affiche =[[1, 4, 8], [7, 3, 6]]
 Méthode 1 : sans indices Méthode 2 : avec indices
matrice =[[1, 4, 8], matrice =[[1, 4, 8],
[7, 10, 6]] [7, 10, 6]]
s=0 s=0
for ligne in matrice : n=len(matrice)
for e in ligne : m=len(matrice[0])
s=s+e for i in range(n) :
print(''La somme des éléments est :'', s) for j in range(m) :
s = s + matrice[i][j]
print("La somme des éléments est :", s)
Affichage : Affichage :
La somme des éléments est : 36 La somme des éléments est : 36
 Ecrire une fonction somme_diagonales(matrice) qui prend en entrée une matrice
numérique carrée et qui renvoie la somme des deux diagonales de cette matrice.

 Scénario d’utilisation :
matrice==[[1, 4, 8],
[7, 10, 6],
[2, 6, 1]]
print(somme_diagonales(matrice)) #affiche 22
 Un tuple est une collection ordonnée d'éléments similaire à
une liste mais avec une différence principale : elle est
immutable, cad : elle ne peut pas être modifiée une fois créée.
 Exemple de création d’un tuple :
>>> mon_tuple=(1, 7, 9)
ou plus simplement :
>>> mon_tuple= 1, 7, 9
>>> type(mon_tuple)
<class 'tuple'>
 Comme pour les listes, on peut accéder aux éléments d’un tuple en utilisant leurs
indices (positifs ou négatifs)
 Exemple :
>>>mon_tuple=(1,2, 3, 4, 5)
>>>print(mon_tuple[2])
3
>>>print(mon_tuple[-2])
4
>>>mon_tuple[0]=8
TypeError : ‘tuple’ object does not support item assignment
  Exemple :

def language(*args):
for i in args: Language: Java
print("Language:", i) Language: C++
print("Il y'a", len(args), " langages!") Language: Python
print(type(args)) Il y'a 3 langages!
<class 'tuple'>
language("Java", "C++", "Python")

 La fonction est appelée en passant un nombre quelconque d’arguments, ces

arguments sont stockés dans un tuple
Supposons qu’on dispose d’une liste de tuples, chaque tuple contenant le nom de
l'étudiant suivi de sa note.
Ecrire une procédure premier_classe(résultats) qui prend en paramètre cette liste
de tuples et qui affiche le nom de l'étudiant ayant obtenu la meilleure note ainsi que
sa moyenne. Dans le cas où il y’a des ex-aequo, leurs noms respectifs doivent être
affichés ainsi que leur note commune.
Exemples d’utilisation :
>>>GI2 = [("Toto", 15.45), ("Fifi", 12.07), ("Momo", 18.08), ("Lolo", 14.98)]
>>>premier_classe(GI2)
Momo est le premier, il a eu 18.08
>>>GI2.append(("Riri ", 18.08))
>>>premier_classe(GI2)
Momo et Riri sont les premiers (ex-aecquo), ils ont eu 18.08
 Les chaînes de caractères (strings) sont des séquences de caractères
qui représentent du texte.
 En Python, les chaînes de caractères sont immutables : elles ne
peuvent pas être modifiées une fois créées.
 Exemple :
>>> ma_chaine = "J’adore Python"
>>> print(ma_chaine[0]) #affichage de J
>>> ma_chaine[0]=’L’
TypeError : ‘str’ object does not support item assignment
 La fonction ord(char) retourne le code unicode associé à son paramètre
 La fonction chr(num) fait l’inverse, elle renvoie le caractère correspondant au code unicode
num (qui doit être entre 0 et 1114111)
 Exemple :
>>>ord('a')
97
>>>ord('z')
122
>>>chr(97)
'a’
>>> 'a' < 'i’ < ’z’
True
 Boucle for qui itère sur les caractères Boucle for qui itère sur les indices
ma_phrase="Ce langage est facile!" ma_phrase="Ce langage est facile!"
n=1 n=1
for c in ma_phrase : for i in range(len(ma_phrase)) :
if c == ' ': if ma_phrase[i] == ' ' :
n=n+1 n=n+1
print(f"Il y’a {n} mots dans cette phrase") print(f"Il y’a {n} mots dans cette phrase")
Méthodes Rôles
chaine.upper( ) Fonction qui convertit la chaine en majuscules (renvoie une nouvelle chaine)
chaine.lower() Fonction qui convertit la chaine en minuscules (renvoie une nouvelle chaine)
chaine.startswith(s) Fonction qui renvoie True si chaine commence par le préfixe s et False sinon
chaine.endswith(s) Fonction qui renvoie True si chaine se termine par le suffixe s et False sinon
ch.replace(old, new) Fonction qui crée une nouvelle chaine à partir de ch en remplaçant les occurrences de la
sous-chaine old par new
chaine.isalpha() Fonction qui renvoie True si tous les caractères de chaine sont des lettres alphabétiques
et False sinon
chaine.isdigit() Fonction qui renvoie True si tous les caractères de chaine sont des chiffres et False sinon
chaine.count(s) Fonction qui renvoie le nombre d’occurrences de la sous-chaine s dans chaine
chaine.split() Fonction qui divise la chaine en une liste de sous-chaines en utilisant un séparateur
(l’espace par défaut)
chaine.strip() Fonction qui supprime les espaces et caractères de contrôle(\n, \t, …) présents au début
et à la fin de chaine
ch.join(list) Fonction qui crée une chaine en fusionnant les membres de list avec le mot de liaison ch
Exemple Affichage
>>> date = "11/11/2023"
>>> liste=date.split("/")
>>> liste
['11', '11', '2023']
>>> type(liste)
<class 'list'>
>>> nouvelle_date="-".join(l)
>>> nouvelle_date
'11-11-2023'
>>> type(nouvelle_date)
<class 'str'>
 Écrivez une fonction inverse_mots(chaine) qui prend une chaîne de caractères en
entrée et renvoie une nouvelle chaîne où les mots sont inversés, mais l'ordre des
mots reste le même. Un mot est défini comme une séquence de caractères séparée
par des espaces.
 Exemple :
>>>chaine = "Python est génial"
>>>print(inverse_mots(chaine))
nohtyP tse lainég
 Les ensembles en Python sont une structure de données qui permet
de stocker une collection d'éléments uniques et non ordonnés. Ils
sont implémentés à l'aide de la classe set. Les ensembles en Python
sont caractérisés par ce qui suit :
 Ils ne contiennent pas d'éléments dupliqués. Chaque élément d'un ensemble est
unique.
 Ils sont non ordonnés : vous ne pouvez pas accéder à un élément d'un ensemble
par son indice.
 Ils sont mutables : vous pouvez ajouter ou supprimer des éléments d'un
ensemble.
 Ils peuvent contenir des éléments de différents types de données immutables :
entiers, flottants, chaînes de caractères, tuples, etc.
 Exemples :
ensemble_vide=set() #ou bien ensemble_vide={}
ensemble={1, 2, 3} #création d’ensemble qui contient les 3 éléments 1, 2 et 3
o On peut également créer un ensemble à partir d'une liste ou d'un tuple en utilisant la
fonction set() :
liste=[1, 2, 3, 1, 4, 3, 5, 2]
ensemble=set(liste) #création d’un ensemble à partir des éléments uniques de la liste
print(type(ensemble))
<class 'set'>
print(ensemble)
{1, 2, 3, 4, 5}
Remarque : Les ensembles ne sont pas ordonnés, les éléments apparaitront donc dans
un ordre aléatoire
 Union : elle est obtenue en utilisant l’opérateur | ou la méthode union()
 Intersection : elle est obtenue en utilisant l’opérateur & ou la méthode intersection()
 Différence : elle est obtenue en utilisant l’opérateur - ou la méthode difference()
Exemple :
A={1, 2, 3, 4}
B={2, 4, 5}
union=A | B #ou bien union = A.union(B)
print(union) #on obtient {1, 2, 3, 4, 5}
intersection = A & B # ou bien intersection=A.intersection(B)
print(intersection) # on obtient {2, 4}
difference= A - B # ou bien difference=A.difference(B)
print(difference) # on obtient {1, 3}
 Méthodes Rôles
ens.add(elt) Procédure qui ajoute l’élément elt à l’ensemble ens
ens.update(iterable) Procédure qui ajoute tous les éléments de iterable dans ens. Le
paramètre peut être une liste, un tuple, un ensemble ou un
dictionnaire
ens.remove(elt) Procédure qui supprime l’élément elt de l’ensemble ens
ens.clear() Procédure qui supprime tous les éléments de l’ensemble ens
 A= {1, 2, 3, 4, 5}
print(id(A)) #affiche l’adresse de l’objet set
A.add(6)
print(id(A)) #on obtient la même adresse!

A={1, 2, 3, 4, 5}
print(id(A))
A = A | {6}
print(id(A)) #les deux adresses sont différentes

Synthèse :
A.add(e) : ajoute l’élément e à l’ensemble existant référencé par A
A | {e} : crée un nouvel ensemble qui contient l’union des éléments de A et e
 On ne peut pas accéder aux éléments d'un ensemble en utilisant des indices car les
ensembles ne sont pas ordonnés. On peut parcourir les éléments de l'ensemble à l'aide
d'une boucle for.
 Exemple :
gagnants={"Toto", "Momo","Fati"}
for e in gagnants :
print(e)
#on peut avoir un ordre d’affichage différent!
Fati
Momo
Toto
gagnants_competitions = [
("Momo", {"Python", "C", "JAVA"}),
("Toto", {"C"}),
("Mimi", {"Lisp", "C++"}),
("Fifi", {"C++", "Python", "C"})]

def enigme(gagnants_competitions):
m=0 1. Quel est le type de la variable
ens={} gagnants_competitions?
for gagnant, competitions in gagnants_competitions: 2. Qu’affiche ce code?
nb=len(competitions) 3. Quel est le rôle de la fonction
if nb > m: enigme?
m = nb
ens={gagnant}
elif nb == m:
ens.add(gagnant)
return ens

print(enigme(gagnants_competitions))
 Les dictionnaires sont des structures de données qui permettent de stocker des paires clé-valeur, les
clés devant être uniques
 On les appelle également tableaux associatifs dans d’autres langages de programmation
 Les clés peuvent être de n’importe quel type immutable, tels que les nombres ou chaînes de caractères
 Exemples de création d’un dictionnaire :
#création d’un dictionnaire vide
mon_dico={}
#création d’un dictionnaire avec des paires clé-valeur
capitales={
"France" : "Paris",
"Maroc" : "Rabat",
"Espagne" : "Madride"
}
print(type(capitales))
<class 'dict'>
 On peut accéder aux valeurs d'un dictionnaire en utilisant les clés
correspondantes
 Exemples :
print(capitales["Maroc"]) #affiche Rabat (la valeur associée à la clé "Maroc")
print(capitales["France"]) #affiche Paris
capitales["Espagne"]="Madrid" #modification de la valeur de la clé "Espagne"
print(capitales["Espagne"]) #affiche Madrid
 Ajout d’une paire clé-valeur Suppression d’une paire clé-valeur
capitales["Tunisie"]="Tunis" del capitales["Tunisie"]
print(capitales) print(capitales)

Affichage : Affichage :

{'France': 'Paris', 'Maroc': 'Rabat', 'Espagne': {'France': 'Paris', 'Maroc': 'Rabat', 'Espagne':
'Madrid', 'Tunisie': 'Tunis'} 'Madrid'}
 Il existe plusieurs façons de parcourir un dictionnaire en Python. On peut parcourir les clés,
les valeurs ou les paires clé-valeur.

Parcours des clés Parcours des valeurs Parcours des paires clé-valeur

for cle in capitales : for valeur in capitales.values() : for cle, val in capitales.items():
print(cle) print(valeur) print(cle, " a comme capitale " , val)

France Paris France a comme capitale Paris

Maroc Rabat Maroc a comme capitale Rabat
Espagne Madrid Espagne a comme capitale Madrid
Remarque : capitales.items() renvoie un objet qui encapsule une liste de tuples (clé, valeur)
>>>capitales.items()
dict_items([('France', 'Paris'), ('Maroc', 'Rabat'), ('Espagne', 'Madrid')])
 Ecrire une fonction liste_employes_salaire qui prend en entrées un dictionnaire contenant
les informations sur les employés (nom de l'employé en tant que clé et salaire en tant que
valeur) et un salaire donné. La fonction devra renvoyer une liste contenant tous les noms
des employés dont le salaire est supérieur ou égal au salaire passé en paramètre, triés par
ordre alphabétique.
Voici un exemple d’utilisation de cette fonction :
infos_employes = {
"Imane": 5000,
"Ali": 4000,
"Mohamed": 6000,
"Fatima": 5500
}
salaire_minimum = 5000
resultat = liste_employes_salaire(infos_employes, salaire_minimum)
print(resultat) # on obtient la liste ["Fatima", "Imane", "Mohamed"]
 Pour ouvrir un fichier en Python, nous utilisons la fonction open()
 La fonction open() prend deux arguments :
 le chemin du fichier sous forme de chaine de caractères
 le mode d'ouverture qui spécifie si nous voulons lire, écrire ou ajouter des données au
fichier
 Voici les modes d'ouverture les plus courants :

Modes d’ouverture Rôles

r Ouvre le fichier en mode lecture (mode par défaut)
w Ouvre le fichier en mode écriture, écrasant le contenu existant s'il
existe ou créant un nouveau fichier s'il n'existe pas.
a Ouvre le fichier en mode ajout, ajoutant du contenu à la fin du
fichier s'il existe ou créant un nouveau fichier s'il n'existe pas.
x Mode création. Crée un nouveau fichier pour l'écriture, échouant si
le fichier existe déjà.
 Exemple d'ouverture d’un fichier en mode lecture :
fichier = open("C:\\Users\\houda\\Desktop\\mon_fichier.txt", "r")
#effectuer les opérations de lecture
fichier.close() #fermeture du fichier

 Remarque :
Il est essentiel de fermer un fichier après avoir fini de l'utiliser pour libérer les
ressources système associées. Pour cela, on utilise la méthode close() sur l'objet
fichier.
 Pour lire le contenu d'un fichier, nous avons quelques méthodes disponibles :

Méthodes de lecture Rôles

fichier.read() Fonction qui lit tout le contenu du fichier et le renvoie
sous forme d’une chaîne de caractères.
fichier.readline() Fonction qui lit une seule ligne à la fois, et renvoie la
ligne courante sous forme de chaine de caractères
fichier.readlines() Fonction qui lit toutes les lignes du fichier et les renvoie
sous forme de liste de chaînes de caractères
 On suppose que le fichier mes_langages.txt contient les lignes suivantes :

 Exemple d’utilisation de la méthode read() pour lire le fichier :

fichier=open("C:\\Users\\houda\\Desktop\\mes_langages.txt","r")
contenu=fichier.read()
print(contenu)
fichier.close()
 Exemple d’utilisation de la méthode readline() pour lire le fichier mes_langages.txt :
fichier=open("C:\\Users\\houda\\Desktop\\mes_langages.txt","r")
ligne1=fichier.readline()
print(ligne1)
ligne2=fichier.readline()
print(ligne2)
fichier.close()
Remarque : la méthode readline() inclut le caractère '\n' à la fin de chaque ligne lue. Vous
pouvez utiliser la méthode strip() pour supprimer ce caractère (fichier.readline().strip())
 Exemple d’utilisation de la méthode readlines() pour lire le fichier mes_langages.txt :
fichier=open("C:\\Users\\houda\\Desktop\\mes_langages.txt","r")
lignes=fichier.readlines()
print(type(lignes))
print(lignes)
for ligne in lignes:
print(ligne.strip())
fichier.close()
 Pour écrire dans un fichier, nous allons utiliser trois étapes :
 Ouvrir un fichier en mode écriture "w" ou ajout "a".
 Écriture des données dans le fichier avec la méthode write()
 Fermeture du fichier pour libérer les ressources système

 Exemple d‘écriture dans un fichier :

fichier = open("C:\\Users\\houda\\Desktop\\mes_citations.txt", "w")
fichier.write("La motivation vous sert de départ. L’habitude vous fait continuer.\n")
fichier.write("Le succès c’est tomber 7 fois et se relever 8.\n")
fichier.close()
 Si on souhaite ajouter du contenu dans un fichier existant sans effacer son contenu,
il faut utiliser le mode "a" pour ouvrir le fichier.
 Exemple :
fichier = open("C:\\Users\\houda\\Desktop\\mes_citations.txt", "a")
fichier.write("Le succès est la somme de petits efforts répétés jour après jour.\n")
fichier.close()
  Pour éviter d'oublier de fermer un fichier, il est recommandé d'utiliser la clause
with. Cette clause garantit la fermeture automatique du fichier après son utilisation

Utilisation de la clause with Programme équivalent

with open("mes_citations.txt", "r") as fichier : fichier = open("mes_citations.txt", "r")

contenu=fichier.read() contenu=fichier.read()
print(contenu) print(contenu)
# Le fichier est automatiquement fermé après la fin fichier.close()
du bloc with
Supposons que nous disposons d’un fichier
"notes_python.txt" dont les lignes respectent la structure
suivante : "nom,prenom,noteQuiz,noteProjet,noteExamen"
(par ex. "Bennis,Ali,12,14,10").
Sachant que les coefficients du Quiz, Projet et Examen sont
respectivement de 25%, 25% et 50%, générez un rapport
avec le nom, prénom, moyenne générale et meilleure note
de chaque étudiant et écrivez le dans un nouveau fichier
"synthese_notes.txt"
 Une classe est un modèle qui définit la structure et le comportement des objets.
Elle contient des attributs (variables) et des méthodes (fonctions) qui définissent
les caractéristiques et les actions des objets créés à partir de cette classe.
 Exemple de définition d’une classe :
 Un constructeur est une méthode spéciale qui est automatiquement appelée lorsque vous créez
une instance d’une classe.
 Le constructeur porte le nom _ _init_ _, son rôle est d’initialiser les attributs de l'objet courant
 self : est toujours le premier paramètre du constructeur, il fait référence à l'instance en cours de
création (l’objet courant). On l'utilise pour accéder aux attributs de l'objet courant.
 A la différence de Java, en Python, une classe ne peut avoir qu’un seul constructeur
 Syntaxe :
 Le concept d’encapsulation est très utile dans la POO. Il permet de contrôler l'accès
aux attributs et aux méthodes d'une classe
 Les attributs et méthodes privés portent des identifiants préfixés par ‘_ _’
 Exemple :
 Les attributs d'instance sont des propriétés spécifiques à chaque instance d'une
classe. Chaque objet a sa propre copie de ces attributs. Les attributs d'instance
sont généralement définis dans le constructeur (__init__) de la classe.
 Les attributs de classe sont partagés par toutes les instances d'une classe. Ils sont
définis au niveau de la classe elle-même, en dehors de toute méthode, ils sont
utilisés pour stocker des valeurs communes à toutes les instances.
 Les méthodes d'instance agissent sur des objets individuels, elles ont accès aux
attributs d'instance de l'objet courant et peuvent les manipuler. Elles admettent
comme premier paramètre self (pour faire référence à l’objet courant).
 Les méthodes de classe agissent sur la classe elle-même, elles ont accès aux attributs
de classe. Elles sont définies avec le décorateur @classmethod. Elles admettent
comme premier paramètre cls (pour faire référence à la classe).
  On considère une classe Etudiant dotée de 3 attributs d’instance privés nom, filière et moyenne
1. Définir un constructeur qui permet d’initialiser ces 3 attributs, l’initialisation de la moyenne se
fera si la valeur de l’argument est cohérente (entre 0 et 20), sinon un message d’erreur sera
affiché
2. Définir des accesseurs et modificateurs pour ces attributs
3. Définir une méthode d’instance a_réussi(self) qui renvoie True si la moyenne de l’étudiant
courant est >=12 et False dans le cas contraire
4. Définir une méthode d’instance est_meilleur(self, autre) qui prend en paramètre un autre objet
Etudiant et renvoie True si la moyenne de l'étudiant courant est supérieure à celle de l'autre
étudiant, sinon renvoie False.
5. Ecrire un programme principal qui permet de :
1. Créer un étudiant Momo de la filière GI2 ayant une moyenne de 8.9
2. Créer un étudiant Fifi de la filière GI2 ayant une moyenne de 14.1
3. Tester si le premier étudiant a réussi
4. Appliquer la méthode est_meilleur pour repérer le meilleur étudiant
1. On souhaite ajouter un attribut de classe nb_etudiants qui comptera le nombre total d'étudiants
créés. Cet attribut doit être incrémenté à chaque création d'un nouvel étudiant. Modifier le code
précédent
2. Ajouter une méthode de classe get_nb_etudiants(cls) qui renverra le nombre total d'étudiants créés
jusqu'à présent.
3. Définir une méthode de classe get_moy_arith_moyennes(cls) qui renvoie la moyenne arithmétique
des moyennes des étudiants créés. Cette moyenne arithmétique est calculée en additionnant toutes
les moyennes valides et en les divisant par le nombre d'étudiants créés.
4. Tester le programme principal suivant :
e1 = Etudiant("Momo", "GI2", 12)
e2 = Etudiant("Fifi", "GI2", 10)
e3 = Etudiant("Toto", "GI2", 15)
e2.set_moyenne(8)
e3.set_moyenne(13)
print(Etudiant.get_moy_arith_moyennes()) # Affiche 11
 L’héritage est l'un des concepts fondamentaux de la programmation orientée objet (POO).
 Une sous-classe (classe dérivée) peut utiliser et étendre les fonctionnalités de la superclasse
(classe parente) tout en ajoutant ses propres attributs et méthodes.
 Avantages : réutilisation du code, organisation des classes en hiérarchies logiques
 Syntaxe :
 Qu’affiche le code suivant?
 Qu’affiche le code suivant?
 Qu’affiche le code suivant ?