Un tableau est une suite ordonnée d'éléments. Ces éléments sont séparés par des virgules et entourés par des crochets.
En Python, un tableau est de type list.
A voir sur Lumni : https://www.lumni.fr/video/notion-de-listes-en-informatique-et-application-aux-images-numeriques
monTableau = []
monTableau, type(monTableau)
tab_entiers = [ 1, 2, 3, 4, 5]
tab_entiers, type(tab_entiers)
tab_chaines = [ "toto", "titi", "tata", "tutu", "tete"]
tab_chaines, type(tab_chaines)
tab_tuples = [(1, 2, 'moi'),(3, 4, 'toi'),(5, 6, 'nous')]
tab_tuples, type(tab_tuples)
tab_tableaux = [[0, 2, 4, 6, 8],[1, 3, 5, 7, 9]]
tab_tableaux, type(tab_tableaux)
Présentation sous forme de matrice en ligne et colonne :
matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
> Pour cibler un élément particulier de la matrice, on utilise la notation avec "doubles crochets" : matrice[ligne][colonne]
tab_tuples = [(1, 2, 'moi'),
(3, 4, 'toi'),
(5, 6, 'nous')]
tab_tableaux = [[0, 2, 4, 6, 8],
[1, 3, 5, 7, 9]]
Le premier élément est toujours à l'index 0, le dernier est toujours à l'index -1 :
| "toto" | "titi" | "tata" | "tutu" | "tete" |
|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 |
| -5 | -4 | -3 | -2 | -1 |
tab_chaines[-2]
tab_tuples[1][2]
"toto" in tab_chaines
tab_chaines.index("toto")
for element in tab_chaines :
print(element)
La fontion len(monTableau) renvoie la taille d'un tableau, le nombre d'éléments qu'il contient :
for i in range(len(tab_chaines)) :
print(tab_chaines[i])
for i in range(len(tab_tableaux)) :
for j in range(len(tab_tableaux[i])) :
print(tab_tableaux[i][j])
tab_chaines[4]="tyty"
tab_chaines
append()tab_chaines.append("toto")
tab_chaines
# Remplissage d'un tableau dans une boucle
tab_cubes = [] # on déclare un tableau vide
for k in range(10):
tab_cubes.append(k**3) # on ajoute le cube de l'indice à chaque tour de boucle
tab_cubes
remove() ou encore la fonction del()tab_chaines.remove("toto")
tab_chaines
tab_chaines.remove(tab_chaines[-1])
tab_chaines
del(tab_chaines[0])
tab_chaines
tab_chaines = ["toto"] + tab_chaines + ["tete"]
tab_chaines
monTableau = [0] * 6
monTableau
Placer le curseur après le point et appuyer sur la touche
Tab
monTableau.
Il est possible de créer un tableau et de le remplir en une ligne grâce à la compréhension de tableau :
new_tab_entier = [n for n in range(1,6)]
new_tab_entier
new_tab_cubes = [k**3 for k in range(10)]
new_tab_cubes
ma_liste_de_mots = [ "Cosinus", "Sinus", "Tangente", "Cotangente" ]
new_tab = [ len(mot) for mot in ma_liste_de_mots]
new_tab
tab_input = [input("saisir un entier positif = ") for n in range(4)]
tab_decimal = [int(n) for n in tab_input]
tab_binaire = [bin(n) for n in tab_decimal]
tab_hexadecimal = [hex(n) for n in tab_decimal]
tab_input, tab_decimal, tab_binaire, tab_hexadecimal
La compréhension de tableau permet de rajouter une condition if :
new_tab_tableaux = [[i for i in range(10) if i % 2 == 0],[j for j in range(10) if j % 2 == 1]]
new_tab_tableaux
multiples_de_cinq_ou_de_sept_mais_pas_des_deux = [n for n in range(100) if ((n % 5 == 0 or n % 7 == 0) and n % 35 != 0)]
multiples_de_cinq_ou_de_sept_mais_pas_des_deux
Une instruction par compréhension se construit de la façon suivante :
[fonction for i in sequence condition]
Deux tableaux qui sont liés par une relation d'égalité pointent vers la même adresse mémoire.
La modification de l'un entraîne la modification de l'autre.
Si l'on souhaite mémoriser l'état initial d'un tableau avant sa modification il faut le copier au préalable avec la méthode copy()...
t1 = [1,2,3]
t2 = t1
t3 = t1.copy()
t1, t2, t3
t1[0] = 5
t1, t2, t3
from metakernel import register_ipython_magics
register_ipython_magics()
%%tutor
t1 = [1,2,3]
t2 = t1
t3 = t1.copy()
t1[0] = 5
t3[1] = 7
1- Écrire une fonction additionne_element(tableau) qui retourne la somme des éléments d’un tableau.
Tester pour tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]
2- Écrire une fonction moyenne_element(tableau) qui retourne la moyenne des éléments d’un tableau.
Tester pour tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]
Écrire une fonction supprimer_doublons(tableau) qui permet de supprimer les doublons d'un tableau.
Tester pour tableau = [20,41,52,41,20,78,41,63,52,20]
1- Écrire une fonction multiplie_par_2(tableau) qui multiplie par 2 chaque élément du tableau
Tester pour tableau = [ 10 , 20 , 30 , 10 , 20 , 60 , 100 ]
2- Écrire une compréhension de tableau qui permet d’effectuer cette tâche.
3- Compléter cette instruction pour que le tableau ne contienne que des valeurs supérieures à 50
| Contenus | Capacités attendues | Commentaires |
|---|---|---|
| Tableau indexé, tableau donné en compréhension |
Lire et modifier les éléments d’un tableau grâce à leurs index. Construire un tableau par compréhension. Utiliser des tableaux de tableaux pour représenter des matrices : notation a [i] [j]. Itérer sur les éléments d’un tableau. |
Seuls les tableaux dont les éléments sont du même type sont présentés. Aucune connaissance des tranches (slices) n’est exigible. L’aspect dynamique des tableaux de Python n’est pas évoqué. Python identifie listes et tableaux. Il n’est pas fait référence aux tableaux de la bibliothèque NumPy. |
Le type list de Python permet de créer des tableaux (des listes de listes) pas obligatoirement homogènes en taille, ni en type :
monTableau= [[1,2,3,4],["toto","titi","tata"], [-3.14, 0.5, 1, 2.35, 6.48]]
monTableau[1][0], type(monTableau)
La bibliothèque
numpypermet de gérer des tableaux numériques homogènes, des matrices...