Previous Up Next
pdf - e-book - archive

1.5  Tableaux

Considérons un programme dont l’exécution donne :

Saisissez dix valeurs :
1 : 4
2 : 7
3 : 34
4 : 1
5 : 88
6 : 22
7 : 74
8 : 19
9 : 3
10 : 51
Saisissez une valeur :
22
22 est la 6-ème valeur saisie.

Comment programmer cela sans utiliser 10 variables pour stocker les dix premières valeurs saisies ?

1.5.1  Définitions

Une tableau est un regroupement de variables de même type, il est identifié par un nom. Chacune des variables du tableau est numérotée, ce numéro s’appelle un indice. Chaque variable du tableau est donc caractérisée par le nom du tableau et son indice.

Si par exemple, T est un tableau de 10 variables, alors chacune d’elles sera numérotée et il sera possible de la retrouver en utilisant simultanément le nom du tableau et l’indice de la variable. Les différentes variables de T porteront des numéros de 0 à 9, et nous appellerons chacune de ces variables un élément de T.

Une variable n’étant pas un tableau est appelée variable scalaire, un tableau par opposition à une variable scalaire est une variable non scalaire.

1.5.2  Déclaration

Comme les variables d’un tableau doivent être de même type, il convient de préciser ce type au moment de la délaration du tableau. De même, on précise lors de la déclaration du tableau le nombre de variables qu’il contient. La syntaxe est :

<nom> = array('<type>', range(0, <taille>))

Par exemple,

T = array('i', range(0, 4));

déclare un tableau T contenant 4 variables de type int.

Attention ! Vous devez placez au début de votre programme l’instruction

from array import array

1.5.3  Initialisation

Il est possible d’initialiser les éléments d’un tableau à la déclaration. On écrit pour cela entre crochets tous les éléments du tableau, on les dispose par ordre d’indice croissant en les séparant par des virgules. La syntaxe générale de la valeur d’initialisation est donc :

<nom> = array('<type>', [<valeur_0>, <valeur_1>, ..., <valeur_n-1>])

Par exemple, on crée un tableau contenant les 5 premiers nombres impairs de la sorte :

tab = array('i', [1, 3, 5, 7, 9])

1.5.4  Accès aux éléments

Les éléments d’un tableau à n éléments sont indicés de 0 à n−1. On note T[i] l’élément d’indice i du tableau T. Les cinq éléments du tableau de l’exemple ci-avant sont donc notés T[0], T[1], T[2], T[3] et T[4].

1.5.5  Exemple

Nous pouvons maintenant mettre en place le programme du début du cours. Il est nécessaire de stocker 10 valeurs de type entier, nous allons donc déclarer un tableau e de la sorte :

e = array('i', range(0, 10))

La déclaration ci-dessus est celle d’un tableau de 10 int appelé e. Il convient ensuite d’effectuer les saisies des 10 valeurs. On peut par exemple procéder de la sorte :

print ("Saisissez 10 valeurs") e[0] = int(input("1 : ")) e[1] = int(input("2 : ")) e[2] = int(input("3 : ")) e[3] = int(input("4 : ")) e[4] = int(input("5 : ")) e[5] = int(input("6 : ")) e[6] = int(input("7 : ")) e[7] = int(input("8 : ")) e[8] = int(input("9 : ")) e[9] = int(input("10 : "))

Les divers copier/coller necéssaires pour rédiger un tel code sont d’une laideur à proscrire. Nous procéderons plus élégament en faisant une boucle :

for i in range(0, 10): e[i] = int(input(str(i + 1) + " : "))

Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise des boucles pour manier les tableaux, celles-ci permettent d’effectuer un traitement sur chaque élément d’un tableau. Ensuite, il faut saisir une valeur à rechercher dans le tableau :

t = int(input("Saisissez une valeur : "))

Nous allons maintenant rechercher la valeur t dans le tableau e. Considérons pour ce faire la boucle suivante :

i = 0 while e[i] != t: i = i + 1

Cette boucle parcourt le tableau jusqu’à trouver un élément de e qui ait la même valeur que t. Le problème qui pourrait se poser est que si t ne se trouve pas dans le tableau e, alors la boucle pourrait ne pas s’arrêter. Si i prend des valeurs strictement plus grandes que 9, alors il se produira ce que l’on appelle un débordement d’indice. Vous devez toujours veiller à ce qu’il ne se produise pas de débordement d’indice ! Nous allons donc faire en sorte que la boucle s’arrête si i prend des valeurs strictement supérieures à 9.

i = 0 while i < 10 and e[i] != t: i = i + 1

Il existe donc deux façons de sortir de la boucle :

On identifie donc la façon dont on est sorti de la boucle en testant la valeur de i :

if i == 10: print (str(t) + " ne fait pas partie des 10 valeurs saisies.") else: print (str(t) + " est la " + str(i + 1) + "-ème valeur saisie.")

Si (i == 10), alors nous sommes sorti de la boucle parce que l’élément saisi par l’utilisateur ne trouve pas dans le tableau. Dans le cas contraire, t est la i+1-ème valeur saisie par l’utilisateur. On additionne 1 à l’indice parce que l’utilisateur ne sait pas que dans le tableau les éléments sont indicés à partir de 0. Récapitulons :

# -*- coding: utf-8 -*-

from array import array

taille = 10
print ("Saisissez " + str(taille) + " valeurs")
e = array('i', range(0, taille))
for i in range(0, len(e)):
    e[i] = int(input(str(i + 1) + " : "))
t = int(input("Saisissez une valeur : "))
i = 0;
while i < len(e) and t != e[i]:
    i += 1
if i == len(e):
    print (str(t) + " ne fait pas partie des " + str(len(e)) + " valeurs saisies.")
else:
    print (str(t) + " est la " + str(i + 1) + "-ème valeur saisie.")

Télécharger le fichier

1.5.6  La boucle for simplifiée

Il est possible de parcourir un tableau de façon séquentielle et en lecture seule grâce à l’instruction for.

for <variable> in <tableau>: <instructions>

Cette instruction affecte à <variable> pour chaque itération de la boucle un élément de <tableau>. On remarque au passage que le <type> doit être celui des éléments de <tableau>. Par exemple, le programme suivant affiche les quatre premières lettres de l’alphabet :

t = array('u', ['a', 'b', 'c', 'd']) for c in t: print(c);
Previous Up Next