C’est le cours python numéro 12 de la série des cours d’initiation à python.

LE tuple

En plus des listes, il existe d’autres types de données dérivés en Python qui ont des caractéristiques similaires.

Le tuple est aussi une collection d’objets. La seule différence avec la liste est qu’elle n’est plus modifiable une fois initialisée, c’est-à-dire que ses éléments ne peuvent plus être modifiés. On peut donc les lire, mais pas les écrire, ni utiliser des fonctions qui le modifient, comme append(), sort(). On dit que la liste est un objet mutable, tandis que le tuple est immuable.

Pour créer un tuple, vous écrivez ses éléments entre parenthèses. Essayons avec IDLE (j’ai commenté le code pour une meilleure compréhension):

>>> city = ("Rome", "Milan", "Naples") # un tuple de 3 chaînes
>>> len (ville) # ok, je ne change pas le tuple
3
>>> ville [1] # ok, je lis une valeur
'Milan'
>>> ville [2] = "Turin" # erreur, j'essaye de changer une valeur
Traceback (dernier appel le plus récent) :
   Fichier "<pyshell # 10>", ligne 1, dans <module>
     ville [2] = "Turin"
TypeError : l'objet 'tuple' ne prend pas en charge l'affectation d'éléments

Vous vous demandez probablement : quel besoin y a-t-il pour un type de données identique à la liste, mais qui fait moins de choses ? La raison en est l’efficacité : j’ai déjà dit que la philosophie de Python est de cacher le plus possible le travail qu’il fait dans la mémoire de l’ordinateur, afin que le programmeur n’ait pas à s’en soucier. Cependant, il faut bien comprendre que la manipulation d’une liste est une opération très lourde du point de vue de la gestion de la mémoire (la liste pouvant s’allonger et se raccourcir, Python ne sait pas a priori combien de place elle va occuper, et est donc obligé de supprimer et réécrire en continu dans la mémoire de l’ordinateur).

L’utilisation d’un tuple est beaucoup plus simple pour Python : comme il ne peut plus être modifié, il nécessite une quantité fixe de mémoire et donc moins de temps de traitement qu’une liste. Les programmeurs expérimentés utilisent généralement des tuples lorsque vous avez besoin de créer des tables de valeurs prédéfinies qui ne varieront plus tout au long du programme et à partir desquelles vous n’aurez qu’à lire les données.

>>> class_prima_B = ("Abate", "Bartoli", "Concia") #etc.
>>> citta_lazio = ("Viterbo", "Latina", "Rieti", "Frosinone", "Rome")

Enfin il faut dire que Python accepte un tuple même sans écrire les crochets, en écrivant simplement ses éléments séparés par des virgules :

>>> nombres = 1, 2, 3, 4, 5
>>> taper (chiffres)
<classe 'tuple'>

Cette double possibilité peut dérouter les débutants, mais je la signale quand même car on peut la trouver en lisant un programme écrit par d’autres. En particulier, cette syntaxe permet l’affectation multiple, très souvent utilisée dans le langage car elle permet de “sauver” des lignes de code :

a, b, c = 1, 2, 3

c’est-à-dire que nous pouvons affecter plusieurs variables dans une seule instruction : d’abord toutes les expressions de droite sont calculées, puis deux tuples temporaires sont créés et le tuple de droite est affecté à celui de gauche. Il doit y avoir le même nombre de variables à gauche que d’expressions à droite.

Dans tous les cas, étant donné la facilité avec laquelle vous pouvez vous perdre et générer des erreurs inattendues, je recommande pour le moment de toujours utiliser des listes, en laissant la distinction entre listes et tuples jusqu’à ce que vous soyez plus expérimenté.

Range

La plage est encore plus simple : il s’agit simplement d’une séquence d’entiers, également immuables. Il peut être créé avec la fonction range(), qui a trois syntaxes possibles :

Une fonction	Signification
range(stop)	Les nombres de 0 à stop – 1 (stop n’est jamais inclus)
range(start, stop)	Les numéros Du début (inclus) à l’arrêt (non inclus)
range(start, stop, step)	Les numéros étape par étape à partir du début. step peut aussi être négatif pour obtenir une plage de nombres décroissants. Le dernier nombre est inférieur à start si step est positif, supérieur à si step est négatif

Voyons quelques exemples dans IDLE :

>>> plage (10) # les nombres de 0 à 9
>>> range (-2) # vide : stop est <0
>>> gamme (3, 12) # les nombres de 3 à 11
>>> plage (-6, 0) # les nombres de -6 à -1
>>> plage (-2, 13, 3) # les chiffres (-2, 1, 4, 7, 11) (jusqu'au dernier chiffre <13)
>>> plage (10, 0, -1) # nombres décroissants de 10 à 1 (0 n'est pas inclus)

Notez que dans le cas de la plage IDLE, il ne vous répond qu’en répétant la plage (10), etc. sans vous laisser voir les éléments un par un. Print() a également le même comportement.

CONVERSION

Dans tous les cas, les listes, les tuples et les plages peuvent être convertis les uns dans les autres au moyen de fonctions de conversion spéciales (mais une liste ou un tuple ne peut pas être converti en une plage).

Par exemple, supposons que nous ayons besoin d’une liste avec les 10 000 premiers entiers : les écrire un par un serait carrément ennuyeux ! Cependant, nous pouvons facilement les obtenir sous forme de plage, puis les transformer en liste.

a = plage (10000)
b = liste (a) # une liste de 10000 éléments, impossible à écrire à la main
b = list (range (10000)) # mieux encore : une seule déclaration

Essayez maintenant de demander à IDLE la valeur de b …

INDEX ET CHAÎNES

Le mécanisme d’index fonctionne également pour les chaînes, pour lesquelles nous pouvons indiquer des caractères individuels par leur position dans la chaîne. Python renverra une chaîne composée uniquement du caractère correspondant. Voici un exemple dans IDLE ;

>>> s = "Mamma mia !"
>>> s [0]
'M'
>>> s [4]
'pour'
>>> s [5]
''
>>> s [1] + s [9]
'pour!'

Les chaînes sont cependant un type de données immuable, il n’est donc pas possible d’utiliser des index pour les modifier, ni, évidemment, d’utiliser les fonctions de listes sur celles-ci. Cependant, rappelez-vous qu’au lieu d’ajouter (), nous pouvons toujours utiliser la concaténation (somme entre les chaînes). continue comme ça:

>>> s [2] = "t"
Traceback (dernier appel le plus récent) :
   Fichier "", ligne 1, dans
     s [2] = "t"
TypeError : l'objet 'str' ne prend pas en charge l'affectation d'éléments
>>> s.append (10 * s [9])
Traceback (dernier appel le plus récent) :
   Fichier "", ligne 1, dans
     s.append (10 * s [9])
AttributeError : l'objet 'str' n'a pas d'attribut 'append'
>>> s + = (10 * s [9])
>>> s
'Mamma Mia !!!!!!!!!!!'