Premières manipulations de tableaux de tableaux☘
Modifier un élément ou une ligne☘
On définit un tableau de tableaux en python de la façon suivante:
A = [ [1,2,3],
[4,5,6],
[7,8,9]
]
Note
Les tableaux, type abstrait de données (TAD), seront implémentés en python par des listes. On parlera donc dans dans la suite, souvent indifféremment, de tableau (TAD) ou de liste (Type python).
- Modifiez l'élément de valeur 2 par la valeur 42.
Solution
A est constitué des tableaux: A[0], A[1], A[2].
Dans l'interpréteur python:
>>> A = [ [1,2,3],
... [4,5,6],
... [7,8,9]
... ]
>>> A[0]
[1, 2, 3]
>>> A[1]
[4, 5, 6]
>>> A[2]
[7, 8, 9]
L'élément de valeur 2 est l'élément d'indice 1 dans A[0]. On y accède donc par A[0][1].
Dans l'interpréteur python:
>>> A = [ [1,2,3],
... [4,5,6],
... [7,8,9]
... ]
>>> A[0][1]
2
>>> A[0][1] = 42
>>> A
[[1, 42, 3], [4, 5, 6], [7, 8, 9]]
- Remplacez le second tableau (interne) par [666, 69, 96].
Solution
Le tableau à modifier est A[1].
Dans l'interpréteur python:
>>> A = [ [1,2,3],
... [4,5,6],
... [7,8,9]
... ]
>>> A[1] = [666, 69, 96]
>>> A
[[1, 2, 3], [666, 69, 96], [7, 8, 9]]
Afficher une matrice☘
Dans un fichier python:
A = [ [1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(A)
Le résultat:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
On aimerait un affichage où chaque liste interne soit affichée sur une ligne distincte:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Ecrire une fonction python affichageParLigne(tab) pour réaliser ce type d'affichage.
Solution
Un script possible:
def affichage(tab):
"""
tab -- liste de listes de nombres
affiche chaque liste en passant à la ligne entre les listes.
"""
for ligne in tab:
print(ligne)
A = [ [1, 2, 3], [4, 5, 6], [7, 8, 9]]
B = [ [i for i in range(5)],
[i*i for i in range(5)],
[i*i*i for i in range(5)],
[i**4 for i in range(5)],
[i**5 for i in range(5)]
]
print("Affichage de A: ")
affichage(A)
print()
print("Affichage de B: ")
affichage(B)
Améiorer l'affichage dans chaque ligne
La proposition précédente n'est pas complétement satisfaisante car les nombres d'une même colonne
ne sont pas alignés sur une même verticale.
Si l'on demande par exemple l'affichage de A = [ [1, 2], [42, 666]], on obtient:
[1, 2]
[42, 666]
Pour améliorer cela, on peut utiliser
certaines options de la fonction print.
Le script ci-dessous:
def affichage(tab):
"""
tab -- liste de listes de nombres
affiche chaque liste en passant à la ligne entre les listes.
"""
for ligne in tab:
for element in ligne:
print(element, end="\t")
print()
permet d'insérer une tabulation après l'affichage de chaque valeur (avec end = "\t").
Et lorsqu'une ligne est terminée, on insère un passage à la ligne (avec print()).
L'affichage obtenu pour la matrice A = [ [1, 2], [42, 666]] est alors:
1 2
42 666
Note
Par défaut, le paramètre end lors d'un appel de la fonction print a pour valeur \n. C'est ce qui explique
que, si l'on omet ce paramètre, on passe à la ligne après chaque print. Le fait de donner ici la valeur \t à ce
paramètre end permet d'insérer une tabulation plutôt qu'un passage à la ligne.
Note
L'amélioration proposée n'est encore pas optimale. Essayez par exemple d'afficher
A = [ [1000000000000, 2], [42, 666]]... que se passe-t-il ?
Rechercher un élément de valeur maximale☘
Écrire un corps possible pour la fonction suivante:
def maxi(matrice):
"""
matrice -- matrice (non nécessairement carrée) d'entiers
renvoie l'élément de valeur maximale de matrice.
"""
Un code possible
On a découpé la recherche en deux étapes:
- on commence par écrire une fonction (déjà écrite dans le cours sur les listes) qui renvoie le maximum d'une liste (tableau à 1 dimension).
- on écrit ensuite une fonction qui va renvoyer le maximum parmi les maximums de chaque ligne.
def affichage(matrice):
"""
matrice -- matrice de nombres
Affiche la matrice une ligne écran pour chaque ligne matrice.
"""
for ligne in matrice:
for valeur in ligne:
print(valeur, end="\t") # une tabulation après chaque valeur
print() # on passe à la ligne sur l'écran à la fin de chaque ligne matrice
def maxim(vecteur):
"""
vecteur -- liste de nombres (non vide)
renvoie l'élément de valeur maximale de la liste vecteur.
>>> maxim([42, 2, 666, 7])
666
>>> maxim([42])
42
"""
m = vecteur[0]
for element in vecteur:
if element > m:
m = element
return m
def maxi(matrice):
"""
matrice -- matrice (non nécessairement carrée) d'entiers
renvoie l'élément de valeur maximale de matrice.
>>> maxi([ [42, 7], [6, 666] ])
666
>>> maxi([ [42, 7], [6, 666], [1789, 0] ])
1789
"""
# on crée la liste des max de chaque ligne de la matrice:
liste_des_max = [maxim(ligne) for ligne in matrice]
# on renvoie le max des max par ligne:
return maxim(liste_des_max)
# un test
# on commence par afficher une matrice créée aléatoirement:
from random import randint
NB_LIGNES = 4
NB_COLONNES = 5
A = [[randint(0,100) for j in range(NB_COLONNES)] for i in range(NB_LIGNES)]
affichage(A)
# on calcule maintenant la valeur maximale:
print("Elément maximal de la matrice: ", maxi(A))
# lancement des doctests:
import doctest
doctest.testmod(verbose = True)
Autre code
On peut également utiliser directement le principe utilisé pour les listes:
L'idée est de parcourir tous les éléments entiers contenus dans la matrice, en ne retenant à tout moment que le plus grand de ceux
déjà visités (en le stockant dans une variable m).
fonction maxi(matrice):
on "visite" le "premier" élément, c'est à dire matrice[0][0].
Comme c'est pour le moment le seul visité, c'est le plus grand des visités:
m ← matrice[0][0]
Pour chaque liste interne de la matrice:
Pour chaque élément de cette liste interne:
si élément > m:
m ← élément (mise à jour de m à chaque fois qu'on rencontre un élément plus grand que celui stocké dans m)
renvoyer m
def maxi(tab):
"""
tab: liste constituée de listes d'entiers
renvoie le plus grand entier
"""
m = tab[0][0] # m contiendra la valeur max des valeurs déjà vues
# on visite un par un les entiers en mettant à jour m si besoin:
for liste in tab:
for element in liste:
if element > m:
m = element
return m