Fiche de révision : Introduction aux Listes en Python

📋 Plan du Cours

1. Listes en Python
2. Indexation et slicing
3. Listes imbriquées et matrices
4. Fonctions et méthodes listes
5. Copie de listes
6. Tuples immuables
7. Générateur range

📖 1. Listes en Python

🔑 Notions clés & Définitions

Liste : AUTEUR (aucune date) : une suite d’objets, rangés dans un certain ordre, encadrée par des crochets. Elle permet de stocker plusieurs éléments de manière séquencée.

Objet hétérogène : AUTEUR (aucune date) : un objet pouvant appartenir à différents types, présents dans une même liste. La liste n’est pas limitée à un seul type d’objet.

Crochets : AUTEUR (aucune date) : symboles [ et ] qui encadrent une liste, délimitant le début et la fin de la séquence.

Séquence ordonnée : AUTEUR (aucune date) : caractéristique d’une liste où chaque élément possède une position précise, déterminée par son indice.

Élément séparé par virgule : AUTEUR (aucune date) : chaque objet dans une liste est séparé par une virgule, permettant de distinguer les différents éléments.

📝 Points essentiels

Une liste est une suite d’objets, rangés dans un certain ordre, encadrée par des crochets. Chaque objet est séparé par une virgule. La liste peut contenir des objets de types différents, ce qui signifie qu’elle n’est pas homogène. Il est également possible d’insérer une liste à l’intérieur d’une autre liste, créant ainsi des listes imbriquées.

La manipulation fondamentale consiste à extraire ou modifier un élément de la liste. La syntaxe pour cela est ListName[index], où l’indice commence à 0. Si l’indice dépasse la taille de la liste, Python renvoie une erreur. La sous-liste peut être extraite en utilisant la syntaxe ListName[i:j], avec i comme indice de début (inclus) et j comme indice de fin (exclu). On peut aussi préciser un pas k avec ListName[i:j:k]. Lorsqu’on utilise des tranches, les dépassements d’indices sont permis et ne provoquent pas d’erreur.

💡 À retenir

Les listes en Python sont des séquences ordonnées et hétérogènes, encadrées par des crochets, permettant une manipulation flexible des objets, y compris la création de listes imbriquées et l’extraction de sous-listes par slicing.

📖 2. Indexation et slicing

🔑 Notions clés & Définitions

Indexation : L’indexation consiste à accéder à un élément précis d’une liste en utilisant sa position. En Python, chaque élément d’une liste est identifié par un indice, qui indique sa position dans la liste.

Indice zéro-based : En Python, la numérotation des éléments d’une liste commence à 0. Le premier élément se trouve à l’indice 0, le second à l’indice 1, etc. Cela permet une manipulation cohérente et efficace des listes.

Slicing : Le slicing est une opération permettant d’extraire une sous-liste à partir d’une liste initiale, en spécifiant un indice de début, un indice de fin et éventuellement un pas. La syntaxe est ListName[i:j:k], où i est l’indice de départ (inclus), j l’indice de fin (exclu), et k le pas.

Sous-liste : La sous-liste est le résultat du slicing, c’est une nouvelle liste contenant une sélection d’éléments de la liste d’origine, selon les indices et le pas spécifiés.

Pas dans slicing : Le pas (k) dans le slicing détermine la fréquence à laquelle les éléments sont sélectionnés. Par exemple, k=2 sélectionne tous les deux éléments. Si k n’est pas précisé, il vaut 1 par défaut.

📝 Points essentiels

• Les indices des listes commencent à 0 en Python. Cela signifie que le premier élément d’une liste est accessible via l’indice 0, le second via l’indice 1, etc.
• La syntaxe ListName[index] permet d’accéder à un élément précis ou de le modifier directement.
• Le slicing ListName[i:j:k] extrait une sous-liste allant de l’indice i (inclu) à l’indice j (exclu), en sautant k éléments selon le pas. Par exemple, ListName[1:4:2] sélectionne les éléments aux indices 1 et 3.
• Lorsqu’on utilise des tranches (slicing), les dépassements d’indices ne provoquent pas d’erreur. Si i ou j dépassent la taille de la liste, Python ajuste automatiquement la plage sans erreur.

💡 À retenir

Maîtriser l’accès aux éléments et sous-ensembles d’une liste grâce à l’indexation et au slicing permet une manipulation précise et efficace des données, même en cas de dépassement d’indices.

📖 3. Listes imbriquées et matrices

🔑 Notions clés & Définitions

• Liste imbriquée : Structure composée de listes à l’intérieur d’autres listes, permettant de représenter des données bidimensionnelles ou plus complexes. AUCUN auteur ou définition spécifique n’est fourni dans le contenu source.
• Matrice : Représentation d’un tableau à deux dimensions sous forme d’une liste de listes, où chaque sous-liste correspond à une ligne de la matrice. AUCUN auteur ou définition spécifique n’est fourni dans le contenu source.
• len() pour dimensions : Fonction qui retourne le nombre d’éléments dans une liste ou sous-liste. AUCUN auteur ou définition spécifique n’est fourni dans le contenu source.
• Nombre de lignes : Donnée par len(A), où A est une matrice, correspondant au nombre de sous-listes (lignes). AUCUN auteur ou définition spécifique n’est fourni dans le contenu source.
• Nombre de colonnes : Donnée par len(A[0]), correspondant au nombre d’éléments dans la première sous-liste (colonnes). AUCUN auteur ou définition spécifique n’est fourni dans le contenu source.

📝 Points essentiels

• Une matrice est représentée par une liste de listes (listes imbriquées). Chaque sous-liste représente une ligne de la matrice, facilitant la manipulation bidimensionnelle.
• len(A) donne le nombre de lignes d’une matrice A, c’est-à-dire le nombre de sous-listes qu’elle contient.
• len(A[0]) donne le nombre de colonnes de la matrice A, c’est-à-dire le nombre d’éléments dans la première sous-liste.

💡 À retenir

Une matrice peut être visualisée comme une liste imbriquée, où len() permet d’obtenir ses dimensions : le nombre de lignes avec len(A) et le nombre de colonnes avec len(A[0]).

📖 4. Fonctions et méthodes listes

🔑 Notions clés & Définitions

• Opérations in et not in :

• AUTEUR : voir section 1

• Fonctions sum, len, max, min, sorted, reversed :
  AUTEUR (date) :

  • sum(a) calcule la somme des éléments numériques de la liste a.
  • len(a) donne le nombre d’éléments dans a.
  • max(a) retourne l’élément le plus grand.
  • min(a) retourne l’élément le plus petit.
  • sorted(a) trie la liste a et retourne une nouvelle liste triée, sans modifier a.
  • reversed(a) retourne un itérateur qui parcourt la liste a dans l’ordre inverse.

• Méthodes append, extend, insert, remove, pop, index, count, sort, reverse :
  AUTEUR (date) :

  • a.append(x) ajoute l’élément x en fin de liste a.
  • a.extend(b) concatène la liste b à a en ajoutant ses éléments.
  • a.insert(i, x) insère x à la position i dans a.
  • a.remove(x) supprime la première occurrence de x dans a.
  • a.pop() retire et retourne le dernier élément de a.
  • a.index(x) retourne la position de la première occurrence de x dans a.
  • a.count(x) compte le nombre d’occurrences de x dans a.
  • a.sort() trie la liste a en place, avec options key et reverse.
  • a.reverse() inverse l’ordre des éléments de a.

• Opérations + et * sur listes :
  AUTEUR (date) :

  • a + b concatène deux listes a et b pour produire une nouvelle liste.
  • a * n répète la liste a n fois, créant une nouvelle liste.

📝 Points essentiels

• La vérification de la présence d’un élément x dans une liste a s’effectue avec x in a ; si x est dans a, l’opération retourne True, sinon False. La négation not in teste l’absence de x dans a.
• La fonction sum(a) calcule la somme des éléments numériques de la liste a.
• La méthode a.append(x) permet d’ajouter efficacement un élément x à la fin de la liste a.
• La méthode a.sort() trie la liste en place, avec la possibilité d’utiliser des options key pour préciser le critère de tri et reverse pour inverser l’ordre.
• Les opérations + et * permettent respectivement de concaténer deux listes et de répéter une liste un certain nombre de fois, facilitant la manipulation et la création de listes complexes.

💡 À retenir

Exploiter pleinement les fonctions, méthodes et opérations sur listes permet de manipuler efficacement ces structures, en réalisant des tris, des recherches, des ajouts ou des répétitions de manière concise et performante.

📖 5. Copie de listes

🔑 Notions clés & Définitions

Référence de liste : La référence d’une liste désigne le lien ou l’adresse mémoire pointant vers cette liste. Elle permet d’accéder ou de modifier la liste sans en créer une nouvelle.

Copie superficielle : La copie superficielle (shallow copy) d’une liste crée une nouvelle liste, mais ne duplique pas les objets imbriqués. Elle copie uniquement la structure de la liste principale, tandis que les éléments imbriqués restent liés à l’original.

Copie profonde (deepcopy) : La deepcopy crée une copie indépendante de toute la structure de la liste, y compris tous ses objets imbriqués. Elle assure qu’aucun lien ne subsiste entre la liste originale et la copie.

Alias de liste : Un alias est une autre référence pointant vers la même liste. Modifier l’un affecte l’autre, car ils désignent la même structure mémoire.

📝 Points essentiels

• L’affectation b = a crée une référence, pas une copie indépendante. Ainsi, b et a désignent la même liste en mémoire.
• Modifier b modifie aussi a si b est une référence à a. Toute modification sur l’un impacte l’autre, car ils sont des alias.
• deepcopy crée une copie indépendante d’une liste imbriquée. Elle duplique tous les niveaux de la structure, évitant ainsi tout effet de bord lors de modifications ultérieures.
• Une liste fonctionne comme un carnet d’adresses des objets qu’elle contient. Elle référence chaque objet, mais ne contient pas nécessairement une copie de ces objets.

💡 À retenir

Différencier clairement référence et copie est essentiel pour éviter les effets de bord lors de la manipulation des listes. La copie profonde garantit une indépendance totale, contrairement à la simple référence ou copie superficielle.

📖 6. Tuples immuables

🔑 Notions clés & Définitions

Tuple : Un tuple est une séquence ordonnée d’objets encadrée par des parenthèses. Il permet de stocker plusieurs valeurs dans une seule variable, tout en conservant leur ordre.

Immuabilité : La propriété selon laquelle un objet ne peut pas être modifié après sa création. Dans le cas du tuple, cela signifie que ses éléments ne peuvent pas être changés ou supprimés une fois le tuple créé.

Parenthèses : Les parenthèses sont utilisées pour délimiter un tuple, différenciant sa syntaxe de celle des listes (qui utilisent des crochets). La présence de parenthèses indique que la structure est un tuple.

Hétérogénéité : Un tuple peut contenir des objets de types différents. Par exemple, un tuple peut contenir un entier, une chaîne de caractères et un autre tuple.

• Séquence ordonnée : voir section 1

📝 Points essentiels

• Un tuple est une séquence ordonnée d’objets encadrée par des parenthèses. La syntaxe ressemble à celle des listes, mais utilise des parenthèses pour délimiter le tuple.
• Les tuples ne peuvent pas être modifiés après création (immuables). Cela garantit l’intégrité des données stockées.
• Un tuple peut contenir des objets de types différents, ce qui offre une grande flexibilité dans la gestion de données hétérogènes.
• La syntaxe est similaire à celle des listes, mais la différence majeure réside dans l’utilisation des parenthèses pour définir un tuple.

💡 À retenir

Les tuples sont des séquences immuables qui garantissent l’intégrité des données en empêchant toute modification après leur création, tout en permettant de stocker des objets hétérogènes dans un ordre précis.

📖 7. Générateur range

🔑 Notions clés & Définitions

range | | Aucune définition spécifique fournie dans le contenu source.

Itérateur | | Aucune définition spécifique fournie dans le contenu source.

Génération paresseuse | | Aucune définition spécifique fournie dans le contenu source.

Séquence d’entiers | | Aucune définition spécifique fournie dans le contenu source.

📝 Points essentiels

• La fonction range crée un itérateur qui génère des entiers à la demande, sans stocker toute la séquence en mémoire.
• Elle est plus efficace en mémoire que la création d’une liste d’entiers, car elle ne conserve pas tous les éléments simultanément.
• range peut être utilisée dans des boucles pour parcourir des indices ou des valeurs entières, facilitant la gestion de séquences d’entiers sans surcharge mémoire.

💡 À retenir

Utiliser range permet de générer efficacement des séquences d’entiers sans surcharge mémoire, en produisant les valeurs à la demande lors de leur utilisation dans des boucles.

📅 Repères chronologiques

(aucune date explicite dans le contenu fourni, cette section est omise)

📊 Tableaux de Synthèse

⚠️ Pièges & Confusions Fréquentes

1. Confondre l’indice 0 avec l’indice 1 lors de l’accès aux éléments.
2. Oublier que la syntaxe slicing n’engendre pas d’erreur même si les indices dépassent la taille de la liste.
3. Utiliser une syntaxe incorrecte pour le slicing (ex: oublier le pas ou mal positionner les deux points).
4. Confondre liste imbriquée et matrice sans distinguer leur structure (liste de listes).
5. Modifier une liste avec une méthode qui change la liste en place (ex: sort()) sans en faire attention.
6. Tenter d’accéder à un indice hors limite sans utiliser de slicing.
7. Confondre concaténation (+) et répétition (*), ou mal utiliser ces opérations.

✅ Checklist Examen

1. Connaître la définition d’une liste selon l’auteur (suite d’objets rangés dans un ordre).
2. Maîtriser la syntaxe pour accéder à un élément via l’indice [index].
3. Savoir utiliser le slicing avec ListName[i:j:k] et comprendre le comportement en cas de dépassement d’indices.
4. Identifier une liste imbriquée comme une liste contenant d’autres listes.
5. Connaître la différence entre len() pour dimensions et la manipulation des listes.
6. Savoir créer une matrice sous forme de liste de listes et accéder à ses éléments.
7. Maîtriser l’utilisation des fonctions sum(), max(), min(), sorted() et reversed().
8. Connaître les méthodes append(), extend(), insert(), remove(), pop(), index(), count(), sort() et reverse().
9. Comprendre l’effet des opérations + (concaténation) et * (répétition) sur les listes.
10. Savoir vérifier si un élément x appartient à une liste a avec x in a.
11. Être capable d’utiliser a.sort() avec des options key et reverse.
12. Connaître que la manipulation des listes est flexible grâce aux méthodes et opérations disponibles.