22 - Tableaux (bilan)
Nous avons déjà vu deux structures jouant le rôle de conteneurs indexés :
- Les strings permettant de stocker des caractères. Les strings sont immuables après création.
- Les tableaux permettant de stocker... n'importe quoi. Les tableaux sont muables en Python.
Aujourd'hui, nous allons faire un bilan de l'utilisation des tableaux statiques en Python.
Documents de cours : open document ou pdf
Logiciel nécessaire pour l'activité : Thonny ou juste Python 3
Evaluation : -
Résumé : Version HTML ou fond blanc ou ou PDF (couleur ou gris)
1 - Tableaux
Le tableau ressemble par de nombreux aspects au string mais il possède deux différences notables :
- On peut y stocker d'autres choses que des caractères
- Il est muable en Python on peut changer le contenu d'une case du tableau sans changer l'adresse mémoire de la variable-tableau
1 - Tableau (statique) en informatique
Le mot tableau sera étudié plus en détail dans la partie DONNEES.
En informatique, un tableau statique (ou tableau tout court) est une structure de données ayant les propriétés suivantes :
- Les données sont stockées dans des cases possèdant un numéro nommé indice (ou index en anglais).
- Le nombre de cases est constant après l’initialisation.
- Contenu homogène : même type de données dans toutes les cases du tableau.
Voici deux exemples de tableaux
Un tableau de caractéres de taille 3
| Indice | Contenu |
|---|---|
| 0 | 'A' |
| 1 | 'B' |
| 2 | 'C' |
Un tableau de dictionnaires de taille 2
| Indice | Contenu |
|---|---|
| 0 | {'nom':'alice', 'classe':'1e1', 'nsi':True} |
| 1 | {'nom':'bob', 'classe':'1e4', 'nsi':True} |
2 - Déclaration d'un tableau avec des crochets [] en Python (RAPPEL)
- Les éléments délimitateurs sont les crochets.
- Chaque élément du tableau est séparé des autres par une virgule.
- Cette structure est implémentée via le type list en Python.
Exemple
>>> t = ['a', 'b', 'c']
>>> t
['a', 'b', 'c']
>>> type(t)
<class 'list'>
>>> type(t) == list
True
Que désigne une variable-tableau ?
La variable tab ci-dessous désigne le conteneur (l'armoire), pas le contenu de l'armoire.
>>> tab = ['a', 'b', 'c']
>>> type(tab)
<class 'list'>
>>> type(t[0])
<class 'str'>
Le type du conteneur est bien list (mais les éléments contenus sont eux des str).
En anglais et en C, un tableau statique s'appelle array.
3 - Nombre d'éléments stockés avec len() (RAPPEL)
La taille du tableau caractérise son nombre de "cases".
La fonction native len() renvoie le nombre d'éléments stockés dans le tableau.
Exemple
>>> tableau = ['a', 'b', 'c']
>>> len(t)
3
>>> nbr = len(t)
>>> nbr
3
>>> t = [{'nom':'alice', 'classe':'1er1'}, {'nom':bob, 'classe':'1er4'}]
>>> len(t)
2
4 - Accès à l'un des éléments avec [indice] (RAPPEL)
Pour accéder à l'un des éléments, on note le nom de la variable-tableau suivi de crochets et on y place l'indice du numéro voulu.
Exemple
>>> t = ['a', 'b', 'c']
>>> t[0]
'a'
>>> t[1]
'b'
>>> elt = t[2]
>>> elt
'c'
La correspondance indice - élément donne ceci sur l'exemple
| Indice | 0 | 1 | 2 |
| Elément | 'a' | 'b' | 'c' |
On notera que l'indice du premier élément porte le numéro 0 et pas le numéro 1 !
Notez que le dernier indice valide est obtenu avec len(t)-1.
01° L'encodage ASCII des caractères fait correspondre un nombre à quelques caractères.
ascii = ['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f']
Question :Afficher le caractère ayant l'indice 65 en utilisant le tableau ascii ci-dessous.
...CORRECTION...
1
2ascii = ['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f']
print(ascii[65])
5 - Lecture des éléments à l'aide d'une boucle et de l'indice (méthode classique) (RAPPEL)
Dans cette boucle FOR, on utilise la syntaxe in range pour obtenir successivement différentes valeurs d'indice.
Exemple avec un tableau de 14 éléments :
notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
Nous avons 14 éléments mais des indices 0 à 13.
| Indice | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 |
| Elément | 15 | 18 | 8 | 10 | 12 | 15 | 20 | 5 | 12 | 17 | 12 | 10 | 18 | 4 |
5.1 - Version bisounours
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for i in range(14)):
print(notes[i])
|
La variable de boucle i va alors prendre successivement les valeurs 0 puis 1 puis 2 ... et finalement 13.
Ce programme affiche bien le contenu des cases puisqu'on demande en ligne 4 d'afficher notes[i] et pas juste i :
15
18
8
10
12
15
20
5
12
17
12
10
18
4
C'est donc comme si vous aviez tapé ceci :
1
2
3
4
5
. | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
print(notes[0])
print(notes[1])
print(notes[2])
...
print(notes[13])
|
5.2 - Version réelle
On utilisera plutôt len() pour ne pas avoir à taper directement la taille du tableau.
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for i in range(len(notes)):
print(notes[i])
|
5.3 - Contenu de case ou numéro de case ?
- La variable i contient le numéro d'une case du tableau
- L'expression notes[i] correspond au contenu de la case i.
5.4 - Gestion du print
Si on désire voir les notes s'afficher en les séparant par un tiret, on peut utiliser ceci :
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for i in range(len(notes)):
print(notes[i], end="-")
|
On obtient alors ceci
15-18-8-10-12-15-20-5-12-17-12-10-18-4-
02° Observer attentivement ces programmes. On veut afficher le contenu des cases.
Questions
- Doit-on prendre le programme 1 ou le programme 2 ?
- Quelles sont les valeurs que va prendre la variable de boucle i ?
- Quel va être l'affichage ?
Programme 1
1
2
3
4 | notes = [15, 18, 8]
for i in range(len(notes)):
print(i, end="|")
|
Programme 2
1
2
3
4 | notes = [15, 18, 8]
for i in range(len(notes)):
print(notes[i], end="|")
|
...CORRECTION...
- Le programme 2 car on affiche le contenu en demandant avec notes[i].
- La variable i vaut d'abord 0 puis 1 puis 2 puisqu'il y a 3 cases.
- Quel va être l'affichage obtenu après deux tours de boucle ?
- Quel va être l'affichage final ?
i vaut 0. On aura donc 0| à l'écran.
i vaut 1. On rajoute donc 1| et on obtiendra au total 0|1| .
i vaut 2. On rajoute donc 2| et on obtiendra au total 0|1|2| .
03° Compléter la fonction maximum() qui doit renvoyer la position de la valeur maximum dans le tableau. En cas d'égalité, on devra renvoyer la première valeur maximale rencontrée.
notes = [15, 18, 8, 10, 12, 15, 18, 4]
L'appel maximum(notes) devrait renvoyer 1 sur cet exemple, car le 18 est en position 1 et 6.
1
2
3
4
5
6
7
8
9
10 | |
...CORRECTION...
1
2
3
4
5
6
7 | |
04° Compléter la fonction progression() qui doit renvoyer le nombre de fois où une case contient une valeur plus grande que la précédente.
notes = [15, 18, 8, 10, 12, 15, 20, 4]
L'appel progression(notes) devrait renvoyer 5 : 18 plus grand que 15, et plus loin, on trouve une succession de 4 valeurs successivement plus grandes : 8-10-12-15-20.
1
2
3
4
5
6
7 | |
...CORRECTION...
1
2
3
4
5
6
7 | |
6 - Lecture directe des éléments un à un (NOUVEAU)
Dans cette boucle FOR, on note le nom du tableau directement derrière le in. Aucun range à l'horizon.
1
2
3
4
5
6
7
8
9 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for note in notes:
if note > 12:
print(f"Bien : {note}")
elif note < 8:
print(f"Pas bien : {note}")
else:
print(f"Moyen : {note}")
|
La variable de boucle note va alors contenir successivement tous les éléments du tableau notes.
note va donc valoir d'abord 15, puis 18 au tour de boucle suivant, puis 8...
Ce programme affiche "Bien", "Pas bien" ou "Moyen" devant chaque note sans avoir à passer par un indice de case :
Bien : 15
Bien : 18
Moyen : 8
Moyen : 10
Moyen : 12
Bien : 15
Bien : 20
Pas bien : 5
Moyen : 12
Bien : 17
Moyen : 12
Moyen : 10
Bien : 18
Pas bien : 4
05° Compléter la fonction positif_uniquement() qui doit recevoir un tableau de nombres entiers positifs ou négatifs (précondition) et qui doit afficher à l'écran uniquement les nombres s'ils sont positifs.
Cette fonction doit :
- Lire chaque valeur v contenue dans le paramètre t.
- Afficher (avec passage à la ligne) uniquement les notes supérieures ou égales à 0.
1
2
3
4
5
6
7
8
9 | |
Vous devriez obtenir l'affichage suivant :
66
68
...CORRECTION...
1
2
3
4
5
6
7
8
9 | |
Plus compliqué : nous allons réaliser une fonction capable d'afficher le texte correspondant à une suite de nombres encodant un texte en ASCII. Cela vous permettra de comprendre qu'un texte n'est qu'une suite de nombres pour un systme informatique.
Vous allez donc devoir lire les valeurs v contenues dans un tableau et utiliser ces valeurs comme des indices dans le tableau ascii...
06° Compléter la fonction decode() qui doit recevoir un tableau de nombres entiers positifs compris entre 0 et 127 et qui affiche le string correspondant à l'écran.
Cette fonction doit :
- Lire chaque valeur entière code contenue dans le tableau t reçu en paramètre.
- Afficher (sans passage à la ligne) le caractère placé à l'indice code dans le tableau ascii.
1
2
3
4
5
6
7
8
9
10
11
12 | |
Vous devriez obtenir l'affichage suivant :
ABC
Bravo
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
11
12 | |
7 - Les tableaux sont muables en Python (RAPPEL + NOUVEAU)
Dans beaucoup de langages, les tableaux sont muables : cela veut dire qu'on peut modifier les contenus d'un tableau sans modifier l'adresse-mémoire du tableau lui-même.
On dit qu'on modifie l'état du tableau lorsqu'on modifie son contenu.
>>> t = ['a', 'b', 'c']
>>> t
['a', 'b', 'c']
>>> t[0] = 'Z'
>>> t
['Z', 'b', 'c']
Point important : la modification de contenu nécessite l'utilisation de l'indice. Il faut donc nécessairement passer par la version de la boucle for avec indice.
Exemple qui FONCTIONNE
Si on veut multiplier par deux toutes les notes d'un tableau (spécial ProfQuiFaitUnDsTropDur), on pourra faire ceci :
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for i in range(len(notes)):
notes[i] = notes[i] * 2
|
Après application de ce programme, le tableau notes contiendrait
- | notes = [30, 36, 16, 20, 24, 30, 40, 10, 24, 34, 24, 20, 36, 8]
|
Exemple qui NE FONCTIONNE PAS
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for note in notes:
note = note * 2
|
Après application de ce programme, le tableau notes n'aura pas été modifié !
Pourquoi ? Car en ligne 4, on modifie juste la variable locale note, pas le contenu d'une case du tableau.
8 - Une explication par l'exemple de la modification (NOUVEAU)
On considère initialement un tableau nommé t qui contient ['a', 'b', 'c']. Voici l'espace des noms et l'espace-mémoire à ce moment :
- On voit que :
- t ne contient pas le contenu du tableau mais son adresse (1485)
- Le contenu de la case 0 est référencé à l'adresse 1485+0 = 1485.
- Le contenu de la case 1 est référencé à l'adresse 1485+1 = 1486.
- Le contenu de la case 2 est référencé à l'adresse 1485+2 = 1487.
- Si on modifie le tableau avec t[0] = 'Z', le tableau fait toujours référence à 1485 mais la case-mémoire 1485 mène maintenant à l'adresse 170 qui contient 'Z'.
Si on veut voir ce que va renvoyer t[0], il suffit de voir que l'adresse du tableau est 1485 dans l'espace des noms. Puisqu'on veut la case d'indice 0, on regarde juste le contenu de la case mémoire 1485. Cela nous mène à l'adresse-mémoire 78 qui mène à 'a'.
07° Réaliser un court programme (sans fonction) pour les profs lunatiques : on transforme les notes contenues dans un tableau fourni en début de programme. Les notes initialement supérieures ou égales à 10 sont transformées en 20. Les notes inférieures à 10 sont transformées en 0.
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for i in range(len(notes)):
pass
|
Exemple AVANT / APRES :
[15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
[20, 20, 0, 20, 20, 20, 20, 0, 20, 20, 20, 20, 20, 0]
...CORRECTION...
1
2
3
4
5
6
7 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for i in range(len(notes)):
if notes[i] >= 10:
notes[i] = 20
else:
notes[i] = 0
|
9 - Alors, quelle boucle for ?
Ca dépend des situations.
(Cas 1) Vous voulez modifier le contenu du tableau : une seule solution
Vous avez besoin de connaître le numéro d'indice, il faut utiliser
- for i in range(len(a)) avec
- un accès au contenu de la case avec a[i]
- une modification du contenu de la case avec a[i] = nouveau_contenu
Exemple : vous voulez mettre 0 dans toutes les cases (spécial Prof PasContent).
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for i in range(len(notes)):
notes[i] = 0
|
(Cas 2) Vous voulez lire le contenu et agir en fonction de la position du contenu : une seule solution
Vous avez besoin de connaître le numéro d'indice, il faut utiliser for i in range(len(a))
(Cas 3) : vous voulez juste lire le contenu du tableau
Puisque vous n'avez pas besoin de connaître l'indice de l'élément, vous pouvez utiliser la version que vous voulez.
- for i in range(len(t)) avec un accès au contenu avec
t[i] - for v in t avec un accès au contenu avec v
2 - Création de tableaux par compréhension
Jusqu'à présent, vous ne savez créer des tableaux qu'en extension : on fournit directement dans les crochets les valeurs voulues. Pour créer un tableau contenant les entiers de 1 à 3000, ca risque d'être long à taper...
10 - Déclaration de tableau par compréhension à partir d'un tableau initial
La déclaration d'un tableau par compréhension consiste à créer un tableau à l'aide d'une boucle for. Créons un nouveau tableau nt.
nt = [None for element in base]
Comme doit-on comprendre cela ? Suivez bien ce qui suit.
- On voit d'abord qu'on déclare un nouveau tableau nt :
- Cette déclaration contient une boucle, il s'agit d'une déclaration par compréhension :
- Faire quoi ? Rajouter une nouvelle case à notre nouveau tableau. Case qui contient quoi ? Ce qui se trouve devant le for.
nt = [...]
nt = [... for element in base]
Il faut comprendre que pour chaque element lu dans le tableau base, il faut faire quelque chose.
nt = [None for element in base]
En tapant ceci, voici ce que peut comprendre l'interpréteur Python : "Crée un nouveau tableau initialement vide nommé nt. Pour chaque case du tableau base, crée une case contenant None dans nt.
Exemple 1
>>> base = [1, 2, 5]
>>> nt = [None for valeur in base]
>>> nt
[None, None, None]
On obtient bien un nouveau tableau ayant autant de cases mais rempli de None.
Exemple 2
On peut mettre autre chose que None dans chaque case : on peut indiquer un calcul expliquant ce que doit être le contenu de la nouvelle case.
dd = [v * 2 for v in b]
L'interpréteur Python comprend qu'on veut créer un nouveau tableau dd où chaque case correspond au double de ce qui est contenu dans la case correspondante du tableau b.
>>> b = [1, 2, 5]
>>> dd = [v*2 for v in b]
>>> dd
[2, 4, 10]
08° Créer, par compréhension, un tableau qui contient des valeurs 100 fois plus grandes que le tableau suivant :
>>> t1 = [1, 2, 3, 5, 7, 11]
...CORRECTION...
>>> t1 = [1, 2, 3, 5, 7, 11]
>>> dd = [v*100 for v in t1]
>>> dd
[100, 200, 300, 500, 700, 1100]
09° Créer, par compréhension, un tableau longueurs dont les cases contiennent le nombre de lettres des prénoms contenus dans le tableau prenoms :
>>> prenoms = ["Lisa", "Scott", "Matthias", "Antoine", "Ethan", "Lucas", "Manon", "Alexandre", "Alexandre", "Kenzo", "Thomas", "Lilou", "Aurélien", "Charles", "Manon", "Francia", "Imrane", "Sarah", "Yassin", "Sofian", "Noé", "Lenny", "Matt", "Ryiad", "Yanis", "Jason", "Damien", "Antonin", "Samy", "Laurine", "Rayan", "Eliot", "Victor", "Theo", "Julien", "Benjamin"]
Vous devriez pouvoir visualiser ceci dans la console après exécution de votre création par compréhension :
>>> longueurs
[4, 5, 8, 7, 5, 5, 5, 9, 9, 5, 6, 5, 8, 7, 5, 7, 6, 5, 6, 6, 3, 5, 4, 5, 5, 5, 6, 7, 4, 7, 5, 5, 6, 4, 6, 8]
...CORRECTION...
>>> prenoms = ["Lisa", "Scott", "Matthias", "Antoine", "Ethan", "Lucas", "Manon", "Alexandre", "Alexandre", "Kenzo", "Thomas", "Lilou", "Aurélien", "Charles", "Manon", "Francia", "Imrane", "Sarah", "Yassin", "Sofian", "Noé", "Lenny", "Matt", "Ryiad", "Yanis", "Jason", "Damien", "Antonin", "Samy", "Laurine", "Rayan", "Eliot", "Victor", "Theo", "Julien", "Benjamin"]
>>> longueurs = [len(p) for p in prenoms]
>>> longueurs
[4, 5, 8, 7, 5, 5, 5, 9, 9, 5, 6, 5, 8, 7, 5, 7, 6, 5, 6, 6, 3, 5, 4, 5, 5, 5, 6, 7, 4, 7, 5, 5, 6, 4, 6, 8]
11 - Déclaration de tableau par compréhension avec indice
On peut également créer des tableaux contenant un nombre précis d'élements de façon assez facile : il suffit d'utiliser range().
Exemple 1
>>> t = [0 for i in range(10)]
>>> t
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Cela veut dire qu'on place 0 dans une case pour chaque des valeurs i (qui vaut 0 puis 1 puis 2 ... jusqu'à 9)
Exemple 2
>>> t = [i*10 for i in range(10)]
>>> t
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
Cette fois, la variable de boucle i va varier de 0 à 9 et pour chacune des valeurs qu'elle prend, on place 10 fois plus dans une nouvelle case du nouveau tableau.
Exemple 3
>>> import random
>>> tableau = [random.randint(1, 100) for x in range(10)]
>>> tableau
[42, 41, 96, 35, 58, 94, 16, 21, 84, 51]
Cette fois, on crée 10 cases dans lesquelles on place un nombre aléatoire entre 1 et 100.
10° Créer par compréhension un tableau de 100 éléments contenant des nombres aléatoires compris entre 20 et 50.
...CORRECTION...
>>> import random
>>> tableau = [random.randint(2, 50) for x in range(100)]
11° Créer par compréhension un tableau de 500 éléments contenant 0.
...CORRECTION...
>>> tableau = [0 for _ in range(500)]
On peut même faire mieux : on peut inclure une instructions conditionnelles ou même un appel de fonction dans la construction.
12 - Déclaration par compréhension avec condition
Premier exemple de construction par compréhension : avec condition d'ajout :
On crée un tableau de 50 notes comprises entre 0 et 20. On crée un second tableau à partir du premier : on ne garde que les notes supérieures ou égales à 10.
>>> import random
>>> t = [random.randint(0,20) for i in range(50)]
>>> t
[12, 8, 1, 3, 3, 17, 8, 2, 2, 10, 15, 3, 16, 13, 5, 18, 12, 15, 19, 10, 9, 14, 0, 15, 11, 6, 11, 1, 10, 6, 17, 3, 17, 10, 9, 8, 1, 9, 7, 12, 15, 10, 15, 15, 9, 8, 18, 8, 9, 6]
>>> t2 = [note for note in t if note >= 10]
>>> t2
[12, 17, 10, 15, 16, 13, 18, 12, 15, 19, 10, 14, 15, 11, 11, 10, 17, 17, 10, 12, 15, 10, 15, 15, 18]
Deuxième exemple de construction par compréhension : avec fonction :
On peut utiliser des fonctions pour déterminer la valeur à placer lors de la création par compréhension. Imaginons qu'on dispose de cette fonction en mémoire :
1
2
3
4
5 | def pas_plus(valeur, seuil):
"""Fonction qui écrête : elle renvoie la valeur ou le seuil si la valeur est supérieure au seuil"""
if valeur > seuil:
return seuil
return valeur
|
>>> import random
>>> tableau = [pas_plus(random.randint(0,20), 15) for valeur in range(10)]
>>> tableau
[14, 15, 7, 14, 11, 1, 13, 12, 15, 1]
On obtient bien un tableau de 10 éléments sans qu'aucun élément ne soit plus grand que 15.
12° Créer un tableau p6 dont les cases contiennent les prénoms de 6 caractères ou plus contenus dans le tableau prenoms :
>>> prenoms = ["Lisa", "Scott", "Matthias", "Antoine", "Ethan", "Lucas", "Manon", "Alexandre", "Alexandre", "Kenzo", "Thomas", "Lilou", "Aurélien", "Charles", "Manon", "Francia", "Imrane", "Sarah", "Yassin", "Sofian", "Noé", "Lenny", "Matt", "Ryiad", "Yanis", "Jason", "Damien", "Antonin", "Samy", "Laurine", "Rayan", "Eliot", "Victor", "Theo", "Julien", "Benjamin"]
Vous devriez pouvoir visualiser ceci dans la console après exécution de votre création par compréhension :
>>> p6
['Matthias', 'Antoine', 'Alexandre', 'Alexandre', 'Thomas', 'Aurélien', 'Charles', 'Francia', 'Imrane', 'Yassin', 'Sofian', 'Damien', 'Antonin', 'Laurine', 'Victor', 'Julien', 'Benjamin']
...CORRECTION...
>>> prenoms = ["Lisa", "Scott", "Matthias", "Antoine", "Ethan", "Lucas", "Manon", "Alexandre", "Alexandre", "Kenzo", "Thomas", "Lilou", "Aurélien", "Charles", "Manon", "Francia", "Imrane", "Sarah", "Yassin", "Sofian", "Noé", "Lenny", "Matt", "Ryiad", "Yanis", "Jason", "Damien", "Antonin", "Samy", "Laurine", "Rayan", "Eliot", "Victor", "Theo", "Julien", "Benjamin"]
>>> p6 = [p for p in prenoms if len(p) >= 6]
>>> p6
['Matthias', 'Antoine', 'Alexandre', 'Alexandre', 'Thomas', 'Aurélien', 'Charles', 'Francia', 'Imrane', 'Yassin', 'Sofian', 'Damien', 'Antonin', 'Laurine', 'Victor', 'Julien', 'Benjamin']
13 - Tableau statique ou list-Python ?
Nous avons travaillé ici avec la notion de tableaux statiques : des tableaux dont
- toutes les cases contiennent le même type de données et
- le nombre de cases est fixe. Pas moyen d'en supprimer ou d'en rajouter. Si le tableau a 20 cases, il gardera 20 cases jusqu'à la fin.
Les tableaux statiques s'implémentent en Python à l'aide du type list.
Pour informations, sachez qu'une list Python est bien plus flexible qu'un tableau statique. Il s'agit d'un tableau dynamique (on peut ajouter ou supprrimer des cases) donc le contenu n'a pas à être homogène.
La plupart du temps, nous utiliserons une List-Python comme un tableau statique, sans chercher à profiter des fonctionnalités ci-dessous.
On pourrait donc créer une list Python contenant ceci :
exemple = [1, 1.55, 'bonjour']
Mais dans ce cas, nous ne dirons pas que la variable exemple fait référence à un tableau.
Nous verrons en fin d'année et en terminale, comme rajouter une case derrière les autres avec append() ou supprimer la dernière case avec pop(). Juste un petit exemple pour vous montrer comment cela s'utilise en attendant :
- append() ne renvoie rien mais modifie le tableau en mémoire en rajoutant l'élément fourni en tant que dernière case.
- pop() modifie le tableau en mémoire en supprimant sa case finale et renvoie l'élément qui y était contenu.
>>> t = []
>>> t.append("Alice")
>>> t
['Alice']
>>> t.append("Bob")
>>> t
['Alice', 'Bob']
>>> t.append("Charlie")
>>> t
['Alice', 'Bob', 'Charlie']
>>> t.pop()
'Charlie'
>>> t
['Alice', 'Bob']
Attention : pas de telle utilisation des Lists pour l'instant.
3 - Alias et copie
Nous avons vu qu'une variable faisant référence à un tableau ne contient pas le contenu du tableau mais simplement son identifiant-mémoire, la zone où les données sont référencées.
Et comme le tableau est muable en Python, on peut modifier son contenu si on connaît cette adresse.
14 - Alias de tableau
Une "variable-tableau" contient l'identifiant de la zone-mémoire où se trouve le premier contenu, celui de l'indice 0. On trouve facilement les autres en augmentant ensuite de 1.
Exemple :
- t fait référence à l'adresse 5000.
- L'adresse 5000 contient l'adresse faisant référence à t[0].
- L'adresse 5001 contient l'adresse faisant référence à t[1].
- L'adresse 5002 contient l'adresse faisant référence à t[2].
- ...
On crée facilement un alias d'un tableau en notant une instruction de ce type :
>>> t = [10, 20, 50]
>>> id(t)
xxxx128
>>> t2 = t
>>> id(t2)
xxxx128
On voit clairement que t et t2 référencent la même zone-mémoire. Du coup, si on modifie le contenu de l'un, on modifie le contenu de l'autre puisqu'il s'agit de la même zone-mémoire.
Sur l'exemple, t et t2 sont deux façons de nommer la zone-mémoire 128.
>>> t
[10, 20, 50]
>>> t2
[10, 20, 50]
>>> t[0] = 100000
>>> t
[100000, 20, 50]
>>> t2
[100000, 20, 50]
C'est comme appelé quelqu'un par son vrai nom ou par son surnom. Ca ne change rien à la personne designée.
13° Donner le contenu de t à la fin des instructions suivantes :
>>> t = [i*10 for i in range(4)]
>>> a = t
>>> b = a
>>> c = b
>>> a[2] = a[2]*2
>>> t
???
...CORRECTION...
Hyper facile lorsqu'on a compris.
On crée t par compréhension. i prendra les valeurs 0, 1, 2, 3.
Le tableau t fait donc référence à un contenu qui correspond à [0, 10, 20, 30].
a, b, c ont en réalité la même référence mémoire que t, un tableau muable.
L'instruction a[2] = a[2]*2 se comprend en l'analysant de droite à gauche. On évalue d'abord a[2] et on obtient 20. On double et on obtient 40. On stocke ce 40 dans la case d'indice 2 du tableau a.
Mais puisque les 4 variables sont des alias de la même zone mémoire, on a alors :
a = b = c = t = [0, 10, 40, 30]
15 - Copie de tableau
Pour éviter ces modifications d'un tableau sur l'autre, il faut créer une copie du tableau de base et pas juste en faire un alias.
1er méthode : copie par compréhension (à privilégier en NSI)
>>> t = [0, 10, 20, 30]
>>> t2 = [v for v in t]
>>> t
[0, 10, 20, 30]
>>> t2
[0, 10, 20, 30]
>>> t[0] = 1000
>>> t
[1000, 10, 20, 30]
>>> t2
[0, 10, 20, 30]
>>> t2[3] = 3000
>>> t
[1000, 10, 20, 30]
>>> t2
[0, 10, 20, 3000]
Cette fois, t et t2 sont bien des contenus similaires au début mais on peut les modifier l'un ou l'autre sans impacter l'autre. Ce sont des copies d'un même contenu et pas des alias d'une même zone mémoire.
Important : Cela ne fonctionnera pas si le premier tableau contient des éléments muables (d'autres tableaux par exemple). Dans ce cas, il faudra faire une copie dite profonde.
2e méthode : copie en utilisant la méthode des list nommée copy()
>>> t = [0, 10, 20, 30]
>>> t2 = t.copy()
On obtient à ce moment, deux tableaux identiques mais indépendants l'un par rapport à l'autre.
>>> t
[0, 10, 20, 30]
>>> t2
[0, 10, 20, 30]
>>> t[0] = 1000
>>> t
[1000, 10, 20, 30]
>>> t2
[0, 10, 20, 30]
>>> t2[3] = 3000
>>> t
[1000, 10, 20, 30]
>>> t2
[0, 10, 20, 3000]
Important : Cela ne fonctionnera pas si le premier tableau contient des éléments muables (d'autres tableaux par exemple). Dans ce cas, il faudra faire une copie dite profonde.
Si votre tableau contient d'autres tableaux, il faut donc en faire une copie profonde. Le plus facile pour être certain de n'avoir aucun alias d'une autre zone mémoire est d'utiliser la fonction deepcopy() du module nommé copy. Nous en reparlerons lorsque le besoin s'en fera sentir.
14° Donner le contenu de t à la fin des instructions suivantes :
>>> t = [i*10 for i in range(4)]
>>> a = t
>>> b = a
>>> c = [v for v in b]
>>> c[2] = c[2]*2
>>> t
???
...CORRECTION...
Hyper facile lorsqu'on a compris.
On crée t par compréhension. i prendra les valeurs 0, 1, 2, 3.
Le tableau t fait donc référence à un contenu qui correspond à [0, 10, 20, 30].
a, b ont en réalité la même référence mémoire que t, un tableau muable.
Par contre, c est une copie du contenu-mémoire référencé par b et donc t également.
On crée c par compréhension en demandant de créer un tableau qui contient une case ayant le même contenu que celle de t, pour chaque valeur de t.
Modifier c ne va donc pas modifier du tout t.
4 - Raccourcis
Il y a encore beaucoup à dire sur les tableaux.
Vous vous doutez bien par contre que la plupart des actions ou recherches usuelles qu'on peut faire sur les tableaux sont déjà implémentées en Python.
Le but de la NSI n'est pas de vous faire utiliser ces fonctions mais de vous permettre de les créer pour comprendre comment elles sont implémenter et donc comprendre leurs coûts.
Vous allez ainsi voir dans la partie algorithmique :
- Comment réaliser une recherche de minimum, de maximum ou de somme des éléments d'un tableau autrement qu'en passant par ces fonctions natives forts pratiques. Vous pouvez les utiliser en NSI si leurs utilisations ne sont pas le ressort principal de la question qu'on vous pose.
- Comment vérifier l'appertenance d'un élément : cet élément est-il dans le tableau ?
- Comment trier une copie triée d'un tableau ?
- Comment obtenir la moyenne issue d'un tableau de nombres ?
>>> t = [10, 30, 25, -5]
>>> min(t)
-5
>>> max(t)
30
>>> sum(t)
60
>>> t = [10, 30, 25, -5]
>>> 30 in t
True
>>> 29 in t
False
>>> t = [10, 30, 25, -5]
>>> t2 = sorted(t)
>>> t
[10, 30, 25, -5]
>>> t2
[-5, 10, 25, 30]
>>> t = [10, 30, 25, -5]
>>> m = sum(t) / len(t)
15.0
15° Utiliser les exemples précédents pour vous convaincre qu'ils fonctionnent correctement.
16° Pendant une épreuve de programmationn on vous demande de créer une fonction qui renvoie le maximum des valeurs d'un tableau, un élève peut-il rendre ceci et espérer avec des points ?
1
2 | |
...CORRECTION...
J'espère que vous avez bien compris qu'il aurait 0.
Par contre, pour vos propres projets, c'est pratique, n'hésitez pas.
5 - Matplotlib
Le succés mondial de Python vient de la gestion assez aisée des données et de la manipulation des données. Même quelqu'un sans formation informatique réelle peut parvenir (avec du mal !) à faire de l'analyse de données.
Analyser, c'est bien. Afficher, c'est mieux.
Cette partie traite justement de la réalisation de graphiques avec le module Python nommé matplotlib.
17° Si cela n'est pas fait, installer la bibliothèque matplotlib dans Thonny :
- Outils
- Gérer les paquets
- Lancer la recherche sur matplotlib puis activer l'installation
Lancer le programme pour visualiser le graphique obtenu.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 | |
18° Répondre aux questions suivantes :
- Comment se nomme le tableau qui contient les valeurs d'abscisse ?
- Comment se nomme ce type de création ?
- Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
- Comment se nomme le tableau qui contient les valeurs d'ordonnée ?
- Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
- Lorsqu'on utilise la fonction plot() située dans le module dont l'alias est ici plt :
- que doit contenir le premier argument envoyé ?
- que doit contenir le deuxième argument envoyé ?
- à quoi sert l'envoi de color='orange' ?
...CORRECTION...
- Comment se nomme le tableau qui contient les valeurs d'abscisse ?
- Comment se nomme ce type de création ?
- Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
- Comment se nomme le tableau qui contient les valeurs d'ordonnée ?
- Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
- Lorsqu'on utilise la fonction plot() située dans le module dont l'alias est ici plt :
- que doit contenir le premier argument envoyé ?
- que doit contenir le deuxième argument envoyé ?
- à quoi sert l'envoi de color='orange' ?
12 | |
Création pour compréhension.
On voit qu'on va rajouter une case contenant une valeur pour chaque valeur entière de l'intervalle [0; 100[. Cela veut donc dire qu'on aura 100 cases allant de 0 à 99.
13 | |
Pour chaque valeur x du tableau tx, on rajoute une case dans ty qui va contenir x2.
19 | |
Visiblement, il faut envoyer les valeurs x pour l'abscisse.
Visiblement, il faut envoyer les valeurs y pour l'ordonnée.
A donner la couleur attribuée à cette courbe.
Voici maintenant quelques options pratiques, comme le choix des échelles ou la présence d'une grille facilitant la lecture des coordonnées.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 | |
19° Mettre cette version plus élaborée en mémoire, vérifier qu'elle fonctionne puis répondre aux questions :
- L21 : A votre avis, que va contenir xmax après avoir stocké la réponse de la fonction native max() ?
- L22 : A votre avis, que va contenir ymax après avoir stocké la réponse de la fonction native max() ?
- L23 : On envoie à la fonction axis() dans l'ordre la valeur min puis max qu'on veut en abscisse puis la même chose en ordonnée. Quel est le type de l'argument qu'il faut lui envoyer ?
- Sur quelle ligne demande-t-on d'afficher une grille de lecture ?
...CORRECTION...
- L21 : A votre avis, que va contenir xmax après avoir stocké la réponse de la fonction native max() ?
- L22 : A votre avis, que va contenir ymax après avoir stocké la réponse de la fonction native max() ?
- L23 : On envoie à la fonction axis() dans l'ordre la valeur min puis max qu'on veut en abscisse puis la même chose en ordonnée. Quel est le type de l'argument qu'il faut lui envoyer ?
- Sur quelle ligne demande-t-on d'afficher une grille de lecture ?
La plus grande valeur qu'on puisse trouver dans le tableau tx.
La plus grande valeur qu'on puisse trouver dans le tableau ty.
Il faut envoyer un tableau des 4 cases visiblement. L'indice 0 doit contenir la valeur minimale sur l'axe des abscisses, l'indice 1 la valeur d'abscisse maximale, l'indice 2 la valeur minimale en ordonnée et l'indice 3 la valeur maximale sur l'ordonnée.
L28 : on demande le placement d'une grille en utilisant la fonction grid() qui se trouve dans le module plt.
Deux dernières choses pour aujourd'hui :
- On peut placer le calcul à faire dans une fonction (L18-L19 qui vont référence aux fonctions f() et g() des lignes 8-9 et 11-12)
- On peut tracer plus d'une courbe sur un même graphique en utilisant duex fois la fonction plot() en lignes 22 et 23.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 | |
20° Mettre cette version qui affiche deux courbes sur un même graphique, vérifier qu'elle fonctionne puis répondre aux questions :
- L18 : Expliquer ce que fait cette ligne, en français.
- L19 : Expliquer ce que fait cette ligne, en français.
...CORRECTION...
Sur la ligne 18, on voit qu'on crée un tableau en compréhension : pour chaque valeur x contenue dans tx, on ajoute une case dont la valeur est f(x).
Sur la ligne 19, on voit qu'on crée un tableau en compréhension : pour chaque valeur x contenue dans tx, on ajoute une case dont la valeur est g(x).
6 - FAQ
Rien pour l'instant
Activité publiée le 01 11 2019
Dernière modification : 29 03 2024
Auteur : ows. h.