comment multiplier tous les nombres dans une séquence (python)

Comme si je disais le programme n=10, comment pourrais-je faire retour 10*9*8*7*6*5....1?

J'ai pensé à une boucle while mais je sens que j'ai foiré quelque part car il n'a pas la somme de tous les chiffres de la séquence.

Mon code ressemble à ceci

def product(n):
  i=n
  a=n-1
  while a>0:
    return i * a
    b=i * a
    a=a-1
    i=i-1

Sont là les meilleures façons de le faire sans l'aide de la récursivité? Désolé pour le incroyablement question de débutant, mais je suis en train de m'enseigner comment code. Vous devez commencer quelque part!

Merci!

Somme ou de se multiplier? PS vous êtes returning première chose dans votre boucle...
multipliez-vous,comment puis-je la faire revenir à tout?
Lorsque vous return vous n'êtes pas à laisser tout le reste de la boucle de code à exécuter, et vous êtes seulement en boucle une fois.
donc, en mettant la valeur de retour à l'extérieur de la boucle devrait résoudre cela? Je suis confus sur la façon de la boucle while est de multiplier tous les nombres. Comme je ressens avec mon code actuel, à chaque fois qu'il boucle sa va réinitialiser la valeur, si cela a un sens.
Vous pouvez utiliser reduce si vous le souhaitez, mais si le but est d'apprendre que ce n'est probablement pas très bon. reduce(range(1, n+1), lambda a, b: a*b) Ou math.factorial

OriginalL'auteur Billy Thompson | 2012-09-02

  1. 7

    Depuis que vous essayez d'apprendre à coder, je ne vais pas vous donner une solution totale, mais
    Je vais vous donner quelques conseils à la place:

    • Ont un for boucle qui s'exécute de 1 à n (à l'aide de range(1, n+1)) à la place de votre whileen boucle. Cela va générer les valeurs que vous souhaitez multiplier et de réitérer le bon nombre de fois (ce qui peut être un peu délicat avec while boucles, parfois).

    • Avoir une variable nommée product pour stocker le résultat de la multiplication de chaque passage dans la boucle.

    • Initialiser product avant d'entrer dans la foren boucle. Une fois à l'intérieur vous serez tout simplement la mise à jour de la valeur de product.

    • Après vous avez terminé avec la boucle, vous pouvez utiliser le return instruction pour renvoyer la valeur de product.

    • Enfin, pour des fins de test, vous voudrez peut-être commencer avec une petite valeur de n, comme 4, et d'imprimer les valeurs de calcul à l'intérieur de la boucle pour vérifier comment votre code de travail.

    Il y a plus laconique et pythonic façons de le faire, mais il utilise la structure du code, vous avez déjà mis en place. Et bien sûr, de manière récursive, ainsi que vous le mentionner.

    Une fois que vous maîtrisez les bases, vous apprécierez la plus idiomatique les moyens de l'écriture, ou en appelant les fonctions appropriées qui le font pour vous.

    Merci, je vais essayer ça tout de suite!
    bon .. laissez-moi savoir si vous avez des questions/comment il va, je pense que c'est plus utile dans le long terme que de voir comment les fonctions d'appel, ou d'obtenir un déjà écrit solution.
    Ok vais faire 🙂 Exactement, je veux être en mesure de comprendre la méthode derrière la folie avant de passer l'appel de fonctions.

    OriginalL'auteur Levon

  2. 4

    Bien, voici un autre Pythonic approche.

    >>> import operator
>>> numbers = range(1, 11)
>>> numbers
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> reduce(operator.mul, numbers)
3628800
    Oui, mais comment est-ce que c'OP apprendre à programmer? OP états "je suis en train de m'enseigner comment code". Cela montre comment appeler les fonctions ...
    Cela répond directement à la question posée dans le titre. "comment multiplier tous les nombres dans une séquence"
    Un Débordement de pile n'est pas seulement pour l'OP, c'est aussi pour les gens qui débarquent ici par exemple à partir d'une recherche sur Google.
    Je suis d'accord avec vous, DONC n'est pas seulement pour les OP, mais ce question est. Basé sur des OP messages, je doute de voir reduce() etc va aider l'OP. Je suppose que tout le monde essaie de les aider dans leur propre chemin.
    Je pense que c'est la meilleure solution au problème.

    OriginalL'auteur FogleBird

  3. 2

    En supposant que vous avez ce que vous vouliez dire, est fonction factorielle, vous pouvez simplement utiliser le math.factorial(): 

    >>> import math
>>> math.factorial(10)
3628800
    Merci, mais j'essaie de comprendre la logique derrière le factoriel de ses aspects. Cela viendra dans maniable.
    Je ne pense pas que cela aide OP apprendre à programmer, mais plutôt comment faire pour appeler des fonctions.
    Ma réponse inclus math.factorial ainsi que d'une tentative pour lui montrer comment la mettre en œuvre sur son propre :-p
    Désolé, je suis en désaccord. Je crois que "comment appeler le droit de fonctions" plutôt que de la mise en œuvre de tout à partir de zéro, est une partie importante de l'apprentissage de la façon de programmer. Apprendre comment faire ce genre de jugement est encore plus important. En outre, l'OP a demandé clairement si il y a un moyen plus facile de le faire "sans récursivité", et il est. Compte tenu de ces raisons, je ne vois pas en quoi ma réponse mérite un downvote.
    Je n'ai pas downvoted un répondre ici .. juste parce que j'ai de faire des commentaires, n'implique pas que .. donc merci de ne pas sauter aux conclusions. Peut-être les autres à trouver votre approche pas utile? Au moins une autre personne doit. Et vous n'êtes pas aider les OP apprendre à programmer, mais utiliser le produit d'autres programmeurs.

    OriginalL'auteur K Z

  4. 2

    Vous essayez de trouver la factorielle d'un nombre n, pour l'essentiel. Pour trouver la factorielle d'un nombre, il y a 2 méthodes

    1. À l'aide d'une structure de Boucle
    2. En utilisant la Récursivité (comme vous l'avez mentionné)

    Comme un nouveau programmeur, vous serait mieux avec une simple structure de boucle qui va de 1 à n et met en valeur multipliée à chaque itération dans une variable. Cette variable est votre réponse. Mais nous savons aussi que la récursivité permettra également de travailler et de rendre le code look élégant. Bonne Programmation !

    OriginalL'auteur asudhak

  5. 1

    Ce qui est appelé la factorielle. 10! est équivalent à 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1.

    def factorial(n):
    product = 1
    while n > 0:
        product *= n
        n -= 1
    return product

    Par la façon dont, dans la pratique, il suffit d'utiliser math.factorielle.

    Woah, merci beaucoup. Mais, je vais avoir un peu de mal à comprendre. Ce qui ne l' *= n? Je suis en supposant qu'elle permet à n être multipliée par n-1? Mais, je vais avoir de la difficulté à enveloppant ma tête autour de lui parce que, pourquoi ne n magasin lui-même n*(n-1) à chaque fois qu'il fait une boucle. Désolé, difficile pour moi de mettre des mots pourquoi il me confond.
    n signifie product = product * n; il multiplie le produit jusqu'à présent pour chaque n jusqu'à ce qu'il atteigne 0. n -= 1 est le même que n = n - 1, en soustrayant 1 chaque tour de boucle.
    essentiellement, il compte à partir de n à 0, stocker le résultat de l'accumulation de produit dans product.
    Merci à vous, qui les aide à mettre en perspective pour moi. Je n'en ai pas été mis en place à cette syntaxe encore. Je vais essayer de bien saisir et de les appliquer dès maintenant.
    Le composé d'affectation des opérateurs de sténographie... ne pas se sentir stressé 🙂

    OriginalL'auteur oldrinb

  6. 1
     def factorial(n):
     if n <= 1: return 1
     return n * factorial(n-1)

    Je pense toujours factorielle comme l'exemple par excellence dans l'apprentissage de la récursivité ...

    Ouais, mais j'essaie juste de comprendre comment le faire de manière itérative avant de me déplacer sur la récursivité. Merci pour vous réponse.
    Essayez de calculer factorial(1000) avec cette approche. :^)
    oui, je sais que l'habitude de travailler 😛 ... j'ai l'habitude fait cet exercice en C terre qui avait encore ses questions mais moins que python pour ce problème
    Votre code sera de retour factorial(-10) == 1 comme True, tandis que la factorielle de nombres négatifs est pas défini. Problème mineur, mais tout de même.
    Factorielle est donc clairement mis en œuvre à l'aide d'une itération sur la récursivité, je pense que c'est l'exemple par excellence de contorting un problème à un particulier de programmation rubrique.

    OriginalL'auteur Joran Beasley

  7. 0

    Une autre façon de le faire est d'utiliser scipy.product.

    >>> import scipy
>>> scipy.product(xrange(1,11))
3628800

    OriginalL'auteur Akavall

  8. 0

    En apprenant que vous devriez le faire sans l'aide de tous intégré les fonctions qu'il vous aidera à apprendre la programmation plutôt à l'outil que l'apprentissage d'un outil est beaucoup plus facile de vous devenir un bon programmeur. il y a deux façons de faire ce que j'ai mis en œuvre des versions plus simples.

    En Utilisant La Récursivité:

    def product(n):
    if n== 1:
        return 1
    return n * product(n-1)

    À L'Aide De Simple Boucle:

    def product(n):
    res = 1
    while n>1:
        res = res * n
        n = n - 1
    return res

    OriginalL'auteur sharafjaffri