1

PYTHON: PROCEDDURALE ET L’ORIENTEE OBJET

Ecrit par Joël Pero/Développeur web et Enseignant d’Université /+243 82 151 1441

SCRIPT COURS PYTHON – LES BASES #1 : INTRODUCTION

INTRODUCTION DU COURS

Bonjour et bienvenue dans ce premier cours d’Introduction à Python.

Aujourd’hui, nous allons découvrir ce qu’est Python, à quoi il sert, et pourquoi il est
devenu l’un des langages les plus utilisés au monde.

1. Python, c’est quoi ?

Python est un langage qui permet de parler à l’ordinateur. On écrit des instructions
simples comme print("Bonjour").

2. Pourquoi Python est-il populaire ?

- Facile à apprendre

- Utilisé partout : sites web, IA, data, cybersécurité, automatisation

- Fonctionne sur Windows, Linux, Mac

3. Exemples à Kolwezi

- Inventaire d’un dépôt

- Calcul des salaires

- Analyse minière
 2

- Automatisation WhatsApp

4. Installer Python

Étapes 1 : télécharger → installer → tester avec python –version

Etapes 2 si vous utiliser un éditeur de code tel que VS CODE, vous aller installer
l’extension de python sur l’éditeur :

5. Premier programme

print("Bonjour le monde")

6. Variables

nom = "Hakili"

age = 23

ville = "Kolwezi"

7. Types de données

str, int, float, bool, listes.

 3

8. Commentaires

# Ceci est un commentaire

9 Operateurs

Liste

La liste est composée d’une suite des valeurs ou d’éléments.

Pour utliser une liste on met des pairs de cochers

Exemple :

ventes = [12000, 5000, 8000, 15000, 7000, 0, 9000]

jours = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]

# 1) total

total = sum(ventes)
 4

# 2) moyenne journalière (arrondie)

moyenne = round(total / len(ventes))

# 3) jour(s) avec la meilleure vente

meilleure = max(ventes)

jours_meilleurs = [jours[i] for i, v in enumerate(ventes) if v == meilleure]

print("Total semaine :", total, "FC")

print("Moyenne journalière :", moyenne, "FC")

print("Meilleure vente :", meilleure, "FC, jour(s) :", ", ".join(jours_meilleurs))

les tuples

les tuples sont pareils au liste , sauf que les tuples peuvent contenir plusieurs types
de valeur,

Dictionnaire

Un dictionnaire est une structure de données qui permet de stocker des informations
sous forme :

clé : valeur

On l’utilise quand on veut stocker des informations organisées, un peu comme une fiche
d’information.

Exemple simple :

personne = {
 5

"nom": "Hakili",

"age": 22,

"ville": "Kolwezi"

10. Exemple pratique

Calcul du gain par jour, conversion USD → FC

FIN DU COURS

Les structures conditionnelles

1. C’est quoi une structure conditionnelle ? (Explication simple)

Imagine que ton cerveau est comme un ordinateur :

tu prends des décisions en fonction de ce que tu vois.

Par exemple :

 S’il pleut, je prends un parapluie.

 Sinon, je sors sans parapluie.

C’est exactement ce que fait une structure conditionnelle en Python :

 6

👉 Elle permet au programme de choisir quoi faire selon une condition.

✔️ 2. Les mots magiques en Python

Python utilise trois mots importants :

🔹 if → “si …”

On teste une condition.

Ex : if age >= 18: signifie “si l’âge est supérieur ou égal à 18”.

🔹 elif → “sinon si …”

Ce que Python va vérifier si la première condition n’est pas vraie.

🔹 else → “sinon …”

Ce que Python fait quand aucune des conditions précédentes n’est vraie.

🏗️ 3. Comment ça se présente ?

Voici la forme générale :

if condition1:

# action 1

elif condition2:

# action 2

else:
 7

# action 3

🔍 4. Expliquer avec un exemple très simple

age = 16

if age >= 18:

print("Tu es majeur.")

else:

print("Tu es mineur.")

Ici :

 On teste si age >= 18

 Si oui → Python affiche "Tu es majeur"
 Sinon → "Tu es mineur"

Python lit toujours du haut vers le bas, et il s’arrête dès qu’une condition est vraie.

📌 5. Les opérateurs de comparaison

Pour faire des conditions, on utilise :

Opérateur Signification Exemple

== égal à a == 5
!= différent de a != 3
> supérieur à a > 10
< inférieur à a<2
>= supérieur ou égal à age >= 18
 8

Opérateur Signification Exemple

<= inférieur ou égal à taux <= 16

🌍 6. Exercice Résolu 1 (Adapté à la réalité de Kolwezi)

➡ Déterminer le prix d’un ticket de transport en fonction de l’âge

Règles :

 Moins de 12 ans → ticket = 500 FC

 Entre 12 et 20 ans → ticket = 800 FC
 Plus de 20 ans → ticket = 1 000 FC

✔️ Solution Python

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

if age < 12:

prix = 500

elif age <= 20:

prix = 800

else:

prix = 1000

print("Le prix du ticket de transport est :", prix, "FC")

 9

✔️ Explication

 Python teste d’abord age < 12

 Si ce n’est pas vrai, il teste age <= 20
 Si ce n’est pas vrai, il va au else
 On affiche le prix correspondant

🌍 7. Exercice Résolu 2 (Adapté à une boutique à Kolwezi)

➡ Calculer la réduction sur un produit

Règles :

 Si le montant est < 10 000 FC → pas de réduction

 Si le montant est entre 10 000 et 50 000 FC → réduction 5%
 Si le montant est > 50 000 FC → réduction 10%

✔️ Solution Python
montant = int(input("Entrez le montant de votre achat (en FC) : "))

if montant < 10000:

reduction = 0

elif montant <= 50000:

reduction = montant * 0.05

else:

reduction = montant * 0.10

 10

prix_final = montant - reduction

print("Réduction :", reduction, "FC")

print("Montant final à payer :", prix_final, "FC")

✔️ Explication

 Python regarde dans quelle tranche se trouve le montant

 Il applique le bon pourcentage
 Il calcule le prix final
 Les libellés sont clairs pour l'utilisateur

🎯 Résumé

 Les conditions, c’est comme prendre une décision :

“Si ceci arrive, alors je fais ça.”
 Python utilise : if – elif – else
 Tu peux faire des tests avec ==, <, >=, etc.
 Ça te permet d’automatiser des règles comme dans la vraie vie :
prix, âge, réduction, transport, facturation…


Mini Projet sur les structures conditionnelles

Mini-projet Python : "Système de Facturation Intelligent d’une Boutique"

Ce mini-projet inclut :

✔️ des conditions (if / elif / else)

✔️ des calculs de réduction

✔️ la gestion des clients fidèles

 11

✔️ la gestion de la TVA
✔️ un ticket final de facture

✔️ un code clair et commenté

✔️ adapté au contexte de Kolwezi

🚀 OBJECTIF DU MINI-PROJET

Créer un programme qui :

1. Demande le montant de l’achat d’un client

2. Demande si le client a une carte "Fidélité"
3. Applique des réductions selon le montant
4. Ajoute la TVA
5. Affiche un ticket final parfaitement lisible

🏗️ Règles du système

🎯 1. Réductions selon montant acheté

Montant (FC) Réduction

< 10 000 0%
10 000 – 50 000 5%
> 50 000 10%

🎯 2. Avantages clients fidèles

Si le client est fidèle : + 2 % de réduction supplémentaire

🎯 3. TVA

On applique une TVA de 16 % (RDC).

📦 Code Complet du Mini-projet

 12

# Mini-Projet : Système de Facturation Intelligent

print("=== SYSTEME DE FACTURATION BOUTIQUE KOLWEZI ===\n")

# 1. Lecture du montant de l'achat

montant = int(input("Entrez le montant total de l'achat (en FC) : "))

# 2. Vérifier si le client possède une carte fidélité

carte = input("Le client possède-t-il une carte fidélité ? (oui / non) : ").lower()

# ----------------------------

# CALCUL DES REDUCTIONS

# ----------------------------

# Réduction de base selon montant

if montant < 10000:

reduction = 0

elif montant <= 50000:

reduction = montant * 0.05 # 5%

else:

reduction = montant * 0.10 # 10%

# Bonus fidélité

bonus_fidelite = 0

if carte == "oui":
 13

bonus_fidelite = montant * 0.02

# Réduction totale

reduction_totale = reduction + bonus_fidelite

# ----------------------------

# CALCUL TVA

# ----------------------------

tva = (montant - reduction_totale) * 0.16

# ----------------------------

# PRIX FINAL

# ----------------------------

prix_final = montant - reduction_totale + tva

# ----------------------------

# AFFICHE LE TICKET

# ----------------------------

print("\n========== TICKET DE FACTURATION ==========")

print("Montant initial :", montant, "FC")

print("Réduction de base :", reduction, "FC")

if carte == "oui":

print("Bonus fidélité (+2%) :", bonus_fidelite, "FC")

 14

else:

print("Bonus fidélité : 0 FC")

print("Réduction totale :", reduction_totale, "FC")

print("TVA (16%) :", tva, "FC")

print("------------------------------------------")

print("=> TOTAL À PAYER :", prix_final, "FC")

print("==========================================")

📝 EXPLICATION DU MINI-PROJET

🔸 1. Conditions sur les montants

On vérifie le montant pour appliquer les bonnes réductions.

🔸 2. Condition sur la carte fidélité

Si carte == "oui", on ajoute 2% de réduction.

🔸 3. TVA

TVA appliquée uniquement après réduction (comme en RDC).

🔸 4. Ticket final

Tout est affiché comme dans une vraie boutique ou supermarché.

Les boucles

1. Les boucles : c’est quoi ?

 15

Imagine que tu dois faire une action plusieurs fois.

Exemples simples :

 ramasser 10 cailloux
 dire bonjour à 5 personnes
 compter de 1 à 20

Plutôt que de répéter la même chose 20 fois, Python dit :

👉 “Ne me fais pas écrire 20 lignes, je tourne en boucle pour toi !”

C’est ça une boucle.

2. La boucle for (Le robot qui compte pour toi)

La boucle for sert quand tu sais combien de fois tu veux répéter une action.

Exemple :

for i in range(5):
print("Bonjour !")

Cela affiche 5 fois “Bonjour !”.

Imagine ça :

Tu dis à un robot :

 “Compter jusqu’à 5”
 Et à chaque nombre, tu dis “Bonjour”

Et le robot obéit.
 16

3. La fonction range() (La règle qui donne des chiffres)

range() crée une séquence de nombres.

 range(5) → 0, 1, 2, 3, 4
 range(1, 6) → 1, 2, 3, 4, 5
 range(2, 10, 2) → 2, 4, 6, 8

Donc c’est comme une règle graduée que Python utilise pour compter.

4. La boucle while (Le robot qui continue tant que…)

La boucle while continue tant que une condition est vraie.

Exemple :

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

Cela compte de 1 à 5.

Exemple simple :

“Tant que tu n’es pas à la maison, continue de marcher.”

C’est la logique de while.

5. L’instruction break (Stop ! Arrête tout !)

break sert à dire :

👉 “Arrête la boucle immédiatement.”

 17

Exemple :

for i in range(1, 11):

if i == 5:
break
print(i)
La boucle s’arrête quand i = 5.

6. L’instruction continue (Ignore et saute)

continue sert à dire :

👉 “Passe cette étape et continue avec la suivante.”

Exemple :

for i in range(1, 6):

if i == 3:
continue
print(i)
Le chiffre 3 est sauté !

RÉSUMÉ

Mot clé Ce que ça fait

for Répète un nombre précis de fois

range Donne une liste de nombres

while Répète tant qu’une condition est vraie

break Stoppe toute la boucle

continue Ignore une étape et continue

 18

📝 EXERCICE RÉSOLU 1

Compter les sacs de ciment jusqu’à trouver un sac déchiré

Une boutique reçoit 10 sacs de ciment.

Le sac n°4 est déchiré.
Arrêter la vérification quand on arrive au sac déchiré.

✔️ Solution :

print("Vérification des sacs de ciment :")

for sac in range(1, 11):

print("Sac numéro :", sac)

if sac == 4:

print("⚠ Sac déchiré trouvé ! On arrête la vérification.")

break

Explication :

 On compte les sacs 1 par 1

 Quand on arrive au sac numéro 4
 On s’arrête immédiatement avec break
 19

📝 EXERCICE RÉSOLU 2

Calculer combien de clients ont payé (en sautant ceux qui n'ont pas d'argent)

Un agent M-Pesa sert 6 clients, mais certains n'ont pas d'argent.

Si un client n’a pas d’argent (montant = 0), on saute ce client.

Montants :
[5000, 0, 2000, 0, 10000, 1500]

✔️ Solution :

montants = [5000, 0, 2000, 0, 10000, 1500]

print("Montants traités :")

for m in montants:

if m == 0:

print("Client sans argent → ignoré")

continue # on saute ce client

print("Client a payé :", m, "FC")

✔️ Explication :

 Quand le montant = 0 → on saute avec continue

 Sinon → on affiche le paiement
 20

Mini-projet : "Gestion Ventes & Relances — Boutique Kolwezi"

1) Objectif

Aider un petit commerçant à :

 enregistrer des ventes (produit, quantité, client, montant),

 mettre à jour le stock,
 détecter les ruptures et erreurs (quantité négative),
 lister les clients ayant des paiements en attente,
 générer un rapport journalier (total ventes, meilleures ventes),
 relancer automatiquement (simulé) les clients n’ayant pas payé.

Tout cela via un menu simple en console. Le programme utilise boucles et contrôles
(break, continue) pour la robustesse.

2) Règles / Hypothèses

 On a une petite base initiale (produits + stock).

 Les ventes sont enregistrées et stock mises à jour.
 Si quantité saisie est None ou vide → on saute l’enregistrement (continue).
 Si quantité saisie est négative → erreur → stop (break) pour corriger.
 Les ventes non-payées sont marquées et listées pour relance.

3) Code complet (fichier suggéré : gestion_ventes.py)

# gestion_ventes.py

# Mini-projet : Gestion Ventes & Relances - Boutique Kolwezi

# Utilise : for, while, range, break, continue

 21

import csv

from datetime import date

# Données initiales (exemple)

produits = {

"Ciment": 50,

"Savon": 30,

"Huile": 20,

"Sucre": 40

# Liste pour stocker ventes (en mémoire) ; chaque vente = dict

ventes = []

# Exemple : [Link]({"client": "Eric", "produit":"Ciment", "qte":2,

"montant":29000, "payé":False, "date":"2025-11-23"})

def afficher_stock():

print("\n--- STOCK ACTUEL ---")

for i, (nom, qte) in enumerate([Link](), start=1):

print(f"{i}. {nom} : {qte} unités")

 22

print("--------------------\n")

def enregistrer_vente():

print("\n--- ENREGISTRER UNE VENTE ---")

afficher_stock()

produit = input("Nom du produit (exact) : ").strip()

if produit not in produits:

print("Produit non trouvé. Retour au menu.")

return

# Lecture quantité, gestion d'erreurs et de sauts

qte_str = input("Quantité vendue (laisser vide pour annuler) : ").strip()

if qte_str == "":

print("Saisie vide → annulation.")

return

try:

qte = int(qte_str)

except ValueError:

print("Quantité invalide. Annulation.")

return
 23

# Si quantité négative => erreur grave : on stoppe l'opération

if qte < 0:

print("ERREUR : Quantité négative détectée ! Interruption pour correction.")

return # on n'utilise pas break ici (dans une ft), mais l'idée est d'arrêter
l'opération

# Vérifier stock

if qte > produits[produit]:

print(f"Attention : stock insuffisant (stock = {produits[produit]}). Vente annulée.")

return

prix_unitaire = float(input("Prix unitaire (FC) : "))

montant = prix_unitaire * qte

client = input("Nom du client : ").strip()

payé = input("Le client paie maintenant ? (oui/non) : ").strip().lower()

payé_bool = True if payé == "oui" else False

# Enregistrer la vente

vente = {

"client": client,
 24

"produit": produit,

"qte": qte,

"montant": montant,

"payé": payé_bool,

"date": str([Link]())

[Link](vente)

# Mettre à jour le stock

produits[produit] -= qte

print(f"Vente enregistrée : {qte} x {produit} pour {montant} FC. Paiement : {'oui' if

payé_bool else 'non'}.\n")

def rapport_journalier():

if not ventes:

print("\nAucune vente enregistrée aujourd'hui.\n")

return

print("\n--- RAPPORT JOURNALIER ---")

total = 0

tot_non_payes = 0
 25

ventes_par_produit = {}

for v in ventes:

total += v["montant"]

if not v["payé"]:

tot_non_payes += v["montant"]

ventes_par_produit[v["produit"]] = ventes_par_produit.get(v["produit"], 0) +
v["qte"]

print(f"Nombre de ventes : {len(ventes)}")

print(f"Chiffre d'affaire (TTC approximatif) : {total} FC")

print(f"Montant non payé : {tot_non_payes} FC")

# Top produit(s)

max_qte = max(ventes_par_produit.values())

top = [p for p,q in ventes_par_produit.items() if q == max_qte]

print("Meilleure(s) vente(s) :", ", ".join(top), f"avec {max_qte} unités vendues")

print("--------------------------\n")

def lister_clients_non_payes():

print("\n--- CLIENTS AVEC PAIEMENT EN ATTENTE ---")

trouvés = False
 26

for v in ventes:

if not v["payé"]:

trouvés = True

print(f"Client: {v['client']} | Produit: {v['produit']} | Montant: {v['montant']} FC |

Date: {v['date']}")

if not trouvés:

print("Aucun client en attente.")

print("-----------------------------------------\n")

def sauvegarder_csv(nom_fichier="ventes_journalieres.csv"):

# Sauvegarde simple de toutes les ventes en CSV

champs = ["client","produit","qte","montant","payé","date"]

with open(nom_fichier, mode="w", newline='', encoding="utf-8") as f:

writer = [Link](f, fieldnames=champs)

[Link]()

for v in ventes:

[Link](v)

print(f"Ventes sauvegardées dans {nom_fichier}\n")

def menu():

while True:
 27

print("=== MENU PRINCIPAL ===")

print("1. Afficher le stock")

print("2. Enregistrer une vente")

print("3. Rapport journalier")

print("4. Lister clients non payés (relance)")

print("5. Sauvegarder ventes (CSV)")

print("6. Quitter")

choix = input("Choix (1-6) : ").strip()

if choix == "1":

afficher_stock()

elif choix == "2":

enregistrer_vente()

elif choix == "3":

rapport_journalier()

elif choix == "4":

lister_clients_non_payes()

elif choix == "5":

sauvegarder_csv()

elif choix == "6":

print("Au revoir !")

 28

break # on quitte la boucle while principale

else:

print("Choix invalide, réessaie.\n")

# Lancer le programme

if __name__ == "__main__":

menu()

4) Explication pas-à-pas (pour un débutant / comme à un enfant)

 Menu (while True) : on affiche les options et on attend que l’utilisateur

choisisse. La boucle recommence jusqu’à ce que l’utilisateur choisisse “Quitter”
(on utilise break pour sortir).
 for et enumerate dans afficher_stock() : on parcourt chaque produit et
on affiche son numéro et sa quantité.
 continue logique : si l’utilisateur laisse la quantité vide (annulation), on saute
l’enregistrement de la vente (on retourne au menu).
 Contrôle d’erreur : si la quantité est négative, on abandonne l’action (prévenir et
ne pas déduire du stock). Ici on ne break pas la boucle globale directement, on
annule l’opération ; mais si tu veux arrêter tout le programme sur erreur grave tu
peux utiliser break.
 Mise à jour du stock : après une vente, on enlève la quantité vendue du stock.
 Rapport journalier : on parcourt ventes (boucle for) pour calculer le total et
déterminer le produit le plus vendu.
 Relance : on parcourt ventes et on affiche les entrées non payées (on pourrait
ensuite envoyer un SMS — ici on simule par prints).
 Sauvegarde CSV : on écrit toutes les ventes dans un fichier pour garder un
historique.
 29

5) Exemple d’usage (session simulée)

 Lancement → menu.
 Choix 2 → enregistrer une vente : Ciment, qte 2, prix unitaire 15000, client
Eric, payé non.
 Choix 2 → enregistrer une vente : Savon, qte 1, prix 500, client Amina, payé
oui.
 Choix 3 → rapport : montre chiffre d’affaire, meilleur produit.
 Choix 4 → lister non payés : montre Eric.
 Choix 5 → sauvegarde CSV.
 Choix 6 → quitter.

6) Extensions proposées (tu choisis)

 Ajouter validation stricte (reprompt si entrée invalide).

 Permettre ajout / suppression de produits (menu).
 Implémenter la relance automatique : génération d’un message pour chaque
client non payé (fichier log ou simulation d’envoi SMS).
 Interface simple avec Tkinter.
 Stock persistant : lire/écrire produits et ventes depuis/vers des fichiers
JSON/CSV au démarrage/arrêt.
 Rapport avancé : moyenne journalière, top-3 produits (utilise sorted() et
range() pour top N).

Les fonctions en Python — expliquées très simplement

Imagine que tu fais la même tâche encore et encore — par exemple : préparer une tasse
de thé. Une fonction en Python, c’est comme une recette ou une boîte à outils : tu écris
la recette une fois, puis tu peux la réutiliser quand tu veux sans tout réécrire.
 30

Tu donnes les ingrédients (paramètres), la recette fait son travail, et tu peux obtenir un
résultat (valeur renvoyée).

1. Pourquoi utiliser des fonctions ?

 Éviter de répéter le même code (DRY = Don’t Repeat Yourself).

 Rendre ton code plus clair et plus facile à comprendre.
 Tester chaque petite partie séparément.
 Partager des recettes utiles dans d’autres programmes.

2. Comment on crée une fonction ? (la base)

def dire_bonjour():

print("Bonjour !")

 def : mot magique qui dit "je définis une fonction".

 dire_bonjour : nom de la fonction.
 () : endroit pour mettre les paramètres (les ingrédients).
 : puis indent => le corps (les instructions).

Pour l’appeler

dire_bonjour()

# affiche "Bonjour !"

3. Paramètres — donner des ingrédients à la fonction

def dire_bonjour_a(nom):

print("Bonjour", nom, "!")

 31

Appel :

dire_bonjour_a("Eric")

# affiche: Bonjour Eric !

Tu peux donner plusieurs ingrédients :

def addition(a, b):

print(a + b)

4. return — rendre quelque chose (la fonction donne un résultat)

Différence : print() affiche quelque chose maintenant ; return renvoie une valeur
que tu peux réutiliser.

def addition(a, b):

return a + b

somme = addition(3, 4) # somme = 7

print(somme) # affiche 7

5. Valeurs par défaut — paramètre optionnel

def saluer(nom="ami"):

print("Bonjour", nom)

saluer() # Bonjour ami

saluer("Amina") # Bonjour Amina

6. Arguments nommés (keyword args) — plus clair

 32

def creer_client(nom, ville):

print(nom, "de", ville)

creer_client(ville="Kolwezi", nom="Eric")

7. *args et **kwargs — pour plusieurs ingrédients flexibles

 *args : reçoit plusieurs valeurs positionnelles (comme une liste).

 **kwargs : reçoit plusieurs valeurs nommées (comme un dict).

def somme_multiple(*args):

total = 0

for v in args:

total += v

return total

somme_multiple(1,2,3)

# renvoie 6

def afficher_infos(**kwargs):

for cle, val in [Link]():

print(cle, ":", val)

afficher_infos(nom="Amina", age=25)

8. Portée (scope) — où les variables vivent

 Variables locales : créées dans la fonction — disparaissent quand la fonction finit.

 Variables globales : définies en dehors — accessibles partout (mais attention,
mieux vaut limiter leur usage).
 33

x = 10 # global

def f():

y = 5 # local

print(x + y)

f() # OK

# print(y) -> erreur, y n'existe pas ici

9. Fonction anonyme : lambda (petite recette sans nom)

carre = lambda x: x * x

print(carre(4)) # 16

Utile pour de petites fonctions rapides (souvent utilisées avec map, filter, sorted).

10. Fonctions qui appellent d'autres fonctions / réutilisables

Les fonctions peuvent s'appeler entre elles — c'est la composition.

def TVA(montant, taux=16):

return montant * taux / 100

def prix_ttc(montant_ht, taux=16):

return montant_ht + TVA(montant_ht, taux)

Exercice 1 — (résolu) : Calculer le prix total TTC

Contexte réel : Ton magasin vend un article. On lit prix HT, quantité, taux TVA. Écris
une fonction qui calcule le prix total TTC.

Code :
def calcul_prix_ttc(prix_ht, quantite, taux_tva=16):
 34

"""

Calcule le prix total TTC pour une quantité donnée.

prix_ht : prix unitaire hors taxe (float)

quantite : nombre d'articles (int)

taux_tva : taux en pourcentage (float), défaut 16%

"""

montant_ht = prix_ht * quantite

montant_tva = montant_ht * (taux_tva / 100)

montant_ttc = montant_ht + montant_tva

return montant_ttc

# Exemple d'utilisation

prix_unitaire = 10000.0

qte = 2

total = calcul_prix_ttc(prix_unitaire, qte, 16)

print(f"Prix total TTC pour {qte} articles : {total} FC")

Explication :

1. La fonction reçoit prix_ht, quantite, taux_tva.

2. Elle calcule montant_ht = prix_ht * quantite.
3. Puis montant_tva = montant_ht * taux_tva/100.
4. Retourne la somme (TTC).
5. On peut réutiliser la fonction pour n’importe quel produit.
 35

Exercice 2 — (résolu) : Fiche d’apprenant + moyenne

Contexte réel : On veut une fonction qui crée une fiche pour un apprenant et calcule sa
moyenne et son statut (Admis si moyenne ≥ 12).

Code :
def creer_fiche(eleve_nom, notes):

"""

notes : liste de nombres (ex : [15, 12, 18])

Renvoie un dict avec nom, notes, moyenne, statut

"""

if not notes:

moyenne = 0

else:

moyenne = sum(notes) / len(notes)

statut = "Admis" if moyenne >= 12 else "Ajourné"

return {

"nom": eleve_nom,

"notes": notes,

"moyenne": round(moyenne, 2),

"statut": statut

}
 36

# Exemple d'utilisation

fiche = creer_fiche("Eric", [15, 13, 18, 10])

print(fiche)

# -> {'nom': 'Eric', 'notes': [15, 13, 18, 10], 'moyenne': 14.0, 'statut': 'Admis'}

Explication :

 creer_fiche prend le nom et une liste de notes.

 Calcule la moyenne, arrondit, détermine le statut via une condition ternaire.
 Renvoie un dictionnaire (structure pratique).

Mini-projet (adapté à la réalité) : "Kit de Fonctions — Gestion Simple d’une Boutique"

Objectif

Créer un petit module de fonctions réutilisables pour une boutique (Kolwezi) qui permet
de :

 calculer prix TTC (par article et pour toute une vente)

 appliquer réduction selon montant et fidélité
 créer et afficher un reçu (ticket) propre
 sauvegarder le reçu dans un fichier texte

Ce mini-projet montre comment composer des fonctions propres et réutilisables.

Code complet — boutique_fonctions.py

# boutique_fonctions.py

from datetime import datetime

def calcul_prix_ttc(prix_ht, quantite, taux_tva=16):

montant_ht = prix_ht * quantite

montant_tva = montant_ht * (taux_tva / 100)

 37

return round(montant_ht + montant_tva, 2)

def reduction_par_montant(montant_ht):

"""

Applique une réduction selon le montant HT :

<10000 -> 0%

10000-50000 -> 5%

>50000 -> 10%

"""

if montant_ht < 10000:

return 0

elif montant_ht <= 50000:

return montant_ht * 0.05

else:

return montant_ht * 0.10

def reduction_fidelite(montant_ht, est_fidele=False):

"""Si client fidèle, 2% de réduction sur le montant HT"""

if est_fidele:

return montant_ht * 0.02

return 0

def calcul_total_vente(lignes_vente, taux_tva=16, est_fidele=False):

 38

"""

lignes_vente : liste de dicts : [{"produit":"Ciment", "prix_ht":10000, "qte":2}, ...]

Retourne un dict récapitulatif avec montant_ht, reductions, tva, total_ttc

"""

montant_ht_total = 0

for ligne in lignes_vente:

montant_ht_total += ligne["prix_ht"] * ligne["qte"]

red_base = reduction_par_montant(montant_ht_total)

red_fid = reduction_fidelite(montant_ht_total, est_fidele)

red_tot = red_base + red_fid

ht_apres_reduc = montant_ht_total - red_tot

tva = ht_apres_reduc * (taux_tva / 100)

total_ttc = ht_apres_reduc + tva

return {

"montant_ht": round(montant_ht_total, 2),

"reduction": round(red_tot, 2),

"ht_apres_reduc": round(ht_apres_reduc, 2),

"tva": round(tva, 2),

"total_ttc": round(total_ttc, 2)
 39

def generer_recu(client, lignes_vente, recap):

"""

client: nom du client

lignes_vente: liste de dicts

recap: dict retourné par calcul_total_vente

"""

now = [Link]().strftime("%Y-%m-%d %H:%M")

lines = []

[Link]("=== RECU BOUTIQUE KOLWEZI ===")

[Link](f"Client : {client}")

[Link](f"Date : {now}")

[Link]("----------------------------------")

[Link]("Produits :")

for l in lignes_vente:

[Link](f"- {l['produit']} x{l['qte']} @ {l['prix_ht']} FC = {l['prix_ht']*l['qte']} FC")

[Link]("----------------------------------")

[Link](f"Montant HT : {recap['montant_ht']} FC")

[Link](f"Réduction : {recap['reduction']} FC")

[Link](f"HT après réduction : {recap['ht_apres_reduc']} FC")

 40

[Link](f"TVA : {recap['tva']} FC")

[Link](f"TOTAL TTC : {recap['total_ttc']} FC")

[Link]("==================================")

return "\n".join(lines)

def sauvegarder_recu(fichier_nom, texte):

with open(fichier_nom, "w", encoding="utf-8") as f:

[Link](texte)

# Exemple d'exécution (si on exécute ce fichier directement)

if __name__ == "__main__":

lignes = [

{"produit":"Ciment", "prix_ht":15000, "qte":2},

{"produit":"Savon", "prix_ht":500, "qte":3},

recap = calcul_total_vente(lignes, taux_tva=16, est_fidele=True)

recu = generer_recu("Eric", lignes, recap)

print(recu)

sauvegarder_recu("recu_exemple.txt", recu)

print("\nReçu sauvegardé dans 'recu_exemple.txt'")

 41

Explication du mini-projet (simple)

1. calcul_prix_ttc : petite fonction utile pour un article.

2. reduction_par_montant et reduction_fidelite : fonctions séparées pour la
logique des réductions (séparation des responsabilités).
3. calcul_total_vente : combine les lignes (articles) et applique les réductions
puis la TVA. Renvoie un dictionnaire récapitulatif.
4. generer_recu : crée un texte joli pour le ticket.
5. sauvegarder_recu : écrit le reçu dans un fichier texte pour archives.

RETURN / Factoriel / Récursivité / Variables locales & globales

Qu’est-ce que return ? 🔁

 Imagine une boîte magique (la fonction). Tu donnes des ingrédients, la boîte les
transforme et te donne quelque chose en sortie.
 En Python, pour que la boîte rende quelque chose, on utilise return.

Exemple simple :

def double(x):

return x * 2

res = double(5) # res vaut 10

print(res) # affiche 10

 Sans return, la fonction fait le travail mais ne renvoie rien (elle renvoie None par
défaut).

 return termine aussi immédiatement l’exécution de la fonction — tout code après

return dans la fonction n’est pas exécuté.

Le factoriel — définition simple 🧮

Pour un entier n ≥ 0, le factoriel n! est :

 0! = 1 (par convention)
 1! = 1
 2! = 2 × 1 = 2
 3! = 3 × 2 × 1 = 6
 42

 4! = 4 × 3 × 2 × 1 = 24
 etc.

Le factoriel sert pour compter des arrangements (combien d’ordres possibles pour n
objets).

Récursivité — c’est quoi ? ♻️

 Récursivité : une fonction qui s’appelle elle-même pour résoudre un petit

morceau du problème.
 Très naturelle pour le factoriel : n! = n × (n-1)! — la fonction factorielle
calcule n × factoriel(n-1) jusqu’à atteindre le cas de base 0 ou 1.

Important : toujours définir un cas de base (arrêt), sinon la fonction s’appellera sans fin
→ erreur (dépassement de profondeur).

Exemple : factoriel récursif et itératif

def factoriel_rec(n):

if n < 0:

raise ValueError("n doit être >= 0")

if n == 0 or n == 1:

return 1 # cas de base

return n * factoriel_rec(n - 1)

Itératif (boucle) :

def factoriel_iter(n):

if n < 0:

raise ValueError("n doit être >= 0")

resultat = 1

for i in range(2, n + 1):

resultat *= i

return resultat
 43

Les deux donnent le même résultat. La version itérative utilise une boucle for; la récursive
utilise des appels de fonctions empilés.

Variables locales & globales — où vivent les variables ? 🌍 / 🏠

 Variable locale : déclarée dans la fonction. Elle n’existe que pendant l’exécution
de cette fonction.

def f():

a = 5 # a est locale

Après f() → a n’est plus accessible.

 Variable globale : déclarée en dehors de toutes les fonctions. Accessible de partout

(mais attention !).

x = 10 # globale

def g():

print(x) # peut lire x

Modifier une globale depuis une fonction : on doit utiliser global (à éviter si possible).

compteur = 0

def inc():

global compteur

compteur += 1

Mieux vaut retourner une valeur et l’assigner à l’extérieur :

def inc_local(c):

return c + 1

compteur = inc_local(compteur)

Pourquoi éviter global ? parce que ça rend le code fragile et difficile à comprendre
quand de nombreuses fonctions modifient les mêmes variables.
 44

Cas pratique : compter les appels récursifs (expliquer la portée)

Exemple (mauvaise idée avec global) :

calls = 0

def fact_bad(n):

global calls

calls += 1

if n <= 1:

return 1

return n * fact_bad(n - 1)

print(fact_bad(5)) # calcule 120

print(calls) # affiche combien d'appels (ici 6)

Précautions sur la récursivité

 Python limite la profondeur d’appel (par défaut ~1000). Pour de très grands n,
récursion récursive simple peut échouer.
 Pour gros calculs, on préfère des solutions itératives ou des techniques comme la
mémoïsation (cacher les résultats précédents) ou utiliser [Link]().

Exercice 1 — (Résolu) Factoriel en contexte réel (arrangements de caisses)

Énoncé (réalité) :
Un commerçant veut savoir de combien de façons il peut placer sur une étagère n caisses
différentes (chaque disposition différente compte). Écris une fonction récursive
arrangements(n) qui rend n!. Explique et donne un exemple pour n = 5.

Solution — code + explication

# solution récursive simple
def arrangements(n):
"""
Retourne n! (nombre de permutations de n caisses)
"""
 45

if n < 0:
raise ValueError("n doit être >= 0")
if n == 0 or n == 1:
return 1
return n * arrangements(n - 1)

# Exemple
n = 5
print(f"Nombre d'arrangements pour {n} caisses :", arrangements(n))

Étapes / explication pour un enfant :

 Si tu as 5 caisses, pour choisir la place de la première caisses tu as 5 choix, pour la

deuxième 4, puis 3, 2, 1.
 Donc total = 5 × 4 × 3 × 2 × 1 = 120.
 La fonction fait la même chose : elle se réduit à n × (n-1)! jusqu’à 1! qui vaut 1
(cas de base).

Sortie attendue :

Nombre d'arrangements pour 5 caisses : 120

Exercice 2 — (Résolu) Récursivité et portée : calculer la somme des prix en

récursion sans global

Énoncé (réalité) :
Tu as une liste de montants reçus dans la journée (en FC) : ventes = [5000, 12000,
0, 8000]. Écris une fonction récursive somme_ventes(ventes, idx) qui calcule la
somme des ventes depuis l’indice idx jusqu’à la fin. Fais la version récursive qui
retourne le total (sans utiliser de variable globale). Donne l’exécution pour cette liste.

Solution — code + explication

def somme_ventes(ventes, idx=0):
"""
Retourne la somme des éléments de la liste ventes
à partir de l'indice idx jusqu'à la fin (récursif).
"""
# cas de base : si idx dépasse la liste, somme = 0
if idx >= len(ventes):
return 0
# sinon : valeur courante + somme du reste
return ventes[idx] + somme_ventes(ventes, idx + 1)

# Exemple réel
ventes = [5000, 12000, 0, 8000]
total = somme_ventes(ventes)
print("Total des ventes :", total, "FC")
 46

Explication simple :

 On prend la première vente, on ajoute la somme des ventes suivantes (celle-ci

calculée par l’appel récursif).
 Quand on atteint la fin de la liste (indice trop grand), on renvoie 0 — c’est le cas
de base.
 Pas besoin de variable globale : chaque appel renvoie sa partie de la somme, et les
résultats sont additionnés en remontant.

Sortie attendue :

Total des ventes : 25000 FC

Bonus pédagogique : mesurer le nombre d’appels récursifs proprement

(sans global)

On peut renvoyer (résultat, count) comme tuple :

def fact_with_count(n):
"""
Retourne (factoriel_de_n, nombre_d'appels_effectues)
"""
if n <= 1:
return 1, 1
sub_fact, sub_calls = fact_with_count(n - 1)
return n * sub_fact, sub_calls + 1

f, calls = fact_with_count(5)
print("5! =", f, " — appels récursifs :", calls)

Sortie :

5! = 120 — appels récursifs : 6

Récapitulatif simple

 return → la fonction te donne quelque chose en sortie.

 Factoriel (n!) → produit de tous les entiers de 1 à n.
 Récursivité → la fonction se répète elle-même sur un petit problème (toujours
avec un cas de base !).
 Local vs global → mieux garder les variables locales et retourner les résultats
plutôt que d’utiliser global.

 47

Les Fonctions Natives & les Paramètres Avancés (*args, kwargs) en Python

1. Les fonctions natives (built-in functions)

Python possède déjà plusieurs fonctions “prêtes à l’emploi”, comme des outils dans une
boîte.
Tu n’as pas besoin de les créer toi-même : elles sont déjà là.

🎒 Exemple simple

 print() → affiche quelque chose

 len() → compte la longueur d’une liste, chaîne…
 sum() → additionne tous les éléments d’une liste
 max() → donne le plus grand élément
 min() → donne le plus petit
 type() → donne le type (int, str, float…)
 range() → sert à créer des séquences de nombres
 input() → permet à l’utilisateur d’écrire

Imagine :

Python, c’est comme une école.

Dans cette école, il y a des professeurs déjà présents (fonctions natives).
Tu peux les appeler quand tu veux.

Exemples concrets

👉 Exemple 1 : len()

nom = "Hakili"

print(len(nom)) # Résultat : 6

👉 Exemple 2 : sum()
notes = [12, 15, 17]
print(sum(notes)) # Résultat : 44

👉 Exemple 3 : max()
temperatures = [29, 31, 33, 30]
print(max(temperatures)) # Résultat : 33
 48

2. **Les paramètres avancés : *args et kwargs

Ces deux mots sont très puissants et très simples à comprendre si on les imagine bien.

A. *Comprendre args (les arguments multiples)

Imagine que tu es vendeur de beignets à Kolwezi.

Une personne vient et dit :

“Donne-moi 3 beignets”
→ Tu mets 3 beignets.

Mais *args c’est différent :

C’est comme si quelqu’un arrivait avec 1, 3, ou 10 commandes, et toi tu dois accepter
tout.

⛳ Idée :
*args = une liste de valeurs qu’on reçoit, même si on ne connaît pas leur nombre.

👉 Exemple
def addition(*args):
return sum(args)

print(addition(2, 4))
print(addition(1, 2, 3, 4, 5))

Python accepte tous les nombres que tu envoies.

B. **Comprendre kwargs (arguments nommés)

Imagine maintenant qu’un client commande dans ta boutique :

 riz=5 kg
 sucre=2 kg
 huile=1 litre

Chaque chose a un nom et une valeur.

C’est exactement ce que fait **kwargs.

 49

⛳ Idée :
**kwargs = un dictionnaire de valeurs nommées.

👉 Exemple
def afficher_infos(**kwargs):
for cle, valeur in [Link]():
print(cle, ":", valeur)

afficher_infos(nom="Hakili", ville="Kolwezi", age=23)

Comparaison simple
Syntaxe Signifie Métaphore

*args Plusieurs valeurs un sac de beignets

**kwargs Plusieurs valeurs avec noms une facture détaillée

3. Exercices résolus (adaptés à la réalité)

*Exercice 1 (Résolu) — Utiliser args

🎯 Énoncé

Créer une fonction qui calcule le montant total dépensé par un client dans une journée
(il peut faire 1, 3 ou 10 achats).

✅ Solution
def total_depenses(*args):
return sum(args)

print("Total du client :", total_depenses(500, 2000, 1500, 800), "FC")

Explication

 *args accepte n’importe combien de montants.

 sum() additionne tout.
 50

**Exercice 2 (Résolu) — Utiliser kwargs

Énoncé

Créer une fonction qui affiche proprement les informations d’un étudiant inscrit dans un
centre de formation.

Exemple d’appel :
infos_etudiant(nom="Daniel", age=22, filiere="Informatique",
ville="Kolwezi")

✅ Solution
def infos_etudiant(**kwargs):
print("=== FICHE ÉTUDIANT ===")
for cle, valeur in [Link]():
print(f"{[Link]()} : {valeur}")

infos_etudiant(nom="Daniel", age=22, filiere="Informatique",

ville="Kolwezi")

**Mini-Projet : Système de Facturation Flexible (Avec *args et kwargs)

🎯 Objectif

Créer un programme qui :

1. calcule le total d’achats du client (*args)

2. affiche les informations du client (**kwargs)
3. donne automatiquement la facture finale

Code complet et commenté

def total_achats(*args):
"""Calcule le total de tous les montants envoyés."""
return sum(args)

def infos_client(**kwargs):
"""Affiche les informations du client de manière propre."""
print("=== INFORMATIONS CLIENT ===")
for cle, valeur in [Link]():
print(f"{[Link]()} : {valeur}")
print()

def facture(**kwargs):
 51

"""Crée une facture simple."""

print("=== FACTURE ===")
for cle, valeur in [Link]():
print(f"{[Link]()} : {valeur}")
print()

# ---- Programme principal ----

# 1. Informations du client
infos_client(nom="Kande", ville="Kolwezi", telephone="0971234567")

# 2. Total des achats du jour

montant = total_achats(1500, 3000, 2500, 700)
print("Montant total :", montant, "FC\n")

# 3. Génération de la facture
facture(client="Kande", total=str(montant) + " FC", statut="Payé")

Résultat attendu
=== INFORMATIONS CLIENT ===
Nom : Kande
Ville : Kolwezi
Telephone : 0971234567

Montant total : 7700 FC

=== FACTURE ===

Client : Kande
Total : 7700 FC
Statut : Payé
 52

POO #1 — Introduction à la Programmation Orientée Objet

(Python)

1. C’est quoi la POO ?

Imagine le monde réel :

 Une voiture
 Un chien
 Un téléphone
 Un élève

Tous ces objets existent, ont des caractéristiques et peuvent faire des actions.

👉 La Programmation Orientée Objet (POO) consiste à apprendre à Python à créer ce

genre d’objets, comme s’il construisait un mini-monde.

Exemple simple

Imagine que tu veux créer un chien dans Python.

Un chien :

 a un nom (Rex)
 a un âge (4 ans)
 peut aboyer

Donc en POO, Python peut créer ce chien sous forme d’objet.

2. Les 2 mots magiques : Classe & Objet

1) Classe

Une classe, c’est comme le plan d’une maison.

On ne peut pas y habiter.

C’est juste un plan, un modèle, une recette.

👉 Exemple :
Une classe Chien explique :
 53

 comment un chien devrait être,

 quelles caractéristiques il doit avoir,
 quelles actions il peut effectuer.

2) Objet

L’objet, c’est la maison construite à partir du plan.

C’est l’exemple réel.

 Le plan = classe
 La maison construite = objet

👉 La classe "Chien" → permet de créer des chiens (objets) :

 Rex
 Samba
 Milou

3. Pourquoi utiliser la POO ? (Explication très simple)

La POO permet :

✔️ De mieux organiser le code

Comme ranger des vêtements dans différents tiroirs.

✔️ D’éviter de répéter le code

On fait un plan (classe) → on l’utilise plusieurs fois.

✔️ De créer des programmes plus grands

Plus les projets sont complexes, plus la POO devient utile.

4. Première classe Python

Voici une classe simple :

class Chien:
pass

pass = rien dedans pour l’instant.

 54

C’est juste le plan vide d’un chien.

🐕 5. Ajouter des attributs (caractéristiques)

Un chien a des caractéristiques :

 Nom
 Âge

On les met dans la fonction spéciale __init__().

class Chien:
def __init__(self, nom, age):
[Link] = nom
[Link] = age

👉 Explication comme à un enfant :

 __init__ = le constructeur (il construit l’objet)

 self = "moi-même" (le chien lui-même)
 nom et age → les valeurs envoyées

🐾 6. Créer un objet

Maintenant, créons un chien :

mon_chien = Chien("Rex", 4)

👉 Ici :

 mon_chien est l'objet

 "Rex" → nom
 4 → âge

📣 7. Ajouter des méthodes (actions)

Un chien peut aboyer.

 55

class Chien:
def __init__(self, nom, age):
[Link] = nom
[Link] = age

def aboyer(self):
print(f"{[Link]} aboie : Waouh ! Waouh !")

👉 Explication simple :

Une méthode, c’est une fonction spéciale qui appartient à l’objet.

🐶 Utilisation :
mon_chien = Chien("Rex", 4)
mon_chien.aboyer()

➡ Affiche :
Rex aboie : Waouh ! Waouh !

Concept Explication
Classe Le plan / modèle
Objet Le résultat réel créé à partir du plan
Attribut La caractéristique (nom, âge…)
Méthode L’action (aboyer, courir…)
init Le constructeur (il crée l’objet)
self L’objet lui-même

Exercice 1 (résolu) – Adapté à la réalité

🎯 Énoncé

Créer une classe Etudiant, avec :

 nom
 filière
 une méthode presentation() qui affiche :

“Je m’appelle … et j’étudie … à Kolwezi”

 56

Solution :

class Etudiant:

def __init__(self, nom, filiere):

[Link] = nom

[Link] = filiere

def presentation(self):

print(f"Je m'appelle {[Link]} et j'étudie {[Link]} à Kolwezi.")

etu1 = Etudiant("Linda", "Informatique")

[Link]()

📝 Exercice 2 (résolu) – Adapté à la réalité

🎯 Énoncé

Créer une classe Produit pour un magasin à Kolwezi, avec :

 nom
 prix
 une méthode afficher()
qui montre : “Produit : … – Prix : … FC”

Solution :
class Produit:
def __init__(self, nom, prix):
[Link] = nom
[Link] = prix

def afficher(self):
print(f"Produit : {[Link]} – Prix : {[Link]} FC")

p1 = Produit("Riz 25kg", 45000)

[Link]()
 57

Mini-Projet POO (Introduction)

🏪 Système simple de gestion de clients (Kolwezi Shop)

🎯 Objectif

Créer un programme qui :

 crée des clients

 stocke leur nom et leur numéro
 permet de les saluer
 affiche leurs informations

💻 Code complet
class Client:
def __init__(self, nom, telephone):
[Link] = nom
[Link] = telephone

def saluer(self):
print(f"Bonjour {[Link]}, merci d'être passé à notre boutique
!")

def infos(self):
print(f"Client : {[Link]} | Téléphone : {[Link]}")

# ---- Programme principal ----

c1 = Client("Patrick", "0970001234")
c2 = Client("Miriam", "099459876")

[Link]()
[Link]()

print()

[Link]()
[Link]()

🎉 Résultat
Bonjour Patrick, merci d'être passé à notre boutique !
Client : Patrick | Téléphone : 0970001234

Bonjour Miriam, merci d'être passé à notre boutique !

Client : Miriam | Téléphone : 099459876
 58

Le Constructeur en Python ( init )

🎯 1. C’est quoi un constructeur ?

Imagine que tu veux construire une maison.

Avant d’y habiter, tu dois :

 choisir la couleur
 mettre des portes
 installer des fenêtres
 poser un toit

Le constructeur, dans Python, c’est une fonction spéciale qui construit l’objet au
moment où il naît.

👉 En POO, quand tu dis :

maison = Maison()

Python demande :

“Que dois-je mettre dans cette maison ?”

La réponse se trouve dans :

python

def __init__(self, ...):

🐣 2. Le constructeur __init__

 __init__ → signifie “initialiser”, “préparer”, “construire”.

 Il est appelé automatiquement à la création d’un objet.
 Il sert à donner les caractéristiques de départ d’un objet.

💡 Tu n’as pas besoin d’appeler __init__ toi-même.

Python le fait tout seul !

Exemple simple

Voici une classe Chien avec un constructeur :

 59

class Chien:
def __init__(self, nom, age):
[Link] = nom
[Link] = age

Quand tu fais :

c = Chien("Rex", 3)

Python exécute automatiquement :

[Link] = "Rex"
[Link] = 3

Donc c devient un objet chien avec :

 nom = Rex
 âge = 3

🛠 3. Pourquoi utiliser un constructeur ?

✔️ pour définir les informations obligatoires d’un objet

✔️ pour éviter de répéter du code
✔️ pour s’assurer que chaque objet est créé proprement
✔️ pour donner une “identité” à chaque objet dès sa naissance

🧮 4. Le rôle de self

self est très simple :

👉 self = moi-même

Si l’objet s’appelle “Rex”, alors :

 [Link] = le nom de Rex

 [Link] = l’âge de Rex

Chaque objet a son propre espace.

 60

📦 5. Exemple 1 — Adapté à la réalité : Un étudiant

🎯 Énoncé

Créer une classe Etudiant avec nom + filière.

✅ Code
class Etudiant:
def __init__(self, nom, filiere):
[Link] = nom
[Link] = filiere

etu = Etudiant("Junior", "Informatique")

print([Link])
print([Link])

➡ Résultat

Junior
Informatique

📱 Exemple 2 — Un téléphone

🎯 Énoncé

Créer une classe Téléphone avec marque + modèle.

✔️ Code
class Telephone:
def __init__(self, marque, modele):
[Link] = marque
[Link] = modele

t1 = Telephone("Samsung", "A52")
t2 = Telephone("Tecno", "Spark 8")

print([Link], [Link])
print([Link], [Link])

🚀 6. Mini Projet — Gestion de Produits dans un Magasin de Kolwezi

🎯 Objectif du mini-projet

Créer un programme qui gère des produits avec :

 61

 nom
 prix
 quantité
 une méthode pour afficher les infos
 une méthode pour calculer la valeur totale du stock

Tout repose sur le constructeur.

🏪 Code complet
class Produit:
def __init__(self, nom, prix, quantite):
[Link] = nom
[Link] = prix
[Link] = quantite

def afficher(self):
print(f"Produit : {[Link]}")
print(f"Prix : {[Link]} FC")
print(f"Quantité : {[Link]}")
print("-----------------------------")

def valeur_stock(self):
return [Link] * [Link]

# --- Programme principal ---

p1 = Produit("Riz 25kg", 45000, 12)

p2 = Produit("Huile 5L", 12000, 20)
p3 = Produit("Sucre 5kg", 9000, 15)

[Link]()
[Link]()
[Link]()

print("Valeur totale du stock :")

total = p1.valeur_stock() + p2.valeur_stock() + p3.valeur_stock()

print(total, "FC")

🧮 Résultat attendu
Produit : Riz 25kg
Prix : 45000 FC
Quantité : 12
-----------------------------
Produit : Huile 5L
Prix : 12000 FC
 62

Quantité : 20
-----------------------------
Produit : Sucre 5kg
Prix : 9000 FC
Quantité : 15
-----------------------------
Valeur totale du stock :
873000 FC