Ils affichent l'un et l'autre ceci dans la console :
20
8
18
12
Le coût de la lecture de toutes les cases est LINÉAIRE par rapport au nombre n d'éléments.
Pourquoi ? On remarquera que dans le premier programme :
Le calcul de la longueur L3 est à coût constant
La ligne 4 est à coût constant
Le boucle L3-L4 est réalisée n fois (autant que de cases).
On réalise donc n fois des actions à coût constant : c'est donc LINÉAIRE.
(RAPPELS) 1.3 n-UPLET : parcours par indices
On utilise une boucle foriinrange(len(tup)).
Ainsi avec ("In Borderland", "Alice", 18, True), on a 4 éléments d'indices 0 à 3.
1
2
3
4
eleve = ("In Borderland", "Alice", 18, True)foriinrange(len(eleve)):# Pour chaque indice possible dans eleveprint(eleve[i])# Affiche le contenu de la case i
Ils affichent l'un et l'autre ceci dans la console :
'In Borderland'
'Alice'
18
True
Accès à toutes les cases (tuple) : coût LINÉAIRE par rapport au nombre n d'éléments.
01° Compléter la fonction somme_tableau() qui renvoie la somme des entiers POSITIFS contenus dans le tableau.
Documentation rapide
L'indication de type t:list[int] indique que t doit être un tableau contenant des integers.
1
2
3
4
5
6
7
defsomme_tableau(t:list[int])->int:"""Renvoie la somme des entiers dans le tableau t"""s=...foriin...:ift[i]...0:s=...return...
>>> somme_tableau([10, 20, -50, 30])
60
...CORRECTION...
1
2
3
4
5
6
7
defsomme_tableau(t:list[int])->int:"""Renvoie la somme des entiers dans le tableau t"""s=0# Initialisation d'un compteurforiinrange(len(t)):# Pour chaque indice possible dans tift[i]>=0:# Si le contenu de la case i est positifs=s+t[i]# On incrémente s de la valeur dans la casereturns# APRES avoir fait tous les tours
1.4 Boucle POUR : somme d'un tableau
1
2
3
4
5
6
defsomme_tableau(t:list[int])->int:"""Renvoie la somme des entiers dans le tableau t"""s=0# Initialisation d'un compteurforiinrange(len(t)):# Pour chaque indice possible dans ts=s+t[i]# On incrémente s de la valeur dans la casereturns# APRES avoir fait tous les tours
L'un des intérêts d'obtenir les indices est notamment de pouvoir modifier toutes les cases correspondantes d'un tableau.
(RAPPELS) 1.5 TABLEAU STATIQUE : muable en Python (modification possible)
En Python, les tableaux sont muables (ou mutables en anglais) : on peut modifier le contenu d'une case après la création du tableau.
Imaginons qu'on ai oublié des points à Bob (l'élève d'indice 1) : il n'a pas 8 mais 11 finalement. Voici comment nous pourrions modifier le tableau APRES création
Ce n'est pas une affectation sur le tableau lui-même : l'affectation est faite sur l'une des cases notes[i] du tableau.
Accès en modification (list) : coût CONSTANT par rapport au nombre n d'éléments.
02° Lancer le programme suivant, comprendre ce qu'il réalise pour compléter les commentaires pour donner la signification en français de chacune des lignes.
1
2
3
4
5
6
7
8
9
10
t=[5,2,-7,15,-10]# ?print("Avant la boucle")print(t)# ?foriinrange(len(t)):# ?ift[i]<0:# ?t[i]=-t[i]# ?print("Après la boucle")print(t)# ?
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
t=[5,2,-7,15,-10]# Création du tableau tprint("Avant la boucle")print(t)# Affichage sur la console du tableauforiinrange(len(t)):# Pour chaque indice possible dans le tableauift[i]<0:# Si le contenu de la case i est négatift[i]=-t[i]# On remplit la case par son opposé, positif doncprint("Après la boucle")print(t)# Affichage sur la console du tableau
defsomme_dict(d:dict[(str,int)]):"""Renvoie la somme des entiers dans le dictionnaire d"""s=0# Initialisation d'un compteurforcleind.keys():# Pour chaque clé du dictionnaire difd[cle]>=0:# Si la valeur associée à cette clé est positives=s+d[cle]returns
2.2 Boucle POUR : somme d'un dictionnaire
1
2
3
4
5
6
7
defsomme_dict(d:dict[(str,int)])->int:"""Renvoie la somme des entiers dans le dictionnaire d"""s=0# Initialisation d'un compteurforcleind.keys():# Pour chaque clé du dictionnaire ds=s+d[cle]# Incrémente la somme avec cette valeur associéereturns# Renvoie la somme
L'un des intérêt d'avoir connaissance des clés une par une est de pouvoir modifier les cases du dictionnaire.
(RAPPELS) 2.3 DICTIONNAIRE : muable en Python (modification possible)
En Python, les dictionnaires sont muables (ou mutables en anglais) : on peut modifier le contenu d'une case après la création du dictionnaire.
Modification d'un couple existant
Imaginons qu'on ai oublié des points à Bob : il n'a pas 8 mais 11 finalement. Voici comment nous pourrions modifier le tableau APRES création
Notez bien que ce n'est pas une affectation sur le dictionnaire : l'affectation est faite sur l'un des contenus des associations clé-valeur du dictionnaire, pas sur le dictionnaire lui-même.
Accès en modification (dict) : coût CONSTANT par rapport au nombre n d'éléments.
Rajout d'un nouveau couple
On peut rajouter de la même façon un couple qui n'existe pas encore.
Imaginons un nouvel élève nommé David qui a eu 15.
04° Lancer le programme suivant, comprendre ce qu'il réalise pour compléter les commentaires pour donner la signification en français de chacune des lignes.
1
2
3
4
5
6
7
8
9
10
d={"A":12,"B":20,"C":7}# ?print("Avant la boucle")print(d)# ?forcleind.keys():# ?if(d[cle]%2)==0:# ?d[cle]=d[cle]+1# ?print("Après la boucle")print(d)# ?
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
d={"A":12,"B":20,"C":7}# Création du dictionnaire dprint("Avant la boucle")print(d)# Affichage sur la console du dictionnaireforcleind.keys():# Pour chaque clé possible dans le dictionnaireif(d[cle]%2)==0:# Si la valeur (le contenu de la case) est paired[cle]=d[cle]+1# On rajoute 1 à la caseprint("Après la boucle")print(d)# Affichage sur la console du dictionnaire
La syntaxe permettant d'accéder à tous les indices ou toutes les clés est un peu lourde.
Or, elle n'est indispensable que si on désire MODIFIER le contenu de la structure.
Si on désire simplement lire le contenu, on peut utiliser une autre syntaxe qui permet d'accéder directement au contenu, sans passer par les étiquettes (indices ou clés).
3.1 STRING : parcours par valeurs
Si on désire uniquement LIRE les caractères d'un string, on PEUT utiliser une boucle for v in s en l'associant directement au nom du string.
La variable de boucle va alors contenir les caractères un par un, et non plus l'indice du caractère.
Ainsi avec "bonjour", on a 7 caractères.
1
2
3
4
s="bonjour"forcins:# Pour chaque caractère possible dans sprint(c) # Affiche le caractère c
Ils affichent l'un et l'autre ceci dans la console :
20
8
18
12
Accès à toutes les valeurs (list) : coût LINÉAIRE par rapport au nombre n d'éléments.
3.3.2 Impossible de MODIFIER avec cette boucle
Notez bien qu'on ne peut que LIRE.
Le code suivant ne modifie pas le tableau.
3
4
fornoteint:# Pour chaque valeur possible dans tnote=note+5# Ne modifie absolument pas le contenu du tableau !
3.4 DICTIONNAIRE : parcours par valeurs
3.4.1 Syntaxe
Si on désire uniquement LIRE les valeurs d'un dictionnaire, on PEUT utiliser une boucle for ... in en utilisant la méthode values() sur le dictionnaire.
1
2
3
4
ds = {"Alice":13, "Bob":8, "Charlie":12}forvinds.values():# Pour chaque valeur possible dans dsprint(v)# Affiche la valeur lue sur ce tour de boucle
Ils affichent l'un et l'autre ceci dans la console :
13
8
12
3.4.2 Impossible de MODIFIER avec cette boucle
Notez bien qu'on ne peut que LIRE.
Le code suivant ne modifie pas le contenu du dictionnaire.
3
4
forvinds.values():# Pour chaque valeur possible dans dsv=v+5# Ne modifie pas le contenu du dictionnaire !
05° Modifier la fonction somme() pour qu'elle réalise bien la somme des éléments du tableau. On impose l'utilisation de la lecture directe des valeurs plutôt que de passer par les indices.
1
2
3
4
5
6
7
8
9
10
11
12
13
t=[10,20,30]defsomme(t:list[int])->int:"""Renvoie la somme des valeurs contenues dans le tableau"""s=...# Initialisation de la variable sommeforvin...:# Pour chaque valeur du tableau...=...+...# Incrémente s de cette valeurreturn...# Après avoir fait toute la boucleprint(somme(t))
...CORRECTION...
1
2
3
4
5
6
7
8
9
10
11
12
13
t=[10,20,30]defsomme(t:list[int])->int:"""Renvoie la somme des valeurs contenues dans le tableau"""s=0# Initialisation de la variable sommeforvint:# Pour chaque valeur du tableaus=s+v# Incrémente s de cette valeurreturns# Après avoir fait toute la boucleprint(somme(t))
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...
Nous allons voir que le parcours par et par valeur permettent de créer un nombre énorme de tableaux assez complexes à réaliser à la main.
4.1 Création par compréhension à partir d'un autre tableau
A - Principe
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=[ 0 forelementinbase]
Comme doit-on comprendre cela ? "Pour chaque élément du tableau initial, créé une case contenant 0 dans le nouveau tableau". Voici l'explication :
On déclare un nouveau tableau nt crée par compréhension puisqu'on y voit une boucle :
nt=[... for ...]
"Pour chaque élément du tableau initial" se note :
nt=[...forelementinbase]
"Crée une case contenant 0 dans le nouveau tableau" se note :
nt=[ 0 forelementinbase]
B - Exemple 1 ; tableau de même taille
>>> base = [1, 2, 5]
>>> nt = [100 for valeur in base]
>>> nt
[100, 100, 100]
On peut traduire cela par :
Crée un tableau nt par compréhension où
pour chaque valeur contenue dans base
on crée une case contenant 100 dans nt.
C - Exemple 2 : copie peu profonde
copie=[vforvinb]
On peut traduire cela par :
Crée un tableau dd par compréhension où
pour chaque valeur contenue dans b
on crée une case contenant la même valeur.
>>> b = [1, 2, 5]
>>> copie = [v for v in b]
>>> copie
[1, 2, 5]
D - Exemple 3 : copie peu profonde modifiée
On peut indiquer une expression expliquant ce que doit être le contenu de la nouvelle case.
copie_mod=[v*100forvinb]
On peut traduire cela par :
Crée un tableau dd par compréhension où
pour chaque valeur contenue dans b
on crée une case contenant le double de la case de b.
>>> b = [1, 2, 5]
>>> copie_mod = [v*100 for v in b]
>>> copie_mod
[100, 200, 500]
⚙ 06° Créer, par compréhension, un tableau qui contient des valeurs 10 fois plus grandes que le tableau suivant :
>>> t1 = [1, 2, 3, 5, 7, 11]
...CORRECTION...
>>> t1 = [1, 2, 3, 5, 7, 11]
>>> dix = [v*10 for v in t1]
>>> dix
[10, 20, 30, 50, 70, 110]
⚙ 07° Créer, par compréhension, un tableau longueurs dont les cases contiennent le nombre de lettres des prénoms contenus dans le tableau prenoms :
4.2 Création par compréhension sans tableau initial
A - Principe
On peut créer des tableaux contenant un nombre précis d'élements en utilisant range().
B - Exemple 1
>>> t = [0 for i in range(10)]
>>> t
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
On place 0 dans une case pour chaque indice i (qui vaut 0 puis 1 puis 2 ... jusqu'à 9). Donc 10 cases.
C - Exemple 2
>>> t = [i*10 for i in range(10)]
>>> t
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
La variable de boucle i varie de 0 à 9, et on place 10 fois plus dans la case correspondante du nouveau tableau.
D - Exemple 3
>>> import random
>>> tableau = [random.randint(1, 100) for i in range(10)]
>>> tableau
[42, 41, 96, 35, 58, 94, 16, 21, 84, 51]
On crée 10 cases dans lesquelles on place un nombre aléatoire entre 1 et 100.
⚙ 08° Créer, par compréhension, un tableau de 500 éléments contenant 0.
...CORRECTION...
>>> tableau = [0 for _ in range(500)]
⚙ 09° 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(20, 50) for _ in range(100)]
4.3 Création par compréhension avec condition
A - Principe
On peut rajouter une expression booléenne à la toute fin de la déclaration.
B - Réaliser un filtrage
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.
La fonction détermine 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
6
defpas_plus(valeur:int,seuil:int)->int:"""Fonction qui écrête : elle renvoie la valeur ou le seuil si la valeur est supérieure au seuil"""ifvaleur>seuil:returnseuilreturnvaleur
>>> import random
>>> t = [random.randint(1, 20) for _ in range(10)]
>>> t
[14, 19, 7, 14, 11, 1, 13, 12, 20, 1]>>> t2 = [pas_plus(valeur, 15) for valeur in t]
>>> t2
[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.
⚙ 10° Créer un tableau p6 dont les cases contiennent les prénoms de 6 caractères ou plus contenus dans le tableau prenoms :