Les p-uplets

Un p-uplet (type tuple), est une suite ordonnée d’éléments qui peuvent être chacun de n’importe quel type.

Création d’un p-uplet

Pour créer un p-uplet non vide, on écrit des valeurs séparées par des virgules.

Par exemple :

• t = "a","b","c", 3 ou bien t = ("a", "b", "c", 3) pour un tuple à 4 éléments ;
• t = "a", ou bien t = ("a",) pour un tuple à 1 éléments (attention à la virgule) ;
• t = () pour un tuple à 0 éléments (ici, pas de virgule, mais des parenthèses obligatoires).

Pour écrire un p-uplet qui contient un n-uplet, l’utilisation de parenthèses est nécessaire.

Voici un exemple avec un tuple à 2 éléments dont le second est lui-même un tuple : t = 3, ("a","b","c")

Remarque : en général, les parenthèses sont obligatoires dès que l’écriture d’un p-uplet est contenue dans une expression plus longue. Dans tous les cas, les parenthèses peuvent améliorer la lisibilité.

 

Opérations

Nous avons deux opérateurs de concaténation qui s’utilisent comme avec les chaînes de caractères, ce sont les opérateurs + et *.

De nouveaux p-uplets sont créés.

>>> t1 = "a", "b"
>>> t2 = "c", "d"

>>> t1 + t2
('a','b','c','d')

>>> 3 * t1
('a','b','a','b','a','b')

 

Appartenance

Pour tester l’appartenance d’un élément à un tuple, on utilise l’opérateur in :

>>> t = "a", "b", "c"
>>> "a" in t
True

>>> "d" in t
False

 

Utilisation des indices

Les indices permettent d’accéder aux différents éléments d’un tuple. Pour accéder à un élément d’indice i d’un tuple t, la syntaxe est t[i].

L’indice i peut prendre les valeurs entières de 0 à n−1 où n est la longueur du tuple.

Cette longueur s’obtient avec la fonction len() :

>>> t ="a", 1,"b", 2,"c", 3

>>> len(t)
6

>>> t[2]
'b'

Les éléments d’un tuple ne sont pas modifiables par une affectation de la forme t[i] = valeur. Cela provoque une erreur.

 

La notation est celle utilisée avec les suites en mathématiques (\(u_0,u_1,u_2,…\)) : les indices commencent à 0.

Par exemple le troisième élément a pour indice 2.

Le dernier élément d’un tuple t  a pour indice len(t)-1. On accède ainsi au dernier élément avec t[len(t)-1]  qui peut s’abréger en t[-1].

>>> t = "a", 1, "b", 2, "c", 3
>>> t[-1]
3

>>> t[-2]
'c'

 

Exemple avec des tuples emboîtés (un tuple contenant des tuples) :

>>> t = ("a", "b"), ("c", "d")
>>> t[1][0]
'c'

Explication : t[1] est le tuple ("c", "d") et "c"  est l’élément d’indice 0 de ce tuple.

 

 

Affectation multiple

Prenons pour exemple l’affectation a, b, c = 1, 2, 3.

Ceci signifie que le tuple (a, b, c) prend pour valeur le tuple (1, 2, 3), autrement dit, les valeurs respectives des variables a, b et c sont 1, 2 et 3.

En particulier, l’instruction a, b = b, a permet d’échanger les valeurs des deux variables a et b.

Les valeurs des éléments d’un tuple peuvent ainsi être stockées dans des variables.

>>> t = 1, 2, 3
>>> a, b, c = t
>>> b
2

 

Cette syntaxe s’utilise souvent avec une fonction qui renvoie un tuple.

Voici un exemple avec une fonction qui calcule et renvoie les longueurs des trois côtés d’un triangle ABC. La fonction prend en paramètres trois p-uplets représentant les coordonnées des trois points.

from math import sqrt

def longueurs(A,B, C):
   xA,yA = A
   xB,yB = B
   xC,yC = C
   dAB= sqrt((xB - xA) ** 2 + (yB - yA) ** 2)
   dBC= sqrt((xC - xB) ** 2 + (yC - yB) ** 2)
   dAC= sqrt((xC - xA) ** 2 + (yC - yA) ** 2)
   return dAB, dBC, dAC

La fonction étant définie, nous l’utilisons dans l’interpréteur :

>>> M = (3.4, 7.8)
>>> N = (5, 1.6)
>>> P = (-3.8, 4.3)
>>> dMN, dNP, dMP = longueurs(M, N, P)
>>> dMN
6.4031242374328485