.. _tut-tuples:
**********
Les tuples
**********
Une vidéo de présentation des tuples...
.. raw:: html
Contrairement à la :class:`list`, le :class:`tuple` est une séquence *immutable*. Comme la liste, c'est une collection ordonnée. Il est défini par les opérateurs ``(`` et ``)``. Bien que le langage le permette, **il n'est pas conseillé d'utiliser une liste pour stocker des collections hétérogènes**. Cet usage est plutôt réservé au :class:`tuple`::
>>> ev = ('Everest', 8848, 'Asie', 'Himalaya')
>>> type(ev)
>>> len(ev)
4
Slicing
=======
Le :class:`tuple` étant une **sequence**, il dispose des mêmes opérations que la :class:`list`, à l'exception des opérations de modification puisque le :class:`tuple` est *immutable*.
L'indexation::
>>> ev[0]
'Everest'
>>> ev[1]
8848
et le slicing::
>>> ev[:2]
('Everest', 8848)
Le tuple est immutable
======================
Le :class:`tuple` est *immutable* et toute opération tentant à le modifier déclenche une erreur::
>>> ev[1] = 8849
Traceback (most recent call last):
File "", line 1, in
TypeError: 'tuple' object does not support item assignment
Idem si l'on tente de supprimer un de ses éléments::
>>> del(ev[2])
Traceback (most recent call last):
File "", line 1, in
TypeError: 'tuple' object doesn't support item deletion
L'opération d'indexation d'un :class:`tuple` ne peut apparaître qu'à droite (RHS) de l'opérateur d'affectation ``=``.
Appartenance
============
Le :class:`tuple` dispose de toutes les méthodes de **sequence**. On peut en particulier utiliser l'opérateur :keyword:`in` pour tester l'appartenance::
>>> 'Everest' in ev
True
>>> 'Kilimandjaro' in ev
False
Itérer sur un tuple
===================
Comme la :class:`list`, le :class:`tuple` est une séquence et l'opérateur :keyword:`in` est utilisé pour l'itération::
>>> for elt in ev:
... print(elt)
...
Everest
8848
Asie
Himalaya
Les méthodes de :class:`tuple`
==============================
Le :class:`tuple` étant une séquence immutable, les interactions possibles avec celui ci sont limitées.
.. admonition:: A expérimenter...
Même si le nombre de méthodes d'un :class:`tuple` est limité, il en existe cependant deux. Trouvez les, de deux façons différentes:
- en utilisant une fonction Python dans l'interpréteur interactif ;
- en recherchant dans `la documentation officielle `_.
Listes de tuples
================
Comme on l'a vu précédemment, la :class:`list` peut contenir tout type de donnée, et en particulier on peut construire une liste de :class:`tuple`::
>>> ac = ('Aconcagua', 6959, 'Amérique du Sud', 'Cordillère des Andes')
>>> mc = ('McKinley', 6190, 'Amérique du Nord', 'Alaska')
>>> ki = ('Kilimandjaro', 5892, 'Afrique', 'Vallée du Grand Rift')
>>> sommets = [ev, ac, mc, ki]
>>> sommets
[('Everest', 8848, 'Asie', 'Himalaya'),
('Aconcagua', 6959, 'Amérique du Sud', 'Cordillère des Andes'),
('McKinley', 6190, 'Amérique du Nord', 'Alaska'),
('Kilimandjaro', 5892, 'Afrique', 'Vallée du Grand Rift')]
Chaque élément est accessible par une indexation multiple, dont la profondeur dépend de la complexité de la structure de données::
>>> sommets[2][3]
'Alaska'
.. _named-tuples:
Les tuples nommés
=================
Le :class:`tuple` est parfaitement adapté à la création d'une structure de données complexe, à l'image des structures du langage C. Cependant l'accès à chacun des champs à partir de l'index (comme on vient de le voir) n'est pas très commode. Le module :mod:`collections` dispose d'un :func:`~collections.namedtuple` autorisant un accès facilité aux éléments::
>>> from collections import namedtuple
>>> Sommet = namedtuple('Sommet', ['nom', 'alt', 'pays', 'chaine'])
>>> ev = Sommet('Everest', 8848, 'Asie', 'Himalaya')
>>> ev
Sommet(nom='Everest', alt=8848, pays='Asie', chaine='Himalaya')
>>> ev.nom
'Everest'
>>> ev.chaine
'Himalaya'
Ce qu'il faut retenir
=====================
.. quiz:: quizz-07
:title: Les tuples
- :quiz:`{"type":"TF","answer":"F"}` Un tuple se délimite avec ``[`` et ``]``
- :quiz:`{"type":"TF","answer":"T"}` Un tuple se délimite avec ``(`` et ``)``
- :quiz:`{"type":"TF","answer":"F"}` Un tuple se délimite avec ``{`` et ``}``
- :quiz:`{"type":"TF","answer":"T"}` Un tuple peut contenir des objets hétérogènes
- :quiz:`{"type":"TF","answer":"T"}` Un tuple est une collection ordonnée
- :quiz:`{"type":"TF","answer":"F"}` Les opérations de slicing sur un tuple sont légèrement différentes des opérations de slicing sur une chaine de caractères
- :quiz:`{"type":"TF","answer":"F"}` Un tuple est *mutable*
- :quiz:`{"type":"TF","answer":"T"}` Une fois créé, la taille d'un tuple est figée
- :quiz:`{"type":"TF","answer":"F"}` On peut insérer un élément dans un tuple après sa création
- :quiz:`{"type":"TF","answer":"F"}` On peut supprimer un élément d'un tuple
- :quiz:`{"type":"TF","answer":"T"}` Un tuple dispose de méthodes
- :quiz:`{"type":"TF","answer":"T"}` Le slicing peut être utilisé pour extraire des éléments d'un tuple
- :quiz:`{"type":"TF","answer":"F"}` Le slicing peut être utilisé pour insérer des éléments dans un tuple
- :quiz:`{"type":"TF","answer":"T"}` Le slicing ne peut pas modifier la taille d'un tuple
- :quiz:`{"type":"TF","answer":"T"}` Sur un tuple, l'opérateur d'appartenance ``in`` fonctionne exactement comme pour une liste
- :quiz:`{"type":"TF","answer":"T"}` La façon privilégiée de parcourir un tuple est d'itérer sur ses éléments
- :quiz:`{"type":"TF","answer":"F"}` La façon privilégiée de parcourir un tuple est d'itérer sur l'index de ses éléments
- :quiz:`{"type":"TF","answer":"F"}` Un tuple dispose d'une méthode pour trier ses éléments
- :quiz:`{"type":"TF","answer":"T"}` On peut construire un tuple dont les éléments sont triés
- :quiz:`{"type":"TF","answer":"T"}` Un tuple peut contenir n'importe quel objet Python
- :quiz:`{"type":"TF","answer":"T"}` On peut construire des tuples imbriqués