Boucles, in, break et listes

Bonjour,

Par où dois-je commencer ?

 Mais par le début, bien sûr !

CCM ne fait pas les exercices. Une aide peut être donnée si un travail personnel est démontré.

Difficile, de commencer par le début si je ne comprends pas la démarche à faire

Tu m'apprends quelques chose là, si j'ai fini par demander de l'aide sur un forum c'est bien parce qu'avec mes propres cours j'ai du mal & Oui espérons.

Bonjour,

Le but est de tes exercices (très scolaires et pas très bien écrits soit dit en passant) est de te faire apprendre la syntaxe des instructions de bases (

for, if, break

) et j'imagine aussi des comprehension-{list, tuple, dict, set}.

Pour rappel, python propose les containers suivants de base :

• list

  : une liste d'éléments. Exemple :

  [1, 2, 3, 2]

  .

• set

  : un ensemble (pas de doublons), non trié, et tel que ses éléments sont hashables. Exemple : {1, 2, 3}.

• tuple

  : un n-uplet (donc plus général qu'un couple ou un triplet). Exemple :

  (1, 2, 3, 2)

  .

• dict

  : une dictionnaire, qui associe à une clé (hashable) une valeur. Exemple :

  {'a' : 1, 'b' : 2}

  .

La syntaxe

Commençons par un exemple jouet. Supposons que tu veux créer une liste qui contient les carrés de 1 à 9. Commençons par la syntaxe de base

l = list()
for i in range(10):
    l.append(i ** 2)
print(l)

La boucle

for <variable> in <iterable>

permet d'itérer sur les valeurs de 1 (inclu) à 10 (exclu). L'instruction

append

permet d'ajouter un élément en fin de list. L'opérateur

** 2

calcule le carré d'un nombre.

En compréhension list cela devient :

l = [i ** 2 for i in range(10)]
print(l)

Ces deux de codes produisent la même chose : la liste

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

. On voit que ce qui était à l'intérieur de la boucle est passé devant.

Supposons qu'on veuille la liste des carrés pairs de 1 à 9. On écrirait

l = list()
for i in range(10):
    if i % 2 == 0:
        l.append(i ** 2)
print(l)

Le test

if

permet de ne faire l'ajout en liste que si le test

i % 2 == 0

est vrai (ce qui revient à tester si

i

est pair).

En compréhension list cela devient :

l = list(i ** 2 for i in range(10) if i % 2 == 0)
print(l)

... et on obtient dans les deux cas

[0, 4, 16, 36, 64]

. On observe donc qu'un comprehension-* peut contenir des

for

et des

if

. L'ordre des

for

et

if

est préservé.

Maintenant, que tu as compris la syntaxe pour les comprehension-list, il faut savoir qu'elle s'applique aussi pour les tuples et les sets :

s = set(i ** 2 for i in range(10) if i % 2 == 0)
print(s)
t = tuple(i ** 2 for i in range(10) if i % 2 == 0)
print(t)

Souvent, tu verras le constructeur

list()

(resp.

set()

) remplacés par des [ ] (resp. { }) :

l = [i ** 2 for i in range(10)]
s = {i ** 2 for i in range(10)}

Note toutefois qu'il n'y a pas de syntaxe pour les tuples (si tu utilises des ( ), tu auras un générateur, ce qui n'est pas la même chose).

Il est bien entendu possible d'imbriquer plusieurs boucle for ou if si tu le souhaites. Par exemple si tu veux stocker tous les couples de carrés et de cubes, cela donnerait :

l = list()
for i in range(10):
    for j in range(10):
        l.append((i ** 2, j ** 3))
print(l)

... ou encore :

l = [
    (i **2, j ** 3)
    for i in range(10)
    for j in range(10)
]
print(l)

Je passe sur les dictionnaires car on n'en parle pas dans ton exercice mais le principe est le même.

Ce qu'il faut retenir

• Si tu es capable d'écrire l'exercice avec du code ordinaire et que le code est localisé dans le bloc le plus imbriqué, alors on peut l'écrire sous forme de comprehension-*.
• Si tu sais écrire une comprehension list, tu peux facilement écrire un comprehension tuple ou un comprehension set.
• Quand tu débutes, il est plus facile de raisonner sans comprehension-* et avec une list, quitte ensuite à réarranger le code ensuite : mettre le bon constructeur et déplacer l'instruction devant les boucles impliquées dans le comprehension-*.

Instructions

break

et

continue

.

Quand tu es dans une boucle, tu peux décider de l'interrombre (

break

), typiquement lorsqu'une condition d'arrêt est atteinte, ou ignprer le tour de boucle en cours (

continue

). Note qu'on arrive alors dans un cas où les boucles ne peuvent plus s'écrire sous forme de comprehension-*.

Supposons que je veux tous les carrés positifs inférieur à 50 (et que mon cerveau soit trop délabré pour savoir que dois en vrai m'arrêter à i == 7). Alors je pourrais écrire :

l = list()
for i in range(1000):
    x = i ** 2
    if x > 50:
        break
    l.append(x)
print(l)

Si de plus je ne veux considérer que les carrés pairs, je peux écrire :

l = list()
for i in range(1000):
    x = i ** 2
    if x % 2 == 0: # Ne considérer que les nombres pairs
        if x > 50:
            break
        l.append(x)
print(l)

... ou de manière équivalente, utiliser un continue pour ignorer les impairs :

l = list()
for i in range(1000):
    x = i ** 2
    if x % 2 == 1: # Ignorer les nombres impairs
        continue
    if x > 50:
        break
    l.append(x)
print(l)

... et j'obtiendrai alors

[0, 4, 16, 36]

.

Maintenant, tu as tous les éléments en main pour faire tes exercices, mais si quelque chose n'est pas clair, n'hésite pas à demander des précisions...

Bonne chance