Participer au site avec un Tip
Rechercher
 

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Module « builtins » Python 3.11.1

Classe « tuple »

Informations générales

Héritage

builtins.object
    builtins.tuple

Définition

class tuple(builtins.object):

Description

le type tuple permet de représenter une collection de données immuable. Une fois instancié, il n'est plus possible de changer le contenu d'un tuple (ce qui n'est pas le cas d'une liste Python). Pour introduire un tuple, il faut utiliser une paire de parenthèses, contrairement à une liste ou il fallait utiliser une paire de crochets. Voici un premier exemple de définition de tuple.

>>> data = (10, 20, 30, 40, 50)
>>> data
(10, 20, 30, 40, 50)
>>> type(data)
<class 'tuple'>
>>> 
Exemple de définition d'un tuple en Python

Comme nous l'avons dit, une fois son instanciation terminée, un tuple est immuable (non modifiable). Le plus simple, pour s'en rendre compte, est de tenter de modifier une valeur du tuple ou de supprimer une information. Voici les messages d'erreurs qui seront alors produits.

>>> data = (10, 20, 30, 40, 50)
>>> data[2]
30
>>> data[2] = 3000
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del data[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> data.append(60)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>> 
Un tuple est non modifiable.

Un tuple Python n'est pas limité à un type de données unique : vous pouvez donc avoir des données quelconque dans un tuple. Voici un exemple de définition d'un tuple contenant des données diverses et variées.

>>> data = (10, 2.3, True, "Une chaîne", False, ["une", "sous", "liste"])
>>> data
(10, 2.3, True, 'Une chaîne', False, ['une', 'sous', 'liste'])
>>> 
Un tuple peut contenir de données de types divers et variés.

Pour calculer la taille d'une tuple, il faut utiliser la fonction len.

>>> data = (10, 20, 30, 40, 50)
>>> nb = len(data)
>>> print("Nombre d'éléments :", nb)
Nombre d'éléments : 5
>>> 
Récupération de la taille d'un tuple

Une fois la taille du tuple connue, vous pouvez commencer à manipuler les valeurs qui y sont contenues via l'opérateur []. Cet opérateur permet d'accéder à un élément du tuple par sa position. Il est important de mémoriser que les indices (les positions) dans un tuple commencent à 0. Ainsi, si un tuple contient cinq éléments alors les indices seront compris entre 0 et 4. Voici un exemple de récupération des valeurs d'un tuple.

>>> data = (10, 20, 30, 40, 50)
>>> data[0]     # On récupère le premier élément
10
>>> data[1]     # Le second
20
>>> data[2]
30
>>> data[3]
40
>>> data[4]     # Le dernier élément du tuple
50
>>> data[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> 
Accès par position aux éléments d'un tuple.

Contrairement à certains autres langages de programmation, Python autorise l'utilisation d'index négatifs : Dans ce cas, on accède aux valeurs de la collection par la fin : -1 correspond à l'indice du dernier éléments du tuple, -2 correspond à l'indice de l'avant-dernier élément... Voici un exemple d'utilisation d'index négatif.

>>> data = (10, 20, 30, 40, 50)
>>> data[-1]    # Dernier élément
50
>>> data[-2]
40
>>> data[-3]
30
>>> data[-4]
20
>>> data[-5]
10
>>> data[-6]    # Premier élément
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> 

Il est aussi possible de savoir si une valeur est présente dans le tuple en utilisant l'opérateur in. Voici un exemple d'utilisation.

>>> l = (10, 20, 30, 40, 50)
>>> 10 in l
True
>>> 100 in l
False
>>> is_present = 30 in l
>>> if is_present: print("30 est présent dans le tuple")
... 
30 est présent dans le tuple
>>> 

Il est bien entendu possible de parcourir tous les éléments d'un tuple avec une boucle (for ou while).

 1 
 2 
 3 
 4 
 5 
 6 
 7 
data = (10, 20, 30, 40, 50)

# On traite chaque élément du tuple, un par un
for value in data:
    print(value)
    
print("Parcours terminé")
Fichier sample.py : exemple de parcours d'une liste avec une boucle for

Nous avons parlé de l'opérateur [] qui permet d'accéder aux éléments d'un tuple. Pour le moment, nous avons accédé aux valeurs une à une, mais il est aussi possible d'accéder à plusieurs valeurs du tuple via un seul appel à l'opérateur [] (un sous-tuple). Dans ce cas, on parle de « slice » (de tranches, si l'on parle en français).

Pour extraire une sous-tuple, à l'instar des chaînes de caractères ou des listes, il faut passer l'indice de début (basé à partir de 0) et l'indice de fin (position exclusive) de cette dernière. Les deux indices doivent être séparés par un caractère :. Voici quelques exemples d'utilisation.

>>> data = (10, 20, 30, 40, 50)
>>> data[1:3]
(20, 30)
>>> data[1:4]
(20, 30, 40)
>>> data[1:5]
(20, 30, 40, 50)
>>> data[:4]
(10, 20, 30, 40)
>>> data[2:]
(30, 40, 50)
>>> data[:]
(10, 20, 30, 40, 50)
>>> 
comme vous le constatez, si vous ne mentionnez pas l'indice de début, la valeur 0 sera considérée. De même, si vous ne spécifiez pas l'indice de fin, la valeur len(le_tuple) sera considérée. Dans les deux cas, le caractère : doit impérativement être présent, sans quoi un seul élément du tuple sera considéré.
l'indice de fin est exclusif, ce qui implique que la valeur à la position de fin ne fera pas partie du sous-tuple. Le nombre d'éléments à extraire vaut donc indice_de_fin - indice_de_debut : data[1:4] permettra donc d'extraire 3 valeurs (4 - 1 = 3).

Il est aussi possible d'extraire les éléments d'un sous-tuple tout les « n » éléments. Imaginons que vous ayez une liste qui contiennent des coordonnées x, y qui suivent les une après les autres. Si vous souhaitez extraire que les abscisses (les x), vous pouvez le faire en spécifiant la slice suivante : coords[::2] (avec le pas en troisième paramètre de la slice). Pour obtenir toutes les ordonnées (les y), veuillez utiliser la slice suivante : coords[1::2], pour débuter l'extraction à partir de la seconde valeur par pas de 2. Voici un exemple d'utilisation.

>>> #         x, y, x,  y, x,  y,  x, y
>>> coords = (0, 0, 10, 5, 13, 12, 5, 7)
>>> 
>>> all_x = coords[::2]
>>> all_x
(0, 10, 13, 5)
>>> 
>>> all_y = coords[1::2]
>>> all_y
(0, 5, 12, 7)
>>> 

De nombreux autres opérateurs sont aussi proposés par la classe tuple. Voici quelques exemples d'utilisation.

>>> t = (10, 20, 30, 40, 50)
>>> t2 = (60, 70, 80, 90, 100)
>>> 
>>> # Concaténation de tuples
>>> full = t + t2
>>> full
(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
>>> 
>>> # Répétition d'un tuple
>>> t * 3
(10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50)
>>> 
>>> # Comparaison de tuples
>>> t == t2
False
>>> 
>>> # Recherche d'une valeur dans un tuple
>>> 30 in t
True
>>> 70 in t
False
>>> 
Exemple d'utilisation d'opérateurs disponibles pour vos tuples.

Il est possible de typer vos tuples en utilisant la syntaxe suivante.

 1 
 2 
 3 
# Attention : Python 3.9 ou supérieur requis !!!
data: tuple[float] = (10, 20.2, 13.4)
print(data)
Typage d'une variable en tant que tuple de valeurs flottantes.

help(tuple)

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.

Exemple(s) de code

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
#!/usr/bin/python3

data = (
    ("Andon", 43.77348, 6.78596),
    ("Caille", 43.77887, 6.72979),
    ("Séranon", 43.77435, 6.70415),
    ("Valderoure", 43.79629, 6.70749)
    # Vous ne devez pas présager du nombre de triplets.
)

city_count = len(data)

separator = f"+{'-' * 15}+{'-' * 15}+{'-' * 15}+"
header = f"| {'Ville':13s} | {'Latitude':>13s} | {'Longitude':>13s} |"

print(separator)
print(header)
print(separator)
for city_data in data:
    city = city_data[0]
    lat = city_data[1]
    long = city_data[2]
    print(f"| {city:13s} | {lat:13.5f} | {long:13.5f} |")
print(separator)
Exemple d'utilisation de la class tuple.

Et voici les résultats produits par cet exemple.

$> python3 sample.py
+---------------+---------------+---------------+
| Ville         |      Latitude |     Longitude |
+---------------+---------------+---------------+
| Andon         |      43.77348 |       6.78596 |
| Caille        |      43.77887 |       6.72979 |
| Séranon       |      43.77435 |       6.70415 |
| Valderoure    |      43.79629 |       6.70749 |
+---------------+---------------+---------------+
$> 

Constructeur(s)

Signature du constructeur Description
__new__(*args, **kwargs) Create and return a new object. See help(type) for accurate signature. [extrait de __new__.__doc__]
__init__(self, /, *args, **kwargs) Initialize self. See help(type(self)) for accurate signature. [extrait de __init__.__doc__]

Liste des opérateurs

Signature de l'opérateur Description
__add__(self, value) Return self+value. [extrait de __add__.__doc__]
__contains__(self, key) Return key in self. [extrait de __contains__.__doc__]
__eq__(self, value) Return self==value. [extrait de __eq__.__doc__]
__ge__(self, value) Return self>=value. [extrait de __ge__.__doc__]
__getitem__(self, key) Return self[key]. [extrait de __getitem__.__doc__]
__gt__(self, value) Return self>value. [extrait de __gt__.__doc__]
__le__(self, value) Return self<=value. [extrait de __le__.__doc__]
__lt__(self, value) Return self<value. [extrait de __lt__.__doc__]
__mul__(self, value) Return self*value. [extrait de __mul__.__doc__]
__ne__(self, value) Return self!=value. [extrait de __ne__.__doc__]
__rmul__(self, value) Return value*self. [extrait de __rmul__.__doc__]

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques Méthodes dépréciées
Signature de la méthodeDescription
__class_getitem__ See PEP 585 [extrait de __class_getitem__.__doc__]
__getattribute__(self, name) Return getattr(self, name). [extrait de __getattribute__.__doc__]
__getnewargs__(self)
__hash__(self) Return hash(self). [extrait de __hash__.__doc__]
__iter__(self) Implement iter(self). [extrait de __iter__.__doc__]
__len__(self) Return len(self). [extrait de __len__.__doc__]
__repr__(self) Return repr(self). [extrait de __repr__.__doc__]
count(self, value) -> int Compte le nombre d'occurrences de la valeur spécifiée en paramètre. Return number of occurrences of value. [extrait de count.__doc__]
index(self, value, start=0, stop=2**63-1) -> int Renvoie la position de la première occurrence d'une valeur dans le tuple courant. Return first index of value. [extrait de index.__doc__]

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __getstate__, __init_subclass__, __reduce__, __reduce_ex__, __setattr__, __sizeof__, __str__, __subclasshook__

Voir aussi

Classe list
Classe dict
Classe set

Fonction len
Fonction max
Fonction min
Fonction sum