Rapport Académique : Introduction à Python pour l’Intelligence

Artificielle
Auteur : El Azzab Ghizlane Date : 3 Novembre 2025

1. Introduction
Ce rapport présente une analyse approfondie du document de travail intitulé “Introduction
à Python pour l’Intelligence Artificielle”. L’objectif principal de ce document est de
familiariser le lecteur avec les fondations du langage Python et ses bibliothèques
essentielles (NumPy, Pandas, Matplotlib) qui constituent la base du calcul scientifique et de
l’apprentissage automatique. Le rapport détaille les concepts clés abordés dans le notebook,
fournit une explication technique des extraits de code et présente les solutions complètes
aux exercices proposés.
L’approche adoptée vise à fournir une perspective académique et technique, en mettant
l’accent sur la clarté et la précision des concepts, tout en évitant le style souvent généré par
les outils d’intelligence artificielle.

2. Les Fondamentaux de Python

Le notebook commence par une introduction aux bases de Python, un langage de
programmation de haut niveau, à typage dynamique, reconnu pour sa lisibilité et sa
capacité à exprimer des idées complexes avec un minimum de code.

2.1. Types de Données de Base et Structures de Contrôle

Le document explore les types de données fondamentaux :
• Nombres (Integers et Floats) : Les opérations arithmétiques de base sont présentées,
ainsi que les opérateurs d’affectation composés (+=, *=).
• Booléens : Les opérateurs logiques (and, or, not) sont introduits, utilisant des mots-
clés anglais plutôt que des symboles.
• Chaînes de Caractères (Strings) : Les méthodes courantes de manipulation de
chaînes (capitalize(), upper(), rjust(), center(), replace(), strip()) sont
illustrées.
• Listes : Structures de données mutables et ordonnées. Le concept de list
comprehension est mis en évidence comme une méthode concise et efficace pour créer
des listes.
• Dictionnaires : Collections non ordonnées de paires clé-valeur. La méthode get() est
montrée pour accéder aux valeurs avec une valeur par défaut, évitant ainsi les erreurs
KeyError.
• Sets : Collections non ordonnées d’éléments uniques.
• Tuples : Structures de données ordonnées et non modifiables (immutables), souvent
utilisées comme clés dans les dictionnaires.
2.2. Fonctions et Classes
Le notebook couvre la définition de fonctions avec le mot-clé def, y compris l’utilisation
d’arguments optionnels par mot-clé (e.g., loud=False). La programmation orientée objet
est introduite avec la définition de classes, l’utilisation du constructeur __init__ et des
méthodes d’instance.

2.3. Solution de l’Exercice 1 : Recherche de Chaîne

L’exercice demande de vérifier la présence d’une chaîne dans un texte et d’indiquer sa
position.
Code de la solution :
def string_search_exercise(search_string = "Python", text=""):
"""
Vérifie si une chaîne de caractères est présente dans un texte
donné,
et si oui, indique sa position.
"""
if search_string in text:
position = [Link](search_string)
print(f"La chaîne '{search_string}' est présente dans le texte à
la position {position}.")
else:
print(f"La chaîne '{search_string}' n'est pas présente dans le
texte.")

Résultats obtenus :

Chaîne
recherchée Texte Résultat
“Python” “Python est un La chaîne ‘Python’ est présente dans le texte à
longuage…” la position 0.
“Java” “Python est un La chaîne ‘Java’ n’est pas présente dans le
longuage…” texte.

3. NumPy : Le Calcul Numérique

NumPy est la bibliothèque fondamentale pour le calcul scientifique en Python, fournissant
l’objet ndarray (tableau N-dimensionnel) qui permet des opérations vectorielles et
matricielles rapides.

3.1. Les Tableaux (Arrays)

Les tableaux NumPy sont des grilles de valeurs, toutes du même type, et sont la structure de
données centrale. Le code montre la création de tableaux à partir de listes Python et
l’utilisation de fonctions de création spécialisées ([Link], [Link], [Link], [Link],
[Link]).
3.2. Indexation et Découpage
L’indexation permet d’accéder aux éléments. Le découpage (slicing) est une technique
puissante pour extraire des sous-tableaux. Il est crucial de noter que le découpage crée une
vue des données originales, et non une copie. Toute modification du sous-tableau modifie le
tableau d’origine.

3.3. Solution de l’Exercice 2 : Manipulation de tableaux NumPy

L’exercice se concentre sur la manipulation de base des tableaux NumPy.
Code de la solution :
import numpy as np
[Link](42)
array_ex2 = [Link](5, 5)
# ... (autres étapes)
subset_ex2 = array_ex2[:3, :2]
mean_ex2 = array_ex2.mean()
sum_cols_ex2 = array_ex2.sum(axis=0)
array_ex2_modified = array_ex2.copy()
array_ex2_modified[array_ex2_modified < 0.5] = 0

Résultats obtenus :

Opération Résultat
Forme du tableau (5, 5)
Type de données float64
Sous-partie (3x2) [[0.3745, 0.9507], [0.1559, 0.0580],
[0.0205, 0.9699]]
Moyenne totale 0.4408
Somme par colonne [1.3463, 2.4224, 3.2475, 2.2104,
1.7932]
Tableau modifié (éléments < 0.5 Les éléments tels que 0.3745 et 0.1559 sont
mis à 0) remplacés par 0.0.

4. Pandas : Manipulation de Données

Pandas est une bibliothèque essentielle pour l’analyse et la manipulation de données,
introduisant les structures de données Series et DataFrame.

4.1. DataFrames et Statistiques Descriptives

Un DataFrame est une structure de données tabulaire, similaire à une feuille de calcul ou
une table de base de données. Le code montre la création d’un DataFrame à partir d’un
dictionnaire et l’utilisation de méthodes pour l’inspection des données :
• [Link]() / [Link]() : Afficher les premières/dernières lignes.
• [Link] : Afficher les dimensions (lignes, colonnes).
• [Link]() : Fournir des statistiques descriptives (moyenne, écart-type, min,
max, quartiles) pour les colonnes numériques.
• [Link]() : Afficher un résumé du DataFrame, y compris les types de données et le
nombre de valeurs non nulles.

4.2. Manipulation Avancée

Le notebook présente des opérations de manipulation courantes :
• Suppression : [Link]() pour supprimer des lignes (par index) ou des colonnes
(axis=1).
• Ajout : Création de nouvelles colonnes par affectation ou ajout de lignes avec
[Link]().
• Tri : df.sort_values() pour trier selon une ou plusieurs colonnes.
• Indexation : Utilisation de [Link][] pour l’accès basé sur l’étiquette et le filtrage
conditionnel.
• Agrégation : La fonction groupby() est fondamentale pour diviser les données en
groupes basés sur une ou plusieurs clés, appliquer une fonction (e.g., mean(), sum()) à
chaque groupe, et combiner les résultats.

4.3. Solution de l’Exercice 3 : Analyse de Données COVID-19

Cet exercice utilise un jeu de données réel (cas COVID-19 agrégés par pays) pour appliquer
les concepts de Pandas.
Étapes clés de la solution :
1. Chargement et Inspection : Le DataFrame est chargé depuis une URL. L’inspection
initiale révèle une structure de 161568 lignes et 5 colonnes (Date, Country,
Confirmed, Recovered, Deaths).
2. Sélection de Colonnes : df_selected = data_ex3[["Country", "Date",
"Confirmed"]] isole les colonnes pertinentes.
3. Calcul du Total par Pays : L’utilisation de groupby("Country")
["Confirmed"].max() permet d’obtenir le nombre cumulatif maximal (total) de cas
confirmés pour chaque pays.
4. Filtrage Temporel : La colonne Date est convertie en type datetime
(pd.to_datetime()) pour permettre un filtrage efficace par date
(data_ex3['Date'] > '2020-03-01').
5. Moyenne Journalière : groupby("Country")["Confirmed"].mean() calcule la
moyenne des cas confirmés enregistrés par jour pour chaque pays sur l’ensemble de la
période.
Résultats Partiels :

Opération Résultat (Extrait)

Pays avec max. cas US (80625120 cas)
Top 5 Total Confirmés US, India, Brazil, France, Germany
Top 5 Moyenne US (2.81e+07), India (1.79e+07), Brazil (1.22e+07), France
Journalière (5.62e+06), UK (5.36e+06)

4.4. Solution de l’Exercice 4 : Division des Données (Train/Test Split)

L’exercice demande d’implémenter manuellement une fonction de division des données en
ensembles d’entraînement et de test, un prérequis essentiel en apprentissage automatique.
Code de la solution (Implémentation manuelle) :
def split_test(data, ratio):
test_size = int(len(data) * ratio)
[Link](42)
shuffled_indices = [Link](len(data))
test_indices = shuffled_indices[:test_size]
train_indices = shuffled_indices[test_size:]
return data[train_indices], data[test_indices]

Résultats obtenus :
Pour un jeu de données de 100 éléments et un ratio de test de 0.2 (20%) :

Ensemble Taille Premiers éléments (Exemple)

Entraînement 80 [55, 88, 26, 42,
69, ...]
Test 20 [83, 53, 70, 45,
44, ...]

5. Matplotlib : Visualisation de Données

Matplotlib est la bibliothèque de traçage standard pour Python, permettant de créer des
visualisations statiques, animées et interactives. La section se concentre sur le module
[Link].

5.1. Concepts de Base du Traçage

Le code illustre le traçage de fonctions mathématiques (sinus et cosinus) :
import [Link] as plt
# ... (Calcul de x, y_sin, y_cos)
[Link](x, y_sin)
[Link](x, y_cos)
[Link]('x axis label')
[Link]('y axis label')
[Link]('Sine and Cosine')
[Link](['Sine', 'Cosine'])
[Link]()

Explication du code Matplotlib :

• import [Link] as plt : Importe le module pyplot,
conventionnellement abrégé en plt.
• [Link](x, y_sin) : C’est la fonction principale pour tracer des lignes. Elle prend
les coordonnées des points x et y et les relie.
• [Link](), [Link]() : Ajoutent des étiquettes aux axes pour clarifier les
variables représentées.
• [Link]() : Définit le titre général du graphique.
• [Link]() : Affiche une légende pour identifier les différentes séries de données
tracées (ici, ‘Sine’ et ‘Cosine’).
• [Link]() : Affiche la figure. Dans un environnement Jupyter/IPython, la directive
%matplotlib inline (utilisée au début de la section) assure que les graphiques sont
intégrés directement dans le notebook.

5.2. Types de Graphiques Populaires

Le notebook présente ensuite une série de visualisations courantes, en utilisant un jeu de
données sur le lait ([Link]) et en introduisant la bibliothèque Seaborn (import
seaborn as sns), qui est construite sur Matplotlib et fournit une interface de haut niveau
pour des graphiques statistiques plus esthétiques.

Type de
Graphique Code Matplotlib/Seaborn Rôle et Interprétation
Histogramme [Link](data['pH'], bins=20, Représente la distribution de
...) la variable pH. Il montre la
fréquence des valeurs dans
différents intervalles (bins).
Nuage de [Link](data['pH'], Visualise la relation entre deux
Points data['Temprature'], ...) variables (pH et Temprature).
Permet d’identifier des
corrélations ou des clusters.
Boîte à [Link](x='Grade', Montre la distribution du pH
Moustaches y='pH', data=data) pour différentes catégories
(Box Plot) (Grade). Il affiche la médiane,
les quartiles, et les valeurs
aberrantes.
Diagramme en [Link](grade_counts.index, Représente le décompte
Barres (Bar grade_counts.values, ...) (value_counts()) d’une
Chart) variable catégorielle (Grade).
Utile pour comparer les
effectifs des différentes
catégories.
Diagramme en [Link](x='Grade', Combine le box plot avec une
Violon (Violin y='pH', data=data) estimation de la densité de
Plot) probabilité. Il montre la forme
de la distribution du pH par
 Grade.
Heatmap [Link](correlation_matri Visualise une matrice de
x, annot=True, ...) corrélation. Les couleurs
représentent l’intensité de la
corrélation entre les variables
(ici, Temprature et pH).
annot=True affiche les valeurs
numériques.

Ces exemples démontrent la flexibilité de Matplotlib (souvent via Seaborn) pour

l’exploration et la communication des résultats d’analyse de données.

6. Conclusion
Ce document a servi de guide complet à travers les concepts fondamentaux de Python et de
ses bibliothèques scientifiques clés. La maîtrise de ces outils — NumPy pour le calcul
vectoriel efficace, Pandas pour la manipulation de données structurées, et Matplotlib pour
la visualisation — est indispensable pour toute application en Intelligence Artificielle. Les
solutions aux exercices ont validé la compréhension pratique de ces concepts, fournissant
une base solide pour des études plus avancées en apprentissage automatique et en science
des données.