Programmation avancée
La programmation est au cœur de la démarche de l'ingénieur en SI : modéliser un système, simuler son comportement, traiter des données capteurs ou piloter un automate. En Terminale SI, Python s'impose comme langage de référence pour la simulation numérique, le traitement du signal et l'algorithmique.
Objectifs
- Concevoir et analyser des algorithmes classiques (tri, recherche, récursivité)
- Utiliser des structures de données adaptées (listes, dictionnaires, tableaux NumPy) en Python
- Implémenter une simulation numérique d'un système physique par méthode d'Euler
Algorithmes et complexité
Un algorithme est une suite d'instructions finies résolvant un problème. La complexité temporelle mesure le nombre d'opérations en fonction de la taille n des données. Les complexités courantes : O(1) constante (accès tableau), O(log n) logarithmique (recherche dichotomique), O(n) linéaire (parcours de liste), O(n²) quadratique (tri par insertion, bulles), O(n log n) quasi-linéaire (tri fusion, rapide). En SI, on privilégie les algorithmes efficaces pour le traitement temps-réel : la recherche dichotomique dans un tableau trié (O(log n)) est bien plus rapide qu'une recherche séquentielle (O(n)) pour de grands jeux de données.
Structures de données en Python
Les listes Python (list) sont dynamiques et hétérogènes : append(), pop(), len(), slicing. Les tuples sont immuables — utiles pour des coordonnées ou des paramètres fixes. Les dictionnaires (dict) associent clé:valeur avec accès O(1) : parfaits pour des tables de correspondance (code capteur → valeur mesurée). Les tableaux NumPy (numpy.array) sont homogènes, performants pour le calcul vectoriel : addition, multiplication élément par élément, fonctions mathématiques appliquées à tout un tableau en une ligne. Pour la simulation numérique (intégration, dérivation), NumPy et SciPy sont incontournables.
Simulation numérique — méthode d'Euler
La méthode d'Euler permet d'intégrer numériquement une équation différentielle ordinaire (EDO) du type dy/dt = f(t, y). Principe : discrétiser le temps en pas h (en s), puis itérer : y(t+h) = y(t) + h × f(t, y(t)). Exemple : simulation de la charge d'un condensateur RC (uc(t+h) = uc(t) + h × (E-uc(t))/(R×C)). Le pas h doit être suffisamment petit devant la constante de temps du système (h << τ = RC) pour garantir la stabilité et la précision. En Python, on utilise une boucle for sur le vecteur temps généré par numpy.linspace.
Fonctions, modules et bonnes pratiques
En Python, une fonction est définie par def nom(paramètres): et retourne un résultat avec return. La récursivité (fonction qui s'appelle elle-même) est utile pour certains algorithmes (factorielle, tri fusion) mais attention à la profondeur maximale de récursion. Les modules clés pour l'ingénieur : numpy (calcul numérique), matplotlib.pyplot (tracé de courbes), scipy.signal (traitement du signal, filtres), sympy (calcul symbolique), pandas (tableaux de données). Bonnes pratiques : nommer les variables de façon explicite, documenter avec des docstrings, tester chaque fonction unitairement, versionner avec Git.
Relations et formules clés
y[i+1] = y[i] + h × f(t[i], y[i])h est le pas de temps en s, f(t,y) est la dérivée dy/dt. On démarre avec la condition initiale y[0] = y0 et on calcule l'état suivant à chaque pas. Plus h est petit, plus la simulation est précise mais plus longue.
k = ceil(log2(n))n est la taille du tableau trié. La dichotomie divise l'espace de recherche par 2 à chaque étape. Pour n = 1 024, k = 10 itérations suffisent vs 1 024 en séquentiel — gain de facteur 100.
τ = R × Cτ en secondes, R en ohms, C en farads. La simulation Euler doit utiliser h << τ (typiquement h = τ/100) pour que la courbe simulée colle à la réponse théorique exponentielle uc(t) = E × (1 - e^(-t/τ)).
Exercice d'application
Question : Écrire en Python une fonction euler_rc(R, C, E, t_fin, h) qui simule la charge d'un condensateur RC (uc(0) = 0 V, source E volts) par méthode d'Euler et retourne les listes t et uc. Appliquer avec R = 1000 Ω, C = 100 µF, E = 5 V, t_fin = 1 s, h = 0.001 s. Quelle est la valeur théorique de uc à t = τ ?
Voir la solution
Réponse : import numpy as np def euler_rc(R, C, E, t_fin, h): t = [0.0]; uc = [0.0] while t[-1] < t_fin: duc = (E - uc[-1]) / (R * C) uc.append(uc[-1] + h * duc) t.append(t[-1] + h) return t, uc t, uc = euler_rc(1000, 100e-6, 5, 1, 0.001) La constante de temps τ = R × C = 1000 × 100×10⁻⁶ = 0,1 s. À t = τ, la valeur théorique est uc(τ) = E × (1 - e⁻¹) = 5 × 0,632 ≈ 3,16 V. La simulation doit donner une valeur très proche, confirmant la validité du pas h = 0,001 s << τ = 0,1 s.
