Chap. 09 — Structures de données, les séquences 1 : listes et tuples

Chap. 09 — Structures de données, les séquences 1 : listes et tuplesLes séquencesPrésentationModèle d'accès aux séquencesOpérateurs des types séquentielsConcaténationRépétitionAppartenanceDécoupageFonctions intégrées du language Python qui agissent sur les séquencesConversion de typesFonctions opérant sur les types séquentielsParcours des séquencesParcours en utilisant directement les élémentsParcours en utilisant les indicesParcours en utilisant les indices et les élémentsLes listesPrésentationPremières manipulationsComment créer et affecter une liste à une variable ?Comment accéder aux données stockées dans une liste ?Comment modifier une liste ?Action des opérateurs des types séquentiels sur les listesAction des fonctions intégrées du language Python sur les listesQuelques méthodes spécifiques aux listesPrésentationComment accéder à la liste de ces méthodes ?Liste des méthodesUne méthode particulière et très efficace de création de listes : compréhension de listeLes tuplesPrésentationPremières manipulationsComment créer et affecter un tuple à une variable ?Comment accéder aux éléments d'un tuple ?Action des opérateurs des types séquentiels sur les tuplesAction des fonctions intégrées du language Python sur les tuplesExercicesExercice 1. Introduction à l'utilisation des listesExercice 2Exercice 3Exercice 4Exercice 5Exercice 6Exercice 7Exercice 8


Les séquences

Présentation

Les séquences forment un groupe de structures de données au sein desquelles les éléments sont ordonnés séquentiellement et sont accessibles via des indices.

On appelle ce groupe séquences car, d'un point de vue logique, les structures qui le composent sont « des suites » d'éléments. Par exemple, une chaîne de caractères est une séquence de caractères : le premier caractère de la chaîne "Bonjour" est le 'B', le deuxième le 'o', le troisième 'n', etc.

Toutes les séquences possèdent des caractéristiques, des opérateurs en commun. De même, certaines fonctions natives du langage Python agissent de la même façon sur toutes les séquences. Dans cette partie, nous allons donc essayer de faire émerger tout ce qui est commun à toutes les séquences.

Remarque. Dans toute cette section, les séquences seront repérées par le mot générique seq. Nous adapterons ce mot, par la suite, en fonction de la structure (chaîne de caractères, liste, tuple).

Modèle d'accès aux séquences

Les types séquentiels partagent tous le même modèle d'accès : ce sont des structures ordonnées au sein desquelles on accède aux éléments à partir d'indices.

Le schéma ci-dessous illustre le mode de stockage et d'accès aux éléments d'une séquence. est la longueur de la séquence ; les indices varient donc de 0 à .

im1

En Python,

Opérateurs des types séquentiels

OpérationOpérateurFonction
Découpage, un seul élémentseq[i]Élément de la séquence situé à l'indice
Découpage, trancheseq[i:j]Éléments de la séquence situés de l'indice à l'indice
Répétitionseq * nLa séquence est répétée (entier) fois
Concaténationseq1 + seq2Création d'une nouvelle séquence, résultat de la concaténation des séquences seq1 et seq2
Appartenanceelt in seqTeste si elt est membre de la séquence seq
Appartenanceelt not in seqTeste si elt n'est pas membre de la séquence seq

Concaténation

Répétition

Appartenance

Découpage

Attention ! Cette partie est Hors-Programme, elle n'est ici présente qu'à titre documentaire. Vous pourrez utiliser ces notions dans vos programmes mais elles ne feront jamais parti des contrôles.

Fonctions intégrées du language Python qui agissent sur les séquences

Conversion de types

Les fonctions list, str et tuple permettent de convertir n'importe quel type séquentiel en un autre.

FonctionOpération
list(seq)Convertit la séquence en liste
str(obj)Convertit l'objet en chaîne (représentation affichable)
tuple(seq)Convertit la séquence en tuple

Fonctions opérant sur les types séquentiels

FonctionOpération
enumerate(seq)Accepte une séquence et retourne un tuple à deux éléments (indice, élément) de seq
len(seq)Retourne la longueur (le nombre d'éléments) de seq
max(seq)Retourne le plus grand élément de seq
min(seq)Retourne le plus petit élément de seq
reversed(seq)Parcourt la séquence en ordre inverse
sorted(seq)Accepte une séquence et retourne une liste triée (des arguments optionnels permettent de choisir le type de tri)
sum(seq)Retourne la somme des nombres de seq
zip(seq0, seq1, ..., seqN)Retourne une liste de tuples dont les éléments sont membres de chaque séquence transmise, c'est à dire [(it0[0],it1[0],...itN[0]), (it0[1],it1[1],...itN[1]), ...(it0[N],it1[N],...itN[N])]

Parcours des séquences

La boucle Pour chaque (instruction for) parcourt les éléments d'une séquence et se termine quand tous les éléments sont épuisés. Sa syntax est :

Parcours en utilisant directement les éléments
Parcours en utilisant les indices

Remarque. Le parcours par élément est plus performant en Python que le parcours par indice.

Parcours en utilisant les indices et les éléments

On prend très vite l'habitude d'utiliser le parcours par élément, lorsqu'on souhaite extraire les éléments d'une séquence. Il est cependant parfois utile de récupérer en même temps l'indice de l'élément. La fonction intégrée enumerate permet de réaliser ces deux opérations en une seule instruction :

Les listes

Présentation

Les listes sont des objets conteneurs pouvant contenir un nombre arbitraire et modifiable d'objets Python différents.

Premières manipulations

Comment créer et affecter une liste à une variable ?

L'opération est identique à celle de l'affection d'un littéral entier à une variable : création de la liste et affectation de l'objet nouvellement créé à une variable.

Comment accéder aux données stockées dans une liste ?

Le découpage fonctionne comme pour toutes les séquences, on utilise l'opérateur de découpage [] avec le ou les indices.

Remarque. On rappelle que les tranches ne sont pas au programme : les instructions une_liste[1:3] et une_liste[:3] sont donc présentes à titre documentaire.

Comment modifier une liste ?

On modifie un ou plusieurs éléments d'une liste en spécifiant une « tranche » à gauche de l'opérateur d'affectation= et la ou les nouveaux objets à droite de cet opérateur.

Remarque. On rappelle que les tranches ne sont pas au programme : l'instruction une_liste[0:2] = ['remplace int', 'remplace string'] est donc présente à titre documentaire.

Attention ! Les listes étant des structures modifiables, il est souvent préférable d'utiliser l'une des nombreuses méthodes décrites à la section 2.3.

Action des opérateurs des types séquentiels sur les listes

Tous les opérateurs des types séquentiels présentés dans la première section de ce chapitre s'appliquent aux listes.

Attention ! a + b n'est pas équivalent à a += b comme on peut le voir dans l'exemple précédent. La première instruction crée une nouvelle liste alors que la seconde modifie la liste référencée par la variable à gauche de l'opérateur d'affectation. En fait, a += b est équivalent à a.extend(b).

Action des fonctions intégrées du language Python sur les listes

Toutes les fonctions des types séquentiels présentées dans la première section de ce chapitre s'appliquent aux listes.

Quelques méthodes spécifiques aux listes

Présentation

Les listes, en Python, possèdent des méthodes. Une méthode, concept de la programmation objet, peut être considérée comme une fonction (ou une procédure) s'appliquant à un objet spécifique. Les méthodes décrites dans cette section se comportent donc exactement comme des fonctions intégrées qui n'opéreraient que sur des listes.

Comment accéder à la liste de ces méthodes ?

Liste des méthodes

MéthodeOpération
liste.append(obj)Ajoute obj à la fin de liste
liste.count(obj)Retourne le nombre d'occurences de obj dans liste
liste.extend(seq)Ajoute le contenu de la séquence seq à la fin de liste
liste.index(obj)Par défaut retourne l'indice de la première occurence deobj
liste.insert(index, obj)Insère obj dans liste à la position index
liste.pop()Supprime et retourne le dernier élément de la liste
liste.remove(obj)Supprime obj de la liste
liste.reverse()Inverse les objets de la liste, en place
liste.sort()Trie les membres de la liste

Les méthodes des objets modifiables qui modifient l'objet n'ont pas de valeur de retour.

Attention !!! Une erreur courante consiste à écrire : music_media = music_media.sort(). L'instruction music_media référence alors l'objet None, car la méthode sort ne retourne rien !!!

La façon correcte d'utiliser ces méthodes consiste à les appeler sur les objets, sans réaliser d'affectation.

Une méthode particulière et très efficace de création de listes : compréhension de liste

Le langage Python met à disposition une méthode efficace, concise et claire pour créer des listes que nous aborderons à travers des exemples.

Les tuples

Présentation

Les tuples (ou n-uplets en français) sont des objets conteneurs pouvant contenir un nombre arbitraire et non modifiable d'objets Python différents.

De nombreux points communs existent donc entre les tuples et les listes. La grande différence est le caractère modifiable ou pas.

Premières manipulations

Comment créer et affecter un tuple à une variable ?

La création et l'affectation de tuples sont pratiquement identiques à celles des listes, à l'exception des tuples ne contenant qu'un seul élément.

Attention. Pour Python ce qui fait la spécificité d'un tuple, ce ne sont pas les parenthèses mais la virgule.

Comment accéder aux éléments d'un tuple ?

Remarque. On rappelle que les tranches ne sont pas au programme : l'instruction un_tuple[1:4] est donc présente à titre documentaire.

Action des opérateurs des types séquentiels sur les tuples

Tous les opérateurs des types séquentiels présentés dans la première section de ce chapitre s'appliquent aux tuples.

Action des fonctions intégrées du language Python sur les tuples

Toutes les fonctions des types séquentiels présentées dans la première section de ce chapitre s'appliquent aux tuples.

Exercices

Exercice 1. Introduction à l'utilisation des listes

  1. Décrire l'action de chacune des instructions.
  2. Comparer les trois dernières structures de boucles.

Solution
  1. [1, 0, 0, 0, 0, 0, 0]
  2. [1, 3, 5, 7, 9, 11, 13]
  3. 
    Valeur 0 : 1
    Valeur 1 : 3
    Valeur 2 : 5
    Valeur 3 : 7
    Valeur 4 : 9
    Valeur 5 : 11
    Valeur 6 : 13
                    
  4. 
    Valeur : 1
    Valeur : 3
    Valeur : 5
    Valeur : 7
    Valeur : 9
    Valeur : 11
    Valeur : 13
                    
  5. 
    Valeur 0 : 1
    Valeur 1 : 3
    Valeur 2 : 5
    Valeur 3 : 7
    Valeur 4 : 9
    Valeur 5 : 11
    Valeur 6 : 13
                    

Exercice 2

Écrire une fonction qui reçoit comme argument une liste de nombres à virgule et recherche lequel est le plus grand et lequel est le plus petit.


Solution

Exercice 3

Écrire une fonction qui reçoit comme argument une liste et détermine le nombre d'éléments dans la liste. Ne pas utiliser la fonction len du langage.


Solution

Exercice 4

Écrire une fonction qui simule le tirage du Loto. Pour rappel, il s'agit de tirer aléatoirement 6 entiers compris entre 1 et 49.

Remarque. Un numéro ne peut apparaître qu'une seule fois. Il est donc nécessaire de stocker le résultat de chaque tirage dans une liste et de vérifier s'il est présent ou pas.


Solution

Exercice 5

Écrire une fonction qui reçoit une liste de notes comprises entre 0 et 20 comme argument et retourne la moyenne de ces notes et le pourcentage de ces notes comprises dans les intervalles : , et est la valeur moyenne des notes.

La signature de la fonction est :

Cette fonction doit utiliser les deux fonctions de signature :

et


Solution

Exercice 6

Écrire une fonction qui, partir de deux points de l'espace à trois dimensions, calcule la distance euclidienne entre ces deux points. Remarque. Les coordonnées d'un point sont stockées dans un tuple.

La signature de la fonction est :


Solution

Exercice 7

Reprendre l'exercice précédent et considérer que les points appartiennent à un espace de dimension ( étant potentiellement grand).


Solution

Exercice 8

Écrire une fonction qui retourne une la table de multiplication de tous les nombres entiers compris entre 0 et n.

La spécification de la fonction est :


Solution