Informatique : Leçon 6. Tuples - Listes
Sommaire
C'est quoi un tuple ?
- C'est un nouveau type d'objets. Il correspond en maths, aux \(p\)-listes ou \(p\)-upplets : suites ordonnées de \(p\) objets.
- En Python, les tuples sont délimités, comme en maths, par des parenthèses.
- En maths, les éléments d'un \(p\)-upplet s'appellent les coordonnées ou les composantes du \(p\)-upplet. En Python, les éléments d'un tuple sont appelés les items du tuple. Ils sont séparés par des virgules, comme en maths.
Maths | Analogue Python |
---|---|
\(p\)-upplet = \(p\)-liste | tuple |
coordonnée ou composante | item |
délimité par des parenthèses | délimité par des parenthèses |
séparateur : la virgule \(\mathtt{,}\) | idem : la virgule \(\mathtt{,}\) |
Premiers exemples
my_first_tuple = ( -3 , 2, 0.5, 0) print my_first_tuple
(-3, 2, 0.5, 0)
type(my_first_tuple)
tuple
Ce tuple possède 4 items qui sont des flottants ou des entiers.
** Remarque.** Cela veut dire que dans un tuple, on peut mettre des items de type divers. En particulier, on peut mêler chaînes de caractères et flottants, ou même mettre un tuple dans un tuple.
Exemple.
t1 = ('toto', 25, (1,2.5)) ; type(t1)
tuple
Le tuple \(\mathtt{t_1}\) est un tuple constitué de trois items qui sont :
- une chaîne de caractères
- un entier.
- un tuple, lui-même constitué d'un entier et d'un flottant.
Nombre d'items d'un tuple
Comme pour les chaînes de caractères, pour connaître le nombre d'items d'un tuple, on utilise la fonction \(\mathtt{len}\) :
t1 = ('toto', 25, (1,2.5)) len(t1)
3
Accès aux items d'un tuple
Comme pour les chaînes de caractères, les éléments d'un tuple sont numérotés à partir de 0, et on peut y faire les mêmes opérations que dans les chaînes de caractères.
t1 = ('toto', 25, (1,2.5)) t1[-1] # le dernier item
(1, 2.5)
t1[0] # le premier item
'toto'
** Exercice **. Récupérer le \(\mathtt{1}\) dans \(\mathtt{t_1}\) en une seule instruction.
t1
('toto', 25, (1, 2.5))
t1[-1]
(1, 2.5)
t1[-1][0] # le premier item du dernier item de t1 ...
1
Remarque. On a déjà rencontré des tuples, dans la construction des fonctions, notamment les fonctions qui retournent plusieurs arguments de sortie.
def inutile(x): """ fonction inutile qui prend un réel x et retourne en sortie son carré et son cube """ return x**2,x**3 # Deux arguments de sortie x^2 et x^3
z = inutile(4) # je calcule inutile(4) print(z)
(16, 64)
type(z)
tuple
Remarque. En particulier, les parenthèses sont optionnelles dans un tuple : \(\texttt{(x,y)}\) est la même chose que \(\texttt{x,y}\).
Exercice. Comment construire un tuple ne possédant qu'un seul item, l'entier 3 par exemple ?
x=(3); type(x)
int
Ne marche pas. Essayons avec le séparateur : la virgule.
x=(3,) # grâce à la virgule on sait qu'on a un tuple
type(x)
tuple
JE LE REDIS (je ne m'énerve pas, j'explique) : les parenthèses sont optionnelles :
y = 3, type(y)
tuple
Remarque. Un nombre complexe est aussi un tuple. Mais il constitue en Python un type d'objets à part entière.
Une utilisation intéressante des tuples : échange de variables
x = 'toto' y = 2
Solution. Si j'échange bêtement, j'écrase le contenu d'une variable par celui de l'autre. L'idée est d'introduire une variable tierce qui sert de transition :
t = x # j'envoie x dans la variable tierce x = y # je peux sans scrupules écraser le contenu de x y = t # j'envoie dans y le contenu de x. x,y
(2, 'toto')
Réponse pythonique. Sous Python, les tuples permettent d'éviter le passage par une variable intermédiaire :
x = 'toto' y = 2 x,y = y,x print x,y
2 toto
Exercice. Utilisez cette fonctionnalité pour le problème suivant :
Soit \(a,b\) deux réels donnés et \((u_n)\) la suite définie par :
- Créez une fonction \(\texttt{def srl2(a,b,u0,u1,n):}\) qui retourne en sortie le terme \(u_n\) de la suite définie par la relation \((R)\).
- Pour vérifier que votre fonction est correctement programée, vérifiez que \(\texttt{ srl2(-1,-1,0,1,6)}\) renvoie \(\texttt{8}\).
def srl2(a,b,u0,u1,n): # à chaque étape k : u = u0 # u joue le rôle de u_k v = u1 # v joue le rôle de u_{k+1} for k in range(0,n-1): # pour avoir u_n, on fait n-1 calculs # successifs w = -a*v - b*u v,u = w,v # le nouveau v est le w calculé # le nouveau u est le v d'avant ! if n==0: return u # le programme doit renvoyer u0 else: # si l'utilisateur rentre n = 0 return v
srl2(-1,-1,0,1,6) # C'est la suite de Fibonnaci: u0 = 0, u1 = 1, on demande u6
8
Les tuples ne sont pas mutables
Question naturelle. Est-ce que je peux changer la valeur d'un item dans un tuple ? Regaronds ! Je reprends le tuple \(\mathtt{t_1}\) :
t1
('toto', 25, (1, 2.5))
Je vais par exemple essayer de remplacer le \(\texttt{25}\) par un \(\texttt{30}\) :
t1[1] = 30 # je remplace le 25 par un 30
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-42-3f7b83bf835b> in <module>() ----> 1 t1[1] = 30 # je remplace le 25 par un 30 TypeError: 'tuple' object does not support item assignment
Le message d'erreur me dit (si on traduit la fin en français) : on ne peut pas faire d'affectation d'item dans un tuple. Morale : > 1. ** Vous ne pouvez pas modifier un tuple : on dit que les tuples ne sont pas mutables. ** > > 2. ** De même, les chaînes de caractères ne sont pas mutables. **
Un autre type voisin des tuples : les listes.
C'est exactement la même chose que les tuples, mais les listes, ont le bon goût d'être mutables. Du point de vue de la construction d'une liste, les listes sont délimitées par des crochets.
Tuples en Python | Listes en Python | |
---|---|---|
délimiteurs | ( ) | [] |
séparateur des items | , | , |
mutable | non | oui |
Ces deux types d'objets peuvent servir* suivant les besoins* à représenter des \(p\)-listes mathématiques.
t2 = (7,22,11,34,17) # un tuple
L2 = [7,22,11,34,17] # ce qui lui correspondrait en termes de listes
Regardons le type :
type(L2)
list
La plupart des opérations vues sur les tuples ou chaînes de caractères s'appliquent :
len(L2)
5
L2[-2] # Le deuxième élément de L2 en partant de la fin
34
Mutons notre liste en modifiant un coefficient :
L2[0] = 10000000 # Pas de message d'erreur : ma liste a muté !
Vérifions :
L2
[10000000, 22, 11, 34, 17]
Vous voyez bien que \(\mathtt{L2}\) est mutable, contrairement à \(\mathtt{t2}\).
** Remarque ** On a déjà rencontré des listes :
range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
type( range(1,10))
list
Remarque.
- En Python 3, \(\mathtt{range}\) n'est plus de type liste, mais de type range (type à part entière).
- On verra plus tard le problème des clones et des siamois pour les listes.
Petite digression sur les mots et les listes. Split et join
Un autre exemple de liste en lien avec le cours de combinatoire, pour vous rappeler qu'un mot n'est qu'une liste de lettres, et pourquoi on les identifie dans les raisonnement combinatoires :
L3 = ['a','t','t','e','n','t','i','o','n'] # je crée une liste de lettres L3
['a', 't', 't', 'e', 'n', 't', 'i', 'o', 'n']
Cela vous évoque sans difficultés le mot : attention
Remarque.
- Vous pouvez générer la liste des mots appraissant dans une phrase avec \(\mathtt{split( )}\)
- inversement, vous pouvez générer la chaîne de caractères avec la liste de ses lettres par \(\mathtt{join( )}\)
'a t t e n t i o n'.split() # toutes les séquences séparées par des espaces # sont splittés et consignées dans une liste
['a', 't', 't', 'e', 'n', 't', 'i', 'o', 'n']
Inversement, dans une liste de chaînes de caractères, je peux joindre les chaînes par la séquence que je veux.
''.join(L3) # je relie tous les caractères de la liste # par le caractère ''.
'attention'
'----'.join(L3) # pourquoi pas ainsi
'a----t----t----e----n----t----i----o----n'