Лист за преговор: Introduction aux Structures de Données en Python

📋 Plan du Cours

1. Indentation Python
2. Syntaxe de base
3. Structures de contrôle
4. Structures de données
5. Fonctions Python
6. Modules et importation
7. Gestion fichiers Python
8. Visualisation données
9. NumPy tableaux

📖 1. Indentation Python

🔑 Notions clés & Définitions

• Indentation comme délimiteur de blocs : En Python, l’indentation est utilisée pour délimiter la portée des blocs de code, remplaçant ainsi les accolades ou mots-clés explicites présents dans d’autres langages (ex : C, MATLAB, R). Elle indique la hiérarchie et l’imbrication des instructions (source : Machine Learning Polycopié).

• Indentation cohérente obligatoire : Toutes les lignes d’un même bloc doivent utiliser le même nombre d’espaces ou de tabulations pour garantir la validité syntaxique. Toute incohérence entraîne une erreur de type IndentationError (source : Machine Learning Polycopié).

• Indentation pour l’imbrication de blocs : Chaque niveau supplémentaire d’imbrication dans une structure conditionnelle ou une boucle est représenté par une indentation supplémentaire. Cela permet de visualiser la hiérarchie logique du programme (source : Machine Learning Polycopié).

• Erreurs fréquentes d'indentation : Mélanger espaces et tabulations ou utiliser un nombre variable d’espaces pour une même indentation provoque des erreurs. La convention recommande d’utiliser uniquement 4 espaces par niveau d’indentation, et de configurer l’éditeur en conséquence (source : Machine Learning Polycopié).

• Comparaison avec d’autres langages : Contrairement aux langages comme C, MATLAB ou R, où la délimitation des blocs se fait par des symboles ou mots-clés ({}, end), Python utilise l’indentation pour définir la structure, ce qui favorise la lisibilité et impose une discipline stricte (source : Machine Learning Polycopié).

📝 Points essentiels

• En Python, l’indentation n’est pas une simple convention stylistique mais une règle syntaxique essentielle.
• Un bloc commence après un deux-points (:) et doit être indenté de façon cohérente.
• La convention recommandée par la communauté est d’utiliser 4 espaces par niveau d’indentation.
• Le mélange d’espaces et de tabulations est une erreur fréquente qui cause des IndentationError.
• La comparaison avec d’autres langages montre que Python privilégie la simplicité visuelle et la lisibilité en utilisant l’indentation pour structurer le code.

💡 À retenir

L’indentation en Python est la clé de la délimitation des blocs de code, remplaçant les symboles utilisés dans d’autres langages, et doit être cohérente pour assurer la validité syntaxique et la lisibilité du programme.

📖 2. Syntaxe de base

🔑 Notions clés & Définitions

• Typage dynamique : Caractéristique de Python où le type d’une variable est déterminé à l’exécution et peut changer au cours du programme, facilitant le développement rapide (voir section 6).
• Types de base : Les principaux types primitifs en Python sont :
  • int : Entiers, par exemple x = 42.
  • float : Nombres réels, par exemple pi = 3.14.
  • str : Chaînes de caractères, par exemple nom = "Jean".
  • bool : Valeurs booléennes True ou False.
• Affectation et changement de type : En Python, une variable peut se voir attribuer une valeur de n’importe quel type sans déclaration préalable, et son type peut évoluer dynamiquement, par exemple : x = 10 puis x = "texte" (voir section 6).
• Syntaxe de base des variables : La déclaration ne nécessite pas de mot-clé spécifique, l’affectation se fait par le symbole =. La variable est créée lors de la première affectation, et son type est déduit automatiquement.

📝 Points essentiels

• Python est un langage à typage dynamique, ce qui permet une grande flexibilité dans la manipulation des variables.
• Les types fondamentaux (int, float, str, bool) sont utilisés pour représenter les données de base.
• L’affectation d’une valeur à une variable se fait simplement par =, sans déclaration explicite de type, par exemple : x = 5 ou x = "bonjour".
• La modification du type d’une variable est automatique, par exemple : x = 42 puis x = "texte".
• La syntaxe de base est simple : nom de variable, symbole =, valeur.

💡 À retenir

Le typage dynamique de Python permet de changer le type d’une variable à tout moment, rendant la syntaxe simple et flexible, mais exigeant une attention particulière à la gestion des types lors des conversions.

📖 3. Structures de contrôle

🔑 Notions clés & Définitions

• Conditions (if, elif, else) : Permettent d'exécuter un bloc de code uniquement si une expression booléenne est vraie. AUTEUR (date) : Les conditions contrôlent le flux d'exécution en fonction de critères logiques, en utilisant des expressions booléennes pour diriger le programme.

• Boucle for : Structure qui parcourt une séquence (liste, range, chaîne) en exécutant un bloc pour chaque élément. AUTEUR (date) : La boucle for facilite la répétition d’un bloc de code sur une collection d’éléments, avec une syntaxe simple et lisible.

• Boucle while : Répète un bloc tant qu’une condition est vraie. AUTEUR (date) : La boucle while permet d’exécuter indéfiniment un bloc de code jusqu’à ce qu’une condition devienne fausse, utile pour des répétitions conditionnelles.

• Instructions de contrôle de boucle (break, continue) : Modifient le comportement d’une boucle en interrompant ou en sautant une itération. AUTEUR (date) : Ces instructions donnent une flexibilité supplémentaire pour gérer la sortie anticipée ou le saut d’itérations dans une boucle.

• Blocs imbriqués : Structures de contrôle imbriquées dans d’autres, permettant de gérer des logiques complexes. AUTEUR (date) : L’imbrication de blocs conditionnels ou de boucles permet de modéliser des scénarios hiérarchiques ou dépendants, en respectant l’indentation.

📝 Points essentiels

• Les conditions (if, elif, else) permettent de diriger le flux selon des critères logiques. La syntaxe repose sur des expressions booléennes (ex : if x > 0:).
• La boucle for est idéale pour parcourir des séquences, avec une syntaxe claire : for element in sequence:.
• La boucle while répète un bloc tant qu’une condition est vérifiée, ce qui nécessite souvent une mise à jour de la condition pour éviter les boucles infinies.
• Les instructions break et continue modifient le comportement des boucles : break quitte la boucle immédiatement, continue saute à l’itération suivante.
• Les blocs imbriqués permettent de combiner plusieurs structures de contrôle pour gérer des logiques complexes, en respectant une indentation cohérente.
• La syntaxe Python repose sur l’indentation pour délimiter les blocs, contrairement à d’autres langages utilisant accolades ou mots-clés explicites (ex : end en MATLAB).

💡 À retenir

Les structures de contrôle en Python, notamment les conditions et les boucles, permettent de gérer efficacement le flux d’un programme, avec une syntaxe claire et une indentation essentielle pour délimiter les blocs. Leur maîtrise est fondamentale pour écrire des programmes logiques et modulaires.

📖 4. Structures de données

🔑 Notions clés & Définitions

• Listes : Séquences ordonnées, modifiables et indexables en Python, pouvant contenir des objets de types variés. AUTEUR (voir source) : "Les listes peuvent contenir n’importe quel type d’objet, homogènes ou hétérogènes."
• Tuples : Structures immuables, similaires aux listes mais ne pouvant pas être modifiées après création. AUTEUR (voir source) : "Un tuple est similaire à une liste mais immuable (ne peut pas être modifié après création)."
• Dictionnaires (dict) : Collections non ordonnées de paires clé/valeur, permettant un accès rapide via la clé. AUTEUR (voir source) : "Un dict est une collection non ordonnée de paires clé/valeur."
• Ensembles (set) : Collections non ordonnées d’éléments uniques, utilisées pour tester l’appartenance ou effectuer des opérations ensemblistes. AUTEUR (voir source) : "Ensembles (set) : collections non ordonnées d’éléments uniques."
• Conversion entre structures : Opérations permettant de transformer une structure de données en une autre, par exemple, convertir une liste en set ou un tuple en liste. AUTEUR (voir source) : "Conversion entre structures de données" (ex : list(), tuple(), set()).

📝 Points essentiels

• Les listes sont très flexibles, avec des opérations d’accès, de modification, de concaténation via +, extend() ou append(). La création d’un tableau 2D se fait par une liste de listes, permettant de représenter des matrices ou tableaux de mesures.
• Les tuples, immuables, sont idéaux pour représenter des données fixes comme des coordonnées, et peuvent être parcourus avec for ou enumerate().
• Les dictionnaires offrent un accès rapide par clé, facilitant la gestion de données associatives, avec possibilité d’ajouter ou modifier des paires clés/valeurs.
• Les ensembles sont utiles pour éliminer les doublons, tester l’appartenance ou réaliser des opérations ensemblistes (union, intersection).
• La conversion entre structures permet d’adapter le stockage selon le besoin : par exemple, transformer une liste en set pour supprimer les doublons, ou un tuple en liste pour modification.

💡 À retenir

Les structures de données en Python (listes, tuples, dictionnaires, ensembles) offrent une grande flexibilité pour organiser et manipuler efficacement des données, avec des opérations spécifiques à chaque type pour répondre à différents besoins en programmation.

📖 5. Fonctions Python

🔑 Notions clés & Définitions

• Fonction en Python : Un bloc de code réutilisable qui effectue une tâche spécifique, défini à l’aide du mot-clé def et pouvant prendre des paramètres (voir aussi "Paramètres et arguments"). Selon PERROUX (date), la fonction permet de structurer le code, de le rendre modulaire et plus lisible.
• Paramètres et arguments : Les paramètres sont des variables déclarées dans la définition d’une fonction, tandis que les arguments sont les valeurs passées lors de l’appel de la fonction. PERROUX (date) précise que cette distinction facilite la flexibilité et la réutilisation des fonctions.
• Valeur de retour : La valeur ou le résultat qu’une fonction peut renvoyer à la fin de son exécution, généralement avec l’instruction return. Elle permet de transmettre une information à l’extérieur de la fonction, comme souligné par PERROUX (date).
• Portée des variables dans les fonctions : La portée désigne la zone où une variable est accessible. En Python, les variables déclarées à l’intérieur d’une fonction ont une portée locale, limitée à cette fonction, tandis que celles déclarées en dehors sont globales. La compréhension de cette portée est essentielle pour éviter les erreurs de variable (voir aussi "la légitimité" (section 3)).

📝 Points essentiels

• La définition d’une fonction commence par def, suivie du nom, de parenthèses avec éventuellement des paramètres, puis deux points. Exemple :

  def ma_fonction(param1, param2):  
      # corps de la fonction  
      return resultat  
  

• Les paramètres permettent de passer des valeurs à la fonction, qui peuvent avoir des valeurs par défaut (ex : def f(x=2):). Les arguments sont les valeurs concrètes lors de l’appel : f(5).
• La valeur de retour est facultative ; si aucune n’est spécifiée, la fonction retourne None par défaut. La fonction peut effectuer des calculs ou manipulations et transmettre un résultat via return.
• La portée des variables est locale par défaut : une variable déclarée à l’intérieur d’une fonction ne peut pas être utilisée en dehors, sauf si déclarée global. Cela permet d’isoler les effets de chaque fonction et d’éviter les conflits de variables (voir aussi "la légitimité").
• La modularité et la réutilisation sont facilitées par l’utilisation de fonctions, notamment dans le cadre du Machine Learning où des opérations répétitives sont courantes.

💡 À retenir

Les fonctions en Python permettent de structurer le code en blocs réutilisables, avec des paramètres pour la flexibilité, des valeurs de retour pour transmettre des résultats, et une portée locale pour gérer l’indépendance des variables.

📖 6. Modules et importation

🔑 Notions clés & Définitions

• Importation de modules entiers : Consiste à importer un module complet en utilisant la syntaxe import nom_module. Cela permet d’accéder à toutes ses fonctions et variables via la notation nom_module.fonction().
• Importation de fonctions spécifiques : Permet d’importer uniquement certaines fonctions d’un module avec la syntaxe from nom_module import fonction1, fonction2. Cela évite de charger tout le module et facilite l’utilisation directe des fonctions.
• Alias pour modules : Technique qui consiste à donner un nom abrégé ou différent à un module lors de l’importation, avec import nom_module as alias. Cela simplifie la syntaxe et évite les conflits de noms.
• Module random pour nombres aléatoires : Module standard en Python (random) permettant de générer des nombres pseudo-aléatoires, avec des fonctions comme randint(), uniform(), ou choice().
• Bonnes pratiques d’importation : Recommandations pour optimiser la lisibilité et la performance du code, notamment en évitant les importations globales excessives, en utilisant des alias pertinents, et en important uniquement ce qui est nécessaire.

📝 Points essentiels

• L’importation d’un module entier (import module) permet d’accéder à ses fonctionnalités via la syntaxe module.fonction(). Par exemple, import random puis random.randint(1, 10) pour générer un nombre aléatoire.
• L’importation spécifique (from module import fonction) permet d’utiliser directement la fonction sans préfixe, par exemple from math import sqrt puis sqrt(16).
• L’utilisation d’un alias (import module as alias) facilite la lecture et évite les conflits, par exemple import numpy as np.
• Le module random fournit des fonctions pour générer des nombres aléatoires, très utilisé en Machine Learning pour la création de jeux de données ou la sélection aléatoire d’échantillons.
• Pour importer des modules externes, il faut souvent utiliser des gestionnaires de paquets comme pip pour l’installation (pip install nom_module).
• Il est conseillé de suivre les bonnes pratiques d’importation : importer uniquement ce qui est nécessaire, utiliser des alias pour clarifier le code, et respecter la convention PEP8 (importations en début de fichier, séparées en groupes).

💡 À retenir

L’importation de modules en Python permet d’étendre ses fonctionnalités de façon flexible et efficace. Privilégier l’importation spécifique ou avec alias pour un code clair et performant, notamment avec des modules comme random pour la génération de nombres aléatoires ou numpy pour la manipulation de tableaux numériques.

📖 7. Gestion fichiers Python

🔑 Notions clés & Définitions

• Lecture de fichiers texte : processus d’ouverture, de lecture et de fermeture d’un fichier contenant du texte brut, permettant d’accéder à son contenu ligne par ligne ou en totalité. AUTEUR (source) : permet d’extraire des données pour analyse ou traitement ultérieur.

• Écriture dans un fichier : opération d’ouverture d’un fichier en mode écriture pour y insérer ou remplacer des données textuelles. La méthode overwrite efface le contenu précédent, sauf si mode ajout est spécifié. AUTEUR (source) : utile pour sauvegarder résultats ou logs.

• Ajout de données dans un fichier : mode d’ouverture spécifique permettant d’ajouter du contenu à la fin d’un fichier existant sans supprimer ses données précédentes. La méthode append est privilégiée. AUTEUR (source) : facilite la constitution progressive de fichiers de logs ou de résultats.

• Lecture et écriture de données numériques : manipulation de données numériques stockées dans des fichiers, nécessitant souvent une conversion entre texte et format numérique (float, int). La lecture peut se faire ligne par ligne, puis conversion, et l’écriture nécessite une conversion inverse. AUTEUR (source) : essentiel pour traiter des résultats expérimentaux ou des séries temporelles.

• Gestion des erreurs lors de l’ouverture d’un fichier : mécanisme permettant de capturer et traiter les exceptions (ex. FileNotFoundError, IOError) qui peuvent survenir si le fichier n’existe pas ou si l’accès est refusé. Utilisation de blocs try/except pour assurer la robustesse du programme. AUTEUR (source) : garantit la stabilité face aux erreurs d’accès.

📝 Points essentiels

• L’ouverture d’un fichier se fait avec la fonction open() en précisant le mode ('r' pour lecture, 'w' pour écriture, 'a' pour ajout). La fermeture est recommandée avec close() ou via le gestionnaire with qui assure la fermeture automatique.

• La lecture de fichiers texte peut se faire ligne par ligne (readline()) ou en totalité (read()). La lecture ligne par ligne est souvent préférée pour traiter de gros fichiers.

• L’écriture dans un fichier se réalise avec la méthode write() ou writelines(). La méthode write() écrit une chaîne de caractères, nécessitant souvent une conversion de données numériques en texte.

• Lors de l’ajout de données, le mode 'a' permet d’écrire à la fin du fichier sans supprimer son contenu existant.

• La gestion d’erreurs lors de l’ouverture est cruciale pour éviter que le programme ne plante en cas de fichier manquant ou de problème d’accès. La structure try/except permet de capturer ces exceptions et de réagir en conséquence.

• La conversion de données numériques en texte et inverse est indispensable pour la lecture/écriture de données numériques dans des fichiers texte. Par exemple, str() pour convertir en texte, float() ou int() pour convertir en numérique.

• La méthode with est recommandée pour ouvrir un fichier, car elle garantit la fermeture automatique même en cas d’erreur.

💡 À retenir

L’accès aux fichiers en Python repose sur l’ouverture avec open(), la lecture ou écriture via des méthodes adaptées, et la fermeture du fichier. La gestion des erreurs avec try/except et l’utilisation du gestionnaire with assurent la robustesse et la simplicité du traitement des fichiers. La conversion entre données numériques et texte est essentielle pour manipuler efficacement ces données dans des fichiers texte.

📖 8. Visualisation données

🔑 Notions clés & Définitions

• Création de graphiques simples : Réalisation d’un graphique unique pour représenter une série de données ou une variable, permettant une lecture immédiate des tendances ou distributions (ex : ligne, barre, histogramme).
• Graphiques multiples et styles : Utilisation de plusieurs graphiques dans une même figure ou application de styles variés (couleurs, tracés, légendes) pour comparer ou mettre en valeur différentes séries de données. AUTEUR (date) : cette approche facilite l’analyse comparative et la visualisation enrichie.
• Histogrammes : Graphiques représentant la distribution d’une variable continue ou discrète, en regroupant les données en classes ou intervalles. AUTEUR (date) : outil essentiel pour analyser la fréquence ou la densité des valeurs dans un ensemble de données.
• Nuages de points (scatter plots) : Graphiques où chaque point représente une paire de valeurs (x, y), permettant d’observer la relation ou la corrélation entre deux variables. AUTEUR (date) : utile pour détecter des tendances, des clusters ou des outliers dans des données bivariées.

📝 Points essentiels

• La création de graphiques simples est souvent réalisée avec des bibliothèques comme Matplotlib, en utilisant des fonctions telles que plot() pour une ligne ou bar() pour des barres.
• Les graphiques multiples permettent d’afficher plusieurs séries dans une même figure, en utilisant par exemple subplot() ou en superposant plusieurs tracés avec différents styles (lignes, points, couleurs).
• Les histogrammes sont construits via la fonction hist(), qui regroupe les données en classes et affiche la fréquence ou la densité. La sélection du nombre de classes influence la lisibilité et l’interprétation.
• Les nuages de points (scatter plots) sont générés avec scatter(), en représentant chaque paire de valeurs par un point, ce qui facilite l’analyse de la relation entre deux variables.
• La personnalisation des graphiques (titres, légendes, axes, couleurs) est essentielle pour une communication claire des résultats.
• La visualisation doit respecter la fidélité des données, éviter les biais visuels et privilégier la simplicité pour une interprétation immédiate.

💡 À retenir

Les graphiques simples, histogrammes, nuages de points et styles multiples sont des outils fondamentaux pour explorer, analyser et présenter efficacement des données en Machine Learning et data science.

📖 9. NumPy tableaux

🔑 Notions clés & Définitions

• Import de la bibliothèque : La bibliothèque NumPy doit être importée pour manipuler efficacement des tableaux numériques en Python, généralement avec la syntaxe import numpy as np.
• Création de tableaux NumPy : La fonction np.array() permet de créer des tableaux NumPy à partir de listes ou autres séquences, facilitant la manipulation de données multidimensionnelles.
• Opérations élément par élément : Les opérations arithmétiques (addition, multiplication) appliquées à des tableaux NumPy s’effectuent de manière élément par élément, grâce à la vectorisation, contrairement aux opérations sur des listes classiques.
• Multiplication par un scalaire : La multiplication d’un tableau par un scalaire en NumPy modifie chaque élément du tableau par ce scalaire, sans boucle explicite, grâce à la diffusion (broadcasting).
• Fonctions mathématiques usuelles : NumPy propose des fonctions mathématiques telles que np.sin(), np.exp(), np.sqrt(), qui s’appliquent élément par élément sur des tableaux, permettant des calculs vectoriels rapides.
• Indexation et slicing : La sélection d’éléments ou de sous-tableaux dans un tableau NumPy se fait via l’indexation (avec des crochets []) et le slicing (avec :), permettant d’accéder rapidement à des portions spécifiques de données.

📝 Points essentiels

• L’import de NumPy se fait généralement par import numpy as np, ce qui facilite l’utilisation de ses fonctions et classes.
• La création de tableaux se fait avec np.array(), en passant une liste ou une liste de listes pour des tableaux multidimensionnels.
• Les opérations arithmétiques entre tableaux (addition, multiplication) se font directement, en exploitant la vectorisation, ce qui est beaucoup plus performant que les boucles classiques.
• La multiplication par un scalaire utilise la diffusion automatique de NumPy, permettant de modifier tous les éléments du tableau en une seule opération.
• Les fonctions mathématiques de NumPy appliquent des opérations élément par élément, simplifiant les calculs vectoriels complexes.
• Indexer ou slicer un tableau NumPy permet d’accéder à des éléments précis ou à des sous-ensembles, en utilisant la syntaxe tableau[indices] ou tableau[start:stop].

💡 À retenir

Les tableaux NumPy, créés avec np.array(), permettent de réaliser des opérations mathématiques et des manipulations de données de façon vectorielle, rapide et efficace, grâce à leur compatibilité avec les fonctions mathématiques et leur capacité d’indexation avancée.

📊 Tableaux de Synthèse

Fonctionnalité	Listes	Tuples	Dictionnaires	Ensembles
Mutabilité	Modifiables	Immuables	Modifiables	Modifiables
Syntaxe de création	[éléments]	(éléments)	{clé: valeur, ...}	{éléments}
Ordre	Oui	Oui	Non (depuis Python 3.7, insertion ordonnée)	Non
Accès aux éléments	Index (list[0])	Index (tuple[0])	Clé (dict['clé'])	Non indexé, recherche par valeur
Utilisation principale	Stockage de collections modifiables	Stockage de données immuables	Associations clé/valeur	Opérations ensemblistes

Fonctionnalité	Listes	Tuples	Dictionnaires	Ensembles
Opérations courantes	Ajout (append), suppression, slicing	Immutabilité, accès par index	Ajout, suppression, accès par clé	Union, intersection, différence
Cas d’usage typique	Listes de données modifiables	Constantes, clés immuables	Données associatives	Vérification d’appartenance

⚠️ Pièges & Confusions Fréquentes

1. Mélanger listes et tuples : utiliser un tuple quand la structure doit être immuable, une liste pour modifiable.
2. Oublier que les dictionnaires sont non ordonnés (avant Python 3.7) : ne pas compter sur l’ordre d’insertion.
3. Confondre set et list : set ne conserve pas l’ordre et ne contient pas d’éléments dupliqués.
4. Accéder à un index inexistant dans une liste ou un tuple provoque une erreur IndexError.
5. Utiliser = pour copier une liste ou un dictionnaire crée une référence, pas une copie indépendante.
6. Oublier que les clés de dictionnaire doivent être immuables (ex : pas de liste comme clé).
7. Ne pas utiliser add() pour ajouter un élément à un set ou dict[key] = value pour un dictionnaire.

✅ Checklist Examen

• Connaître la différence entre liste, tuple, dictionnaire et ensemble, notamment leur mutabilité et leur usage.
• Savoir créer, accéder, modifier et supprimer des éléments dans ces structures.
• Maîtriser les méthodes principales : append(), pop(), insert(), update(), add().
• Comprendre la différence entre mutabilité et immutabilité, notamment pour listes et tuples.
• Être capable d’utiliser un dictionnaire pour stocker des données associatives et d’accéder aux valeurs via leurs clés.
• Connaître la syntaxe pour créer des ensembles et leurs opérations ensemblistes (union, intersection, difference).
• Savoir que les listes et dictionnaires sont mutables, tandis que les tuples et les strings ne le sont pas.
• Identifier les pièges liés à la copie de collections : référence vs copie indépendante.
• Connaître les contraintes sur les clés de dictionnaire (doivent être immuables).
• Savoir utiliser les opérations de recherche et de modification dans ces structures.
• Comprendre que les dictionnaires sont non ordonnés en versions Python antérieures à 3.7.
• Vérifier la maîtrise des opérations courantes et des méthodes associées pour chaque structure.