Notes de cours détaillées pour « Python pour les

méthodes numériques »
Ces notes sont destinées aux étudiants. Elles contiennent : - Des explications détaillées des concepts
vus en cours - Des exemples de code commentés - Des conseils pratiques

Le module est organisé en deux sessions (Session 1 et Session 2). Chaque session comporte : - 1 heure
de cours magistral (notes ci-dessous) - 1 heure de laboratoire (notebooks fournis séparément)

Session 1 – Cours détaillé (1 h)

1. Introduction et motivations

Pourquoi choisir Python pour les méthodes numériques ?

• Lisibilité et syntaxe claire : Python utilise une syntaxe indentée, proche du pseudocode, ce qui
facilite la compréhension des algorithmes.
• Écosystème scientifique riche : bibliothèques optimisées comme NumPy (calcul vectorisé),
Matplotlib (visualisation), SciPy (algorithmes numériques avancés), pandas, etc.
• Large communauté et documentation : abondance de tutoriels, forums, exemples. Les
étudiants peuvent trouver rapidement de l’aide.
• Portabilité et interopérabilité : Python s’exécute sur différents systèmes (Windows, macOS,
Linux). Il peut interfacer du code en C/C++ ou Fortran pour accélérer certaines parties.

Organisation du module - Deux sessions de 2 heures chacune (1 h de cours + 1 h de labo). - Travail

préparatoire avant chaque session : lecture courte ou installation des outils. - Exercices pratiques en
laboratoire pour ancrer les concepts. - Travaux autonomes après les sessions pour approfondissement.

Pré-requis - Connaissances de base en programmation (variables, boucles, conditions). Si besoin, revoir

un tutoriel Python introductif. - Avoir Python installé (recommandation : Anaconda ou installation
standard + virtualenv). - IDE ou environnement interactif : Jupyter Notebook/Lab, VS Code ou autre.

2. Vérification de l’environnement et rappel rapide

Installation et configuration - Python : version 3.7+ recommandée. Vérifier avec

python --version ou python3 --version . - Environnements virtuels : pour isoler les
dépendances. Exemple :

python3 -m venv env

source env/bin/activate # Linux/macOS
.\env\Scripts\activate # Windows
pip install --upgrade pip

1
- Anaconda : distribue Python avec NumPy, Matplotlib, Jupyter. Vous pouvez créer un environnement
conda :

conda create -n num_methods python=3.9

conda activate num_methods
conda install numpy matplotlib jupyter

- Vérifier l’installation des bibliothèques en ouvrant Python ou Jupyter :

import numpy as np
import matplotlib.pyplot as plt
print(np.__version__, plt.__version__)

IDE / éditeur - Jupyter Notebook/Lab : idéal pour démonstrations interactives, exécution cellule par
cellule, tracés intégrés. - VS Code : support Jupyter, scripts Python, débogage. - Autres : PyCharm,
Spyder, etc.

Rappel ultra-rapide de Python de base (à compléter par la pré-lecture) - Variables et types :

a = 3 # int
b = 2.5 # float
s = "texte" # str
flag = True # bool

- Collections : listes ( [1,2,3] ), tuples ( (1,2) ), dictionnaires ( {'clé': valeur} ), ensembles

( set([1,2,3]) ). - Contrôle de flux :

if a > 0:
print("Positif")
for i in range(5):
print(i)
while condition:
...

- Fonctions de base :

def ma_fonction(x):
return x**2

- Import : import module , from module import fonction . - Types immuables vs mutables (liste
modifiable, tuple immuable). Attention aux effets de bord.

Note aux étudiants : Si vous n’êtes pas à l’aise avec ces notions, consultez le support
fourni ou un tutoriel rapide. Le cours suppose ces bases pour se concentrer sur l’aspect
numérique.

2
3. Introduction à NumPy : calcul vectorisé

3.1 Qu’est-ce que NumPy ?

• NumPy est la bibliothèque fondamentale pour le calcul numérique en Python.

• Elle fournit l’objet ndarray (tableau multidimensionnel) implémenté en C pour des opérations
rapides.
• Les opérations sur ndarray sont vectorisées : écrites en style déclaratif plutôt qu’itératif, ce qui
réduit le temps d’écriture et améliore la performance.

3.2 Création de tableaux

• À partir de listes Python :

import numpy as np
arr = np.array([1, 2, 3], dtype=float)

• Génération de séquences :
• np.arange(start, stop, step) : intervalle demi-ouvert [start, stop).
• np.linspace(start, stop, num) : num points uniformément répartis entre start et stop
inclus.
• Tableaux préremplis :
• np.zeros((m, n)) , np.ones((m, n)) , np.eye(n) pour matrice identité.
• np.empty((m,n)) crée un tableau non initialisé (utile quand on va remplir explicitement).

3.3 Propriétés et méthodes des arrays

• Attributs :
• arr.shape : tuple décrivant les dimensions, ex. (100,) pour vecteur, (m,n) pour matrice.
• arr.ndim : nombre de dimensions.
• arr.size : nombre total d’éléments.
• arr.dtype : type de données (float64, int32, etc.).
• Reshape :

b = arr.reshape((n, m)) # si arr.size == n*m

• Copie vs vue :
• Slicing renvoie généralement une vue (view) qui partage la mémoire : modifier la vue modifie
l’original.
• Pour forcer une copie : arr.copy() .

3.4 Indexation et slicing

• Indexation simple :

arr[0], arr[-1]

• Slicing :

3
 arr[1:5], arr[:], arr[::2]

• Indexation multi-dimensionnelle :

M = np.array([[1,2,3],[4,5,6]]) # shape (2,3)

M[0,1] # élément ligne 0, colonne 1
M[:,2] # troisième colonne

• Boolean indexing :

mask = arr > 0.5

arr_pos = arr[mask]

• Fancy indexing :

indices = [0, 2, 4]
arr_sub = arr[indices]

3.5 Opérations vectorisées et fonctions universelles (ufunc)

• Opérations élémentaires :

a + b, a * 2, a / b

• Fonctions universelles : disponibles dans np , ex. np.sin(arr) , np.exp(arr) ,

np.sqrt(arr) . Elles s’appliquent élément par élément.
• Avantages :
• Code plus compact, évite boucles explicites.
• Implémentation optimisée en C pour la plupart des opérations lourdes.

3.6 Exemples pratiques

• Calcul vectorisé d’une fonction f(x) = sin(x) * exp(-x/5)

import numpy as np
x = np.linspace(0, 10, 100)
f = np.sin(x) * np.exp(-x/5)

• Comparaison performancielle : mesurer temps pour grande taille (1e6) avec vectorisation vs
boucle Python (montrer la différence significative).

3.7 Algèbre linéaire de base

• Produit scalaire et produit matriciel :

4
 u = np.array([1,2,3])
v = np.array([4,5,6])
dot = np.dot(u, v) # ou u @ v

• Matrices :

A = np.array([[3,1,2],[1,4,0],[2,0,5]], dtype=float)
b = np.array([5,6,7], dtype=float)
x = np.linalg.solve(A, b)

• Conditionnement :

condA = np.linalg.cond(A)

• Expliquer brièvement que conditionnement élevé (>>1) signifie qu’une petite erreur en b peut
engendrer une grande variation en x.
• Broadcasting : mentionner concept (phénomène où arrays de formes différentes sont
automatiquement adaptés pour opérations). Exemple simple : addition d’un vecteur à chaque
ligne d’une matrice.

3.8 Conseils pratiques NumPy

• Choisir le bon dtype : par défaut float64 ; pour économies mémoire, on peut utiliser float32 si la
précision le permet.
• Eviter les boucles Python sur des tableaux : préférer les opérations vectorisées.
• Attention aux copies involontaires : comprendre quand les vues sont renvoyées.
• Profiling simple : %timeit en Jupyter pour mesurer.
• Documentation : encourager à consulter la doc officielle https://numpy.org/doc/ .

4. Introduction à Matplotlib : visualisation de données numériques

4.1 Présentation et import

• Importer :

import matplotlib.pyplot as plt

• Cas d’usage : tracer des courbes, histogrammes, scatter plots, etc., pour analyser visuellement
les résultats numériques.

4.2 Tracé de base

• Courbe simple :

plt.plot(x, f, label='f(x)')
plt.title('Titre du graphe')
plt.xlabel('x')
plt.ylabel('f(x)')

5
 plt.legend()
plt.show()

• Histogramme :

data = np.random.normal(size=1000)
plt.hist(data, bins=30)
plt.title("Histogramme")
plt.show()

• Scatter :

plt.scatter(x, y)

• Sous-graphes (subplots) : si utile, montrer plt.figure() , plt.subplot(1,2,1) , etc.

• Pour cette session, restez simple : au maximum deux tracés par figure.

4.3 Personnalisation minimum

• Titres, labels, légende.

• Limites d’axes : plt.xlim(min, max) , plt.ylim(min, max) .
• Styles de ligne et marqueurs : on peut mentionner mais utiliser les valeurs par défaut sauf
besoin précis.
• Sauvegarde :

plt.savefig('nom_figure.png', dpi=150)

• Interactivité en Jupyter : %matplotlib inline ou %matplotlib notebook .

4.4 Exemples d’application

• Tracer la fonction f(x) calculée précédemment.

• Visualiser la convergence : si l’on avait un algorithme itératif (préparer pour la suite). Ex. tracer
l’erreur en fonction du nombre d’itérations.
• Histogramme pour Monte-Carlo (Session 2 mais on peut teaser) : distribution des estimations.

4.5 Conseils

• Toujours vérifier que les graphiques sont lisibles (axes bien nommés, légende claire).
• Sauvegarder les figures pour rapport ou présentation.
• Utiliser Jupyter pour ajuster rapidement.
• Documenter le code de tracé pour faciliter modifications ultérieures.

5. Conclusion du cours et préparation du laboratoire

5.1 Récapitulatif des points clés de la session 1

• Installation et vérification de l’environnement.

• Rappel de Python de base (pré-lecture).

6
 • Concepts fondamentaux de NumPy : création d’array, indexation, vectorisation, algèbre linéaire
de base.
• Concepts fondamentaux de Matplotlib : tracés simples, personnalisation minimale.

5.2 Instructions pour le laboratoire

• Ouvrir le notebook de Session 1 (fichier Jupyter fourni).

• Exécuter les cellules et réaliser les exercices : calcul vectorisé, résolution de système linéaire,
tracés.
• Explorer les variations : tailles de tableaux, modifications de la fonction, tests de performance.

5.3 Préparation pour la Session 2

• Lire un tutoriel court sur : définition de fonctions en Python, modules, argparse , notions de
portée (LEGB).
• S’assurer de comprendre comment créer et importer un module Python local ( .py ).
• Installer éventuellement des outils pour tests (pytest) et se familiariser brièvement.

Session 2 – Cours détaillé (1 h)

1. Introduction et rappel des acquis

• Retour sur Session 1 : concepts clés NumPy/Matplotlib, importance de la vectorisation et

visualisation.
• Objectifs de la Session 2 :
• Apprendre à structurer le code Python via fonctions et modules.
• Utiliser les modules mathématiques standards pour des tâches numériques courantes.
• Comprendre la portée des variables (scoping) pour éviter bugs.
• Savoir écrire et exécuter des scripts Python robustes (CLI, logging, tests).

2. Fonctions et modularisation

2.1 Définir des fonctions en Python

• Syntaxe :

def nom_fonction(param1, param2=valeur_defaut, *args, **kwargs):

"""Docstring décrivant l’objectif, les paramètres et la valeur de
retour."""
# Corps de la fonction
result = ...
return result

• Paramètres :
• Positionnels obligatoires.
• Arguments par mot-clé avec valeur par défaut.
• *args capte arguments positionnels supplémentaires dans un tuple.
• **kwargs capte arguments nommés supplémentaires dans un dictionnaire.
• Docstrings :

7
 • Importance de décrire clairement le rôle de la fonction, types attendus, exceptions
éventuellement levées.
• Styles recommandés (Google, NumPy style). Exemple :

def eval_poly(coeffs, x):

"""
Évalue un polynôme aux coefficients donnés en x.

Args:
coeffs (list of float): coefficients [a0, a1, ..., an]
correspondant à a0 + a1*x + ... + an*x^n.
x (float or array_like): valeur(s) de la variable.

Returns:
float or ndarray: valeur(s) du polynôme en x.
"""
...

• Bonnes pratiques :
• Fonctions courtes et cohésives (une seule responsabilité).
• Nom clair, explicite.
• Vérifier les entrées si nécessaire (par ex. s’assurer que coeffs est itérable). Sinon documenter
clairement les préconditions.

2.2 Modularisation (modules et packages)

• Module : fichier .py contenant fonctions, classes, constantes.

• Exemple : créer utils_num.py avec eval_poly , fonctions auxiliaires.
• Importer un module local :
• Dans le même dossier, import utils_num ou from utils_num import eval_poly .
• S’assurer que le dossier courant est dans le PYTHONPATH (en général, exécution dans le même
répertoire). Sinon, configurer correctement.
• Packages : dossier contenant un fichier __init__.py . Permet organiser plusieurs modules
sous un même namespace.
• Organisation recommandée pour un petit projet :

projet_numerique/
├── src/
│ ├── utils_num.py
│ └── integrale_trap.py
├── tests/
│ └── test_utils.py
├── notebooks/
│ └── laboratoire1.ipynb
├── requirements.txt
└── README.md

• Gestion des dépendances :

8
 • requirements.txt listant les paquets ( numpy , matplotlib , etc.) pour recréer
l’environnement via pip install -r requirements.txt .
• Si conda : environnement environment.yml .

2.3 Exemple pratique en direct

• Fonction eval_poly :
• Implémentation par la méthode de Horner pour efficacité et simplicité :

def eval_poly(coeffs, x):

"""Évalue un polynôme via Horner."""
result = 0
for a in reversed(coeffs):
result = result * x + a
return result

• Tester sur valeur scalaire : eval_poly([1, -3, 2], 5) donne 1 - 3*5 + 2*5^2 = 1 -
15 + 50 = 36 .
• Tester sur tableau NumPy : eval_poly([1, -3, 2], np.array([0,1,2])) renvoie
tableau.
• Organisation en module : créer utils_num.py , y placer eval_poly . Importer dans
notebook ou script.
• Gestion d’erreurs : vérifier si coeffs est vide (polynôme nul), ou si x type incorrect :
documenter ou lever exception.

3. Modules mathématiques standards

3.1 Module math vs NumPy

• math : fonctions pour scalaires (float). Exemples : math.sin , math.cos , math.exp ,

math.log , constantes math.pi , math.e . Utile dans des boucles sur des scalaires ou scripts
légers.
• NumPy : np.sin , etc., s’appliquent sur arrays. Plus performant pour traitements vectoriels.
• Conseil : pour calcul uniforme sur tableaux, préférer NumPy.

3.2 Module random et numpy.random

• random : génère des nombres aléatoires scalaires (uniforme random.random() , entier

random.randint() , etc.).
• numpy.random : génère vecteurs/matrices de nombres aléatoires de façon vectorisée (ex.
np.random.rand(1000) ), distributions variées ( normal , uniform , etc.).
• Exemple Monte-Carlo : estimation de π.

import random
def estimate_pi(n):
count = 0
for _ in range(n):
x, y = random.random(), random.random()
if x*x + y*y <= 1:

9
 count += 1
return 4 * count / n

• Avec NumPy :

import numpy as np
def estimate_pi_np(n):
pts = np.random.rand(n, 2)
dist2 = pts[:,0]**2 + pts[:,1]**2
return 4 * np.count_nonzero(dist2 <= 1) / n

• Calculer moyenne/écart-type : module statistics pour scalaires ou listes ; np.mean ,

np.std pour arrays.

import statistics
results = [estimate_pi(100000) for _ in range(10)]
m = statistics.mean(results)
s = statistics.pstdev(results)

3.3 Précision numérique : decimal et fractions

• decimal : arithmétique décimale à précision réglable, utile pour éviter erreurs d’arrondi dans
certains calculs financiers ou très sensibles.

from decimal import Decimal, getcontext

getcontext().prec = 50
a = Decimal('1') / Decimal('7')

• fractions : rationnels exacts (numérateur/denominateur entiers). Utile pour démonstrations

ou calculs exacts, mais moins performant.
• Cas d’usage : généralement, pour méthodes numériques, on reste en float ou double ;
mentionner brièvement pour sensibiliser.

3.4 Module statistics

• Moyenne ( statistics.mean ), médiane ( statistics.median ), variance

( statistics.pvariance ou statistics.pstdev ).
• Comparer avec NumPy ( np.mean , etc.) en termes de performance et d’usage (arrays vs listes).

3.5 Exemples pratiques

• Estimation de π : implémentation avec random puis avec numpy.random , comparaison de

performances.
• Sommation précise : exemple où on compare somme d’une série de petits termes en float vs
decimal pour illustrer l’erreur d’arrondi.
• Statistiques descriptives : calcul de moyenne et écart-type sur échantillon, présentation des
résultats.

10
4. Portée des variables (scoping) et gestion de l’état

4.1 Règle LEGB

• Local : variables définies dans la fonction.

• Enclosing (portée englobante) : dans une fonction imbriquée, variables de la fonction externe.
• Global : variables au niveau du module.
• Built-in : noms prédéfinis Python (ex. len , sum ).
• Exemple :

x = 10 # global
def f():
x = 5 # local à f
print(x) # affiche 5
f()
print(x) # affiche 10

4.2 global et nonlocal

• global : permet à une fonction de modifier une variable globale. À éviter autant que possible
pour maintenir la clarté et éviter effets de bord imprévus.
• nonlocal : dans une fonction imbriquée, permet modifier la variable de la fonction englobante.

def outer():
count = 0
def inner():
nonlocal count
count += 1
return count
return inner
f = outer()
print(f()) # 1
print(f()) # 2

• Bonnes pratiques : préférer passer les valeurs en paramètres et retourner de nouveaux

résultats plutôt que modifier des variables externes.

4.3 Mutabilité et immutabilité

• Types immuables : int, float, str, tuple. Passer à une fonction ne modifie pas l’objet original.
• Types mutables : list, dict, set, array NumPy. Attention : si on modifie l’objet à l’intérieur de la
fonction, effet visible à l’extérieur.

def modif_list(lst):
lst.append(5)
L = [1,2,3]
modif_list(L)
print(L) # [1,2,3,5]

11
 • Conseil : si on veut éviter effet de bord, copier la liste à l’intérieur ou clairement documenter que
la fonction modifie l’argument.

4.4 Closures et fonctions imbriquées

• Use case : générer une famille de fonctions paramétrées.

def make_power(n):
def power(x):
return x ** n
return power
square = make_power(2)
cube = make_power(3)
print(square(4), cube(2)) # 16, 8

• Comprendre comment les variables englobantes sont capturées.

4.5 Conseils pour éviter les bugs de portée

• Éviter l’usage excessif de variables globales.

• Préférer passer en paramètres et retourner des résultats.
• Donner des noms explicites pour éviter masquage involontaire.
• Lors de débogage, imprimer les valeurs ou utiliser un debugger pour voir où la variable est
modifiée.

5. Écriture et exécution de programmes Python pour tâches numériques

5.1 Structure d’un script Python

• Bloc principal :

def main():
# code principal
pass

if __name__ == "__main__":
main()

• Permet d’éviter l’exécution de code lors d’un import du module.

5.2 Arguments en ligne de commande avec argparse

• But : rendre le script flexible, paramétrable sans modifier le code.

• Exemple : script d’intégration trapèze.

import argparse
import numpy as np

def f(x):
"""Fonction à intégrer"""

12
 return np.sin(x) # exemple; on peut étendre pour choix dynamique

def trapezoid(a, b, N):

x = np.linspace(a, b, N+1)
y = f(x)
h = (b - a) / N
return h * (0.5*y[0] + y[1:-1].sum() + 0.5*y[-1])

def main():
parser = argparse.ArgumentParser(description="Intégration numérique
par la méthode du trapèze")
parser.add_argument("--a", type=float, required=True, help="borne
inférieure a")
parser.add_argument("--b", type=float, required=True, help="borne
supérieure b")
parser.add_argument("--N", type=int, default=100, help="nombre de
sous-intervalles")
args = parser.parse_args()
result = trapezoid(args.a, args.b, args.N)
print(f"Intégrale approximative de {args.a} à {args.b} avec
N={args.N} : {result}")

if __name__ == '__main__':
main()

• Exécution : dans un terminal :

python integrale_trap.py --a 0 --b 3.1416 --N 1000

• Extensions : choix de la fonction par argument (ex. --function sin ), validations

d’arguments (vérifier b > a , N > 0 ), gestion d’erreurs.

5.3 Logging et débogage

• Logging : module logging pour messages structurés : niveaux DEBUG, INFO, WARNING,
ERROR.

import logging
logging.basicConfig(level=logging.INFO)
logging.info("Début de l’intégration")

• Debugging :
• print pour vérifications rapides.
• Debugger intégré de l’IDE ou module pdb : import pdb; pdb.set_trace() .

5.4 Tests unitaires simples

• Assertions : insérées dans le code ou dans un fichier dédié.

13
 assert trapezoid(0, 1, 1) == 0.5 * (f(0) + f(1)) # cas simple

• pytest :
• Créer fichier test_module.py contenant des fonctions def test_xxx(): ... .
• Installation : pip install pytest .
• Exécution : pytest dans le dossier, détecte et exécute les tests.
• Bonnes pratiques : écrire des tests couvrant cas limites (N très petit, fonction constante, etc.).

5.5 Organisation de projet et bonnes pratiques

• Hiérarchie de fichiers (comme indiqué plus haut). Séparer code de production ( src/ ), tests
( tests/ ), notebooks ( notebooks/ ).
• Gestion de versions : Git, repository hébergé (GitHub, GitLab). Encourager commits fréquents
avec messages clairs.
• Environnements : documenter comment installer les dépendances (fichier
requirements.txt ou environment.yml ).
• Documentation : README pour expliquer le projet, son objectif, comment installer et exécuter.
• Relecture de code (code review) : encourager échanges entre pairs.

5.6 Exemple pratique en direct

• Montrer l’écriture du script d’intégration trapèze complet.

• Ajouter des assertions ou un fichier de tests.
• Exécuter depuis la ligne de commande.
• Illustrer modifications : changer fonction, valider arguments, ajouter logging.

5.7 Perspectives et projets ultérieurs

• Méthodes numériques avancées : implémenter Newton, bissection, interpolation, intégration

adaptative.
• Utilisation de SciPy : pour algorithmes plus avancés (résolution d’EDO, optimisation, FFT, etc.).
• Visualisation avancée : tracer convergence, surfaces 3D, etc.
• Performance : profilage, vectorisation avancée, numba, Cython ou interfacer C.
• Collaboratif : partager et collaborer via Git, documenter des projets.

Conclusion de Session 2

• Récapitulatif des notions approfondies : fonctions, modules, math standard, portée, scripts CLI,
logging, tests.
• Encouragement à pratiquer via le laboratoire proposé et projets personnels.
• Mise à disposition des notebooks et supports.

Annexes et ressources complémentaires

1. Documentation officielle :
2. NumPy : https://numpy.org/doc/stable/
3. Matplotlib : https://matplotlib.org/stable/contents.html
4. Python (fonctions, modules) : https://docs.python.org/3/tutorial/
5. Argparse : https://docs.python.org/3/library/argparse.html
6. Logging : https://docs.python.org/3/library/logging.html

14
 7. Unittest/pytest : https://docs.pytest.org/
8. Tutoriels et articles en français :
9. Tutoriel Python de base (ex. OpenClassrooms, Grafikart).
10. Articles sur NumPy/Matplotlib sur sites francophones.
11. Vidéos : courtes présentations YouTube expliquant la vectorisation NumPy, tracés Matplotlib.
12. Livres :
13. « Python pour les mathématiques » ou ouvrages similaires traitant du calcul numérique.
14. Projets de suivi :
15. Implémenter plusieurs méthodes de résolution d’équations non linéaires, comparer leur
convergence et afficher graphiquement.
16. Écrire un mini-projet d’analyse de données scientifiques (importer un jeu de données, calculs,
tracés).

Conseil final : Partagez ces notes aux étudiants sous forme de PDF ou document
markdown, accompagné des notebooks Jupyter. Encouragez-les à lire avant la session, à
exécuter des exemples, puis à poser des questions en session. Les notes détaillées les
guideront pas à pas et serviront de référence tout au long du cours et au-delà.

15