Python : Des Fondamentaux aux

Structures de Données
Introduction : De l'Algorithmique à Python
Ce cours d'initiation vise à établir un pont direct entre les concepts théoriques de
l'Algorithmique et leur implémentation rigoureuse en Python. Vous apprendrez que Python
est une traduction quasi-directe de vos pseudocodes, avec des exigences syntaxiques très
strictes.

A. Les Fondamentaux et l'Exécution

A.1. Environnement et Syntaxe
1. Philosophie de Python
Python est un langage interprété et à typage dynamique.

Caractéristique Implication

Interprété Le code est exécuté ligne par ligne (facilite

le débogage).

Typage Dynamique Le type d'une variable (int, float, etc.) est

déduit à l'exécution, non à la déclaration.

Exemple de traduction :
● Algorithmique : Var x : Entier
● Python : x = 5

2. L'Indentation : Règle d'Or de Python

Contrairement aux langages utilisant des accolades {} ou des mots-clés Début / Fin, Python
utilise l'indentation (quatre espaces ou une tabulation) pour définir les blocs de code (if, for,
def, etc.).
● Rigueur : L'indentation est obligatoire et fait partie de la syntaxe. Un bloc mal indenté
lève une IndentationError.
● Commentaires : Une ligne commentaire commence par #.
A.2. Types de Données et Variables
1. Correspondance des Types Fondamentaux

Algorithmique Python Exemple Python Notes

Importantes

Entier int x = 10 Précision illimitée

(limitée seulement
par la mémoire).

Réel float y = 3.14 Utilise le point (.)

pour la décimale.
Attention à la
précision des
flottants (IEEE 754).

Booléen bool test = True Majuscule

obligatoire à True
et False.

Chaîne str s = "Bonjour" Délimité par des

guillemets simples
ou doubles.

2. L'enjeu de la Précision
Rappel Culturel (Ariane 5) : Le débordement d'entier (conversion d'un flottant 64-bit en
entier 16-bit) a causé l'explosion de la fusée. Cela souligne l'importance de maîtriser les
limites des types lors des conversions et des calculs critiques.

A.3. Entrées / Sorties

1. Saisie Utilisateur (input)
L'instruction algorithmique Lire(variable) est traduite par input().

Attention : input() renvoie toujours une chaîne de caractères (str). Une conversion explicite
est nécessaire pour les nombres.

# Conversion explicite obligatoire pour obtenir un nombre

age = int(input("Quel est votre âge ? "))

2. Affichage et Formatage (print)

La méthode moderne et recommandée pour l'affichage est l'utilisation des f-strings (ou
chaînes formatées).

nom = "Alice"
print(f"Nom : {nom}")

# Utilisation de \n pour le retour à la ligne

print("Ligne 1\nLigne 2")

A.4. Opérateurs Arithmétiques, Logiques et de

Comparaison
1. Opérateurs Arithmétiques (Nouveautés)

Opération Symbole Exemple Résultat Distinction

Python

Puissance ** 5 ** 2 25 Traduit $x^y$

ou $\text{pow}
(x,y)$.

Division Réelle / 5/2 2.5 Renvoie

toujours un
float.

Division // 5 // 2 2 Quotient de la
Entière division
euclidienne.

Modulo % 5%2 1 Reste de la

division
euclidienne.

2. Opérateurs de Comparaison et Logiques

Le point crucial est la distinction entre l'affectation et la comparaison d'égalité.
 Concept Algorithmique Python

Affectation $\leftarrow$ =

Égalité $=$ ==

Différent $\neq$ !=

Et / Ou / Non ET / OU / NON and / or / not

A.5. Fonctions Usuelles et Modularisation

1. Fonctions Natives (Built-in)
Ces fonctions sont disponibles sans aucune importation :

Fonction Rôle Exemple

abs(x) Valeur absolue $ x

round(x, n) Arrondi à $n$ décimales ` round(3.14159, 2) \to

3.14$

len(x) Longueur d'une séquence `len("Test") \to 4$

2. Les Modules et l'Instruction import

Python est structuré autour de modules (bibliothèques) qui regroupent des fonctionnalités
spécifiques. Pour utiliser une fonction non native (comme la racine carrée), il faut importer le
module adéquat.

Exemple : Calcul scientifique avec math

import math # Importation du module

# On accède aux fonctions via le préfixe 'math.'

hypotenuse = [Link](a**2 + b**2)
print([Link]([Link])) # Cosinus de Pi
Importation sélective : Si vous n'avez besoin que d'une ou deux fonctions :

from math import sqrt, pi

rayon = sqrt(16)

A.6. Structures de Contrôle

1. Conditionnelle (if / elif / else)
La structure Si / Sinon Si / Sinon utilise les deux-points (:) et l'indentation.

note = 14

if note >= 16:

print("Très Bien")
elif note >= 10:
print("Admis")
else:
print("Ajourné")

2. Boucle Conditionnelle (while)

Traduction directe du Tant Que ... Faire.

x=0
while x <= 0:
x = int(input("Entrez un entier positif : "))

3. Boucle Itérative (for et range)

La boucle Pour i allant de ... s'effectue sur une séquence générée par range().

Règle : range(start, stop) va de start inclus à stop EXCLU.

● range(5) $\to$ 0, 1, 2, 3, 4 (5 itérations)
● range(1, 6) $\to$ 1, 2, 3, 4, 5
● range(1, 10, 2) $\to$ 1, 3, 5, 7, 9 (Pas de 2)
Exercice : Implémentation de la Puissance Itérative

def puissance_iter(x, n):

 """
Calcule x^n de manière itérative. (Complexité O(n))
"""
resultat = 1
for _ in range(n): # _ est utilisé quand le compteur n'est pas nécessaire
resultat = resultat * x
return resultat

B. Fonctions et Modularisation
Les fonctions permettent la modularisation et la réutilisation des blocs de code.

B.1. Définition, Appel et Retour

1. La Syntaxe def
def nom_de_la_fonction(parametre1, parametre2):
# Bloc d'instructions indenté
resultat = parametre1 + parametre2
return resultat # Renvoie le résultat

2. Le mot-clé return
● Il termine l'exécution de la fonction et renvoie une valeur.
● Si return est omis ou sans expression, la fonction renvoie la valeur spéciale None.

B.2. Portée des Variables (Scope)

● Variable Locale : Créée dans une fonction, elle n'existe qu'à l'intérieur de celle-ci.
● Variable Globale : Définie au niveau principal du script.
Principe de bonne pratique : Évitez de modifier des variables globales à l'intérieur d'une
fonction (ce qu'on appelle les effets de bord). Une fonction idéale est pure : elle prend des
arguments et retourne un résultat, sans impacter l'état global du programme.

B.3. Arguments Avancés

1. Arguments par Défaut
Ils rendent l'argument optionnel.

Règle de Signature : Les arguments sans valeur par défaut doivent impérativement être
déclarés AVANT les arguments avec valeur par défaut.

def dire_bonjour(nom, message="Salut"): # "Salut" est la valeur par défaut

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

dire_bonjour("Alice") # Utilise la valeur par défaut

dire_bonjour("Bob", "Bonjour") # Surcharge la valeur par défaut

2. Arguments Nommés
Ils permettent de passer les arguments dans n'importe quel ordre en les nommant
explicitement.

dire_bonjour(message="Bienvenue", nom="Charlie")

C. Structures de Données Séquentielles

(Listes)
Une liste est une collection ordonnée, mutable (modifiable) et de taille variable, capable de
contenir des objets de types différents.

C.1. Manipulation de Base

Dans les exemples, $L$ désigne une liste.

Description Code Python Notes

Liste vide L = []

Liste hétérogène L = [3, "lundi", True]

Accès (rang $k$) L[k] L'indexation commence à

0.

Dernier objet L[-1] Indexation négative.

Longueur len(L)

Ajouter à la fin [Link](objet)

 Insérer au rang $k$ [Link](rang, objet) Coûteux en performance
pour les grandes listes.

Concaténation L1 + L2 Crée une nouvelle liste.

C.2. Méthodes Principales

Méthode Action

[Link](L2) Ajoute tous les éléments de $L2$ à la fin

de $L$.

[Link](i) Supprime et retourne l'élément à l'indice

$i$.

[Link](v) Supprime la première occurrence de la

valeur $v$.

[Link]() Renverse l'ordre des éléments (opération

sur place).

del L[i] Instruction pour supprimer par indice

(différent de pop()).

C.3. Parcours de Listes

1. Parcours par Valeurs (Méthode Pythonic)
C'est la méthode à privilégier si l'indice de l'élément n'est pas nécessaire.

def Somme2(L):
S=0
for element in L:
S += element
return S

2. Parcours par Indices (Méthode Algorithmique)

Nécessite l'utilisation de range(len(L)).
def Somme1(L):
S=0
for i in range(len(L)):
S += L[i] # Accès via l'indice
return S

C.4. Listes en Compréhension (List Comprehensions)

C'est une fonctionnalité très puissante pour générer des listes de manière concise.

1. Syntaxe de Base
● Génération : [expression for variable in sequence]
# Liste des entiers de 0 à 9
L1 = [i for i in range(10)]

2. Avec Condition
● Filtrage : [expression for variable in sequence if condition]
# Nombres impairs entre 0 et 9
L3 = [i for i in range(10) if i % 2 != 0]
# Résultat: [1, 3, 5, 7, 9]

C.5. Les Dictionnaires

Définition et Caractéristiques
Définition (Dictionnaire (dict))
Un dictionnaire est une collection de paires clé-valeur. Il est :
● Non ordonné (à partir de Python 3.7, l'ordre d'insertion est préservé, mais la définition
conceptuelle reste "non-séquentielle").
● Mutable (on peut ajouter, modifier et supprimer des éléments).
● Les clés doivent être uniques et immuables (nombres, chaînes de caractères, tuples).
Les valeurs peuvent être de n'importe quel type.
Remarque
En algorithmique, le dictionnaire correspond au concept de Table de Hachage ou de Tableau
Associatif.
Manipulation de Base des Dictionnaires
Exemple (Création, Accès et Modification)

# Contexte : Gestion des propriétés d'un satellite

satellite = {
"nom": "Sentinel-2A",
"masse_kg": 1130,
"orbite_km": 786,
"actif": True
}

# 1. Accès à une valeur par sa clé

nom_satellite = satellite["nom"] # Sentinel-2A
orbite = [Link]("orbite_km") # Méthode plus sûre

# 2. Ajout ou Modification
satellite["masse_kg"] = 1150 # Modification
satellite["lancement_annee"] = 2015 # Ajout

# 3. Suppression
del satellite["actif"]

print(f"Propriétés mises à jour : {satellite}")

Méthodes de Parcours et d'Inspection

Les dictionnaires s'itèrent de manière différente des listes.

Méthode Retourne Utilisation principale

[Link]() Clés uniquement Vérifier la présence d'une

propriété.

[Link]() Valeurs uniquement Calculer des statistiques

sur les valeurs (ex:
moyenne des notes).

[Link]() Paires (clé, valeur) Parcours complet pour un

traitement sur les deux
éléments.
Exemple (Parcours pour analyse de données)

inventaire_composants = {
"Resistance_01": 50,
"Condensateur_A": 120,
"Diode_1N4148": 300,
"Transistor_BC547": 80
}

print("=== État de l'Inventaire ===")

# Parcours par clés et valeurs simultanément

for composant, quantite in inventaire_composants.items():
if quantite < 100:
print(f"ALERTE Stock faible : {composant} (Reste: {quantite})")
else:
print(f"OK : {composant} (Stock: {quantite})")

Exercice d'Application (Fréquence de Caractères)

Exercice (Calcul de Fréquence (Application Dict))
Écrivez une fonction compter_frequences(texte) qui prend une chaîne de caractères en
entrée et retourne un dictionnaire où :
● Les clés sont les caractères rencontrés (en minuscules).
● Les valeurs sont le nombre d'occurrences de ce caractère dans le texte.
(Ignorez les espaces et la casse.)
Solution de l'exercice de fréquence de caractères

def compter_frequences(texte):
"""
Compte la fréquence d'apparition de chaque caractère dans un texte.
"""
frequences = {}
texte_clean = [Link]().replace(' ', '') # Nettoyage

for caractere in texte_clean:

if caractere in frequences:
# La clé existe déjà, on incrémente
frequences[caractere] += 1
else:
# Nouvelle clé, on initialise à 1
 frequences[caractere] = 1

return frequences

# Test de la fonction
analyse = compter_frequences("L'analyse des signaux est essentielle")
print(analyse)
# Résultat attendu : {'l': 1, "'": 1, 'a': 4, 'n': 2, 'y': 1, 's': 4, 'e': 5, 'd': 1, 'i': 1, 'g': 1, 'u': 1, 'x': 1, 't': 1}

D. Exercices de Synthèse et Analyse de

Complexité
D.1. Exercices Progressifs (Rappel du Cours)
Exercice (Niveau Débutant : Calcul de Statistiques Basiques)
Écrivez une fonction analyser_mesures(mesures) qui :
1. Calcule la moyenne des mesures
2. Trouve la valeur maximale et minimale
3. Compte le nombre de mesures supérieures à la moyenne
4. Retourne ces trois valeurs sous forme de tuple

Exercice (Niveau Intermédiaire : Gestion de Capteurs)

Créez un programme qui simule un système de surveillance avec 5 capteurs de température.
Le programme doit :
1. Générer des températures aléatoires entre $-10^\circ$C et $40^\circ$C (nécessite le
module random)
2. Détecter les températures anormales ($>35^\circ$C ou $<0^\circ$C)
3. Calculer la température moyenne
4. Afficher un rapport formaté avec f-strings

Exercice (Niveau Avancé : Analyse de Série Temporelle)

Développez une fonction analyser_serie_temporelle(donnees, fenetre) qui :
1. Calcule la moyenne mobile sur une fenêtre glissante
2. Détecte les pics (valeurs $>$ moyenne $+ 2 \times$ écart-type)
3. Génère une liste des indices où des pics sont détectés

D.2. Exercices d'Algorithmique et Complexité

(Synthèse Finale)
Les exercices suivants reprennent des concepts fondamentaux vus en Algorithmique. Pour
chaque exercice, vous devez :
1. Écrire l'implémentation itérative en Python.
2. Écrire l'implémentation récursive en Python (si possible).
3. Déterminer la complexité temporelle $\mathcal{O}(n)$ de chaque version (où $n$ est
la taille de l'entrée ou le nombre d'itérations).
4. Justifier quelle version devrait être programmée en pratique en Python et pourquoi, en
considérant la performance et la charge mémoire (complexité spatiale).

Exercice (Puissance (Rappel de l'Algorithme))

Écrivez deux fonctions pour calculer $x^n$ (avec $x \in \mathbb{R}$, $n \in \mathbb{N}$), en
utilisant les approches itérative et récursive simple.

Questions d'Analyse :
1. Déterminez la complexité temporelle $T_{\text{iter}}(n)$ et $T_{\text{rec}}(n)$ en $\
mathcal{O}$.
2. Quelle est la complexité spatiale $S_{\text{rec}}(n)$ de la version récursive ?
3. Quelle version choisiriez-vous en Python pour des grandes valeurs de $n$, et pourquoi ?

Exercice (Fonction Mystère (Complexité Logarithmique))

Considérez l'algorithme récursif suivant :

$$\text{Fonction mystery}(n) : \begin{cases} 1 & \text{si } n \le 1 \\ \text{mystery}(\lfloor n/2 \

rfloor) + 1 & \text{sinon} \end{cases}$$
Questions d'Analyse :
1. Écrivez la fonction Python correspondante.
2. Écrivez l'équation de récurrence associée au coût $T(n)$.
3. Résolvez l'équation de récurrence pour déterminer la complexité $T(n)$ en $\mathcal{O}
$.
4. Justifiez l'intérêt (ou le manque d'intérêt) d'implémenter ce type de récursion en Python
par rapport à une boucle while équivalente.

Exercice (Suite de Fibonacci)

Écrivez une fonction fibonacci(n) qui retourne le $n$-ième terme de la suite de Fibonacci
($F_0=0, F_1=1, F_n = F_{n-1} + F_{n-2}$).

Questions d'Analyse :
1. Écrivez la version itérative (en utilisant une boucle for ou while). Déterminez sa
 complexité $T_{\text{iter}}(n)$.
2. Écrivez la version récursive simple. Déterminez sa complexité $T_{\text{rec}}(n)$.
3. Pour quelles valeurs de $n$ la version récursive simple devient-elle inutilisable en
pratique ? (Expliquez le phénomène de la double récurrence).
4. Quelle est la méthode la plus efficace pour calculer $F_n$ et pourquoi ?

Exercice (Recherche d'Éléments)

Considérez la recherche d'un élément $v$ dans une liste triée de $n$ éléments.

Questions d'Analyse :
1. Écrivez la fonction Python de recherche linéaire. Déterminez sa complexité $T_{\
text{linéaire}}(n)$ dans le pire des cas.
2. Écrivez la fonction Python de recherche dichotomique (binaire). Déterminez sa
complexité $T_{\text{dichotomique}}(n)$.
3. Si $n=10^6$, estimez le nombre d'opérations nécessaires dans le pire des cas pour
chaque algorithme. (Utilisez $\log_2(10^6) \approx 20$).
4. Quelle fonction Python devrait être utilisée pour une recherche sur une grande base de
données triée et pourquoi ?

Exercice (Indexation et Dictionnaires (Application))

Un ingénieur doit gérer un catalogue de pièces détachées où chaque pièce a un ID unique et
un nom (le catalogue est fourni sous forme de liste de tuples : [(id, nom), ...]).

Questions d'Analyse :
1. Écrivez une fonction indexer_catalogue(liste_tuples) qui convertit cette liste en un
dictionnaire où la clé est l'ID et la valeur est le nom. Déterminez la complexité $T(n)$ de
cette fonction.
2. Écrivez une fonction trouver_nom_par_id(id, liste_tuples) qui cherche le nom sans utiliser
le dictionnaire. Déterminez sa complexité $T_{\text{recherche}}(n)$.
3. Après avoir créé le dictionnaire, quel est la complexité $T_{\text{dict}}(n)$ pour
retrouver le nom d'une pièce à partir de son ID dans le dictionnaire ?
4. Expliquez pourquoi le dictionnaire est la structure de données privilégiée en Python pour
l'indexation et les recherches rapides.

Conclusion et Perspectives
Ce premier cours Python vous a permis d'établir les fondations essentielles pour la
programmation scientifique et technique. Vous avez appris à :
● Traduire directement vos algorithmes en code Python fonctionnel.
● Maîtriser la syntaxe rigoureuse de Python (indentation, types, opérateurs).
 ● Structurer vos programmes avec des fonctions modulaires.
● Manipuler efficacement les listes et les dictionnaires pour le traitement de données.
● Évaluer l'efficacité de vos algorithmes via l'analyse de complexité.
Les compétences acquises dans ce cours constituent la base nécessaire pour aborder les
concepts plus avancés qui seront vus dans les prochaines séances :
● Structures de données complexes (tuples, ensembles).
● Programmation orientée objet pour la modélisation.
● Gestion des fichiers et des erreurs.
● Introduction aux bibliothèques scientifiques (NumPy, Matplotlib).
Conseil pour la pratique : La programmation n'est qu'une traduction de l'algorithmique.
Maîtriser les concepts de complexité est la clé de l'ingénierie logicielle efficace. Continuez à
pratiquer la traduction de vos algorithmes en code Python pour renforcer cette compétence
cruciale.