Les tableaux
Les tableaux vont vous être très utiles dans vos programmes. Vous verrez que le jeu morpion qui a été fait
en exercice sera modifié et utilisera un tableau. Donc si vous ne l'avez pas fait, je vous conseille
d'essayer de le faire ou de télécharger la correction.
Les tableaux
Un tableau est une grosse variable qui contient plusieurs valeurs de type identique (tous des nombres
entiers, tous des nombres décimaux, etc... ).
Un tableau s'initialise de la manière suivante:
![tableau = [valeur, valeur1, ...]](tuto/Init_tableau.png "Initialisation d'un tableau")
Initialisation d'un tableau.
Dans un tableau, on peut mettre autant de valeurs que l'on veut, mais elles doivent toutes être entre
les crochets. Vous pouvez remarquer que chaque valeur est séparée par une virgule.
Dans la description d'un tableau, j'ai mis que toutes les valeurs doivent être de types identiques.
Donc si "valeur" est de type "int", "valeur1" et toute les autres valeurs seront de type "int".
On sait maintenant créer un tableau, donc il est temps d'apprendre à utiliser ce tableau.
tableau = [5, 4, 15, -1]
Imaginons que l'on veut afficher à l'écran "valeur1" (soit 4).
Si vous tapez le code suivant:
print (tableau)
Vous n'obtiendrez pas 4 mais [5, 4, 15, -1]. C'est à dire que vous avez affiché le tableau en entier.
Mais je vous rappelle que l'on ne veut que le 4.
Pour afficher la partie que l'on veut, on va devoir dire "je veux la deuxième valeur de tableau".
Pour dire cela, on va devoir coder de la manière suivante.
print (tableau[1])
Vous allez me dire : Pourquoi t'as mis 1 !!! Vu que l'on veut la deuxième valeur.
Et bien j'ai mis 1 car la numérotation commence à 0 et non 1 donc pour avoir la 1ere valeur, il faut
taper 0. Pour la deuxième valeur tapez 1, au 6 90 90 ou par sms ...
Donc si on veut la valeur -1 de notre tableau ci-dessus, il faut taper :
print (tableau[3])
Maintenant on désire modifier cette valeur car je n'aime pas être dans le négatif
. On va remplacer -1 par 1234, on code donc :
tableau[3] = 1234
Pour vraiment voir le changement codez ceci :
tableau = [5, 4, 15, -1]
print (tableau[3])
tableau[3] = 1234
print (tableau[3])
print (tableau)
Vous verrez que la valeur est -1 puis devient 1234 et que tableau devient [5, 4, 15, 1234].
Les tableaux dans les fonctions
Je vous ai dit en début de chapitre que j'allais utiliser le jeu du morpion alors que je ne l'ai
toujours pas utilisé. Et bien c'est le moment.
Voici le code de l'exercice qui est intéressant pour ce chapitre:
A1, A2, A3 = " ", " ", " "
B1, B2, B3 = " ", " ", " "
C1, C2, C3 = " ", " ", " "
Maintenant avec le tableau, on fait :
case = [" ", " ", " "," ", " ", " "," ", " ", " "]
case[0] correspond à A1, case[3] correspond à B1, case[6] correspond à C1.
Bon pour soucis de compréhension, on va plutôt coder ceci :
A = [" ", " ", " "]
B = [" ", " ", " "]
C = [" ", " ", " "]
A[0] correspond à A1, B[0] correspond à B1, C[0] correspond à C1.
Affichage sera donc comme ceci :
# codage de l'exercice
def affichage(A1,A2,A3,B1,B2,B3,C1,C2,C3):
print ("\n A B C")
print ("#############")
print ("#", A1, "|", B1, "|", C1, "# 1")
print ("#---+---+---#")
print ("#", A2, "|", B2, "|", C2, "# 2")
print ("#---+---+---#")
print ("#", A3, "|", B3, "|", C3, "# 3")
print ("#############\n")
# codage avec tableaux
def affichage(A, B, C):
print ("\n A B C"
print ("#############")
print ("#", A[0], "|", B[0], "|", C[0], "# 1")
print ("#---+---+---#")
print ("#", A[1], "|", B[1], "|", C[1], "# 2")
print ("#---+---+---#")
print ("#", A[2], "|", B[2], "|", C[2], "# 3")
print ("#############\n")
Comme pour cette partie je parle des tableaux dans les fonctions, je veux que vous portiez une
attention aux paramètres.
Sans les tableaux, on a 9 paramètres alors qu'avec, on en a que 3.
En fait quand on transmet un tableau comme paramètre, on transmet toutes les valeurs qu'il contient.
Si j'aurai utilisé le tableau "case", j'aurai mis qu'un seul paramètre.
Par contre les tableaux s'utilisent de la même façon que s'ils étaient en dehors de fonction.
Si vous voulez voir la différence du programme avec et sans tableaux, téléchargez ces deux codes
sources :
Tableaux à plusieurs dimensions
Il y en encore une façon différente de faire ce morpion (Et oui !!! Je vous l'avais dit lors de
l'énoncé de cet exercice qu'il existait des tonnes de façon de coder). La façon dont je pense est un
tableau à plusieurs dimensions.
Pour le morpion, nous allons créer un tableau à 2 dimensions car il y a la dimension de largeur
(3 cases : A-B-C) et celle de hauteur (3 cases : 1-2-3).
Voici comment on initialise un tableau à plusieurs dimensions :
![tableau = [[valeur1_1, ...], [valeur2_1, ...], ...]](tuto/Init_tableau_2D.png "Initialisation d'un tableau")
Initialisation d'un tableau à plusieurs dimensions.
Vous remarquez qu'il y a des crochets à l'intérieur d'autres crochets, ceci veut dire qu'il y a des
tableaux imbriqués. Un tableau à plusieurs dimensions est donc un tableau ayant d'autres tableaux
comme valeurs.
Chaque imbrication ajoute une dimension au tableau. Donc un tableau dans un tableau donne 2 dimensions,
un tableau dans un tableau dans un tableau donne 3 dimensions, etc...
Comme le morpion à besoin d'un tableau à 2 dimensions, on doit initialiser ce tableau avec une seule
imbrication de tableaux.
# initialisation avec tableaux
A = [" ", " ", " "]
B = [" ", " ", " "]
C = [" ", " ", " "]
# initialisation avec tableau à 2 dimensions
morpion = [[" ", " ", " "],[" ", " ", " "],[" ", " ", " "]]
En fait le 1er tableau correspond à la 1ère ligne, le 2ème tableau correspond à la 2ème ligne, etc...
Le 1er " " de chaque tableau correspond à la 1ère colonne, le 2ème " " correspond à la 2ème ligne
etc...
Maintenant je vais vous expliquer comment affiché une partie du tableau.
morpion = [["X", "O", "X"],["O", "O", "X"],["X", "X", "O"]]
# affichage de la 1ère ligne
print (morpion[0])
# affichage de la 2ème ligne
print (morpion[1])
# affichage de la 3ème ligne
print (morpion[2])
On obtient donc :
['X', 'O', 'X']
['O', 'O', 'X']
['X', 'X', 'O']
C'est bien d'avoir les lignes mais ce qui est vraiment utile pour notre morpion, c'est de récupérer
chaque valeur de chaque ligne. Pour cela on code de la manière suivante :
morpion = [["X", "O", "X"],["O", "O", "X"],["X", "X", "O"]]
# affichage de la 1ère valeur de la 1ère ligne
print (morpion[0][0])
# affichage de la 2ème valeur de la 1ère ligne
print (morpion[0][1])
# affichage de la 3ème valeur de la 1ère ligne
print (morpion[0][2])
# affichage de la 1ère valeur de la 2ème ligne
print (ligne 2 :, morpion[1][0])
Et on obtient donc :
X
O
X
ligne 2 : O
Pour récapituler :
- Pour atteindre une case d'un tableau à 1 dimension, on entre son index entre crochets
(Attention l'index démarre à 0), ça donne quelque chose de ce genre : tableau[0].
- Pour chaque dimension supplémentaire, on ajoute l'index de cette dimension entre crochet,
ex: tableau[0][0]. (tableau[index dimension 1][index dimension 2])
Parcourir un tableau
Pour parcourir un tableau, on utilise une boucle while. A chaque tour, on incrémente (décrémente)
l'index.
tableau = [1,7,6,14,4]
i = 0
while i < len(tableau):
print (tableau[i])
i += 1
len(tableau) permet de récupérer la taille du tableau. Dans ce cas ci, len(tableau) vaut 5.
i va représenter l'index du tableau, c'est pour ça qu'elle est initialisée à 0. Cette variable sera
augmentée jusqu'a ce qu'elle prenne la valeur 5. Quand elle vaut 5, on sort de la boucle et on ne fait
rien. Par contre si sa valeur est inférieure, on affiche la valeur du tableau portant cet index.
Ici on obtient 1 puis 7 puis 6 puis 14 puis 4 car on demandait d'afficher tableau[0] puis tableau[1],
etc...
Pour parcourir un tableau à plusieurs dimensions, il faut coder des boucles imbriquées.
Prenons exemple avec un tableau à 2 dimensions.
tableau = [[1,7,5],[6,14,2]]
i = 0
while i < len(tableau):
j = 0
while j < len(tableau[i]):
print (tableau[i][j])
j += 1
i += 1
i étant la 1ère dimension, elle représente les lignes (ligne1 : [1,7,5], ligne2 : [6,14,2])
j représente les colonnes (pour ligne 1, colonne1 : 1, colonne2 : 7, etc..)
Explication:
Tant que i est inférieur à la taille du tableau (3), on entre dans la boucle. i vaut 0
donc on entre dans la boucle et on exécute la deuxième. Tant que j est inférieur à la taille du
tableau représentant la ligne d'index i, on exécute ce qu'il y a à l'intérieur de la boucle,
c'est-à-dire afficher la valeur qui correspond à la ligne (i) et à la colonne (j) demandée. Dans cet
exemple, 1 est affiché à l'écran puis j est augmenté, puis 7 est affiché et j est de nouveau augmenté,
et on termine par voir 5. j est augmenté mais on sort de la boucle car la condition n'est plus bonne.
Maintenant on continue la première boucle, on augmente i pour passer à la deuxième ligne. La condition
est toujours bonne donc on remet j à 0 et on parcourt cette nouvelle ligne. On verra donc s'afficher 6
puis 14 puis 2. Et là les deux boucles s'arrêtent car les conditions ne sont plus respectées.
Parcourir avec for ... in ... :
Il existe un autre moyen de parcourir un tableau. Ce moyen est d'utiliser une boucle for ... in.
tableau = [1,7,6,14,4]
for i in tableau :
print (i)
On obtient la même chose qu'avec une boucle while mais la méthode diffère un peu car ici la variable
i prend une valeur de "tableau" au lieu de n'être que l'index. i vaut donc tableau[0] puis tableau[1],
etc ... C'est-à-dire 1 puis 7 , etc...
Voici un exemple avec un tableau à 2 dimensions.
tableau = [[1,7,5],[6,14,2]]
for i in tableau :
for j in i :
print (j)
Donc ici i prend la valeur tableau[0] et j prend comme valeur tableau[0][0] puis tableau[0][1] et
tableau[0][2]. Ensuite on revient à la première boucle et i prend comme valeur tableau[1] et avec la
deuxième boucle, j prend la valeur tableau[1][0] puis tableau[1][1] et tableau[1][2]. Ainsi on affiche
1 puis 7, 5, 6, 14, 2.
Les listes
En python, il y a un type de donnée qui est difficilement différentiable des tableaux, c'est les
listes. On peut même considérer que les tableaux sont des listes, la preuve si on tape
"print (type(tableau))" après avoir déclaré la variable "tableau", il nous dit que le type est "list".
Ce qui diffère, c'est que contrairement au tableaux, les valeurs peuvent être de type différent
(une liste peut contenir un nombre et un texte, etc...)
Voici un exemple :
liste = ["mercredi", 19, "septembre", 2007]
Tout ce que je vous ai dit sur l'utilisation des tableaux est identique pour les listes.
Méthodes pour utiliser les tableaux et listes
Voici quelques méthodes et fonctions susceptible de vous servir :
| Méthodes et fonctions |
description : |
| list("...") |
Retourne sous forme de liste chaque caractère.
(ex: list("salut") donne ['s', 'a', 'l', 'u', 't'] ) |
| + |
Ajoute une liste à une autre.
liste1 = [1, 2]
liste2 = [3, 4]
liste = liste1 + liste2
Si on affiche "liste", on voit [1,2,3,4] |
| * |
Multiplie la liste.
liste1 = [1, 2]
liste = liste1*3
Si on affiche "liste", on voit [1,2,1,2,1,2] |
| = |
Modifie une valeur dans la liste.
liste1 = [1, 2]
liste1[0] = 5
Si on affiche "liste1" avant la modification, on voit [1,2]. Après la modification, on
obtient [5,2] |
| len(...) |
Affiche la taille du tableau.
liste = [1, 3, 5, 7, 9]
print (len(liste))
On voit donc 5. |
| del(...) |
Supprime la valeur demandée.
liste = [1, 3, 5, 7, 9]
del(liste[0])
Si on affiche liste, on voit [3, 5, 7, 9]. |
| nom_liste.append(...) |
Ajoute à la liste ce qui est entre parenthèse.
liste = [1, 3, 5, 7, 9]
liste.append(12)
liste à été modifiée. 12 à été ajouté à la fin. |
| nom_liste.remove(...) |
Supprime de la liste ce qui est entre parenthèse.
liste = [1, 3, 5, 7, 9]
liste.remove(5)
liste à été modifiée. 5 à été supprimé. On obtient [1, 3, 7, 9]
Si la valeur n'est pas trouvée, une erreur est provoquée. Ca aurait été le cas si on
aurait mis 4.
Si la valeur est présente plusieurs fois, seule celle qui a le plus petit index sera
supprimée. |
| nom_liste.index(...) |
Retourne l'index de ce qui est entre parenthèse.
liste = [1, 3, 5, 7, 9]
print (liste.index(5))
Il affiche 2.
Si la valeur n'est pas trouvée, une erreur est provoquée. Ca aurait été le cas si on aurait
mis 4.
|
| nom_liste.count(...) |
Retourne le nombre de fois où ce qui est entre parenthèse est
présent dans la liste.
liste = [1, 3, 5, 7, 9, 5]
print (liste.count(5))
Il affiche 2. Si 5 n'aurait pas été présent, on aurait obtenu 0. |
| nom_liste.reverse() |
Modifie la liste en l'inversant.
liste = [1, 3, 5, 7, 9]
liste.reverse()
liste à été modifiée. Si on affiche liste, on obtient [9, 7, 5, 3, 1] |
| nom_liste.sort() |
Modifie la liste en la triant
liste = [1, 9, 7, 3, 5]
liste.sort()
liste à été modifiée. Si on affiche liste, on obtient [1, 3, 5, 7, 9]
Avec du texte, le tri se fait par ordre alphabétique. |
| ''.join(nom_liste) |
Assemble les éléments de la liste sous forme de texte
liste = ['b', 'i', 'd', 'u', 'l', 'e']
print (''.join(liste))
En testant ce code, on obtient bidule |
Les tranches
Les tranches sont comme son nom l'indique, des parties découpées. Ici ce n'est pas du saucisson que
l'on coupe en tranche mais des listes.
Pour créer une tranche, tout se passe entre les crochets quand on appelle la liste.
liste = [1, 2, 3, 4]
tranche = liste[0:2]
print (tranche)
Si vous essayez ce code, vous verrez apparaître "[1,2]" sur votre écran.
Vous ne savez pas pourquoi, c'est normal je ne vous ai pas encore expliqué. En fait on crée une
tranche en mettant "[index du début (inclus) : index de la fin (exclus)]" à la place de l'index seul.
Ici on a demandé de copier dans tranche que liste[0] et liste[1].
liste = [1, 2, 3, 4]
tranche = liste[:3]
print (tranche)
Ceci permet de copier du début jusqu'à l'index demandé (exclus). Ici on obtient [1, 2, 3]
liste = [1, 2, 3, 4]
tranche = liste[1:]
print (tranche)
Ceci permet de copier de l'index demandé (inclus) jusqu'à la fin. Ici on obtient [2, 3, 4]
liste = [1, 2, 3, 4]
tranche = liste[:]
print (tranche)
Ceci crée une copie complète de "liste". Ici on obtient [1, 2, 3, 4]
Conclusion
Voila ce long chapitre est terminé. Si vous voulez le code source du morpion avec un tableau à 2
dimensions,
le voici car je ne l'avais pas donné.
Et une autre version toujours 2 dimensions mais avec une méthode améliorée pour tester la victoire et
pour afficher le morpion :
le voici
Le chapitre qui suit est en fait un cas particulier des tableaux et listes. Ce chapitre parlera des
chaînes de caractères.
