Discussion :

[Matthieu_12]

Salut, je suis en train de me taper le Swinnen et je rencontre un petit problème.
Je remplis une liste d'éléments (string par défaut) dans la première boucle.
Dans la seconde, je cherche à additionner les éléments de la liste ainsi obtenue dans la boucle 1.
Mais je rencontre un problème de type.
J'ai beau tourner le truc dans tous les sens, ça fonctionne pas.
C'est à la ligne 19 que ça chie dans la colle.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# programme qui renvoie la liste des multiples de 3 et 5 compris entre deux bornes
 
liste=[]
bi = int(input("borne inférieure : "))
bs = int(input("borne supérieure : "))
x=bi
i=0
somme=0
n=0
 
while x <= bs: # tant que x, qui part de la borne inférieure, est inférieur à la borne supérieure
    if not x % 3 and not x % 5: # si x est un multiple de 3 et de 5, voire x%3==0?
        liste.append(x) # on l'ajoute à la liste
        x=x+1 # on incrémente pour boucler
    else:
        x=x+1 # si x n'est pas un multiple de 3 et de 5, on ne le prend pas en compte et on boucle
 
while i <= len(liste): # tant qu'on a pas parcouru toute la liste
    somme = somme + eval(liste[i])
    i=i+1
 
print("résultat = ", liste, "=", somme)

Je suis bien conscient que le code ne doit pas être optimal, mais ce n'est pas grave, je ne cherche pas à obtenir le meilleur code possible mais à faire du code par moi-même, que je comprends.
Aussi, pour résoudre ce problème de type/liste, je ne souhaite pas utiliser de fonction pré-intégrée à Python mais à le faire de la manière la plus simple et débutante possible.

[danielhagnoul]

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
bi = 10
bs = 50
somme = 0
liste = []
 
for x in range(bi, bs+1):
    if not x % 3 and not x % 5:
        liste.append(x)
        somme += x
 
print("liste = {}, somme liste = {}, somme = {}".format(liste, sum(liste), somme))
 
# liste = [15, 30, 45], somme liste = 90, somme = 90

[wiztricks]

Salut,

Si liste est une suite d'entiers, quel est l'intérêt de passer par eval (qui attend une chaine de caractères)?

- W

[Sve@r]

Bonjour

C'est à la ligne 19 somme = somme + eval(liste[i]) que ça chie dans la colle.

Je pense que tu voulais écrire somme = somme + int(liste[i]). Toutefois puisque chaque élément de la liste est déjà un entier, même pas besoin => somme = somme + liste[i].
Sinon pourquoi tu écris deux fois l'instruction x=x+1 dans le "if" et dans le "else" ??? Ca ne te parait pas plus logique de ne l'écrire qu'une fois en dehors du if ???

Je suis bien conscient que le code ne doit pas être optimal

Tout à fait. Tu traites des nombres pour créer une liste puis tu traites la liste pour cumuler une somme. L'évidence serait donc de traiter des nombres pour cumuler une somme et bye bye la liste inutile.

[Matthieu_12]

@daniel: je savais bien que ça pouvait être très optimisé ! Mais j'y comprends rien et je souhaite apprendre au fur et à mesure avec le bouquin
@wiztricks: je savais que je n'avais pas très bien compris la fonction eval() ! à la base je ne l'avais pas mise, mais j'ai tout essayé.
@svear: eh bien j'avais déjà essayé les deux version que tu as donné. Pour moi la logique était bien :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

somme=somme+liste[i]

mais ça me renvoie ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Traceback (most recent call last):
  File "ex6-8.py", line 19, in <module>
    somme = somme + liste[i]
IndexError: list index out of range

Bien vu pour le x=x+1 en dehors du if ! C'est corrigé.

[Aelurus_]

Salut,
si len(list) = 3, ta liste est incrémentée avec 0,1,2. Donc while <= 3 va tester list[3] qui n'existe pas. Le pourquoi de l'erreur en ligne 19.
L'exemple de danielhagnoul est très bien sans que je comprenne le bs+1.

[Matthieu_12]

Bon, en fait j'avais simplement mis un = en trop ! (voir commentaire)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
liste=[]
bi = int(input("borne inférieure : "))
bs = int(input("borne supérieure : "))
x=bi
i=0
somme=0
n=0
 
while x <= bs:
    if not x % 3 and not x % 5: 
        liste.append(x)
    x=x+1
 
while i < len(liste): # et non pas <=
    somme = somme + liste[i]
    i=i+1
 
print("les multiples de 5 et 3 sont : ", liste, " et leur somme est de : ", somme)

Le boulet !

[Sve@r]

sans que je comprenne le bs+1.

Un range(bi, bs) donne les nombres situés entre bi inclus et bs exclu. Si tu veux aller jusqu'à bs inclus, tu dois demander range(bi, bs+1).

[Aelurus_]

Salut,
Merci Sve@r, je pensais le range [n,x] et non [n,x[.

Merci

[Invité]

Salut,
Merci Sve@r, je pensais le range [n,x] et non [n,x[.

Merci

Ah ah !

Eh oui quand on débute ça fait bizarre, tout comme cette histoire de commencer " l'indexation " par 0 et quand j'essaye de comprendre pourquoi ben euh "moi toujours pas comprendre" => lien ???

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
print(["a","b","c"].index("a"))
>>> 0

[Sve@r]

Eh oui quand on débute ça fait bizarre, tout comme cette histoire de commencer " l'indexation " par 0 et quand j'essaye de comprendre pourquoi ben euh "moi toujours pas comprendre"

A mon avis tu dois pas être le premier à te poser la question. Déjà je pense qu'il y a une raison historique. Python est écrit en C, et en C les indices des tableaux commencent à 0. Alors pourquoi 0 ? Déjà on peut répondre "pourquoi pas" mais si on va un peu plus loin, je dirais que 0 est le premier nombre à pouvoir être stocké sur un unsigned. Il semble donc naturel que le premier élément d'un tableau commence par le premier nombre disponible dans l'ensemble de N+.
D'autant plus qu'en C, un indice devient l'offset d'un pointeur qui se décale dans le tableau. Il est donc normal que pour le premier élément il n'y ait aucun décalage par rapport au début du tableau.

Autre raison un peu plus métaphysique: le nombre b^n affiché dans la base "b" sera représenté par n chiffres si la numérotation commence à 0, et par n+1 chiffres si elle commence à 1. Exemple 2^3=8. Or le 8° nombre naturel de la base 2 sera 1000 (4 chiffres) si on commence à 1, et 111 (3 chiffres) si on commence à 0.

Ok je ne dis pas que ce choix ne m'a pas gêné. Il m'est par exemple arrivé (en C) de devoir descendre un tableau. Or le size_t (type utilisé pour les indices) étant unsigned, il est impossible d'écrire for (size_t i=n-1; i >= 0; i--) car quand i arrive à 0 et est décrémenté, il repasse à 65535 et cela donne une boucle infinie. Obligé donc d'écrire for (size_t i=n; i > 0; i--) et utiliser i-1 dans les indices. Mais bon, tant pis je fais avec. Et puis d'un autre côté, ça m'arrange bien quand j'utilise un tableau de int tab[100], de savoir que je n'aurai jamais le droit de taper dans tab[100]. J'ai pas besoin de chercher. Le tableau fait 100, l'indice 100 m'est donc interdit, ça entre direct dans mon crâne.

En Python aussi parfois ça me gêne. Par exemple l'indice [-1] donne le premier élément en partant de la fin, par symétrie j'aurais bien aimé voir le premier élément en partant du début représenté par l'indice [1] ça simplifierait certains calculs (ie check palindrome). Mais bon ça passe et je fais avec et finalement je vis bien le 0 comme premier indice.

[Invité]

Autre raison un peu plus métaphysique: le nombre b^n affiché dans la base "b" sera représenté par n chiffres si la numérotation commence à 0, et par n+1 chiffres si elle commence à 1. Exemple 2^3=8. Or le 8° nombre naturel de la base 2 sera 1000 (4 chiffres) si on commence à 1, et 111 (3 chiffres) si on commence à 0.

Ok je ne dis pas que ce choix ne m'a pas gêné. Il m'est par exemple arrivé (en C) de devoir descendre un tableau. Or le size_t (type utilisé pour les indices) étant unsigned, il est impossible d'écrire for (size_t i=n-1; i >= 0; i--) car quand i arrive à 0 et est décrémenté, il repasse à 65535 et cela donne une boucle infinie. Obligé donc d'écrire for (size_t i=n; i > 0; i--) et utiliser i-1 dans les indices. Mais bon, tant pis je fais avec. Et puis d'un autre côté, ça m'arrange bien quand j'utilise un tableau de int tab[100], de savoir que je n'aurai jamais le droit de taper dans tab[100]. J'ai pas besoin de chercher. Le tableau fait 100, l'indice 100 m'est donc interdit, ça entre direct dans mon crâne.