Chapitre 1 : Les tuples et les tableaux en Python ¶
Introduction : types construits¶
Vous avez jusqu'à présent utilisé des types de base (types int, float, boolean, str). Ce type de données ne peut contenir qu'une seule valeur, ce qui devient très vite limité lorsque l'on manipule des données plus complexes (des fichiers, des images, des sons,...) qui sont formées de plusieurs (centaines, milliers, millions de) valeurs.
Heureusement, à partir de ces types de base se constituent des types construits. Dans cette séquence, vous allez découvrir trois de ces types construits : les p-uplets, les tableaux (chapitre 1, donc dans ce document) et les dictionnaires (chapitre 3). Ces types permettent de structurer l'information disponible et d'améliorer la lisibilité des programmes si on les utilise pour nommer correctement la nature des informations enregistrées.
I. Les tuples ou p-uplets¶
Les tuples sont des séquences qui permettent de regrouper plusieurs informations sous un seul nom et ainsi de faire abstraction de la représentation.
Les termes tuple ou p-uplet sont utilisés indifféremment pour désigner cette généralisation du couple, triplet, quadruplet ...
Pour définir un tuple, on utilise des parenthèses comme ci-dessous.
coord = (2, -3)
print(type(coord))
On peut facilement accéder aux différents élements d'un tuple en utilisant des crochets et l'index de l'élément (n'oubliez pas que le premier élément est celui d'index 0).
print(coord[0])
print(coord[1])
Exercice 1 :¶
Voici un tuple de trois valeurs : un nom, un prénom et un numéro de téléphone. Quelles instructions permettent d'accéder à ces trois valeurs ?
individu = ("Richard", "Baptiste", "0611111111")
# à compléter
Exercice 2 :¶
La couleur d'un pixel d'une image est définie par un triplet RVB (Rouge, Vert, Bleu). La nuance de gris de ce pixel est, par exemple, la moyenne entière des trois valeurs du triplet RVB. Complétez le programme ci-dessous pour qu'il affiche la nuance de gris du pixel.
couleur_pixel = (155, 220, 67)
# à compléter
Exercice 3 :¶
Les points sont définis dans un plan par un couple de coordonnées (abscisse, ordonnée). On veut écrire une fonction qui prend en paramètres deux tuples A et B (correspondant aux coordonnées de deux points $A$ et $B$) et qui renvoie les coordonnées du milieu du segment [AB].
Rappel : si $A(x_A;y_A)$ et $B(x_B;y_B)$ sont les coordonnées des points $A$ et $B$ alors le milieu du segment $[AB]$ a pour coordonnées $\left(\frac{x_A+x_B}{2};\frac{y_A+y_B}{2}\right)$.
def milieu(A, B):
# à compléter
# Test
C = (1, 2)
D = (5, 10)
milieu(C, D)
Remarques :
En Python, les tuples ne sont pas typés. Par exemple, au lieu d'indiquer : tuple(int, int), l'interprète indique seulement : tuple
Les tuples ne sont pas mutables, c'est-à-dire qu'on ne peut pas les modifier. On ne peut pas écrire :
A[0] = 2pour modifier un élément d'un tupleA.- Les tuples sont de taille statique : on peut pas ajouter une composante à un tuple existant.
- Malgré la notation indicée, il ne faut pas les confondre avec les tableaux.
Les tuples permettent de simplifier l'écriture des programmes en faisant abstraction de détails.
Sans cette notion, la fonction milieu aurait 4 paramètres, et dans le programme qui l'utilise, il faudrait 2 fois plus de variables pour mémoriser les informations.
La seule précaution à prendre, est qu'il n'y ait pas d'ambiguité sur l'ordre dans lequel les informations sont rangées dans un tuple, sinon il faut en nommer les différentes parties.
II. Les tableaux (listes en Python)¶
Les tableaux, appelés listes en Python, sont des séquences (comme les tuples, comme les chaînes de caractères). Ce sont des objets qui peuvent contenir d'autres objets de n'importe quel type (et même de types différents) : des tableaux de nombres entiers, des tableaux de flottants, des tableaux de chaînes de caractères.
A. Tableaux indexés¶
Les tableaux (ou liste en Python) se déclarent des crochets.
tab1 = [1,5,10,20] # un tableau d'entiers
tab2 = [25.0,17.2,14.8,108.7,137.4] # un tableau de flottants
tab3 = ["Richard", "Baptiste", "0611111111"] # un tableau de chaînes de caractères
tab4 = [True, (10 < 12), ("alpha" >= "beta")] # un tableau de booléens
tab5 = [] # un tableau vide
tab6 = [0]*10 # un tableau de taille 10 composée uniquement d'entiers 0
1. Lire les éléments d'un tableau grâce à leur index¶
Les éléments d'une liste sont indicés, chaque élément a sa place. On accède à un élément d'une liste en utilisant les crochets :
print(tab1[2])
print(tab2[0])
print(type(tab3))
print(tab4)
print(tab5)
print(tab6)
Exercice 4 :¶
- Quelle instruction permet d'afficher les nombres 5 et 20 de
tab1?
tab1 = [1,5,10,20] # un tableau d'entiers
# à compléter
- Quelle instruction permet d'afficher le numéro de téléphone de
tab3?
tab3 = ["Richard", "Baptiste", "0611111111"] # un tableau de chaînes de caractères
# à compléter
- Quelle instruction permet d'afficher les premier et troisième booléens de
tab4?
tab4 = [True, (10 < 12), ("alpha" >= "beta")] # un tableau de booléens
# à compléter
- Quelle instruction permet de créer un tableau de taille 100 composé uniquement de 1 ?
# à compléter
2. Modifier les éléments d'un tableau grâce à leurs index¶
Les tableaux sont des types dits mutables : cela signifie que l'on peut remplacer un élément d'un tableau par un autre (ce qui n'était pas le cas pour les tuples ou les chaînes de caractères).
Exemple :
mon_tab = [1, 2, 3, 4, 5, 6, 7]
mon_tab[2] = 10 # l'élément d'index 2 vaut maintenant 10
print(mon_tab)
Exercice 5 :¶
Le nouveau numéro de téléphone de Baptiste est : 06 22 22 22 22. Quelle instruction permet de modifier le numéro de téléphone de Baptiste dans le tableau suivant ?
contact = ["Richard", "Baptiste", "0611111111"]
# à compléter
Remarque : il était impossible de faire cela avec un tuple !
Exercice 6 :¶
Complétez la fonction suivante pour qu'elle échange les valeurs d'index i et j du tableau tab.
T = [3, 8, 12, 9, 56, 14, 22, 7, 13, 41]
def echange(tab,i,j):
# ---------------
# à compléter
# ---------------
# Test
echange(T,2,4)
T
B. Taille d'un tableau¶
Très important : la taille d'un tableau est renvoyée par la fonction len. Il s'agit du nombre d'éléments du tableau.
tab = [0, 2, 3, 10]
print(len(tab))
T = ["Albert", "Grégory", "Justine", "Anaïs", "Myriam", "Pascal"]
print(len(T))
La taille d'un tableau permettra de parcourir les différents élements du tableau avec une boucle for ou while (voir plus loin) et deviendra très importante dans les calculs de coût des algorithmes.
C. Construire un tableau¶
Supposons que l'on veuille construire un tableau de taille 100 contenant l'entier $2\times i$ dans sa case d'index $i$. On peut bien sûr le construire de la manière suivante
t = [0, 2, 4, 6, 8, 10, 12, ...]
mais c'est extrêment fastidieux car il faudrait écrire les 100 valeurs. Il existe deux solutions pour construire ce tableau de manière plus rapide.
1. Construire un tableau avec une boucle for¶
La première façon est de créer au préalable un tableau de taille 100 avec une valeur arbitraire puis de le remplir ensuite avec une boucle for:
t = [0]*100 # création d'un tableau de taille 100 avec une valeur arbitraire (ici 0)
for i in range(100): # construction du tableau
t[i] = 2*i
print(t) # affichage du tableau
Comme c'est une construction qui revient souvent, Python propose une syntaxe plus compacte encore : une construction par compréhension.
2. Construire un tableau par compréhension¶
Pour construire le tableau précédent par compréhension, l'instruction suivante suffit :
t = [2*i for i in range(100)] # création et construction du tableau
print(t) # affichage du tableau
La fonction suivante crée un tableau de 100 valeurs, chacune étant générée par un appel à la fonction randint.
from random import randint
Tableau = [randint(0,1000) for i in range(100)]
print(Tableau)
Exercice 6 :¶
- En utilisant les deux méthodes, créez un tableau qui contient tous les entiers compris entre 0 et 1000.
# AVEC UNE BOUCLE
# ---------------
# à compléter
# ---------------
# PAR COMPREHENSION
# ---------------
# à compléter
# ---------------
- En utilisant les deux méthodes, créez un tableau qui contient tous les entiers compris entre 5 et 15.
# AVEC UNE BOUCLE
# ---------------
# à compléter
# ---------------
# PAR COMPREHENSION
# ---------------
# à compléter
# ---------------
- En utilisant les deux méthodes, créez un tableau qui contient tous les nombres pairs compris entre 0 et 50.
# AVEC UNE BOUCLE
# ---------------
# à compléter
# ---------------
# PAR COMPREHENSION
# ---------------
# à compléter
# ---------------
- En utilisant les deux méthodes, créez un tableau qui contient les carrés de tous les entiers compris entre 1 et 100 (c'est-à-dire 1, 4, 9, 16, etc.)
# AVEC UNE BOUCLE
# ---------------
# à compléter
# ---------------
# PAR COMPREHENSION
# ---------------
# à compléter
# ---------------
- En utilisant les deux méthodes, créez un tableau de taille 200 contenant des entiers aléatoires compris entre 0 et 10. Pour rappel la fonction
randintde la bibliothèquerandompermet de renvoyer des entiers de manière aléatoire. Exécutez ensuite plusieurs fois le code.
# AVEC UNE BOUCLE
# ---------------
# à compléter
# ---------------
# PAR COMPREHENSION
# ---------------
# à compléter
# ---------------
D. Ajouter un élément à un tableau Python : la méthode append¶
Il est possible d'ajouter un élément à un tableau Python car les tableaux sont définis par le type list en Python, ce qui n'est pas le cas pour les tableaux dans d'autres langages de programmation.
Quoiqu'il en soit, ajouter un élément à un tableau est très utile, notamment dans le traitement de données en tables (voir Séquence 3, Chapitre 4) pour mémoriser les éléments d'un fichier dans une table (= tableau).
La méthode append() permet d'ajouter un élément en fin de tableau.
t1 = [2, 5, 10, -4, 1]
t1.append(8)
t2 = ["Alphonse", "Barbara", "Charline"]
t2.append("Clara")
print(t1)
print(t2)
On peut aussi construire un tableau en utilisant cette méthode, en partant d'un tableau vide :
t = []
for i in range(10):
t.append(i*i) # à chaque tour de boucle, l'élément i*i est ajouté en fin de tableau
print(t) # affichage pour voir l'évolution du tableau à chaque tour de boucle (optionnel)
t
Cela reste tout de même plus long qu'une construction par compréhension
t = [i*i for i in range(10)]
t
III. Tableaux de tableaux¶
Un tableau peut aussi contenir des ... tableaux. Chaque élément du tableau est alors lui-même un tableau, c'est pourquoi on parle d'un tableau de tableaux.
Exemple :
contacts = [['Baptiste', '0611111111'], ['Grégory', '0622222222'],
['Fabien', '0633333333'], ['Regis', '06444444444'],
['Mélinda', '0655555555'], ['Rachel', '0666666666'],
['Elise', '0677777777'], ['Janine', '0688888888']]
A) Accès aux éléments¶
On peut alors accéder à chaque élément du tableau grâce à son index, mais aussi à chaque élément de chaque sous-tableau comme le montre les instructions ci-dessous :
print(contacts[1])
print(contacts[1][0])
print(contacts[1][1])
print(contacts[6])
print(contacts[6][0])
print(contacts[6][1])
print(len(contacts)) # taille du tableau 'contacts'
print(len(contacts[1])) # taille du deuxième élément du tableau 'contacts' (qui est lui-même un tableau)
Exercice 7 :¶
Voici les premières notes de l'année obtenues par un élève en NSI :
| Note | coefficient |
|---|---|
| 15 | 1 |
| 13 | 2 |
| 8 | 1 |
| 18 | 1 |
- Ces notes et coefficients sont d'abord stockées dans deux tableaux comme ci-dessous. Quelle instruction permet d'accéder la troisième note ? Quelle instruction permet d'accéder au coefficient de la deuxième note ?
notes = [15, 13, 8, 18]
coeff = [1, 2, 1, 1]
# ---------------
# à compléter
# ---------------
- Ces notes et coefficient sont maintenant stockées dans un tableau de tableaux. Quelle instruction permet d'accéder à la troisième paire note-coefficient ? Quelle instruction permet d'accéder la troisième note ? Quelle instruction permet d'accéder au coefficient de la deuxième note ?
notes_coeff = [[15, 1], [13, 2], [8, 1], [18, 1]]
# ---------------
# à compléter
# ---------------
B) Construction d'un tableau à deux dimensions¶
Pour construire un tableau de tableaux, il est très avantageux de le construire par compréhension.
tab1 = [[1, 2, 3] for i in range(4)]
tab1
tab2 = [[i*j for j in range(3)] for i in range(5)]
tab2
Exercice 8¶
Ecrire un programme qui construit par compréhension un tableau t de taille 5 $\times$ 5, tel que t[i][j] contient $i+j$.
# à compléter
t = [15, 13, 8, 18]
for e in t:
print(e)
Dans un telle forme, la boucle énumère les éléments du tableau : elle effectue un tour de boucle pour élément de t et l'élément inspecté à un tour donné est associé à la variable e. Le programme précédent est équivalent à cet autre programme
t = [15, 13, 8, 18]
for i in range(len(t)):
e = t[i]
print(e)
dans lequel la boucle énumère les indices i du tableau t, les éléments correspondants étant récupérés via l'expression t[i].
B. Parcours d'un tableau à plusieurs dimensions¶
Pour parcourir les éléments d'un tableau à plusieurs dimensions, on va naturellement utiliser des boucles imbriquées, chaque boucle parcourant une dimension. On peut parcourir le tableau en énumérant les indices
t = [[1,2,4],[5,6,1],[1,0,3],[4,5,3],[8,1,0]]
for i in range(5):
for j in range(3):
print(t[i][j])
ou en énumérant les éléments du tableau
t = [[1,2,4],[5,6,1],[1,0,3],[4,5,3],[8,1,0]]
for l in t: # pour chaque élément l de t (pour chaque sous-tableau l de t)
for x in l: # pour chaque élément x de l (pour chaque élement x du sous-tableau l)
print(x)
Exercice 9¶
Ecrire un programme qui permet de calculer la somme des éléments du tableau t donné ci-dessous.
t = [[1,2,4],[5,6,1],[1,0,3],[4,5,3],[8,1,0]]
# ---------------
# à compléter
# ---------------
Exercice 10 : Un exercice un peu plus appliqué¶
Une image est constituée de pixels, chaque pixel étant défini par un tuple (R,V,B) (nuances de rouge, vert et bleu). Il est possible de stocker la série de pixels d'une image dans un tableau (=liste Python) grâce aux instructions suivantes :
from PIL import Image # on importe le module Image de la bibliothèque PIL
img = Image.open("perroquet.jpg") # on ouvre l'image perroquet.jpg qui doit être placée dans le même repertoire que ce notebook
pixels = list(img.getdata()) # on récupère les données de l'image que l'on converti en une liste et que l'on stocke dans le tableau 'pixels'
display(img) # pour afficher l'image
print(pixels) # pour afficher le tableau 'pixels' contenant tous les pixels de l'image
print("le 4ème pixel est : ", pixels[3]) # pour afficher le 4ème pixel du tableau
print("la composante Rouge du 4ème pixel est : ",pixels[3][0]) # pour afficher les composantes R, V et B du 4ème pixel
print("la composante Verte du 4ème pixel est : ",pixels[3][1])
print("la composante Bleue du 4ème pixel est : ",pixels[3][2])
img.close() # on ferme le flux
On peut alors appliquer des transformations sur ces pixels en manipulant ce tableau. Par exemple, on peut appliquer un filtre rouge à notre image en conservant uniquement la nuance de rouge de chaque pixel et en remplaçant les composantes verte et bleue par 0.
from PIL import Image # on importe le module Image de la bibliothèque PIL
img = Image.open("perroquet.jpg")
pixels = list(img.getdata())
display(img)
# TRANSFORMATION DE L'IMAGE
new_pixels = [0]*len(pixels) # on crée une liste de la même taille que 'pixels'
for i in range(len(pixels)):
new_pixels[i] = (pixels[i][0],0,0) # chaque élément de 'new_pixels' est l'élément (R,0,0) de 'pixels'
img.putdata(new_pixels) # on copie cette nouvelle liste de pixels dans les données de 'img'
# RESULTAT
display(img) # on affiche l'image 'img' ainsi transformée
print(new_pixels) # on affiche les valeurs des nouveaux pixels pour comprendre la transformation
img.close() # on ferme le flux
- Remplacez les lignes 6 à 9 du programme précédent afin que le tableau
new_pixelssoit créé par compréhension.
from PIL import Image # on importe le module Image de la bibliothèque PIL
img = Image.open("perroquet.jpg")
pixels = list(img.getdata())
display(img)
# TRANSFORMATION DE L'IMAGE
# ---------------
# à compléter
# ---------------
img.putdata(new_pixels) # on copie cette nouvelle liste de pixels dans les données de 'img'
# RESULTAT
display(img) # on affiche l'image 'img' ainsi transformée
img.close() # on ferme le flux
- En vous inspirant de ce qui vient d'être fait, écrivez un programme permettant d'appliquer un filtre vert à l'image "perroquet.jpg".
- En vous inspirant de ce qui vient d'être fait, écrivez un programme permettant d'appliquer un filtre cyan à l'image "perroquet.jpg".
Ressources :
- Documents ressources du DIU EIL Nantes
- Spécialité NSI 1re, T. BALABONSKI, S. CONCHON, J.-C. FILLIATRE, K. NGUYEN, éditions ELLIPSES
Germain BECKER & Sébastien POINT, Lycée Mounier, ANGERS 