UE Informatique

1ère année Licence SESI, PEIP, MASS

  English version

Partie 6 : Tuples

Dans cette partie, vous allez découvrir les notions de

  • tuples en Python
  • Créations de tuples
  • Parcours de tuples
  • Opérations élémentaires sur les tuples
  • Une application : l'affectation simultanée.

Qu’est-ce qu’un tuple ?

Un tuple est une structure de données séquentielle capable de contenir un nombre quelconque de données avec répétition possible. Autrement dit un tuple contient, dans un ordre précis, un nombre quelconque de valeurs quelconques.

En Python, on écrit les tuples en plaçant leurs éléments entre deux parenthèses ( et ), les éléments étant séparés par des ,.

Voici un tuple contenant dans l'ordre les trois entiers 1, 2 et 3.

In [1]:
(1,2,3)
Out[1]:
(1, 2, 3)

Ce tuple est différent du tuple contenant les entiers 1, 2, 3 dans un ordre différent.

In [2]:
(1, 2, 3) == (2, 1, 3)
Out[2]:
False
In [3]:
(1, 2, 3) == (3, 1, 2)
Out[3]:
False

Les tuples pouvant contenir des types quelconques de données, il est aussi possible de faire des tuples de booléens, par exemple.

In [4]:
(True,False,True,False)
Out[4]:
(True, False, True, False)

Un tuple peut même être vide

In [5]:
( )
Out[5]:
()

Notons un cas particulier pour un tuple d'un seul élément.

In [6]:
(1)
Out[6]:
1

Entourer l'élément d'une paire de parenthèses ne suffit pas à en faire un tuple : il ne s'agit que d'une expression parenthésée. Pour lever l'ambiguité il est indispensable de toujours ajouter une virgule, après le premier élément.

In [7]:
(1,)
Out[7]:
(1,)

Le type des tuples est tuple indépendamment de(s) type(s) des éléments qu'ils contiennent.

In [8]:
type( (1.5, -3.2))
Out[8]:
tuple

Remarque:

dans idle ou bien dans une console python l'affichage sera plutôt :

<class 'tuple'>

Note:

Les exemples ci-dessus ont montré des tuples dont les éléments ont tous le même type. On parle alors de tuples homogènes. Certains langages de programmation imposent que les tuples soient homogènes. Ce n’est pas le cas de Python qui accepte sans problème les tuples hétérogènes.

In [9]:
(1, 'timoleon', True, -5.26)
Out[9]:
(1, 'timoleon', True, -5.26)

Cependant, travailler avec des tuples hétérogènes est plus difficile qu’avec des tuples homogènes. Dans le cadre de ce cours, nous nous limiterons aux tuples homogènes.

Création de tuples

Sont présentées ici, plusieurs façons classiques de construire des tuples.

Par énumération explicite des éléments

La plus élémentaire des méthodes de construction de tuples consiste à énumérer ses éléments.

In [10]:
()
Out[10]:
()
In [11]:
(1,2,3)
Out[11]:
(1, 2, 3)

Bien évidemment, cette méthode ne peut convenir que pour de petits tuples dont on connaît à l’avance les éléments.

Note :

En règle générale, une expression en Python doit s’écrire sur une seule ligne.

Une exception à cette règle existe pour les tuples (mais pas seulement). Lorsque l’énumération des éléments est trop longue pour tenir raisonnablement sur une seule ligne, il est possible de l’écrire sur plusieurs.

In [12]:
('janvier', 'février', 'mars', 'avril', 
 'mai', 'juin', 'juillet', 'août',      
 'septembre', 'octobre', 'novembre', 'décembre')
Out[12]:
('janvier',
 'février',
 'mars',
 'avril',
 'mai',
 'juin',
 'juillet',
 'août',
 'septembre',
 'octobre',
 'novembre',
 'décembre')

Avec la fonction tuple

La fonction tuple permet de convertir certaines données en tuples. Par exemple, appliquée à une chaîne de caractères, elle renvoie le tuple des caractères de cette chaîne. Et appliquée à un intervalle d’entiers produit par la fonction range, elle renvoie le tuple des entiers de cet intervalle.

In [13]:
tuple ('Timoleon')
Out[13]:
('T', 'i', 'm', 'o', 'l', 'e', 'o', 'n')
In [14]:
tuple (range (1,20,2))
Out[14]:
(1, 3, 5, 7, 9, 11, 13, 15, 17, 19)

Sans argument, elle renvoie le tuple vide.

In [15]:
tuple ()
Out[15]:
()

Cette fonction tuple peut s’appliquer à d’autres types de données encore (les types de données séquences ou itérables). En particulier on peut l’appliquer aussi à un tuple:

In [16]:
tuple((1,2,3))
Out[16]:
(1, 2, 3)

ou encore à un intervalle d’entiers :

In [17]:
tuple (range (5))
Out[17]:
(0, 1, 2, 3, 4)

Attention !

Avertissement :

La fonction tuple n’admet qu’un seul paramètre.

In [18]:
tuple(1,2,3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-18-3e233cfc2777> in <module>()
----> 1 tuple(1,2,3)

TypeError: tuple() takes at most 1 argument (3 given)

Par concaténation

Comme pour les chaînes de caractères, l’opérateur + permet de concaténer deux tuples.

In [19]:
(1,2,3,4) + (5,6)
Out[19]:
(1, 2, 3, 4, 5, 6)

Comme pour les chaînes de caractères, les tuples ne peuvent être utilisés avec l'opérateur -.

In [20]:
(1, 2, 3, 4) - (3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-20-04c341769149> in <module>()
----> 1 (1, 2, 3, 4) - (3)

TypeError: unsupported operand type(s) for -: 'tuple' and 'int'

Par répétition

L’opérateur * employé avec un nombre entier et un tuple construit un nouveau tuple en répétant le tuple autant de fois que l’indique le nombre.

In [21]:
(1,2,3) * 4
Out[21]:
(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)

En compréhension

On dit qu’on construit un tuple en compréhension lorsqu’on le définit en appliquant une fonction à une séquence d’éléments.

Voici à titre d’exemple plus complexe, le tuple des carrés des 10 premiers entiers positifs ou nuls. Il est construit à l’aide de l’expression i*i dans laquelle i prend les valeurs successives 0, 1, ..., 9 (grâce à la boucle for).

In [22]:
tuple(i*i for i in range(10))
Out[22]:
(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

Parcours de tuples

Les tuples sont des données qui, comme les chaînes de caractères, font partie d’une famille appelées séquences. C’est pourquoi on retrouve dans les points qui suivent de nombreuses ressemblances avec les chaînes de caractères.

Longueur d'un tuple

Le nombre d'éléments d'un tuple est donné par la fonction len.

In [23]:
len( ('ga', 'bu', 'zo', 'meu'))
Out[23]:
4

Comme pour toute fonction, on peut obtenir de l'aide sur celle-ci :

In [24]:
help(len)
Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

Indexation des éléments

Tout élément d’un tuple possède un indice. Cet indice est un entier compris entre 0 (inclus) et la longueur du tuple (exclue). Le premier élément d'un tuple l est à l'indice 0 tandis que le dernier se trouve à l'indice len(l)-1.

In [25]:
t = (3, 1, 4, 1, 5, 9, 2)
In [26]:
t[0]
Out[26]:
3
In [27]:
t[6]
Out[27]:
2
In [28]:
t[len(t)]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-28-91750c203874> in <module>()
----> 1 t[len(t)]

IndexError: tuple index out of range

L’indice peut aussi être compris entre l’opposé de la longueur du tuple et -1 (bornes incluses). Comme dans le cas précédent, la valeur la plus élevée est l'indice de la fin du tuple (-1) et la valeur la moins élevée est celle du début de liste (-len(l)).

In [29]:
t[-1]
Out[29]:
2
In [30]:
t[-len(t)]
Out[30]:
3

Tranches de tuples

Une tranche de tuple est un sous-tuple d’éléments consécutifs du tuple.

On construit une tranche de tuple en précisant l’indice du premier élément que l’on veut suivi de l’indice du premier élément que l’on ne veut pas.

In [31]:
t[1:4]
Out[31]:
(1, 4, 1)

Si l’indice du premier élément est manquant, Python considère que c’est 0.

In [32]:
t[:4]
Out[32]:
(3, 1, 4, 1)

Si l’indice de fin est manquant, c’est qu’on va jusqu’au bout du tuple.

In [33]:
 t[3:]
Out[33]:
(1, 5, 9, 2)

Parcours complet d’un tuple

Avec la notation indicielle, on peut effectuer des traitements sur chacun des éléments d’un tuple à l’aide d’une boucle non conditionnelle.

Par exemple, pour imprimer chacun des éléments d’un tuple un par ligne :

In [34]:
for i in range (len (t)):
        print (t[i])
3
1
4
1
5
9
2

On peut aussi construire de nouveaux tuples :

In [35]:
t2 = ()
for i in range (len (t)):
    t2 = t2 + (2*t[i],)
t2
Out[35]:
(6, 2, 8, 2, 10, 18, 4)

Note :

Cette construction peut s’obtenir plus aisément à l’aide d’une construction par compréhension.

In [36]:
t2 = tuple(2*t[i] for i in range (len (t)))
t2
Out[36]:
(6, 2, 8, 2, 10, 18, 4)

Existence d'un élément d'un tuple

Pour vérifier si un élément est présent dans un tuple, plutôt que d'écrire un code qui opérera cette vérification, il faut utiliser l'opérateur in dont le résultat est un booléen.

La syntaxe à suivre est

elem in le_tuple

elem est l'élément dont on veut vérifier la présence dans le tuple appelée le_tuple. Le résultat de l'expression vaut True si l'élément apparaît dans le tuple et False dans le cas contraire.

In [37]:
1 in t
Out[37]:
True
In [38]:
10 in t
Out[38]:
False

Application aux chaînes de caractères

Les chaînes de caractères, tout comme les tuples, peuvent être indicées. La syntaxe vue pour les tuples s'applique tout autant aux chaînes de caractères.

Indexation des chaînes de caractères

In [39]:
chaine = "timoleon"
chaine[0]
Out[39]:
't'
In [40]:
chaine[4]
Out[40]:
'l'

Tranches de chaînes de caractères

In [41]:
chaine[:2]
Out[41]:
'ti'
In [42]:
chaine[3:6]
Out[42]:
'ole'

Parcours complet de chaîne de caractères

In [43]:
for i in range(len(chaine)):
    print(chaine[i])
t
i
m
o
l
e
o
n

L'affectation simultanée

En python on peut procéder à une affectation simultanée de variable ainsi :

In [44]:
a,b= 2,3
In [45]:
print("apres a vaut:",a,"et b vaut:",b)
apres a vaut: 2 et b vaut: 3

Attention !

Biensur le nombre d'éléments doivent correspondre

In [46]:
a,b,c=1,2
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-46-9dab8dbded4c> in <module>()
----> 1 a,b,c=1,2

ValueError: not enough values to unpack (expected 3, got 2)
In [47]:
c,d=1,2,3
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-47-b7faecb960cc> in <module>()
----> 1 c,d=1,2,3

ValueError: too many values to unpack (expected 2)

Remarque

Cela peut être utiliser pour écrire l'échange de variable de manière élégante:

In [48]:
a,b=2,3
a,b=b,a
In [49]:
print("apres a vaut:",a,"et b vaut:",b)
apres a vaut: 3 et b vaut: 2