Salut à tous !

Je débute Python et j'ai un petit problème, sûrement tout bête mais qui me bloque.

En fait j'ai écrit une boucle qui donne une valeur à chaque itération. Moi ce que je veux c'est garder la valeur obtenue à chaque itération et la stocker dans une liste pour obtenir quelque chose de la sorte :
Liste=[Valeur à i, Valeur à i+1, Valeur à i+2, ...].

Je bute un peu

Une idée

Tu initialises ta liste vide avant le début de ta boucle (my_list = []) et à chaque itération, tu l'ajoutes à ta liste (my_list.append(value)).

Pour ajouter une valeur dans une liste tu peux utiliser liste.append(valeur)

Ah oui en effet c'est ça ! Merci à vous deux !

Je suis dégoûté, j'ai essayé des trucs bien lourds alors que je connaissais cette commande mais elle m'est pas revenue ...

Pendant que j'y suis, je vous pose une autre question :

Je dois réaliser cette opération à chaque itération :

A / (élément liste [i] * élément liste [i+1] * élément liste [i+2] * ...)

et ce jusqu'à ce que ma boucle soit terminée.

Vous comprenez ce que je veux dire ?

Tu veux faire le produit des éléments d'une liste ? Poste ta solution d'abord

Faire le produit des éléments d'une liste je connais :

liste[0]*liste[1]*...

Ce qui me pose problème ici c'est de diviser mon nombre A par chaque élément de la liste.
En gros itération 1:
A / liste[0]
itération 2 :
A / (liste[0]*liste[1])

itération i :
A / (liste[0]*liste[1]*...*liste[i])

et pour le coup une solution j'en ai pas trop.

J'arrive pas à lui faire comprendre qu'il doit multiplier autant de fois qu'il y a d'éléments dans la liste.
Moi la ou j'en suis j'ai ca :

itération 1 :
A/liste[0]

itération 2 :
A/liste[1]

Tu peux stocker la valeur du produit des éléments dans une variable

Oui mais comment faire pour que la multiplication se fasse à chaque itération avec le nouvel élément ?

Par exemple si je fais :
x = liste1[z] * liste1[z+1]

à l'itération 1 j'aurai :
x = liste1[0]

et à la suivante :
x = liste1[0] * liste1[1]

puis :
x = liste1[1] * liste1[2]

alors qu'il me faudrait : x=liste1[0] * liste1[1] * liste1[2]

enfin je suis peut être bête mais ca fait deux jours que je bosse la dessus et ca c'est vraiment la toute dernière étape, je craque

Tu initialises x = 1

iteration i:
x = x * liste[i]

donc
iteration 0:
x = x (qui vaut 1) * liste[0]
iteration 1:
x = x (qui vaut liste[0]) * liste[1]
iteration 2:
x = x (qui vaut liste[0] * liste[1]) * liste[2]

Pour le coups stocker le résultat dans une autre variable est inutile, ta solution de faire des divisions successives est mieux je pense.

Tu as aussi la fonction reduce qui fait exactement ce que tu veux.

A / reduce(operator.mul, liste, 1)

AAAAAH Ca marche enfin !

J'ai réussi avec la fonction reduce, il m'a fallut un peu de temps pour comprendre le fonctionnement mais c'est bon.

J'avais un peu de mal avec ce qu'on m'avait proposé au dessus même si j'avais compris le principe et que ca aurait dû marché, ... j'avais peut être un problème d'indice !

En tout cas MERCI BEAUCOUP à vous, c'est super sympa de m'avoir aidé !

Pour ce programme c'est bon, dans les mois à venir j'aurai surement beaucoup d'autres problèmes mais chaque chose en son temps !