Tuples

Objectifs

À la fin de cette séquence vous serez capable de :

• Manipuler les objets de base Python
• Parcourir séquentiellement un tuple
• Indicer et découper un tuple

1. Définition et syntaxe

Un tuple est une collection ordonnée d’objets de types quelconques séparés par des virgules. En français, on parle aussi de n-uplet pour désigner un tuple.
Comme une chaîne de caractères, un tuple, une fois créé, est immuable c’est-à-dire non modifiable. Cela signifie qu'un tuple est défini une fois pour toutes à sa création ; il ne peut pas être modifié ensuite.
Syntaxe :

mon_objet = "spam", "egg", 10, True, 5.7, "Hello world"
print(mon_objet)

catalogue = "café", "farine", "yaourts", "jus de fruits", "pâtes", "jambon", "petits gâteaux"
print(catalogue)

Bonnes pratiques : Pour améliorer la lisibilité du code, il est vivement conseillé d’encadrer le tuple par des parenthèses.
Ainsi :

catalogue = ("café", "farine", "yaourts", "jus de fruits", "pâtes", "jambon", "petits gâteaux")

# mieux encore
catalogue = ("café",
            "farine",
            "yaourts",
            "jus de fruit",
            "pâtes",
            "jambon",
           "petits gâteaux"
            )

Remarque :
Un tuple est aussi appelé un enregistrement.

Un tuple composé d'un seul objet

t = ('spam',) 

Un tuple vide

tuple_vide = ()

type(tuple_vide)

2. Accéder aux éléments d'un tuple

Comme les chaînes de caratères, un tuple est une séquence en Python. Autrement dit, un ensemble fini et ordonné d’objets numérotés de \(0\) à \(n-1\) si le tuple est composé de \(n\) objets.
Ainsi, un tuple peut être parcouru objet par objet. On dit qu’un tuple est un objet itérable.
On considère le tuple ci-après.

catalogue = ("café",
            "farine",
            "yaourts",
            "jus de fruit",
            "pâtes",
            "jambon",
           "petits gâteaux")

index = int(input("\nSaisir le numéro d'indice d'un article dans le catalogue : "))
print(f"À l'indice {index} on a {catalogue[index]}")

Que renvoie les instructions suivantes :

un_tuple[2]

un_tuple[-1]

un_tuple[1:]

un_tuple[:2]

un_tuple[-6:5]

3. Manipuler les tuples

Déterminer le nombre d'éléments d'un tuple

len(catalogue)

Concaténer des tuples

(1, 2, 3) + ('a', 'b', 'c')

Test d'appartenance ou de non appatenance à un tuple

"pâtes" in catalogue

"pâtes" not in un_tuple

Connaître les méthodes applicables aux tuples

dir(tuple)

Construire un tuple à partir d'une chaîne de caractères

adn = 'ATGCCGCGAT'

tuple_adn = tuple(adn)

print(tuple_adn)

('A', 'T', 'G', 'C', 'C', 'G', 'C', 'G', 'A', 'T')

Le tuple unpacking (affectation multiple ou simultanée, on dit aussi déballage)

a, b, c = ('spam', 3, 'guanine')

print(a)

b

c

Permuter les variables référençants deux objets

i = 2
j = 5

# On permute les valeurs de i et j à l'aide d'une variable temporaire
tmp = i
i = j
j = tmp

var1 = 7
var2 = 10

# On permute les valeurs de var1 et var2
var1, var2 = var2, var1

Un tuple est non mutable non (modifiable)

catalogue = ("café",
            "farine",
            "yaourts",
            "jus de fruit",
            "pâtes",
            "jambon",
           "petits gâteaux")

• Que renvoie l'expression catalogue[2] ?
• Est-ce que catalogue.append("eau") fonctionne ? Pourquoi ?
• Est-ce que catalogue[0] = "malware" fonctionne ? Pourquoi ?

4. Parcourir un tuple à l'aide d'une boucle for

Comme avec une chaîne de caractères, on utilise, l'algorithme du parcours séquentiel.

catalogue = ("café",
            "farine",
            "yaourts",
            "jus de fruit",
            "pâtes",
            "jambon",
           "petits gâteaux"
            )

for produit in catalogue:
    print(produit)

L'autre variante du parcours utilisant les indices

#Parcourir une chaîne par les index 
for i in range(len(catalogue)):
    print(catalogue[i])

5. La sous-classe namedtuple du module collections

5.1. Définition

Cette sous-classe permet de créer un tuple avec des champs nommés ; ce qui rend le code plus lisible et explicite. Les tuples nommés peuvent être utilisés partout où les n-uplets natifs sont utilisés, et ils ajoutent la possibilité d'accéder à leurs champs par leur nom au lieu de leur index de position.

5.2. Syntaxe

from collections import namedtuple

# Avec une liste
nom_du_tuple = namedtuple("nom_du_tuple", ["champ1", "champ2", ..., "champN"])

# Avec une chaîne d'espaces
nom_du_tuple = namedtuple("nom_du_tuple", "champ1 champ2 ... champN")

# Avec une chaîne de champs séparés par des virgules
nom_du_tuple = namedtuple("nom_du_tuple", "champ1, champ2,..., champN")

M = (3, 5)

M[0]

from collections import namedtuple

Point = namedtuple("Point", "x y")

M = Point(3, 5)

M

Nous avons maintenant un point avec deux champs nommés de manière appropriée, x et y.
Ce point fournit une représentation plus conviviale et descriptive, Point(x = 3, y = 5). Il permet d'accéder aux coordonnées en utilisant la notation par points, ce qui est pratique, lisible et explicite.
On peut également utiliser des indices pour accéder à la valeur de chaque coordonnée comme avec un tuple.

#Un autre exemple
Vecteur = namedtuple("Vecteur", ["x", "y"])

u = Vecteur(-1, 4)

u

Vecteur = namedtuple("Vecteur", "x, y")

v = Vecteur(-3, -7)

v

5.2. Accéder aux éléments d'un n-uplet nommé

#Accès par le nom
M.x

#Accès par index
M[0]

# Accès par la fonction built-in (intégrée) getattr()
getattr(v, 'x')

getattr(v, 'y')

Musicien = namedtuple("Musicien", "nom titres")

Jackson = Musicien("Michael Jackson", ["Billie Jean", "Beat it"])

Jackson

Johnny_halliday = Musicien("Jean-Philippe Smet", ["L'Envie", "Allumer le feu", "Que je t'aime"])

Johnny_halliday

m = Musicien("Bach", ["Toccata", "Fugue"])
print(m.nom)
print(m.titres)