Outils Pour

Identification

Infoforall

9 - Boucles et types construits


FAIRE INTRO

Evaluation : 5 questions

  questions 05-12-13A-13B

  question 09C

DM 🏠 : Non

Documents de cours : open document ou pdf

1 - Parcours par indices

Il est possible d'utiliser une boucle for de façon à lire ou modifier une à une toutes les "cases" d'un type construit. Pour cela, il faut utiliser :

  • Leurs indices dans les tableaux, les strings et les tuples
  • Leurs clés dans les dictionnaires
(RAPPELS) 1.1 STRING : parcours par indices

On utilise une boucle for .. in range(...) couplée à la fonction len() pour connaître l'indice i limite.

Ainsi avec "bonjour", on a 7 caractères d'indices 0 à 6.

1 2 3 4
s = "bonjour" for i in range(len(s)): # Pour chaque indice possible dans s print(s[i]) # Affiche le contenu de la case i

Ce programme est équivalent à ceci :

1 2 3 4 5 6 7 8 9
s = "bonjour" print(s[0]) print(s[1]) print(s[2]) print(s[3]) print(s[4]) print(s[5]) print(s[6])

Ils affichent l'un et l'autre ceci dans la console :

b o n j o u r

Accès à tous les caractères (str) : coût LINÉAIRE par rapport au nombre n de caractères.

(RAPPELS) 1.2 TABLEAU STATIQUE : parcours par indices

On utilise une boucle for .. in couplée à la fonction len() pour connaitre l'indice i limite.

Ainsi avec [20, 8, 18, 12], on a 4 notes d'indices 0 à 3.

1 2 3 4
t = [20, 8, 18, 12] for i in range(len(t)): # Pour chaque indice possible dans t print(t[i]) # Affiche le contenu de la case i

Ce programme est équivalent à ceci :

1 2 3 4 5 6
t = [20, 8, 18, 12] print(t[0]) print(t[1]) print(t[2]) print(t[3])

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 :

  1. Le calcul de la longueur L3 est à coût constant
  2. La ligne 4 est à coût constant
  3. 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 for .. in couplée à la fonction len() pour connaitre l'indice i limite.

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) for i in range(len(eleve)): # Pour chaque indice possible dans eleve print(eleve[i]) # Affiche le contenu de la case i

Ce programme est équivalent à ceci :

1 2 3 4 5 6
eleve = ("In Borderland", "Alice", 18, True) print(eleve[0]) print(eleve[1]) print(eleve[2]) print(eleve[3])

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
def somme_tableau(t:list[int]) -> int: """Renvoie la somme des entiers dans le tableau t""" s = ... for i in ...: if t[i] ... 0: s = ... return ...
>>> somme_tableau([10, 20, -50, 30]) 60

...CORRECTION...

1 2 3 4 5 6 7
def somme_tableau(t:list[int]) -> int: """Renvoie la somme des entiers dans le tableau t""" s = 0 # Initialisation d'un compteur for i in range(len(t)): # Pour chaque indice possible dans t if t[i] >= 0: # Si le contenu de la case i est positif s = s + t[i] # On incrémente s de la valeur dans la case return s # APRES avoir fait tous les tours
1.4 Boucle POUR : somme d'un tableau

1 2 3 4 5 6
def somme_tableau(t:list[int]) -> int: """Renvoie la somme des entiers dans le tableau t""" s = 0 # Initialisation d'un compteur for i in range(len(t)): # Pour chaque indice possible dans t s = s + t[i] # On incrémente s de la valeur dans la case return s # 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

Indice 0 1 2 3 >>> notes = [20, 8, 18, 12] >>> notes[1] = 11 >>> notes [20, 11, 18, 12]

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) # ? for i in range(len(t)): # ? if t[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 t print("Avant la boucle") print(t) # Affichage sur la console du tableau for i in range(len(t)): # Pour chaque indice possible dans le tableau if t[i] < 0: # Si le contenu de la case i est négatif t[i] = -t[i] # On remplit la case par son opposé, positif donc print("Après la boucle") print(t) # Affichage sur la console du tableau

2 - Parcours par clés

(RAPPELS) 2.1 DICTIONNAIRE : parcours par clés

On utilise une boucle for .. in mais on ne peut pas la coupler à la fonction len puisqu'un dictionnaire possède des clés, pas des indices.

Voici la manière usuelle d'obtenir les clés une par une.

1 2 3 4
ds = {"Alice": 13, "Bob": 8, "Charlie": 12} for cle in ds.keys(): # Pour chaque cle possible dans ds print(ds[cle]) # Affiche la valeur associée à cette clé

Ce programme est équivalent à ceci :

1 2 3 4 5
ds = {"Alice": 13, "Bob": 8, "Charlie": 12} print(ds["Alice"]) print(ds["Bob"]) print(ds["Charlie"])

Ils affichent l'un et l'autre ceci dans la console :

13 8 12

Accès à toutes les cases (dict) : coût LINÉAIRE par rapport au nombre n d'éléments.

03° Compléter la fonction somme_dict() qui renvoie la somme des entiers POSITIFS contenus dans le dictionnaire.

Documentation rapide

L'indication de type d:dict[(str, int)]): indique que d doit être un dictionnaire dont les clés sont des strings et les valeurs sont des integers.

1 2 3 4 5 6 7
def somme_dict(d:dict[(str, int)]) -> int : """Renvoie la somme des entiers dans le dictionnaire d""" s = ... for cle in ...: if ... >= ...: s = ... return s
>>> ds = {"Alice":10, "Bob":20, "Charlie":5} >>> somme_dict(ds) 35

...CORRECTION...

1 2 3 4 5 6 7
def somme_dict(d:dict[(str, int)]): """Renvoie la somme des entiers dans le dictionnaire d""" s = 0 # Initialisation d'un compteur for cle in d.keys(): # Pour chaque clé du dictionnaire d if d[cle] >= 0: # Si la valeur associée à cette clé est positive s = s + d[cle] return s
2.2 Boucle POUR : somme d'un dictionnaire

1 2 3 4 5 6 7
def somme_dict(d:dict[(str, int)]) -> int: """Renvoie la somme des entiers dans le dictionnaire d""" s = 0 # Initialisation d'un compteur for cle in d.keys(): # Pour chaque clé du dictionnaire d s = s + d[cle] return s

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

>>> {"Alice": 13, "Bob": 8, "Charlie": 12} >>> notes["Bob"] 8 >>> notes["Bob"] = 11 >>> notes["Bob"] 11 >>> notes {'Alice': 13, 'Bob': 11, 'Charlie': 12}

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.

>>> {"Alice": 13, "Bob": 11, "Charlie": 12} >>> notes["David"] = 15 >>> notes {'Alice': 13, 'Bob': 11, 'Charlie': 12, 'David': 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) # ? for cle in d.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 d print("Avant la boucle") print(d) # Affichage sur la console du dictionnaire for cle in d.keys(): # Pour chaque clé possible dans le dictionnaire if (d[cle] % 2) == 0: # Si la valeur (le contenu de la case) est paire d[cle] = d[cle] + 1 # On rajoute 1 à la case print("Après la boucle") print(d) # Affichage sur la console du dictionnaire

3 - Parcours par valeurs

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 ... in 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" for c in s: # Pour chaque caractère possible dans s print(c) # Affiche le caractère c

Ce programme est équivalent à ceci :

1 2 3 4 5 6 7 8 9
s = "bonjour" print(s[0]) print(s[1]) print(s[2]) print(s[3]) print(s[4]) print(s[5]) print(s[6])

Ils affichent l'un et l'autre ceci dans la console :

b o n j o u r
3.2 n-UPLET : parcours par valeurs

Si on désire uniquement LIRE les valeurs d'un n-uplet, on PEUT utiliser une boucle for ... in en l'associant directement au nom du n-uplet.

Ainsi avec ("In Borderland", "Alice", 18, True ), on a 4 valeurs.

1 2 3 4
eleve = ("In Borderland", "Alice", 18, True) for v in eleve: # Pour chaque valeur possible dans eleve print(v) # Affiche la valeur

Ce programme est équivalent à ceci :

1 2 3 4 5 6
eleve = ("In Borderland", "Alice", 18, True) print(eleve[0]) print(eleve[1]) print(eleve[2]) print(eleve[3])

Ils affichent l'un et l'autre ceci dans la console :

'In Borderland' 'Alice' 18 True
3.3 TABLEAU STATIQUE : parcours par valeurs

3.3.1 Syntaxe

Si on désire uniquement LIRE les valeurs d'un tableau, on PEUT utiliser une boucle for ... in en l'associant directement au nom du tableau.

Ainsi avec [20, 8, 18, 12], on a 4 notes.

1 2 3 4
t = [20, 8, 18, 12] for note in t: # Pour chaque valeur possible dans t print(note) # Affiche la valeur

Ce programme est équivalent à ceci :

1 2 3 4 5 6
t = [20, 8, 18, 12] print(t[0]) print(t[1]) print(t[2]) print(t[3])

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
for note in t: # Pour chaque valeur possible dans t note = 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} for v in ds.values(): # Pour chaque valeur possible dans ds print(v) # Affiche la valeur lue sur ce tour de boucle

Ce programme est équivalent à ceci :

1 2 3 4 5
ds = {"Alice": 13, "Bob": 8, "Charlie": 12} print(ds["Alice"]) print(ds["Bob"]) print(ds["Charlie"])

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
for v in ds.values(): # Pour chaque valeur possible dans ds v = 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] def somme(t:list[int]) -> int: """Renvoie la somme des valeurs contenues dans le tableau""" s = ... # Initialisation de la variable somme for v in ...: # Pour chaque valeur du tableau ... = ... + ... # Incrémente s de cette valeur return ... # Après avoir fait toute la boucle print(somme(t))

...CORRECTION...

1 2 3 4 5 6 7 8 9 10 11 12 13
t = [10, 20, 30] def somme(t:list[int]) -> int: """Renvoie la somme des valeurs contenues dans le tableau""" s = 0 # Initialisation de la variable somme for v in t: # Pour chaque valeur du tableau s = s + v # Incrémente s de cette valeur return s # Après avoir fait toute la boucle print(somme(t))

4 - Création 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...

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  for element in base]

Comme doit-on comprendre cela ? "Pour chaque élément du tableau initial, créé une case contenant 0 dans le nouveau tableau". Voici l'explication :

  1. On déclare un nouveau tableau nt crée par compréhension puisqu'on y voit une boucle :
  2. nt = [... for ...]

  3. "Pour chaque élément du tableau initial" se note :
  4. nt = [... for element in base]

  5. "Crée une case contenant 0 dans le nouveau tableau" se note :
  6. nt = [  0  for element in base]

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 = [v for v in b]

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*100 for v in b]

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 :

>>> 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(prenom) for prenom 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]
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.

>>> 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]
C - Fonction de filtrage

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

>>> 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 = [prenom for prenom in prenoms if len(prenom) >= 6] >>> p6 ['Matthias', 'Antoine', 'Alexandre', 'Alexandre', 'Thomas', 'Aurélien', 'Charles', 'Francia', 'Imrane', 'Yassin', 'Sofian', 'Damien', 'Antonin', 'Laurine', 'Victor', 'Julien', 'Benjamin']

5 - FAQ

Rien pour le moment

Voilà pour les boucles bornées qui permettent donc de faire plusieurs fois la même chose, ou presque.

Reste à voir les boucles non bornées.

Activité publiée le 02 07 2024
Dernière modification : 02 07 2024
Auteur : ows. h.