python index num

Identification

Infoforall

21 - Tableaux


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 voir en détails l'utilisation des tableaux statiques en Python.

Activité très importante car nous allons apprendre à gérer de façon automatiser les données.

Documents de cours : open document ou pdf

Logiciel nécessaire pour l'activité : Thonny ou juste Python 3

Evaluation ✎ : questions 08-11-12

Résumé : Version HTML ou fond blanc ou ou PDF (couleur ou gris)

1 - Tableaux

Nous allons passer maintenant à une nouvelle structure de données qui ressemble par beaucoup d'aspects au string : le tableau.

Il possède deux différences notables :

  1. On peut y stocker d'autres choses que des caractères
  2. Il est mutable : on peut changer le contenu d'une case du tableau sans changer l'adresse mémoire de la variable-tableau
Tableau en informatique

Le mot tableau sera étudié plus en détail dans la partie DONNEES.

En informatique, un tableau est une structure de données ayant les propriétés suivantes :

  • La structure tableau permet de stocker des données indexées dans un nombre fixé de cases.
  • La taille est définie une fois pour toute lors de la déclaration initiale du tableau.
  • Chacune des cases contient le même type de données (soit des entiers sur 4 octets, soit des caractères, soit des entiers sur 2 octets, soit des floats sur 4 octets ...)

Voici deux exemples de tableaux 

Un tableau de caractéres de taille 3

Index Contenu
0 'A'
1 'B'
2 'C'

Un tableau de flottants de taille 4

Index Contenu
0 5.89
1 12.56
2 15.89
3 5.0

Nous allons voir maintenant comment un tableau s'utilise en Python.

1 - Déclaration d'un tableau avec des crochets [] en Python
  1. Les éléments délimitateurs sont les crochets.
  2. Chaque élément du tableau est séparé des autres par une virgule.
  3. Cette structure de données native en Python se nomme list.

Exemple

>>> t = ['a', 'b', 'c'] >>> t ['a', 'b', 'c'] >>> type(t) <class 'list'> >>> type(t) == list True

La variable t désigne ici le conteneur, pas le contenu. 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.

2 - Nombre d'éléments stockés avec len()

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 = [12.45, 5.0, 17.9, 4.32] >>> len(t) 4

01° Créer un programme qui stocke le nombre nbN de notes de l'élève A contenues dans le tableau notes et le nombre d'élèves nbE dans la classe à partir des données stockées dans le tableau eleves :

notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 13, 14] 

t_eleves = ["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"] 

...CORRECTION...

1 2 3 4 5
notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 13, 14] eleves = ["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"] nbN = len(notes) nbE = len(t_eleves)

On obtient alors les réponses suivantes : 14 notes pour l'èlève A et 36 élèves au total.

>>> nbN 14 >>> nbE 36
3 - Accès à l'un des éléments avec [indice]

Pour accéder à l'un des éléments (notés elt ci-dessous), 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[0] >>> elt 'a' >>> elt = t[1] >>> elt 'b' >>> elt = t[2] >>> elt 'c'

La correspondance indice - élément donne ceci sur l'exemple

Index 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 donc bien qu'un tableau de 3 éléments possède un dernier élement dont l'indice est 2.

On notera également qu'on peut avoir accès à l'élément 5 directement, sans avoir lu au préalable le 2,3 et 4. Ce n'est pas le cas pour toutes les structures de données.

02° L'encodage ASCII des caractères fait correspondre un nombre à quelques caractères.

Afficher le caractère ayant l'indice 65 en utilisant le tableau ascii ci-dessous.

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']

...CORRECTION...

1 2
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'] print(ascii[65])
4 - Lecture des éléments à l'aide d'une boucle et de l'indice (méthode classique)

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.

Index 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

4.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 va afficher ceci dans la console 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])

4.2 - Version réelle

On utilisera plutôt len() pour ne pas avoir à taper directement l'indice maximum 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])

4.3 - Point important à avoir en tête

  • La variable i contient le numéro d'une case du tableau
  • L'expression notes[i] correspond au contenu de la case i.

4.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-

03° Observer attentivement ce programme. Répondre aux questions suivantes :

  1. Quelles sont les valeurs que va prendre la variable de boucle i ?
  2. Quel va être le caractère qui remplace le passage à la ligne à la fin de chaque print() ?
  3. Quel va être l'affichage obtenu après un seul tour de boucle ?
  4. Quel va être l'affichage obtenu après deux tours de boucle ?
  5. Quel va être l'affichage final ?
1 2 3 4
notes = [15, 18, 8] for i in range(len(notes)): print(i, end="|")

...CORRECTION...

  1. Quelles sont les valeurs que va prendre la variable de boucle i ?
  2. La variable de boucle i va prendre successivement les valeurs 0, 1 et 2.

  3. Quel va être le caractère qui remplace le passage à la ligne à la fin de chaque print() ?
  4. On remplace le passage à la ligne défini comme fin par défaut par le tiret vertical | (altGr + 6).

  5. Quel va être l'affichage obtenu après un seul tour de boucle ?
  6. i vaut 0. On aura donc  0|  à l'écran.

  7. Quel va être l'affichage obtenu après deux tours de boucle ?
  8. i vaut 1. On rajoute donc 1| et on obtiendra au total  0|1| .

  9. Quel va être l'affichage final ?
  10. i vaut 2. On rajoute donc 2| et on obtiendra au total  0|1|2| .

04° Légères modifications du programme mais qui change tout. Répondre aux questions suivantes :

  1. Quelles sont les valeurs que va prendre la variable de boucle i ?
  2. Quels sont les caractères qui remplacent le passage à la ligne à la fin de chaque print() ?
  3. Quel va être l'affichage obtenu après un seul tour de boucle ?
  4. Quel va être l'affichage obtenu après deux tours de boucle ?
  5. Quel va être l'affichage final ?
1 2 3 4
notes = [15, 18, 8] for i in range(len(notes)): print(notes[i], end="***")

...CORRECTION...

  1. Quelles sont les valeurs que va prendre la variable de boucle i ?
  2. La variable de boucle i va prendre successivement les valeurs 0, 1 et 2.

  3. Quels sont les caractères qui remplacent le passage à la ligne à la fin de chaque print() ?
  4. On remplace le passage à la ligne défini comme fin par défaut par 3 étoiles à la fin de l'affichage.

  5. Quel va être l'affichage obtenu après un seul tour de boucle ?
  6. i vaut 0. Mais on veut afficher le contenu de la case d'indice 0 puisqu'on envoie notes[0] comme argument à la fonction print(). On aura donc  15***  à l'écran.

  7. Quel va être l'affichage obtenu après deux tours de boucle ?
  8. i vaut 1. On veut donc afficher notes[1]. On obtiendra  15***18*** .

  9. Quel va être l'affichage final ?
  10. i vaut 2. On veut donc afficher notes[2]. On rajoute donc 2|. On obtiendra au total  15***18***8*** .

05° Réaliser un court programme qui affiche les notes

  • en affichant "Alice : " devant les notes dont l'indice est dans l'intervalle [0;9] (0 inclus à 9 inclus),
  • en affichant "Bob : " devant les notes dont l'indice est dans l'intervalle [10;19] et
  • en affichant "Clark : " devant les notes dont l'indice est supérieur à 20.

On utilisera le passage à la ligne classique (définie par défaut) du print(). Pas la peine de définir end.

notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]

Vous devriez donc obtenir quelque chose qui ressemble à ceci :

Alice : 15 Alice : 18 Alice : 8 Alice : 10 Alice : 12 Alice : 15 Alice : 20 Alice : 5 Alice : 12 Alice : 17 Bob: 12 Bob: 10 Bob: 18 Bob: 4

...CORRECTION...

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 i in range(len(notes)): if i < 10: print(f"Alice : {notes[i]}") elif i < 20: print(f"Bob: {notes[i]}") else: print(f"Clark : {notes[i]}")
5 - Lecture directe des éléments un à un

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. note va donc valoir d'abord 15, puis 18 au tour de boucle suivant, puis 8... Avec cette façon de faire, on n'obtient pas l'indice de la case mais directement le contenu de la case.

Ce programme affiche "Bien", "Pas bien" ou "Moyen" devant chaque note sans avoir à passer par un indice :

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

06° Compléter la fonction "à trous" positif_uniquement() qui doit recevoir un tableau de nombres entiers positifs ou négatifs (postcondition) et qui affiche à 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
def positif_uniquement(t:list) -> None: '''AFFICHE uniquement les nombres positifs contenus dans le tableau t''' for v in ???: if v >= ???: print(???) positif_uniquement([-65, 66, -67, 68])

Vous devriez obtenir l'affichage suivant :

66 68

...CORRECTION...

1 2 3 4 5 6 7 8 9
def positif_uniquement(t:list) -> None: '''AFFICHE uniquement les nombres positifs contenus dans le tableau t''' for v in t: if v >= 0: print(v) positif_uniquement([-65, 66, -67, 68])

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...

07° 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 v contenue dans le paramètre t.
  • Afficher (sans passage à la ligne) le caractère placé à l'indice v dans le tableau ascii.
1 2 3 4 5 6 7 8 9 10 11 12
def decode(t:list) -> None: '''AFFICHE les caractères ASCII correspondant aux nombres reçus via le tableau t''' 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'] for v in ???: print(???[???], end="") print() # passage à la ligne final. decode([65, 66, 67]) decode([66, 114, 97, 118, 111])

Vous devriez obtenir l'affichage suivant :

ABC Bravo

...CORRECTION...

1 2 3 4 5 6 7 8 9 10 11 12
def decode(t:list) -> None: '''AFFICHE les caractères ASCII correspondant aux nombres reçus via le tableau t''' 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'] for v in t: print(ascii[v], end="") print() # passage à la ligne final. decode([65, 66, 67]) decode([66, 114, 97, 118, 111])
6- Modifier un tableau : mutabilité / muabilité des tableaux dans Python

Dans beaucoup de langages, les tableaux sont mutables (anglissisme, on dira muable en français) : cela veut dire qu'on peut modifier les contenus d'un tableau après sa création sans modifier l'adresse-mémoire du tableau lui-même.

On dit qu'on modifie son état.

>>> 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

for i in range(len(notes)).

On peut donc modifier l'état du tableau après création, sans modifier l'identifiant-mémoire du tableau lui-même : sur l'animation ci-dessous

  • Avant modification, on peut voir que :
    • La variable-tableau t ne contient pas le contenu du tableau mais son adresse de base : 1485.
    • Le contenu de la case 0 est référencé à l'adresse 1485+0 = 1485. On y y trouve l'adresse 78 qui mène au contenu 'a'.
    • Le contenu de la case 1 est référencé à l'adresse 1485+1 = 1486. On y y trouve l'adresse 85 qui mène au contenu 'b'.
    • Le contenu de la case 2 est référencé à l'adresse 1485+2 = 1487. On y y trouve l'adresse 128 qui mène au contenu 'c'.
  • Après modification avec t[0] = 'Z', la case 0 du tableau référence toujours l'adresse 1485 mais cette case-mémoire mène maintenant à l'adresse 170 qui contient 'Z'.
Animation du changement d'état
CLIQUER SUR L'IMAGE pour ANIMER ou STOPPER

Exemple

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 2 contiendrait 

-
notes = [30, 36, 16, 20, 24, 30, 40, 10, 24, 34, 24, 20, 36, 8]

✎ 08° 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]

Alors, for numérique ou for nominatif ?

Ca dépend des situations.

Situation 1 : modification du contenu : une seule solution

Vous avez besoin de connaître le numéro d'indice, il faut utiliser
for index in range(len(a)) avec

  • un accès au contenu de la case avec a[index]
  • une modification du contenu de la case avec a[index] = 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

Situation 2 : lecture des valeurs mais la connaissance des positions/indices est importante : une seule solution

Vous avez besoin de connaître le numéro d'indice, il faut utiliser
for index in range(len(a))

Situation 3 : vous voulez juste lire le contenu du tableau

Si 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...

7 - Déclaration de tableau par compréhension à partir d'un tableau initial

La déclaration d'un tableau par compréhension consiste à remplir le tableau à l'aide d'une boucle for.

nt = [None for element in base]

Comme doit-on comprendre cela ? Suivez bien ce qui suit.

  1. On voit d'abord qu'on déclare un nouveau tableau nt :
  2. nt = [...]

  3. Cette déclaration contient une boucle, il s'agit d'une déclaration dite déclaration par compréhension :
  4. nt = [... for element in base]

    Il faut comprendre que pour chaque element lu dans le tableau base, il faut faire quelque chose.

  5. Faire quoi ? Rajouter une nouvelle case à notre nouveau tableau. Case qui contient quoi ? Ce qui se trouve devant le for.
  6. 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]

09° Créer 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]

10° Créer 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]
8 - 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.

✎ 11° Créer par compréhension un tableau de 100 éléments contenant des nombres aléatoires compris entre 20 et 50.

✎ 12° Créer par compréhension un tableau de 500 éléments contenant 0.

On peut même faire mieux : on peut inclure une instructions conditionnelles ou même un appel de fonction dans la construction.

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.

13° Créer un tableau p6 dont les cases contiennent les prénoms d'au moins 6 caractères à partir du 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']
Tableau statique ou list-Python ?

Nous avons travaillé ici avec la notion de tableaux statiques : des tableaux dont

  1. toutes les cases contiennent le même type de données et
  2. 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.

  • Une List-Python n'a pas besoin que les éléments soient tous de même nature.
  • On peut modifier le nombre de cases après création.

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 ou supprimer des cases. Juste un petit exemple pour vous montrer comment cela s'utilise en attendant :

>>> t = [] >>> t.append("Alice") >>> t ['Alice'] >>> t.append("Bob") >>> t ['Alice', 'Bob'] >>> t.append("Clark") >>> t ['Alice', 'Bob', 'Clark'] >>> t.pop() 'Clark' >>> t ['Alice', 'Bob']

Attention : pas de telle utilisation des Lists pour l'instant.

3 - 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.

14° 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
# 1 - Importation des modules nécessaires import math import matplotlib.pyplot as plt # 2 - Constantes # 3 - Déclaration des fonctions # 4 - Programme principal # Création des tableaux de données tx = [ x for x in range(100) ] # Tableau des valeurs en abscisse ty = [ x**2 for x in tx ] # Tableau des valeurs en ordonnée # Création puis affichage de la(les) courbe(s) plt.plot(tx, ty, label="Cas 1", color='orange') plt.show() # Affichage à l'écran des courbes
Graphique de la fonction carrée
f(x) = x2

15° Répondre aux questions suivantes :

  1. Comment se nomme le tableau qui contient les valeurs d'abscisse ?
  2. Comment se nomme ce type de création ?
  3. Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
  4. Comment se nomme le tableau qui contient les valeurs d'ordonnée ?
  5. Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
  6. 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...

  1. Comment se nomme le tableau qui contient les valeurs d'abscisse ?
  2. 12
    tx = [ x for x in range(100) ] # Tableau des valeurs en abscisse
  3. Comment se nomme ce type de création ?
  4. Création pour compréhension.

  5. Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
  6. 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.

  7. Comment se nomme le tableau qui contient les valeurs d'ordonnée ?
  8. 13
    ty = [ x**2 for x in tx ] # Tableau des valeurs en ordonnée
  9. Expliquer à l'aide d'une phrase ce que contient ce tableau au final.
  10. Pour chaque valeur x du tableau tx, on rajoute une case dans ty qui va contenir x2.

  11. Lorsqu'on utilise la fonction plot() située dans le module dont l'alias est ici plt :
  12. 19
    plt.plot(tx, ty, label="Cas 1", color='orange')
    • que doit contenir le premier argument envoyé ?
    • Visiblement, il faut envoyer les valeurs x pour l'abscisse.

    • que doit contenir le deuxième argument envoyé ?
    • Visiblement, il faut envoyer les valeurs y pour l'ordonnée.

    • à quoi sert l'envoi de color='orange' ?
    • 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
# 1 - Importation des modules nécessaires import math import matplotlib.pyplot as plt # 2 - Constantes # 3 - Déclaration des fonctions # 4 - Programme principal # Création des tableaux de données tx = [ x for x in range(100) ] # Tableau des valeurs en abscisse ty = [ x**2 for x in tx ] # Tableau des valeurs en ordonnée # Création puis affichage de la(les) courbe(s) plt.plot(tx, ty, label="Cas 1", color='orange') # Choix des axes et autres options graphiques xmax = max(tx) # Fonction native max de Python ymax = max(ty) # Fonction native max de Python plt.axis([0, xmax, 0, ymax]) plt.title("Exemple de graphique obtenu avec Python") plt.legend(loc='upper center') plt.xlabel("Ici, c'est l'abscisse") plt.ylabel("Ici, c'est l'ordonnée") plt.grid() # Ordre final d'affichage des courbes plt.show()

16° Mettre cette version plus élaborée en mémoire, vérifier qu'elle fonctionne puis répondre aux questions :

Graphique de la fonction carrée v2
f(x) = x2, version 2
  1. L21 : A votre avis, que va contenir xmax après avoir stocké la réponse de la fonction native max() ?
  2. L22 : A votre avis, que va contenir ymax après avoir stocké la réponse de la fonction native max() ?
  3. 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 ?
  4. Sur quelle ligne demande-t-on d'afficher une grille de lecture ?

...CORRECTION...

  1. L21 : A votre avis, que va contenir xmax après avoir stocké la réponse de la fonction native max() ?
  2. La plus grande valeur qu'on puisse trouver dans le tableau tx.

  3. L22 : A votre avis, que va contenir ymax après avoir stocké la réponse de la fonction native max() ?
  4. La plus grande valeur qu'on puisse trouver dans le tableau ty.

  5. 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 ?
  6. 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.

  7. Sur quelle ligne demande-t-on d'afficher une grille de lecture ?
  8. 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 :

  1. 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)
  2. 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
# 1 - Importation des modules nécessaires import math import matplotlib.pyplot as plt # 2 - Constantes # 3 - Déclaration des fonctions def f(x:int) -> int: return x**2 def g(x:int) -> int: return 8000 - 10*x # 4 - Programme principal # Création des tableaux de données tx = [ x for x in range(100) ] # Tableau des valeurs en abscisse ty1 = [ f(x) for x in tx ] # Tableau des valeurs en ordonnée ty2 = [ g(x) for x in tx ] # Tableau des valeurs en ordonnée # Création puis affichage de la(les) courbe(s) plt.plot(tx, ty1, label="Cas 1", color='orange') plt.plot(tx, ty2, label="Cas 1", color='red') # Choix des axes et autres options graphiques xmax = max(tx) # Fonction native max de Python ymax = max(ty1) # Fonction native max de Python plt.axis([0, xmax, 0, ymax]) plt.title("Exemple de graphique obtenu avec Python") plt.legend(loc='upper center') plt.xlabel("Ici, c'est l'abscisse") plt.ylabel("Ici, c'est l'ordonnée") plt.grid() # Ordre final d'affichage des courbes plt.show()

17° Mettre cette version qui affiche deux courbes sur un même graphique, vérifier qu'elle fonctionne puis répondre aux questions :

Graphique où deux courbes apparaissent v3
f(x) = x2, version 2
  1. L18 : Expliquer ce que fait cette ligne, en français.
  2. 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).

4 - 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.

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.

18° 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]

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.

19° 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.

5 - 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.
  • >>> t = [10, 30, 25, -5] >>> min(t) -5 >>> max(t) 30 >>> sum(t) 60
  • Comment vérifier l'appertenance d'un élément : cet élément est-il dans le tableau ?
  • >>> t = [10, 30, 25, -5] >>> 30 in t True >>> 29 in t False
  • Comment trier une copie triée d'un tableau ?
  • >>> t = [10, 30, 25, -5] >>> t2 = sorted(t) >>> t [10, 30, 25, -5] >>> t2 [-5, 10, 25, 30]
  • Comment obtenir la moyenne issue d'un tableau de nombres ?
  • >>> t = [10, 30, 25, -5] >>> m = sum(t) / len(t) 15.0

20° Utiliser les exemples précédents pour vous convaincre qu'ils fonctionnent correctement.

Si 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
def maximum(t): return max(t)

...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.

6 - FAQ

Rien pour l'instant

Nous avons vu  

  • Les fonctions
  • Les instructions conditionnelles if elif else
  • Les boucles bornées for
  • Les boucles non bornées while
  • strings et tableaux

Des informations supplémentaires dans la partie FICHES, dont

Activité publiée le 01 11 2019
Dernière modification : 19 03 2022
Auteur : ows. h.