1. Tuples et tableaux

On l'a vu, Python propose 4 types de données de base ( pour rappel : int, float, str et bool ).

A partir de là, il est possible de "construire" ses propres types de données à partir des précédents.

Prenons un exemple : on voudrait stocker dans un script l'ensemble des notes des élèves d'une classe; il faut donc autant de variables qu'il y a de notes, et ce pour chacun des élèves :

Pour un seul élève, ça va encore...

Ensuite, ça ne devient plus gérable...

Il serait alors judicieux de regrouper les notes d'un même élève dans un même ensemble, correspondant à un nouveau type de données appelé par exemple notes; chaque élève correspondrait alors à une "variable" différente de ce nouveau type, mais au contraire des types de base, elles stockeraient plusieurs données à la fois, regroupées sous le même nom :

Le type notes

Plusieurs variables du type notes

C'est ce que permettent de faire les tuples et les tableaux en Python.

Ils correspondent en informatique à un ensemble de données ( une "collection" ), rassemblées de façon à pouvoir y accéder facilement. Chaque donnée correspond à un élément différent de l'ensemble.
Dans de nombreux langages, ces éléments doivent être du même type, mais ce n'est pas le cas en Python : on peut mettre dans un tuple ou tableau Python des données de type différent ( mais c'est à éviter pour des raisons de lisibilité...).

Chaque élément d'un tuple ou tableau correspond donc à une "case" dans laquelle on placerait une donnée. L'ordre dans lequel les données sont rangées permettra alors de les retrouver en désignant la bonne "case" dans laquelle elle est contenue.

La grosse différence entre tuple et tableau est la suivante :

• un tuple, et les éléments d'un tuple, ne peuvent pas être modifiés après création : un tuple est un objet immuable ( = non-mutable ).
  Les éléments d'un tuple sont placés entre parenthèses, séparés par des virgules : (1, 6, 8, 11).
• les tableaux, et les éléments qu'ils contiennent, peuvent au contraire être modifiés : un tableau est un objet mutable.
  Les éléments d'un tableau sont placés entre crochets, séparés par des virgules : [1, 6, 8, 11].

Un tableau ou un tuple a un nom : ce nom est commun à l'ensemble des données stockées dans le tuple ou le tableau; on le choisit arbitrairement, mais comme pour les variables, il y a certaines restrictions dans ce choix : on ne peut pas utiliser les termes du langage Python lui-même, le nom ne doit pas commencer par un chiffre ni un caractère autre qu'une lettre, il ne doit pas y avoir d'espace,...
On peut utiliser des lettres majuscules, sauf au début du nom.

Initialisation d'un tuple ou d'un tableau

Création "de toute pièce"

C'est la seule méthode pour créer un tuple. On décrit l'ensemble des éléments, séparés par des virgules; la syntaxe change pour les tuples et les tableaux :

	tableau1 = [45,32,27,189,78,569,423,785,23,78,630] # utilisation de crochets pour les tableaux

	noms = ('durand','martin','roger','paul','dubois','jean') # utilisation de parenthèses pour les tuples
			

Cas des tableaux

Création d'un tableau vide

Vous aurez parfois besoin d'initialiser un tableau vide, c'est à dire n'ayant aucun élément :

tableau_vide = []
				

"Remplissage automatique"

Pour remplir automatiquement un tableau avec un nombre donné d'éléments tous identiques :

tableau1 = [None]*100  # crée un tableau contenant 100 éléments tous égaux à None ( = "rien" )
tableau2 = [0]*10  # crée un tableau contenant 10 éléments tous égaux à 0
			

( Vous aviez déjà vu cette façon de faire avec les chaînes de caractères...)

Création à l'aide d'une boucle

Méthode 1

La première idée est de créer un tableau ayant un certain nombre d'éléments de valeur quelconque dans un premier temps ( None par exemple, qui signifie "rien" ), et de "remplir" ensuite chaque "case" avec une valeur :

tab = [None]*10  # création d'un tableau de 10 éléments tous égaux à 'None'

for i in range(10):
	tab[i] = 2**i 		# "remplit" chaque élément avec une puissance croissante de 2
			

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
			

Méthode 2

A partir d'un tableau ne contenant initialement aucun élément, on "concatène" les éléments les uns après les autres à la fin du tableau qui se construit donc petit à petit :

tab = [] # tableau vide

for i in range(10):
	tab.append(2**i) # "append" = "ajouter à la fin"
			

Il existe une autre syntaxe, équivalente à la précédente : :

tab = []

for i in range(10):
	tab += [2**i]
			

Les tableaux par compréhension

Équivalent à ci-dessus mais en plus concis, les tableaux par compréhension :

tableau1 = [i for i in range(10)] # crée un tableau contenant 10 éléments de 0 à 9

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
			

tableau2 = [2*i for i in range(10)] # crée un tableau contenant 10 éléments, chaque élément étant le double du compteur i

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>
			

tableau3 = [2*i for i in range(10) if i%3 == 0 ] # crée un tableau contenant les éléments double du compteur i, mais uniquement si i est divisible par 3

[0, 6, 12, 18]
>>>
			

L'expression peut être plus ou moins complexe selon ce que l'on veut faire !

Travail avec les tuples et les tableaux

Repérage d'un élément

Chaque élément d'un tuple ou d'un tableau est repéré par son index ( ou indice ), qui représente la position de la donnée ( en gros, le numéro de la "case" où la donnée est stockée ) depuis le début du tuple ou tableau.

Pour adresser un élément particulier du tuple/tableau, on utilise alors la syntaxe suivante :

nom[index]
			

Exemples pour le tuple/tableau ci-dessus, nommé tup_tab :

tup_tab[0] = 45
tup_tab[3] = 'truc'
tup_tab[8] = 2.3
			

...c'est donc tout à fait le même "mode de fonctionnement" que les chaînes de caractères...

Affichage

Pour afficher un élément d'un tuple/tableau, utiliser la syntaxe précédente :

	print(tup_tab[8])
	>>> 2.3

	print(tup_tab[3])
	>>> 'truc'
				

Pour afficher le tuple/tableau complet, utiliser son nom général :

	print(tup_tab)
	>>> [45,3.2,27.246,'truc',78,'bidule',423,785,2.3,7.896,True,....]
			

Nombre d'éléments dans un tuple ou un tableau

Pour trouver le nombre d'éléments présents dans un tuple ou un tableau, utiliser l'instruction len() :

	taille = len(tableau3)

	print(taille)
	>>> 4
			

Détermination de l'index d'un élément donné

Pour déterminer l'index d'une valeur particulière dans un tuple ou un tableau, utiliser la fonction index() :

	tableau4 = ['lundi','mardi','mercredi','jeudi','vendredi','samedi','dimanche']
	position = tableau4.index('mercredi')

	print(position)
	>>> 2
			

Parcours d'un tuple ou d'un tableau

Un tuple ou un tableau est, comme une chaîne de caractères, un objet itérable, que l'on peut donc parcourir avec une boucle pour "s'adresser" à chacun de ses éléments les uns après les autres.

Parcours par valeur

	for element in tup_tab :
		print(element)
			

	45
	3.2
	27.246
	'truc'
	78
	'bidule'
	....
	>>>
			

A chaque tour de boucle, la variable element contiendra un des éléments successifs du tuple/tableau.

Parcours par index

Cependant, on a parfois besoin de connaître, en plus de l'élément lui-même, l'index de cet élément, ce que ne permet pas de faire la syntaxe précédente.
On peut utiliser la fonction index() vu précédemment, ou alors utiliser une syntaxe plus proche d'une boucle "normale" :

	for i in range(len(tup_tab)) :
		element = tup_tab[i]	# la variable i contient l'index de l'élément stocké dans la variable element
		print(i, element)
			

	0	45
	1	3.2
	2	27.246
	3	'truc'
	4	78
	5	'bidule'
	....
	>>>
			

Test d'appartenance d'un élément

On peut tester la présence de telle ou telle valeur dans un tuple ou un tableau en utilisant l'opérateur in :

	if valeur in tup_tab:
		.................
			

Modification d'un tableau

Au contraire des tuples, les tableaux sont mutables; on peut donc les modifier, et modifier leurs éléments.

Modification d'un élément

Il suffit d'affecter une nouvelle valeur à l'élément :

	tableau = ['A', 'B', 'D', 'D']
	tableau[2] = 'C'

	print(tableau)
			

	['A', 'B', 'C', 'D']
	>>>
			

Concaténation de deux tableaux

Comme pour les chaînes de caractère, l'opérateur + permet de concaténer deux tableaux en un plus grand :

	tableau1 = [1 , 2 , 3]
	tableau2 = [4 , 5 , 6]
	tableau1 = tableau1 + tableau2

	print(tableau1)
			

	[1 , 2 , 3 , 4 , 5 , 6]
	>>>
			

Tuple ou tableau ?

Quand utiliser un tuple ou un tableau ?

Vous venez de voir que les tableaux sont bien plus "souples" que les tuples, et vous en viendrez alors vite à vous demander quel est l'intérêt de ces derniers : pourquoi ne pas toujours utiliser des tableaux ?

Il faut bien voir que leur stockage en mémoire n'est pas du tout le même :

• un tuple n'étant pas modifiable, la place qu'il occupe en mémoire est bien définie et réduite au nécessaire; le parcours de ses éléments est très rapide.
• un tableau pouvant être modifié, rallongé,..., Python est obligé de réserver pour lui en mémoire plus de place que nécessaire ( en l'occurrence c'est le double de la taille du tableau ! ) pour anticiper ces modifications. De plus, le parcours des éléments d'un tableau est beaucoup plus lent.

On aura donc intérêt à utiliser les tuples quand on n'aura à stocker que des données constantes au cours d'un programme.

Les tuples dans les fonctions

Les tuples sont également mis en œuvre lorsqu'une fonction doit renvoyer plusieurs résultats.

Voila par exemple la définition d'une fonction qui calcule et renvoie le quotient et le reste de la division entière de deux entiers :

def division_entiere(n1:int, n2:int) -> int:
	quotient = n1 // n2
	reste = n1 % n2
	return quotient, reste   # renvoi des deux valeurs sous forme d'un tuple ( les parenthèses sont optionnelle dans cette situation )
			

Les deux résultats quotient et reste sont renvoyés sous forme d'un tuple au programme principal.

Il faudra donc penser que le type de la variable utilisée lors de l'appel de la fonction depuis le programme principal sera un tuple :

resultat = division_entiere(146, 78) # affectation du résultat renvoyé par la fonction au tuple 'resultat'

print("Le quotient est égal à", resultat[0])
print("Le reste est égal à", resultat[1])
			

Vous rencontrerez assez souvent des fonctions renvoyant des tuples de plusieurs résultats, faites attention quand c'est le cas !

QCM d'entraînement

Exercices

1. Manipulation de base sur les tableaux (exercice_C01.py)

2. Création de tableaux par compréhension (exercice_C02.py)

Créer par compréhension, puis afficher les tableaux suivants :

t1 = [0, 1.1, 2.3, 4.5, 3.33, 8.25, 4.76, 7.75]

3. Inversion d'un tableau (exercice_C03.py)

4. Statistiques sur l'ADN (exercice_C04.py)