Fiche de révision : Introduction à la manipulation des données en Python

1. 📌 L'ess

Listes : mutables, concaténation [a]+[b], slicing list[1:3], méthodes append(), del.

• Tuples : immuables, accès par index, utilisation pour données fixes.
• Dictionnaires : clés-valeurs, ajout dict[key]=value, suppression del dict[key].
• Chaînes : immuables, slicing [::-1] pour inversion, split(), join().
• Boucles : for sur séquences, while avec compteur.
• Conditions : if, elif, else, opérateurs logiques and, or, not.
• Fonctions : définition def, paramètres par défaut, retour multiple (a, b).
• Expressions lambda : fonctions anonymes courtes lambda x: x-2.
• Comparaisons : is (identité), == (égalité), id() (référence).
• Gestion erreurs : index, type, exceptions courantes.

2. 🧩 Structures & Composants clés

• Liste — séquence mutable, méthodes append(), insert(), count(), index().
• Tuple — séquence immuable, accès par index, utilisé pour données fixes.
• Dictionnaire — collection clé/valeur, méthodes keys(), values(), ajout/suppression.
• Chaîne de caractères — séquence immuable, slicing, split(), join().
• Boucles — itérations sur séquences, contrôles répétitifs.
• Conditions — décisions conditionnelles avec opérateurs logiques.
• Fonctions — modularité, paramètres, valeurs par défaut, retour multiple.
• Lambda — fonctions anonymes, expressions courtes.
• Gestion erreurs — try/except, vérification index, type.

3. 🔬 Fonctions, Mécanismes & Relations

• Listes : concaténation [a]+[b], multiplication [0]*4, slicing list[1:3].
• Listes : méthodes count(), index(), append(), del pour modification.
• Comparaisons : is vérifie l’identité, == l’égalité, id() la référence.
• Chaînes : slicing [::-1] pour inversion, split() pour découper, join() pour assembler.
• Boucles : for pour itérer, while avec compteur pour répétition.
• Conditions : évaluent expressions logiques pour décisions.
• Dictionnaires : ajout dict[key]=value, suppression del dict[key], accès via keys(), values().
• Fonctions : paramètres optionnels, retour multiple (a, b).
• Lambda : fonctions courtes, inline, souvent pour filtres ou opérations rapides.
• Gestion erreurs : capturer index, type, exceptions pour code robuste.

4. Tableau de synthèse

5. 🗂️ Diagramme Hiérarchique ASCII

Manipulation des données
 ├─ Listes
 │    ├─ Concaténation, multiplication
 │    ├─ Méthodes : append(), insert(), count(), index()
 │    └─ Modification par slicing
 ├─ Tuples
 │    └─ Accès, immutabilité
 ├─ Dictionnaires
 │    ├─ Ajout, suppression
 │    └─ Clés, valeurs
 ├─ Chaînes
 │    ├─ Slicing, inversion
 │    ├─ split(), join()
 │    └─ Immutables
 └─ Structures de contrôle
     ├─ Boucles : for, while
     └─ Conditions : if, elif, else

6. ⚠️ Pièges & Confusions fréquentes

• Confondre is (identité) et == (égalité).
• Modifier une liste par slicing sans précaution.
• Oublier que tuples sont immuables.
• Utiliser del sur une variable au lieu d’un élément.
• Confondre split() et join().
• Oublier de gérer les erreurs d’index ou de type.
• Utiliser = au lieu de == dans les conditions.
• Ne pas distinguer mutable (listes, dictionnaires) et immutable (tuples, chaînes).

7. ✅ Checklist Examen Final

• Connaître la syntaxe pour créer et manipuler listes, tuples, dictionnaires.
• Savoir utiliser slicing pour accéder, modifier, inverser.
• Maîtriser méthodes principales : append(), insert(), count(), index(), split(), join().
• Différencier is, ==, id().
• Écrire et utiliser des fonctions avec paramètres par défaut, retour multiple.
• Comprendre et appliquer les expressions lambda.
• Gérer les erreurs courantes : index, type, exceptions.
• Savoir parcourir avec for et while.
• Utiliser les opérateurs logiques dans les conditions.
• Manipuler des dictionnaires : ajout, suppression, accès.
• Reconnaître la différence entre mutable et immutable.
• Visualiser la hiérarchie des structures via diagrammes ASCII.
• Être capable d’écrire un code robuste et efficace pour manipuler des données.

Fin de la fiche. Bonne révision !