Syllabus de Cours : Programmation Python

1. Description du Cours
Ce cours introduit les concepts fondamentaux de la programmation informatique en utilisant le
langage Python. Réputé pour sa syntaxe claire et sa polyvalence, Python permettra aux
étudiants de développer une logique algorithmique solide, de manipuler des structures de
données complexes, d'automatiser des tâches et de s'initier au développement d'applications et
à l'analyse de données.

Volume horaire indicatif : 30 à 45 heures (Cours magistraux, Travaux Dirigés et Travaux

Pratiques)
Niveau : Débutant / Intermédiaire
Prérequis : Aucun (des notions de base en algorithmique sont un plus)

2. Objectifs Pédagogiques
À la fin de ce cours, l'étudiant sera capable de :

Maîtriser la syntaxe de base de Python et l'environnement de développement.

Concevoir des algorithmes pour résoudre des problèmes complexes et les traduire en code
propre.
Manipuler efficacement les structures de données natives (listes, dictionnaires, tuples).
Structurer un code de manière modulaire en utilisant des fonctions et des modules.
Gérer les fichiers (lecture/écriture) et les exceptions.
Appliquer les principes de base de la Programmation Orientée Objet (POO).

3. Plan Analytique du Cours

Module 1 : Introduction et Environnement de Travail
Présentation de Python (Histoire, philosophie, domaines d'application).
Installation de l'environnement (Python, IDE comme VS Code ou PyCharm, Jupyter
Notebooks).
Premier programme ( "Hello, World!" ) et syntaxe de base.
 Variables, types de données dynamiques (entiers, flottants, chaînes de caractères,
booléens) et opérateurs arithmétiques.

Module 2 : Structures de Contrôle et Logique

Les conditions (Instructions if , elif , else ).
Les opérateurs logiques ( and , or , not ) et de comparaison.
Les boucles répétitives : boucle while et boucle for (utilisation de range() ).
Contrôle des boucles : break , continue et pass .

Module 3 : Structures de Données Séquentielles

Les Listes : création, indexation, découpage (slicing), méthodes principales et
compréhensions de listes.
Les Tuples : immuabilité et cas d'utilisation.
Les Dictionnaires : clés-valeurs, manipulation et parcours.
Les Ensembles (Sets) : propriétés et opérations mathématiques (union, intersection).

Module 4 : Modularité : Fonctions et Modules

Définition et appel d'une fonction ( def ).
Paramètres, arguments par défaut et arguments nommés.
Portée des variables (locales vs globales) et valeur de retour ( return ).
Introduction aux fonctions anonymes ( lambda ).
Importation et utilisation de modules standards ( math , random , os , sys ).

Module 5 : Gestion des Fichiers et des Exceptions

Entrées/Sorties : lecture et écriture dans des fichiers texte ( .txt , .csv ) avec l'instruction
with .
Gestion des erreurs et robustesse du code : blocs try , except , finally .
Lever des exceptions personnalisées ( raise ).

Module 6 : Introduction à la Programmation Orientée Objet (POO)

Le paradigme de l'orienté objet : Classes et Objets.
Attributs d'instance, de classe et constructeur ( __init__ ).
Les méthodes d'instance.
Concepts fondamentaux : Encapsulation (notion de privé/public) et Héritage simple.
Module 7 (Optionnel / Ouverture) : Introduction à l'Écosystème
Scientifique
Présentation rapide des bibliothèques phares :
NumPy : Calcul numérique et matrices.
Matplotlib : Tracé de graphiques et visualisation de données.

4. Stratégie Pédagogique et Évaluation

Approche Méthodologique
Le cours privilégie une approche "Learning by Doing" (Apprentissage par la pratique).
Chaque session théorique est immédiatement suivie de mini-exercices d'application (TP).

Mode d'Évaluation (Exemple standard)

Contrôle Continu (40%) :
Quiz de validation des connaissances à la fin de chaque module.
Travaux Pratiques (TP) notés en laboratoire.
Projet Pratique Fin de Semestre (30%) :
Développement d'une petite application complète en autonomie ou en binôme (ex:
gestionnaire de scolarité, mini-jeu textuel, outil d'analyse de données CSV).
Examen Final (30%) :
Épreuve écrite (algorithmique, lecture et correction de code) ou examen pratique sur
machine.

Programmation Python : Support de Cours Complet

Module 1 : Introduction et Environnement de Travail

1.1 Présentation de Python
Python est un langage de programmation interprété, de haut niveau et multi-paradigme, créé
par Guido van Rossum en 1991. Sa philosophie repose sur des principes de lisibilité, de
simplicité et de productivité, résumés dans le célèbre manifeste The Zen of Python (accessible
en tapant import this dans un interpréteur).

Lisible est préférable à illisible.

Simple est préférable à complexe.
Complexe est préférable à compliqué.

Caractéristiques fondamentales :

Langage interprété : Le code source n'est pas directement compilé en code machine,
mais traduit à la volée par un interpréteur en bytecode, exécuté par la machine virtuelle
Python (PVM). Cela garantit une grande portabilité interplateforme.
Typage dynamique : Le type d'une variable est déterminé automatiquement à l'exécution
en fonction de la valeur qui lui est assignée. Il n'est pas nécessaire de déclarer
explicitement le type lors de la création.
Gestion automatique de la mémoire : Un ramasse-miettes (Garbage Collector) libère
automatiquement l'espace mémoire des objets qui ne sont plus référencés.

Domaines d'application principaux :

Data Science et Machine Learning : Écosystème ultra-dominant (NumPy, Pandas, Scikit-

Learn, TensorFlow).
Développement Web : Frameworks robustes comme Django et FastAPI.
Automatisation et Scripting : Administration système, écriture de scripts de maintenance.
Calcul Scientifique : Simulation physique, ingénierie et traitement numérique.

1.2 Installation de l'environnement

Pour mettre en place un environnement de développement opérationnel, trois étapes sont
nécessaires :

1. L'Interpréteur (CPython) : Télécharger la version officielle sur [Link]. Lors de

l'installation sur Windows, il est impératif de cocher la case "Add Python to PATH" pour
pouvoir appeler l'interpréteur depuis n'importe quel terminal.
2. Le Gestionnaire de Paquets ( pip ) : Installé par défaut, il permet d'installer des
bibliothèques tierces depuis le dépôt officiel PyPI via la commande :

pip install nom_du_paquet

 3. **Les Environnements de Développement (IDE) :**
* **VS Code / PyCharm :** Recommandés pour les projets modulaires et de
grande envergure. Ils intègrent l'autocomplétion, la coloration syntaxique et des
outils de débogage avancés.
* **Jupyter Notebook :** Environnement interactif basé sur le web, idéal pour
l'analyse de données, le prototypage rapide et l'enseignement, associant blocs de
code, texte Markdown et graphiques.

### 1.3 Premier programme et syntaxe de base

Le traditionnel programme d'introduction se résume à une seule ligne en Python :

```python
print("Hello, World!")

Règles syntaxiques strictes :

Sensibilité à la casse : MaVariable , mavariable et MAVARIABLE sont trois identifiants

distincts.
Commentaires : Le caractère # initie un commentaire d'une seule ligne. Les chaînes de
caractères triples ( """ ... """ ) servent de commentaires multi-lignes ou de
documentations (docstrings).
L'Indentation : Contrairement à la majorité des langages qui utilisent des accolades {} ou
des mots-clés end , Python utilise l'indentation visuelle (généralement 4 espaces) pour
délimiter les blocs de code. Une mauvaise indentation déclenche immédiatement une
erreur de type IndentationError .

1.4 Variables, types de données dynamiques et opérateurs

Une variable en Python est une étiquette pointant vers une zone mémoire où est stocké un
objet. L'affectation se fait avec l'opérateur = .

Types de données primitifs :

Type Description Exemple de syntaxe

int Entier de précision arbitraire age = 25

float Nombre à virgule flottante (double précision) pi = 3.14159

str Chaîne de caractères (immutable) nom = "Université"

bool Valeur booléenne est_valide = True

La fonction native type() permet de vérifier à tout moment la nature d'une variable :
 x = 42
print(type(x)) # <class 'int'>

x = "Quarante-deux"
print(type(x)) # <class 'str'> (Le type a changé dynamiquement)

Opérateurs arithmétiques fondamentaux :

Addition : + | Soustraction : - | Multiplication : *

Division décimale : / (ex: 5 / 2 donne 2.5 )
Division entière : // (ex: 5 // 2 donne 2 )
Modulo (reste de la division) : % (ex: 5 % 2 donne 1 )
Exposant (puissance) : ` (ex: 2 3 donne 8`)

Module 2 : Structures de Contrôle et Logique

2.1 Les conditions ( if , elif , else )
Les structures conditionnelles permettent d'orienter le flux d'exécution du programme en
fonction de la vérification d'expressions logiques.

note = 14

if note >= 16:

print("Mention Très Bien")
elif note >= 12:
print("Mention Assez Bien")
elif note >= 10:
print("Passable")
else:
print("Ajourné")

2.2 Opérateurs logiques et de comparaison

Les conditions reposent sur des expressions qui renvoient un booléen ( True ou False ).

Opérateurs de comparaison :

Égalité : == (à ne pas confondre avec l'affectation = )

 Différence : !=
Supériorité et infériorité : > , >= , < , <=

Opérateurs logiques (Algèbre de Boole) :

and : Renvoie True si toutes les conditions sont vraies.

or : Renvoie True si au moins une des conditions est vraie.
not : Inverse l'état logique (négation).

age = 20
permis = True

if age >= 18 and permis:

print("Autorisé à conduire.")

2.3 Les boucles répétitives

Les structures itératives exécutent un bloc de code un certain nombre de fois.

La boucle while (Tant que) :

Utilisée lorsque le nombre d'itérations n'est pas connu à l'avance et dépend d'une condition
dynamique.

compteur = 1
while compteur <= 3:
print("Itération numéro", compteur)
compteur += 1 # Équivalent à compteur = compteur + 1

Attention : Si la condition reste toujours vraie, le programme entre dans une boucle infinie,
provoquant un gel de l'exécution.

La boucle for (Pour chaque) :

Utilisée pour parcourir les éléments d'une séquence (liste, chaîne de caractères) ou une plage
de valeurs générée par range() .

La fonction range(start, stop, step) génère une suite d'entiers allant de start inclus à
stop exclu, avec un pas de step .
 # Parcourt les entiers de 0 à 4
for i in range(5):
print(i)

# Parcourt de 1 à 10 avec un pas de 2

for j in range(1, 11, 2):
print(j) # Affiche : 1, 3, 5, 7, 9

2.4 Contrôle avancé des boucles

break : Interrompt immédiatement et définitivement l'exécution de la boucle en cours.
continue : Saute le reste de l'itération actuelle et passe directement à l'évaluation de
l'itération suivante.
pass : Instruction vide utilisée comme espace réservé syntaxique lorsqu'un bloc de code
est requis mais qu'aucune action n'est nécessaire.

for n in range(1, 10):

if n == 5:
break # Arrête la boucle quand n vaut 5
if n % 2 == 0:
continue # Saute les nombres pairs
print(n) # N'affichera que 1 et 3

Module 3 : Structures de Données Séquentielles

3.1 Les Listes
Une liste est une collection ordonnée et mutable (modifiable) d'éléments, pouvant être de
types différents. Elle se définit par des crochets [] .

modules = ["Électronique", "Informatique", "Maths"]

Indexation et Slicing (Découpage) :

Les indices commencent à 0 pour le premier élément. Les indices négatifs permettent
d'accéder aux éléments en partant de la fin (-1 pour le dernier).
 print(modules[0]) # "Électronique"
print(modules[-1]) # "Maths"

Le slicing extrait une sous-liste via la syntaxe liste[début:fin:pas] (la borne de fin est
exclue).

numeros = [10, 20, 30, 40, 50]

print(numeros[1:4]) # [20, 30, 40]
print(numeros[::-1]) # [50, 40, 30, 20, 10] (Renverse la liste)

Méthodes clés des listes :

append(x) : Ajoute l'élément x à la fin.

insert(i, x) : Insère x à l'index i .
remove(x) : Supprime la première occurrence de l'élément x .
pop(i) : Supprime et renvoie l'élément situé à l'index i .

Compréhension de listes :

Une syntaxe concise pour créer de nouvelles listes à partir de séquences existantes.

# Approche classique
carres = []
for x in range(5):
[Link](x**2)

# Par compréhension
carres_rapides = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]

3.2 Les Tuples

Un tuple est une collection ordonnée mais immutable (non modifiable après création). Il se
définit par des parenthèses () .

coordonnees = (4.5, -2.8)

Cas d'utilisation : Garantir l'intégrité des données (constantes, configurations) et optimiser

les performances (les tuples sont plus légers en mémoire que les listes).
Ils permettent le dépaquetage (unpacking) de valeurs :

x, y = coordonnees

3.3 Les Dictionnaires

Un dictionnaire est une collection non ordonnée associant une clé unique à une valeur. C'est
une structure de type table de hachage, définie par des accolades {} et des paires cle:
valeur .

etudiant = {
"nom": "Rakoto",
"filiere": "Maintenance",
"moyenne": 14.5
}

# Accès sécurisé à une valeur via sa clé

print(etudiant["nom"])
# Utilisation de get() pour éviter une erreur si la clé n'existe pas
print([Link]("age", "Non spécifié"))

Manipulation et parcours :

# Ajout ou modification
etudiant["annee"] = 2026

# Parcours des clés et valeurs simultanément

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

3.4 Les Ensembles (Sets)

Un ensemble est une collection non ordonnée d'éléments uniques. Il élimine automatiquement
les doublons et se définit par des accolades {} sans paire clé-valeur.

group_a = {"A", "B", "C", "A"}

print(group_a) # {'A', 'B', 'C'} (Le doublon a disparu)
Opérations mathématiques ensemblistes :

group_b = {"C", "D", "E"}

print(group_a.union(group_b)) # {'A', 'B', 'C', 'D', 'E'}

print(group_a.intersection(group_b)) # {'C'}
print(group_a.difference(group_b)) # {'A', 'B'}

3.5 Synthèse comparative des structures de données

Structure Syntaxe Ordonnée Mutable Unicité des éléments

Liste [a, b, c] Oui Oui Non
Tuple (a, b, c) Oui No Non
Dictionnaire {"k": v} Non Oui Clés uniques / Valeurs non uniques
Ensemble (Set) {a, b, c} Non Oui Oui (Pas de doublons)

Module 4 : Modularité : Fonctions et Modules

4.1 Définition et appel d'une fonction
Une fonction est un bloc de code nommé, réutilisable et autonome, conçu pour effectuer une
tâche spécifique. Elle est introduite par le mot-clé def .

def calculer_puissance(tension, courant):

"""Calcule la puissance électrique en Watts P = UI."""
puissance = tension * courant
return puissance

# Appel de la fonction
p_resultat = calculer_puissance(220, 10)
print(f"Puissance : {p_resultat} W")

4.2 Paramètres avancés

Arguments positionnels : Affectés dans l'ordre de leur définition lors de l'appel.
Arguments nommés : Spécifiés explicitement par leur nom, s'affranchissant de l'ordre.
 Valeurs par défaut : Paramètres pré-remplis si aucune valeur n'est fournie.

def saluer(nom, message="Bonjour"):

print(f"{message}, {nom}!")

saluer("Rindra") # Utilise la valeur par défaut : "Bonjour,

Rindra!"
saluer(message="Bienvenue", nom="Rindra") # Arguments nommés

4.3 Portée des variables (Règle LEGB)

La portée détermine la visibilité d'une variable au sein du code selon la hiérarchie LEGB :

1. L (Local) : Variables définies à l'intérieur d'une fonction.

2. E (Enclosing) : Variables dans les fonctions imbriquées.
3. G (Global) : Variables définies au niveau principal du script.
4. B (Built-in) : Noms natifs de Python ( print , len ).

variable_globale = 100 # Accessible partout

ma_fonction():
variable_locale = 50 # Accessible uniquement dans la fonction
print(variable_locale)

ma_fonction()
# print(variable_locale) -> Déclencherait une NameError

Règle de bonne pratique : Éviter de modifier une variable globale à l'intérieur d'une
fonction (effet de bord), préférer l'utilisation du mot-clé return .

4.4 Fonctions anonymes ( lambda )

Les fonctions lambda sont des fonctions limitées à une seule expression, déclarées en une
ligne sans le mot-clé def .

double = lambda x: x * 2
print(double(5)) # 10

4.5 Utilisation des modules standards

Un module est un fichier contenant du code Python prêt à être réutilisé. On l'incorpore à l'aide
du mot-clé import .

import math
import random

print([Link](16)) # Racine carrée : 4.0

print([Link](1, 10)) # Génère un entier aléatoire entre 1 et 10

On peut importer une fonction spécifique pour alléger la syntaxe :

from os import path

Module 5 : Gestion des Fichiers et des Exceptions

5.1 Entrées/Sorties : Manipulation des fichiers
L'interaction avec le système de fichiers nécessite l'ouverture d'un canal de flux. L'utilisation de
l'instruction with (gestionnaire de contexte) est fortement recommandée, car elle garantit la
fermeture automatique du fichier, même si une erreur survient en cours de lecture ou d'écriture.

Modes d'ouverture principaux :

'r' : Lecture seule (mode par défaut).

'w' : Écriture (écrase le contenu existant ou crée le fichier).
'a' : Ajout en fin de fichier (append).

Écriture dans un fichier :

lines = ["Ligne 1\n", "Ligne 2\n"]

with open("[Link]", "w", encoding="utf-8") as fichier:
[Link]("Début du fichier\n")
[Link](lines)

Lecture d'un fichier :

 with open("[Link]", "r", encoding="utf-8") as fichier:
contenu = [Link]() # Lit tout le fichier d'un coup
print(contenu)

5.2 Gestion des exceptions ( try , except , finally )

Les exceptions sont des erreurs survenant durant l'exécution du programme, capables
d'interrompre brutalement son déroulement si elles ne sont pas capturées.

Pour fiabiliser un code, on encapsule les zones à risques dans une structure de contrôle
dédiée.

try:
numerateur = 10
denominateur = int(input("Entrez un diviseur : "))
resultat = numerateur / denominateur
except ZeroDivisionError:
print("Erreur : Impossible de diviser par zéro.")
except ValueError:
print("Erreur : Vous devez entrer un nombre entier valide.")
else:
print(f"Opération réussie. Résultat = {resultat}")
finally:
print("Cette phrase s'exécutera quoi qu'il arrive.")

try : Bloc contenant le code susceptible de lever une exception.

except : Intercepte et traite une erreur ciblée pour éviter le plantage.
else : S'exécute uniquement si aucune exception n'a été levée dans le bloc try .
finally : S'exécute systématiquement (idéal pour libérer des ressources comme fermer
une base de données).

5.3 Lever une exception ( raise )

Le développeur peut volontairement déclencher une exception logicielle lorsque les conditions
de cohérence métier ne sont pas respectées.

def verifier_age(age):
if age < 0:
raise ValueError("L'âge ne peut pas être négatif !")
 return True

Module 6 : Introduction à la Programmation Orientée Objet

(POO)
6.1 Le paradigme de l'orienté objet
La POO consiste à modéliser des entités du monde réel ou abstrait sous forme d'Objets. Un
objet regroupe des structures de données (appelées Attributs) et les comportements associés
(appelés Méthodes). Une Classe est le plan de fabrication (le moule), tandis qu'un Objet est
une instance concrète issue de cette classe.

6.2 Syntaxe, Constructeur et Attributs

La définition d'une classe s'effectue avec le mot-clé class . La méthode spéciale __init__ est
le constructeur de la classe : elle s'exécute automatiquement lors de la création d'un nouvel
objet pour initialiser ses attributs. Le paramètre self représente l'instance de l'objet en cours
de manipulation.

class Etudiant:
# Attribut de classe (partagé par toutes les instances)
etablissement = "IST"

# Constructeur d'instance
def __init__(self, nom, note_examen):
[Link] = nom # Attribut d'instance
[Link] = note_examen # Attribut d'instance

# Méthode d'instance
def evaluer(self):
if [Link] >= 10:
return f"{[Link]} est admis."
else:
return f"{[Link]} doit passer le rattrapage."

# Instanciation (Création des objets)

etudiant1 = Etudiant("Alice", 14)
etudiant2 = Etudiant("Bob", 8)

# Accès aux attributs et appel des méthodes

print([Link]) # "Alice"
 print([Link]()) # "Alice est admis."
print([Link]()) # "Bob doit passer le rattrapage."

6.3 Encapsulation
L'encapsulation consiste à masquer l'accès direct aux données internes d'un objet afin de
protéger son état des modifications extérieures involontaires ou incohérentes.

En Python, la visibilité est régie par une convention de nommage reposant sur les underscores
_ :

nom : Public (accessible depuis l'extérieur).

_nom : Protégé (usage interne suggéré, à ne pas modifier hors de la classe ou de ses
enfants).
__nom : Privé (inaccessible directement à l'extérieur grâce au mécanisme de Name
Mangling).

class CompteBancaire:
def __init__(self, titulaire, solde_initial):
[Link] = titulaire
self.__solde = solde_initial # Attribut Privé

# Getter : Méthode permettant de lire la donnée privée en sécurité

def consulter_solde(self):
return self.__solde

# Setter : Méthode permettant de modifier la donnée sous contrôle

def deposer(self, montant):
if montant > 0:
self.__solde += montant
else:
print("Montant invalide")

compte = CompteBancaire("Jean", 1000)

# print(compte.__solde) -> Déclenche une AttributeError
[Link](500)
print(compte.consulter_solde()) # 1500

6.4 L'Héritage
L'héritage permet de créer une nouvelle classe (classe fille ou sous-classe) à partir d'une
classe existante (classe mère ou super-classe). La classe fille hérite de tous les attributs et
méthodes de sa mère, tout en pouvant ajouter ses propres spécificités ou modifier des
comportements (surcharge).

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

def se_presenter(self):
print(f"Je m'appelle {[Link]}.")

# Enseignant hérite de Personne

class Enseignant(Personne):
def __init__(self, nom, matiere):
super().__init__(nom) # Appelle le constructeur de la classe mère Personne
[Link] = matiere

# Surcharge de la méthode de la classe mère

def se_presenter(self):
print(f"Je m'appelle {[Link]} et j'enseigne la matière :
{[Link]}.")

# Test des classes

p = Personne("Marc")
e = Enseignant("Prof. Dupont", "Automatique")

p.se_presenter() # "Je m'appelle Marc."

e.se_presenter() # "Je m'appelle Prof. Dupont et j'enseigne la matière :
Automatique."

Module 7 : Introduction à l'Écosystème Scientifique

(Ouverture)
7.1 NumPy : Calcul numérique vectoriel
La bibliothèque standard de Python traite les listes de manière générique. Pour les calculs
mathématiques lourds, les listes affichent des limites en rapidité. NumPy introduit l'objet
ndarray (tableau multidimensionnel), qui impose un type unique pour ses données, permettant
un stockage en mémoire contigu et un traitement vectoriel optimisé en C.

import numpy as np
 # Création d'un tableau NumPy à 1 dimension (vecteur)
vecteur = [Link]([1, 2, 3, 4, 5])

# Opération vectorielle directe (sans boucle for)

resultat = vecteur * 2
print(resultat) # [ 2 4 6 8 10]

# Création d'une matrice 2x3 remplie de zéros

matrice_zeros = [Link]((2, 3))
print(matrice_zeros)

7.2 Matplotlib : Visualisation de données

Matplotlib (et plus particulièrement son sous-module pyplot ) est l'outil de référence pour
générer des représentations graphiques de données bidimensionnelles (courbes,
histogrammes, nuages de points).

L'exemple ci-dessous modélise et trace une fonction sinusoïdale simple (génération de

données via NumPy et mise en forme graphique).

import [Link] as plt

import numpy as np

# Génère 100 points linéairement espacés entre 0 et 2*pi

x = [Link](0, 2 * [Link], 100)
y = [Link](x)

# Construction de la figure graphique

[Link](figsize=(8, 4))
[Link](x, y, label="sin(x)", color="blue", linewidth=2)

# Configuration des axes et titres

[Link]("Évolution d'un Signal Sinusoïdal")
[Link]("Temps / Angle (rad)")
[Link]("Amplitude")
[Link](True) # Ajout d'un quadrillage de lecture
[Link]() # Affichage de la légende

# Affichage du rendu final à l'écran

[Link]()
Travaux Pratiques Récapitulatifs (Évaluation standard)
TP 1 : Algorithmique Fondamentale (Niveau Débutant)
Objectif : Concevoir un script interactif demandant à l'utilisateur de deviner un nombre secret
choisi aléatoirement par la machine entre 1 et 100. Le programme doit guider l'utilisateur en
affichant "Plus grand" ou "Plus petit" jusqu'à la découverte de la bonne réponse, puis afficher le
nombre total d'essais consommés.

TP 2 : Traitement de Données et Fichiers (Niveau Intermédiaire)

Objectif : Écrire un module lisant un fichier texte brut nommé notes_etudiants.csv structuré
sous la forme : Nom,Note_A,Note_B .
Le script doit intercepter l'absence éventuelle du fichier source (gestion de l'exception
FileNotFoundError ), calculer la moyenne arithmétique globale de chaque étudiant, et
enregistrer les résultats formatés au sein d'un nouveau fichier propre nommé
resultats_finaux.txt .

Dataview (inline field '='): Error:

-- PARSING FAILED --------------------------------------------------

> 1 | =
| ^

Expected one of the following:

'(', 'null', boolean, date, duration, file link, list ('[1, 2, 3]'),
negated field, number, object ('{ a: 1, b: 2 }'), string, variable