Boucles, in, break et listes

Fermé
Mell0w Messages postés 3 Date d'inscription jeudi 19 novembre 2020 Statut Membre Dernière intervention 19 novembre 2020 - Modifié le 19 nov. 2020 à 00:39
mamiemando Messages postés 32945 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 février 2024 - 30 nov. 2020 à 15:08
Bonsoir, désolé pour l'heure tardive seulement je bloque énormément sur ces exercices d'infos, pouvez-vous m'éclairer? Par où dois-je commencer ?
Merci d'avance !

4 réponses

Chris 94 Messages postés 50978 Date d'inscription mardi 8 janvier 2008 Statut Modérateur Dernière intervention 17 février 2023 7 320
19 nov. 2020 à 00:42
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é.
0
Mell0w Messages postés 3 Date d'inscription jeudi 19 novembre 2020 Statut Membre Dernière intervention 19 novembre 2020
19 nov. 2020 à 00:44
Difficile, de commencer par le début si je ne comprends pas la démarche à faire
0
Chris 94 Messages postés 50978 Date d'inscription mardi 8 janvier 2008 Statut Modérateur Dernière intervention 17 février 2023 7 320
Modifié le 19 nov. 2020 à 00:49
Conclusion ?

Tu relis tes cours, tu réfléchis, tu ébauches ton boulot et, peut-être, quelqu'un aura-t-il me temps et la patience de t'aider.
0
Mell0w Messages postés 3 Date d'inscription jeudi 19 novembre 2020 Statut Membre Dernière intervention 19 novembre 2020
19 nov. 2020 à 00:47
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.
0
mamiemando Messages postés 32945 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 février 2024 7 721
Modifié le 30 nov. 2020 à 15:11
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
0