10 - Boucles et types construits

⏪

⏬

⏩

1 - for i

2 - for cle

3 - for v

4 - Compréhension

5 - FAQ

Exercices supplémentaires 🏠 : Non

Evaluation : 5 questions

✎ questions 05-12-13A-13B

✌ question 09C

Documents de cours PDF : .PDF

Sources latex : .TEX et entete.tex et licence.tex

MODE COURS (cacher les questions)

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 Parcours par indices d'un string

Voir

On utilise une boucle for i in range(len(s)).

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

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 :

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 : parcours par indices

Voir

Parcours par indices (permet la lecture et la modification)

On utilise une boucle for i in range(len(t)).

#     0  1  2   3
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

Le programme précédent est équivalent à ceci :

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 :

Le coût de la lecture de toutes les cases est LINÉAIRE par rapport au nombre n d'éléments.

L4 : coût constant
La boucle L3-L4 est réalisée n fois (autant que de cases).
C'est donc LINÉAIRE : on réalise n fois une action constante.

(RAPPELS) 1.3 n-UPLET : parcours par indices

Voir

On utilise une boucle for i in range(len(tup)).

Ainsi avec ("In Borderland", "Alice", 18, True ), on a 4 éléments d'indices 0 à 3.

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 :

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.

def somme_tableau(t:list[int]) -> int:
    """Renvoie la somme des entiers POSITIFS dans le tableau t"""
 
    s = ...
    for i in ...:
        if t[i] ... 0:
            s = ...
    return ...


>>> somme_tableau([10, 20, -50, 30])
60

Correction ?

...CORRECTION...

def somme_tableau(t:list[int]) -> int:
    """Renvoie la somme des entiers POSITIFS 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

Voir

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 : mutable en Python (modification possible)

Voir

Les tableaux Python sont mutables : 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. Voici comment modifier le contenu 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.

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 ?

...CORRECTION...

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

Voir

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.

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 :

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.

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 ?

...CORRECTION...

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

Voir

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]    # Incrémente la somme avec cette valeur associée
    return s              # 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)

Voir

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.

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 ?

...CORRECTION...

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 Parcours par valeurs d'un string

Voir

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.

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 :

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

Voir

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

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

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 :

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

Voir

3.3.1 Syntaxe

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

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

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 :

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 :

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

Voir

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.

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 :

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.

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 ?

...CORRECTION...

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

Voir

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 :

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

"Crée une case contenant 0 dans le nouveau tableau" se note :

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 ?

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

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

Voir

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 ?

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

...CORRECTION...


>>> import random
>>> tableau = [random.randint(20, 50) for _ in range(100)]

4.3 Création par compréhension avec condition

Voir

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 :

def pas_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"""
 
    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 ?

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

Voir

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

⏪

⏫

⏩