Python : tuples et listes
Numérique et sciences informatiques
Les séquences en Python
En python, une séquence est une collection ordonnées d'objets qui permet d'accéder à ses éléments par leur numéro de position dans la séquence.
Une séquence est un objet capable de contenir d'autres objets de n'importe quel type. De façon plus précise, nous définirons une séquence comme un ensemble fini et ordonné d'éléments indicés (l'index) de 0 à n-1 (si cette séquence comporte n éléments).
Les listes et les tuples sont des séquences.
p-uplets : Les listes
Une liste est une variable à part entière (de type list). On parle de structure de données ou bien d’objet
conteneur : un objet qui en contient d’autres. Ce peut être des entiers, des réels, des listes, etc…
L’utilisation des listes est très répandue en Python car celles-ci sont modifiables (mutables). Les listes
sont définies entre 2 crochets et les items sont séparés par une virgule.
# Création d'une liste par duplication
liste_de_zeros = [0] * 10
print(liste_de_zeros)
# Création d'une liste avec duplication d'éléments de types différents
liste_3_123 = [1, "toto", 3] * 3
print(liste_3_123)
# Création d'une liste vide
liste_vide = []
print("Une liste vide :", liste_vide)
# Création d'une liste de nombres de différents types
liste_nombres = [2, 10, 5 // 3, 7.2, 8, 2.0]
print("Ma liste :", liste_nombres)
print("Longueur de ma liste :", len(liste_nombres)) # Utilisation de la méthode len()
# Parcours des éléments avec une boucle sur les indices
print('Parcours des éléments avec une boucle sur les indices :')
for i in range(len(liste_nombres)):
print(liste_nombres[i], end=', ')
print('\n')
# Parcours des éléments avec une boucle sans les indices
print('Parcours des éléments avec une boucle sans les indices :')
for element in liste_nombres:
print(element, end='; ')
print('\n')
| L'index d'une liste a deux sens | liste_nombres[-6] |
|---|---|
| exemple avec une chaîne de lettres | S c i e n c e s |
| Position depuis 0 | 0 1 2 3 4 5 6 7 |
| Position depuis la fin | -8 -7 -6 -5 -4 -3 -2 -1 |
# Exemple Python
planetes = ['Mercure', 'Vénus', 'Terre', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune']
# Accéder à un élément en utilisant l'index négatif
print("L'élément à l'index -6 est : ", planetes[-6])Concaténer les listes
Pour concaténer deux listes en Python, la méthode la plus simple est d'utiliser l'opérateur +. Cela permet de combiner les éléments de deux listes en une seule.
Supposons que nous ayons deux listes, une pour les planètes telluriques et une pour les planètes gazeuses :
tellurique = ["Mercure", "Vénus", "Terre", "Mars"]
gazeuse = ["Jupiter", "Saturne", "Uranus", "Neptune"]
La concaténation de ces deux listes se fait simplement en utilisant l'opérateur + :
planetes = tellurique + gazeuse
print(planetes)
# ['Mercure', 'Vénus', 'Terre', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune']
Le résultat est une nouvelle liste appelée planetes qui contient tous les éléments des listes tellurique et gazeuse.
Il est important de noter que cette opération ne modifie pas les listes d'origine, mais crée une nouvelle liste contenant les éléments des deux listes concaténées.
Modification des éléments dans une liste
Les éléments d'une liste sont mutables (modifiables), ce qui constitue une différence fondamentale avec une autre structure, les tuples, que nous verrons ultérieurement.
planetes.append("Pluton")
print(planetes)
# ['mercure', 'Vénus', 'Terre', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune', 'Pluton']
La méthode append() permet d'ajouter un élément à la fin de la liste.
planetes[2] = "La planète Bleue" # Pour modifier le 3ème élément de la liste
print(planetes)
# ['mercure', 'Vénus', 'La planète Bleue', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune', 'Pluton']
La méthode remove() supprime le premier élément de la liste correspondant à l'élément passé en argument. Cela peut poser problème s'il y en a plusieurs occurrences.
planetes.remove("Pluton")
print(planetes)
# ['mercure', 'Vénus', 'La planète Bleue', 'Mars', 'Jupiter', 'Saturne', 'Uranus', 'Neptune']
liste = [2, 10, 5 // 3, 7.2, 8, 2.0]
liste.remove(2.0)
print(liste)
# [10, 1, 7.2, 8, 2.0] # Seul le premier 2 est supprimé !
Copier une liste
Pour créer une copie indépendante d'une liste, il est préférable d'utiliser la méthode copy(). L'utilisation du simple signe d'égalité (=) ne garantit pas une copie distincte.
liste_originale = [5, 10, 15]
copie_liste = liste_originale.copy()
# Modifions la liste originale
liste_originale[0] = 2
# Affichons les deux listes pour comprendre la différence
print("Liste originale :", liste_originale)
print("Copie de la liste :", copie_liste)
# Liste originale : [2, 10, 15]
# Copie de la liste : [5, 10, 15]
Ici, nous avons une liste appelée liste_originale, puis nous utilisons la méthode copy() pour créer une copie appelée copie_liste. En modifiant un élément dans la liste originale, nous pouvons voir que la copie reste inchangée, ce qui démontre l'indépendance des deux listes.
Liste par compréhension
La liste par compréhension est une manière concise et élégante de créer des listes en Python. Elle permet de générer une liste en utilisant une expression pour définir ses éléments, souvent combinée avec une boucle.
matiere = "Numérique"
tableau = [lettre for lettre in matiere]
print("Liste des lettres dans la matière :", tableau)
# Liste des lettres dans la matière : ['N', 'u', 'm', 'é', 'r', 'i', 'q', 'u', 'e']
carres_pairs = [k**2 for k in range(10) if k**2 % 2 == 0] # 'if' permet une sélection à la création
print("Carrés des nombres pairs jusqu'à 10 :", carres_pairs)
# Carrés des nombres pairs jusqu'à 10 : [0, 4, 16, 36, 64]
Dans l'exemple ci-dessus, la première liste est créée en parcourant chaque lettre de la chaîne de caractères "Numérique". La deuxième liste, carres_pairs, est créée en générant les carrés des nombres pairs jusqu'à 10 en utilisant une condition avec l'instruction if.
Tableaux à plusieurs dimensions : listes de listes
Les tableaux à plusieurs dimensions, souvent représentés par des listes de listes en Python, sont utiles pour stocker des données structurées sous forme de grilles. Chaque liste interne peut être considérée comme une ligne du tableau.
tableau_2D = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Accéder à une ligne entière
print("Deuxième ligne du tableau :", tableau_2D[1])
# Accéder à un élément spécifique
print("Élément à la troisième ligne, deuxième colonne :", tableau_2D[2][1])
# Deuxième ligne du tableau : [4, 5, 6]
# Élément à la troisième ligne, deuxième colonne : 8
Dans cet exemple, tableau_2D est une liste de listes représentant un tableau à deux dimensions. Vous pouvez accéder à des lignes entières ou à des éléments spécifiques en utilisant des indices.
Les parties de listes : le slicing
Le découpage d'une liste, également appelé "slicing", permet d'extraire des parties spécifiques d'une liste en utilisant des indices. C'est une fonctionnalité puissante pour manipuler et travailler avec des sous-ensembles de données.
ma_liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Extraire les cinq premiers éléments (de l'indice 0 à l'indice 4 inclus)
print("Les cinq premiers éléments :", ma_liste[:5])
# Extraire les éléments à partir de l'indice 5 jusqu'à la fin
print("Les éléments à partir de l'indice 5 :", ma_liste[5:])
# Extraire les éléments de l'indice 2 à l'indice 5 (exclus)
print("Les éléments de l'indice 2 à l'indice 5 :", ma_liste[2:4])
# Extraire les éléments en sautant un élément (pas de 2)
print("Les éléments en sautant un élément :", ma_liste[::2])
# Extraire les éléments en sautant un élément en sens inverse
print("Les éléments en sautant un élément en sens inverse :", ma_liste[::-2])
Résumé de cours sur les tableaux
| Méthode | Description |
|---|---|
del ma_liste[n] |
Supprime l'élément à la position n dans ma_liste. |
ma_liste.pop(2) |
Supprime l'élément à la position spécifiée (la valeur par défaut est -1, le dernier élément de la liste). |
ma_liste.remove("a") |
Supprime la première occurrence de la valeur "a" dans ma_liste. |
ma_liste.count("a") |
Compte le nombre d'occurrences de "a" dans ma_liste. |
ma_liste.index("a") |
Retourne la première position de l'élément "a" dans ma_liste. |
ma_liste1 + ma_liste2 |
Concatène les éléments de ma_liste1 à ma_liste2. |
ma_liste[-1] |
Retourne le dernier élément de ma_liste. |
ma_liste[:n] |
Retourne la sous-liste des n premiers éléments de ma_liste. |
ma_liste[n:] |
Retourne la sous-liste privée des n premiers éléments de ma_liste. |
ma_chaine.split(",") |
Transforme une chaîne de caractères ma_chaine en une liste en utilisant la virgule comme séparateur. |
len(ma_liste) |
Compte le nombre d'éléments dans ma_liste. |
ma_liste.append(elt) |
Ajoute l'élément elt à la fin de ma_liste. |
for element in ma_liste : |
La boucle for parcourt les éléments de ma_liste. |
ma_liste[i] |
Accède à l'élément de ma_liste d'indice i. |
ma_liste[] |
Crée une liste vide ma_liste. |
ma_liste.sort() |
Trie la liste ma_liste dans l'ordre croissant ou alphabétique. |
ma_liste.reverse() |
Inverse l'ordre des éléments de la liste ma_liste. |
Les tuples en Python
Les tuples, également appelés « n-uplets » en français, sont similaires aux listes, à la différence qu'ils sont non modifiables (non mutables) : on ne peut ni réaffecter leurs éléments ni en ajouter de nouveaux. Si vous essayez de modifier un tuple existant, l'interpréteur Python générera une erreur. Contrairement aux listes qui peuvent être modifiées, notamment lors de la copie, les tuples résolvent ce problème en étant immuables. En pratique, ils utilisent des parenthèses au lieu des crochets. Comme mentionné précédemment, un tuple est une séquence. Voici un exemple simple :
mon_tuple = (19, 10, 2, 9, 6)Entraînement 1: Salle sur demande
- Initialisation de la salle : Créez une liste vide appelée salle_sur_demande pour représenter la salle.
- Ajout d’objets à la salle : Écrivez une fonction ajouter_a_salle(objet) qui prend un paramètre objet (une chaîne de caractères) et l’ajoute à la salle.
- Affichage du contenu de la salle : Écrivez une autre fonction afficher_salle() pour afficher le contenu actuel de la salle.
- Suppression d’un objet : Ajoutez une fonction retirer_de_salle(objet) qui permet de retirer un objet de la salle.
- Vérifier le bon fonctionnement de vos fonctions avec par exemples les objets suivants : le choixpeau magique
# Exemples d'utilisation ajouter_a_salle("Épée de Gryffondor") ajouter_a_salle("Maraudeur's Map") ajouter_a_salle("Vif d'or") afficher_salle()
Entraînement 2: Alternance d'un sur deux
- Écrivez une fonction appelée afficher_un_sur_deux(personnages)qui prend en paramètre la liste des personnages et affiche uniquement les élèves présents à un sur deux. Utilisez la liste suivante des personnages d'Harry Potter :
personnages = [ "Harry Potter", "Draco Malfoy", "Hermione Granger", "Luna Lovegood", "Ron Weasley", "Cho Chang", "Ginny Weasley", "Cedric Diggory", "Neville Longbottom", "Pansy Parkinson", "Fred Weasley", "Seamus Finnigan", ] - Testez votre fonction avec la liste fournie et assurez-vous qu'elle affiche correctement les élèves en alternance d'un sur deux.
Entraînement 3: Alternance d'un sur trois
- Écrivez une fonction appelée afficher_un_sur_deux(personnages)qui prend en paramètre la liste des personnages et affiche uniquement les élèves présents à un sur trois. Utilisez la liste suivante des personnages d'Harry Potter :
personnages = [ "Harry Potter", "Draco Malfoy", "Luna Lovegood", "Hermione Granger", "Ron Weasley", "Cho Chang", "Ginny Weasley", "Cedric Diggory", "Pansy Parkinson", "Neville Longbottom", "Fred Weasley", "Seamus Finnigan", ] - Testez votre fonction avec la liste fournie et assurez-vous qu'elle affiche correctement les élèves en alternance d'un sur trois.
Entraînement 4: Recherche de notes supérieures à 17
Hermione a obtenu des notes dans plusieurs matières. Complétez la fonction appelée recherche_notes_superieures(note) qui prend en paramètre une liste de notes et renvoie le nombre de notes supérieures à 17.
notes_hermione = [16, 18, 15, 20, 17, 19, 14, 18, 16]
def recherche_notes_superieures(liste_notes):
"""
Recherche le nombre de notes supérieures à 17 dans une liste.
Paramètre: liste_notes de type list
Return : compteur de type int
"""
compteur = ...
for elt in ... :
if elt > ... :
compteur = ... + 1
return ...
# une solution
# notes_sup_17 = [note for note in liste_notes if note > 17] # par compréhension (pas forcément le plus simple)
Entraînement 5: Manipulation de Listes dans le Monde de Harry Potter
Considérons une liste de points attribués à différentes maisons à Poudlard. Utilisez la liste suivante :
points_maisons = [200, 123, 14, 18, 6, 19]- Que renvoie les instructions suivantes ?
- len(points_maisons)
- points_maisons[1]
- points_maisons[3]
- points_maisons[6]
- . Que devient la liste points_maisons si on saisit l’instruction points_maisons[1] = 12 ?
Entraînement 6: Construire une liste des prénoms
Construisez une fonction nommée filtrer_prenoms_nsi qui prend une liste de prénoms en paramètre et renvoie une nouvelle liste contenant uniquement les prénoms de 5 lettres ou moins.
prenoms_harry_potter = ["harry", "hermione", "ron", "ginny", "luna","neville",
"draco", "cho", "fred", "george", "albus",
"severus", "nymphadora", "remus", "minerva"]Entraînement 7 : Fonction d'Échange d'Éléments
Draco Malfoy a besoin de votre aide pour créer une fonction qui l'aidera à tromper Hermione Granger lors des cours de potion. Complétez et testez la fonction nommée echange_element qui prend en argument une liste L, ainsi que deux entiers naturels i et j, et renvoie une nouvelle liste où les éléments d'indices i et j de L ont été permutés, si ces indices existent.
def echange_element(L, i, j):
"""
Échange les éléments d'indices i et j dans une liste L.
Parameters:
- L ( ... ): Liste d'éléments.
- i ( ... ): Indice du premier élément.
- j ( ... ): Indice du deuxième élément.
Returns:
list: Liste modifiée avec les éléments d'indices i et j échangés.
"""
# Vérifier si les indices i et j sont valides
if 0 <= i < ... and 0 <= j < ...:
# Échanger les éléments d'indices i et j
temp = L[...]
L[i] = ...
L[j] = ...
return L
# Exemple d'utilisation pour tromper Hermione
liste_potions = ["Potion de Sommeil", "Polynectar", "Felix Felicis", "Draught of Living Death", "Amortentia"]
# Draco trompe Hermione en échangeant la Potion de Sommeil avec Felix Felicis
liste_modifiee = echange_element(liste_potions, 0, 2)
# Affichage du résultat
print("Liste après l'échange pour tromper Hermione :")
print(liste_modifiee) # Vérifiez avec liste_potionsEntraînement 8 : Maison de Poudlard 🏰
Dans cet exercice, nous allons explorer les maisons de Poudlard en manipulant un tableau à deux dimensions en Python.
maisons_poudlard = [
["Gryffondor", "Harry", "Hermione", "Ron"],
["Serpentard", "Draco", "Pansy", "Vincent"],
["Poufsouffle", "Cedric", "Hannah", "Nymphadora"],
["Serdaigle", "Luna", "Cho", "Garrick"]
]-
💡À l'aide des indices de la liste, identifiez la maison et l'élève correspondant à l'indice (0,2) dans le tableau maisons_poudlard.
# Question 1 # Identifiez la maison et l'élève correspondants à l'indice (0, 2) dans le tableau maisons_poudlard. maison_question_1 = maisons_poudlard[0][0] eleve_question_1 = maisons_poudlard[0][2] # Affichage des résultats print("Réponse à la question 1 :") print("Maison : ",maison_question_1," Élève : ",eleve_question_1) - 📜Affichez tous les élèves de la maison Serdaigle en utilisant les indices du tableau. Voir une solution
- 🏡 Écrivez une fonction afficher_maisons qui prend en paramètre maisons_poudlard et affiche chaque maison avec ses élèves.
-
🔎Écrivez une fonction rechercher_eleve qui prend en paramètre maisons_poudlard et le prénom d'un élève, puis retourne la maison à laquelle il appartient.
#Exemple attendu : print(rechercher_eleve(maisons_poudlard, "Hermione")) # ➞ "Gryffondor" print(rechercher_eleve(maisons_poudlard, "Luna")) # ➞ "Serdaigle" -
➕ Écrivez une fonction ajouter_eleve qui prend en paramètre le tableau maisons_poudlard, le prénom d'un élève et le nom de la maison, et ajoute cet élève à la maison spécifiée.
#Exemple attendu : ajouter_eleve(maisons_poudlard, "Neville", "Gryffondor") afficher_maisons(maisons_poudlard)
Entraînement 9 : Transformation d'une Séquence d'ADN
La liste ci-dessous représente la séquence d'un brin d'ADN :
["A","C","G","T","T","A","G","C","T","A","A","C","G"]
Complétez la fonction qui transforme cette séquence en sa séquence complémentaire.
La séquence complémentaire s'obtient en remplaçant A par T, T par A, C par G et G par C.
def sequence_complementaire(adn):
"""
Transforme une séquence d'ADN en sa séquence complémentaire.
Parameters:
- adn (list): Liste représentant la séquence d'ADN.
Returns:
list: Séquence complémentaire d'ADN.
"""
assert sequence_complementaire(["A","C","G","T"]) == ['T', 'G', 'C', 'A']Savoir faire
- Écrire une fonction renvoyant un p-uplet de valeurs
- Lire et modifier les éléments d'un tableau grâce à leur index.
- Construire un tableau par compréhension.
- Utiliser des tableaux de tableaux pour représenter des matrices.
- Itérer les éléments d'un tableau