Exercice 1 

§ Écrivez un script python qui demande à l'utilisateur d'entrer un entier, puis il

détermine s'il est pair ou impair.
§ Vous pourrez utiliser l’opérateur modulo % qui renvoie le reste de la division
entière entre deux nombres.

Exercice 2 :

Voici les notes d’un étudiant : 14, 9, 13, 15 et 12:

§ Créez un script qui affiche la note maximale (utilisez la fonction max()), la note
minimale (utilisez la fonction min()) et qui calcule la moyenne.
§ Affichez la mention obtenue sachant que la mention est « passable » si la
moyenne est entre 10 inclus et 12 exclus, « assez bien » entre 12 inclus et 14
exclus et « bien » au-delà de 14.

On utilise les fonctions max(), min() et calcule la moyenne des notes d'un étudiant. Il
affiche également la mention correspondante en fonction de la moyenne obtenue :

notes = [14, 9, 13, 15, 12]

note_max = max(notes) # Note maximale

note_min = min(notes) # Note minimale
moyenne = sum(notes) / len(notes) # Calcul de la moyenne

print("Note maximale :", note_max)

print("Note minimale :", note_min)
print("Moyenne :", moyenne)

if 10 <= moyenne < 12:

print("Mention : Passable")
elif 12 <= moyenne < 14:
print("Mention : Assez bien")
elif moyenne >= 14:
print("Mention : Bien")
else:
print("Mention : Non définie")

Ensuite, nous calculons la moyenne en utilisant la fonction sum() pour additionner

toutes les notes et la fonction len() pour obtenir le nombre total de notes.
Nous affichons ensuite la note maximale, la note minimale et la moyenne.
Enfin, nous utilisons une structure conditionnelle if-elif-else pour déterminer la mention
en fonction de la moyenne obtenue. Selon les intervalles donnés, nous affichons la
mention correspondante : "Passable" si la moyenne est entre 10 inclus et 12 exclus,
"Assez bien" entre 12 inclus et 14 exclus, et "Bien" au-delà de 14. Si la moyenne ne
correspond à aucun intervalle défini, nous affichons "Non définie".

En exécutant ce script avec les notes [14, 9, 13, 15, 12], vous obtiendrez le résultat
suivant :

Note maximale : 15
Note minimale : 9
Moyenne : 12.6
Mention : Assez bien

Exercice 3 :

Soit la liste ["vache", "souris", "levure", "bacterie"].

§ Affichez l’ensemble des éléments de cette liste (un élément par ligne) de trois
manières différentes (deux avec for et une avec while).

Voici comment afficher les éléments de la liste "['vache', 'souris', 'levure', 'bacterie']" de
trois manières différentes en utilisant des boucles for et une boucle while en langage
Python :

Méthode 1 - Utilisation d'une boucle for avec range() :

liste = ["vache", "souris", "levure", "bacterie"]

# Boucle for avec range()

for i in range(len(liste)):
print(liste[i])
Méthode 2 - Utilisation d'une boucle for avec l'itération directe sur les éléments de la
liste :

liste = ["vache", "souris", "levure", "bacterie"]

# Boucle for avec itération directe
for element in liste:
print(element)
Méthode 3 - Utilisation d'une boucle while :

liste = ["vache", "souris", "levure", "bacterie"]

# Boucle while
i=0
while i < len(liste):
print(liste[i])
i += 1
Les trois méthodes produiront le même résultat, qui est l'affichage des éléments de la
liste "['vache', 'souris', 'levure', 'bacterie']" sur des lignes séparées.

Voici la sortie attendue pour chacune des méthodes :

Méthode 1 (boucle for avec range()) :

vache
souris
levure
bacterie
Méthode 2 (boucle for avec itération directe) :

vache
souris
levure
bacterie
Méthode 3 (boucle while) :

vache
souris
levure
bacterie

Exercice 4 :
Voici les notes d’un étudiant [14, 9, 6, 8, 12].
• Calculez la moyenne de ces notes.

Pour calculer la moyenne des notes données, vous devez ajouter toutes les notes
ensemble, puis diviser la somme par le nombre total de notes. Voici comment vous
pouvez le faire en utilisant le langage Python :

notes = [14, 9, 6, 8, 12]

somme = sum(notes) # Somme des notes
nombre_notes = len(notes) # Nombre total de notes
moyenne = somme / nombre_notes # Calcul de la moyenne

print("La moyenne des notes est :", moyenne)

Dans cet exemple, nous avons une liste notes contenant les notes de l'étudiant. Nous
utilisons la fonction sum() pour calculer la somme de toutes les notes dans la liste.
Ensuite, nous utilisons la fonction len() pour obtenir le nombre total de notes. En
divisant la somme par le nombre de notes, nous obtenons la moyenne.

En exécutant ce code, vous obtiendrez la moyenne des notes, qui sera affichée à l'écran.
Dans cet exemple, la moyenne sera calculée comme suit :

(14 + 9 + 6 + 8 + 12) / 5 = 49 / 5 = 9.8

Donc, la moyenne des notes est 9.8.

Exercice 5 :

Constituez une liste semaine contenant les 7 jours de la semaine.

§ Écrivez une série d’instructions affichant les jours de la semaine (en utilisant
une boucle for), ainsi qu’une autre série d’instructions affichant les jours du
week-end (en utilisant une boucle while).

Voici un exemple de code en Python pour constituer une liste de jours de la semaine
et afficher les jours de la semaine à l'aide d'une boucle "for", ainsi que les jours du
week-end à l'aide d'une boucle "while" :
# Liste des jours de la semaine
semaine = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]

# Affichage des jours de la semaine avec une boucle for

print("Jours de la semaine:")
for jour in semaine:
print(jour)

# Affichage des jours du week-end avec une boucle while

print("\nJours du week-end:")
index = 5 # Indice correspondant au samedi dans la liste
while index < len(semaine):
print(semaine[index])
index += 1
Ce code crée une liste appelée "semaine" contenant les 7 jours de la semaine. Ensuite, il
utilise une boucle "for" pour parcourir la liste et afficher chaque jour de la semaine.
Après cela, il utilise une boucle "while" avec une variable d'indice pour afficher les jours
du week-end à partir de l'indice correspondant au samedi dans la liste.

L'exécution du code donnera le résultat suivant :

Jours de la semaine:
Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche

Jours du week-end:
Samedi
Dimanche
Notez que les jours de la semaine sont affichés dans l'ordre dans lequel ils sont stockés
dans la liste "semaine".
Exercice 6 :

Soit impairs la liste de nombres [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21].
• Écrivez un programme qui, à partir de la liste impairs, construit une liste pairs
dans laquelle tous les éléments de impairs sont incrémentés de 1.

Voici un exemple de programme en Python qui utilise la liste "impairs" pour construire
une nouvelle liste "pairs" où chaque élément est incrémenté de 1 :

impairs = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

pairs = []

for nombre in impairs:

pairs.append(nombre + 1)

print(pairs)
Ce programme utilise une boucle for pour parcourir chaque nombre dans la liste
impairs. À chaque itération, le nombre est incrémenté de 1 et ajouté à la liste pairs à
l'aide de la méthode append(). Enfin, le contenu de la liste pairs est affiché à l'écran avec
print(). Le résultat sera la liste [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22], où chaque élément
est le nombre correspondant de la liste impairs incrémenté de
Exercice 7 :

§ Ecrivez un programme Python qui renvoie la liste des éléments communs entre
deux listes.
L1 = [5 , 19 , 21 , 7 , 13 , 21]
L2 = [3 , 22 , 19 , 12 , 13 , 7]

Voici un exemple de programme Python qui renvoie la liste des éléments communs
entre deux listes :

L1 = [5, 19, 21, 7, 13, 21]

L2 = [3, 22, 19, 12, 13, 7]

# Utilisation de l'opérateur d'intersection entre les deux listes

elements_communs = list(set(L1) & set(L2))

# Affichage des éléments communs

print("Les éléments communs entre L1 et L2 sont :", elements_communs)

Le résultat de l'intersection est converti en liste en utilisant la fonction list(). Enfin, la

liste des éléments communs est affichée à l'aide de la fonction print(). Dans cet
exemple, les éléments communs entre les deux listes sont [19, 7, 13]

Exercice 8 :
§ Ecrivez un algorithme Python qui demande à l'utilisateur de saisir un nombre
entier et renvoie la liste des diviseurs de cet entier.
§ Exemple : si n = 18 , l'algorithme renvoie la liste [1, 2, 3, 6, 9, 18]

# Demander à l'utilisateur de saisir un nombre entier

n = int(input("Entrez un nombre entier : "))

# Initialiser une liste pour stocker les diviseurs

diviseurs = []

# Parcourir les nombres de 1 à n inclusivement

for i in range(1, n + 1):
# Vérifier si i est un diviseur de n
if n % i == 0:
# Ajouter i à la liste des diviseurs
diviseurs.append(i)

# Afficher la liste des diviseurs

print("Les diviseurs de", n, "sont :", diviseurs)
L'algorithme demande à l'utilisateur de saisir un nombre entier en utilisant la fonction
input(). Ensuite, il initialise une liste appelée diviseurs pour stocker les diviseurs de cet
entier.

En utilisant une boucle for qui parcourt les nombres de 1 à n inclusivement, l'algorithme
vérifie si chaque nombre est un diviseur de n en utilisant l'opérateur de modulo (%). Si le
reste de la division de n par i est égal à zéro, alors i est un diviseur de n, et il est ajouté à
la liste diviseurs en utilisant la méthode append().

Enfin, l'algorithme affiche la liste des diviseurs en utilisant la fonction print()

Exercice 9 :

§ En utilisant les fonctions list() et range(), créez la liste entiers contenant les
nombres entiers pairs de 2 à 20 inclus.
§ Calculez ensuite le produit des nombres consécutifs deux à deux de entiers en
utilisant une boucle.
Exemple pour les premières itérations :
2*4=8
4 * 6 = 24
6 * 8 = 48
[…]

Voici le code Python pour créer la liste des nombres entiers pairs de 2 à 20 inclus et
calculer le produit des nombres consécutifs deux à deux :

entiers = list(range(2, 21, 2)) # Crée la liste des entiers pairs de 2 à 20

produits = []
for i in range(len(entiers) - 1):
produit = entiers[i] * entiers[i+1]
produits.append(produit)

# Affiche les produits

for produit in produits:
print(produit)
Cela donnera la sortie suivante :
8
24
48
80
120
168
224
288
360
440
Le code commence par créer une liste appelée "entiers" en utilisant la fonction list() et
la fonction range() avec un pas de 2 pour obtenir les nombres entiers pairs de 2 à 20.
Ensuite, une boucle for est utilisée pour itérer à travers les éléments de la liste "entiers"
à l'exception du dernier élément. À chaque itération, le produit des nombres consécutifs
est calculé en multipliant l'élément actuel de la liste avec l'élément suivant (entiers[i] *
entiers[i+1]). Le produit est ensuite ajouté à la liste "produits".

Enfin, une autre boucle for est utilisée pour afficher les produits un par un.

Exercice 10 :
§ On considère le dictionnaire suivant:
mydict = {"device": "laptop" , "constructeur": "acer" , "ram": "8G" , "processeu
r": "Intel core i5", "stockage": "500 G"}

1. Corrigez l'erreur "stockage": "750 G"

2. Créez un programme qui affiche la liste des clés, la liste des valeurs et la liste
des paires de clés et valeurs
3. Ajoutez la pair clé-valeur : "Système d'exploitation" : "Windows 10"

# Dictionnaire initial
mydict = {"device": "laptop", "constructeur": "acer", "ram": "8G", "processeur": "Intel
core i5", "stockage": "500 G"}

# 1. Correction de la valeur pour la clé "stockage"

mydict["stockage"] = "750 G"

# 2. Affichage des clés, des valeurs et des paires clé-valeur

keys = list(mydict.keys())
values = list(mydict.values())
items = list(mydict.items())

print("Liste des clés:", keys)

print("Liste des valeurs:", values)
print("Liste des paires clé-valeur:", items)

# 3. Ajout de la paire clé-valeur "Système d'exploitation" : "Windows 10"

mydict["Système d'exploitation"] = "Windows 10"

# Affichage du dictionnaire mis à jour

print("Dictionnaire mis à jour:", mydict)
Résultat :

Liste des clés: ['device', 'constructeur', 'ram', 'processeur', 'stockage']

Liste des valeurs: ['laptop', 'acer', '8G', 'Intel core i5', '750 G']
Liste des paires clé-valeur: [('device', 'laptop'), ('constructeur', 'acer'), ('ram', '8G'),
('processeur', 'Intel core i5'), ('stockage', '750 G')]
Dictionnaire mis à jour: {'device': 'laptop', 'constructeur': 'acer', 'ram': '8G', 'processeur':
'Intel core i5', 'stockage': '750 G', 'Système d'exploitation': 'Windows 10'}

Exercice 11 :
§ On considère le dictionnaire suivant dont les clés sont les noms des élèves et
les valeurs des clés sont les moyennes générales obtenues en passant l’examen
final:

etudiants = {"etudiant_1" : 13 , "etudiant_2" : 17 , "etudiant_3" : 9 , "etudiant_4" : 15 , 
       "etudiant_5" : 8 , "etudiant_6" : 14 , "etudiant_7" : 16 , "etudiant_8" : 12 , 
       "etudiant_9" : 13 , "etudiant_10" : 15 , "etudiant_11" : 14 , "etudiant_112" : 9 , 
       "etudiant_13" : 10 , "etudiant_14" : 12 , "etudiant_15" : 13 , "etudiant_16" : 7 ,
       "etudiant_17" : 12 , "etudiant_18" : 15 , "etudiant_19" : 9 , "etudiant_20" : 17}

Voici un programme Python qui partitionne le dictionnaire donné en deux sous-

dictionnaires, "etudiantAdmis" et "etudiantNonAdmis", en fonction des moyennes
obtenues :

etudiants = {"etudiant_1": 13, "etudiant_2": 17, "etudiant_3": 9, "etudiant_4": 15,

"etudiant_5": 8, "etudiant_6": 14, "etudiant_7": 16, "etudiant_8": 12,
"etudiant_9": 13, "etudiant_10": 15, "etudiant_11": 14, "etudiant_112": 9,
"etudiant_13": 10, "etudiant_14": 12, "etudiant_15": 13, "etudiant_16": 7,
"etudiant_17": 12, "etudiant_18": 15, "etudiant_19": 9, "etudiant_20": 17}
etudiantAdmis = {}
etudiantNonAdmis = {}

for etudiant, moyenne in etudiants.items():

if moyenne >= 10:
etudiantAdmis[etudiant] = moyenne
else:
etudiantNonAdmis[etudiant] = moyenne

print("Étudiants admis :", etudiantAdmis)

print("Étudiants non admis :", etudiantNonAdmis)
Ce programme utilise une boucle for pour parcourir chaque clé-valeur du dictionnaire
etudiants. Si la moyenne est supérieure ou égale à 10, l'étudiant est ajouté au sous-
dictionnaire etudiantAdmis, sinon il est ajouté au sous-dictionnaire etudiantNonAdmis.
Enfin, les deux sous-dictionnaires sont affichés.

Voici un programme Python qui partitionne le dictionnaire donné en deux sous-

dictionnaires, 'etudiantAdmis' et 'etudiantNonAdmis', en fonction des moyennes
obtenues :

python
etudiants = {
"etudiant_1": 13,
"etudiant_2": 17,
"etudiant_3": 9,
"etudiant_4": 15,
"etudiant_5": 8,
"etudiant_6": 14,
"etudiant_7": 16,
"etudiant_8": 12,
"etudiant_9": 13,
"etudiant_10": 15,
"etudiant_11": 14,
"etudiant_112": 9,
"etudiant_13": 10,
"etudiant_14": 12,
"etudiant_15": 13,
"etudiant_16": 7,
"etudiant_17": 12,
"etudiant_18": 15,
"etudiant_19": 9,
"etudiant_20": 17
}

etudiantAdmis = {}
etudiantNonAdmis = {}

for etudiant, moyenne in etudiants.items():

if moyenne >= 10:
etudiantAdmis[etudiant] = moyenne
else:
etudiantNonAdmis[etudiant] = moyenne

print("Étudiants admis :", etudiantAdmis)

print("Étudiants non admis :", etudiantNonAdmis)
Ce programme parcourt chaque clé-valeur du dictionnaire 'etudiants' et vérifie si la
moyenne est supérieure ou égale à 10. Les étudiants admis sont ajoutés au dictionnaire
'etudiantAdmis' avec leur moyenne respective, tandis que les étudiants non admis sont
ajoutés au dictionnaire 'etudiantNonAdmis'. Enfin, les deux sous-dictionnaires sont
affichés à l'écran.

Ecrivez un programme Python qui partitionne ce dictionnaire en deux sous

dictionnaires:
1. etudiantAdmis dont les clés sont les étudiants admis et les valeurs des clés sont
les moyennes obtenues (moyenne supérieurs ou égales à 10 ).
 2. etudiantNonAdmis dont les clés sont les étudiants non admis et les valeurs des
clés sont les moyennes obtenues (moyenne inférieur à 10).

Exercice 12:

Codez une classe myString permettant de doter les chaines de caractères des
méthodes append() et pop() faisant les mêmes opérations que celles des listes.
Exemple si on crée des chaines via l'instanciation s1 = myString("Hello") et s2 =
"bonjour", et on lui applique les méthodes :

print(s1.append(" world !")) # affiche 'Hello world !'

print(s2.pop(2)) # affiche ’bonjour'

Voici une implémentation de la classe myString qui ajoute les méthodes append() et
pop() aux chaînes de caractères :

python
class myString:
def __init__(self, string):
self.string = string

def append(self, substring):

self.string += substring
return self.string

def pop(self, index):

if index < 0 or index >= len(self.string):
raise IndexError("Index out of range")
popped_char = self.string[index]
self.string = self.string[:index] + self.string[index+1:]
return popped_char

# Exemple d'utilisation
s1 = myString("Hello")
s2 = myString("bonjour")

print(s1.append(" world !")) # affiche 'Hello world !'

print(s2.pop(2)) # affiche 'n'
Dans cet exemple, nous avons créé la classe myString avec deux méthodes : append() et
pop(). La méthode __init__() est le constructeur de la classe, qui initialise la chaîne de
caractères.
La méthode append() prend une sous-chaîne en entrée et l'ajoute à la fin de la chaîne
principale (self.string). Elle retourne la chaîne complète mise à jour.

La méthode pop() prend un index en entrée et supprime le caractère correspondant de

la chaîne principale. Elle retourne le caractère supprimé. Si l'index est en dehors de la
plage valide, une erreur IndexError est levée.

Dans l'exemple d'utilisation, nous instancions deux objets de la classe myString, s1 et s2.
Ensuite, nous appelons les méthodes append() et pop() sur ces objets pour effectuer les
opérations demandées et afficher les résultats

Exercice 13 :
1. Ecrire une classe Rectangle en langage Python, permettant de construire un
rectangle dotée d’attributs longueur, largeur et couleur.
2. Créer une méthode Perimetre() permettant de calculer le périmètre du
rectangle et une méthode Surface() permettant de calculer la surface du
rectangle.
3. Créer les getters et setters.
4. Créer une classe fille Parallelepipede héritant de la classe Rectangle et dotée
en plus d’un attribut hauteur et d’une autre méthode Volume() permettant de
calculer le volume du Parallélépipède.

class Rectangle:
def __init__(self, longueur, largeur, couleur):
self.longueur = longueur
self.largeur = largeur
self.couleur = couleur

def Perimetre(self):
return 2 * (self.longueur + self.largeur)
 def Surface(self):
return self.longueur * self.largeur

# Getter pour la longueur

def getLongueur(self):
return self.longueur

# Setter pour la longueur

def setLongueur(self, nouvelle_longueur):
self.longueur = nouvelle_longueur

# Getter pour la largeur

def getLargeur(self):
return self.largeur

# Setter pour la largeur

def setLargeur(self, nouvelle_largeur):
self.largeur = nouvelle_largeur

# Getter pour la couleur

def getCouleur(self):
return self.couleur

# Setter pour la couleur

def setCouleur(self, nouvelle_couleur):
self.couleur = nouvelle_couleur
Maintenant, voici la classe Parallelepipede qui hérite de la classe Rectangle et ajoute
l'attribut hauteur et la méthode Volume() pour calculer le volume du parallélépipède :

class Parallelepipede(Rectangle):
def __init__(self, longueur, largeur, couleur, hauteur):
super().__init__(longueur, largeur, couleur)
self.hauteur = hauteur

def Volume(self):
return self.longueur * self.largeur * self.hauteur

# Getter pour la hauteur

def getHauteur(self):
return self.hauteur

# Setter pour la hauteur

 def setHauteur(self, nouvelle_hauteur):
self.hauteur = nouvelle_hauteur
Maintenant, vous pouvez créer des objets de ces classes et utiliser leurs méthodes et
attributs selon vos besoins. Par exemple :

python

# Création d'un rectangle

mon_rectangle = Rectangle(5, 3, "bleu")

# Appel des méthodes

print("Périmètre du rectangle :", mon_rectangle.Perimetre())
print("Surface du rectangle :", mon_rectangle.Surface())

# Utilisation des getters

print("Longueur du rectangle :", mon_rectangle.getLongueur())
print("Largeur du rectangle :", mon_rectangle.getLargeur())
print("Couleur du rectangle :", mon_rectangle.getCouleur())

# Utilisation des setters

mon_rectangle.setLongueur(7)
mon_rectangle.setLargeur(4)
mon_rectangle.setCouleur("rouge")

# Création d'un parallélépipède

mon_parallelepipede = Parallelepipede(5, 3, "bleu", 2)

# Appel des méthodes héritées

print("Périmètre du parallélépipède :", mon_parallelepipede.Perimetre())
print("Surface du parallélépipède :", mon_parallelepipede.Surface())

# Appel de la méthode spécifique à Parallelepipede

print("Volume du parallélépipède :", mon_parallelepipede.Volume())

# Utilisation des getters hérités

print("Longueur du parallélépipède :", mon_parallelepipede.getLongueur())
print("Largeur du parallélépipède :", mon_parallelepipede.getLargeur())
print("Couleur du parallélépipède :", mon_parallele
Exercice 14 :

1. Créez une classe Python nommée CompteBancaire qui représente un compte

bancaire, ayant pour attributs : numeroCompte (type numérique ) , nom (nom
du propriétaire du compte du type chaîne), prénom (nom du propriétaire du
compte du type chaîne), & solde (type réel).
2. Créez un constructeur ayant comme paramètres : numeroCompte, nom,
prenom, solde.
3. Créez une méthode Versement() qui gère les versements.
4. Créez une méthode Retrait() qui gère les retraits.
5. Créez une méthode Agios() permettant d’appliquer les agios à un pourcentage
de 5 % du solde.
6. Créez une méthode afficher() permettant d’afficher les détails sur le compte.
7. Donnez le code complet de la classe CompteBancaire.

Exercice 15 :