La fonction Factorielle pour en Python

Comment puis-je aller sur le calcul d'une factorielle d'un entier en Python?

InformationsquelleAutor Nir Levy | 2011-02-27
  1. 161

    Façon la plus simple: les mathématiques.factorielle(x) (disponible en 2.6 et ci-dessus).

    Si vous voulez/devez écrire vous-même, utilisez quelque chose comme

    def factorial(n):return reduce(lambda x,y:x*y,[1]+range(1,n+1))

    ou quelque chose de plus lisible:

    def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

    Comme toujours, Google est votre ami 😉

    • Ce doit être le moins lisible factorielle de mise en œuvre que j'ai jamais vu.
    • Bien, je viens de copier-collé quelques one-liner, le forum qui est lié a beaucoup plus d'eux et de plus lisible ceux. Édité et ajouté l'un de ceux-ci.
    • Excellente solution! Un couple d'ajouts: je ne comprends pas Pourquoi les avez-vous ajouté [1] à la range, range est ok sans la liste, et vous devez tenir compte de 0! cas. Donc, mon édition de votre solution est def fact(n): return n==0 and 1 or reduce(lambda x, y: x*y, range(1, n+1))
    • Je ne suis pas à comprendre comment vous pouvez utiliser factorial dans le factorial fonction. Comment pouvez-vous utiliser la même fonction au sein de la fonction vous êtes en train de définir? Je suis nouveau sur Python, donc je suis juste essayer de comprendre.
    • Le concept utilisé est appelé ici la récursivité ( en.wikipedia.org/wiki/Recursion_(computer_science) ) - un appel de fonction en elle-même est parfaitement bien, et souvent utile.
    • def fact(n): retourne les réduire(lambda x, y: x*y, range(1, n+1), 1)
    • Et google m'a amené ici, merci pour la réponse, avec l'expression lambda, très cool en effet!
    • factorielle récursive à l'aide de la fonction dépasse la profondeur de récursion pour l'entrée comme 1000
    • Pour un factorielle récursive, envisager factorial = (lambda ǀ:ǀ(ǀ))(lambda ǀ:lambda ǃ:ǃ and ǃ*ǀ(ǀ)(~-ǃ)or-~ǃ) (Besoins Python 3; ne fonctionne pas avec Python 2. Qui a dit que obscurci Python n'est pas une chose?)
    • changement list(range(1,n+1))
    • Pour comprendre ce que la récursivité signifie, vous devez d'abord comprendre ce que la récursivité moyens.

    InformationsquelleAutor schnaader
  2. 103

    Sur la version 2.6 de Python et à la place, essayez de:

    import math
math.factorial(n)
    InformationsquelleAutor Joril
  3. 23

    Pas vraiment nécessaire puisque c'est un ancien fil. Mais je l'ai fait ici est une autre façon de calculer la factorielle d'un entier en utilisant une boucle while. 

    def factorial(n):
    num = 1
    while n >= 1:
        num = num * n
        n = n - 1
    return num
    • factorielle(-1) va retourner 1, devrait soulever ValueError ou quelque chose.
    InformationsquelleAutor ciziar
  4. 19

    Solution existante

    Le plus court et probablement la solution la plus rapide est:

    from math import factorial
print factorial(1000)

    La construction de votre propre

    Vous pouvez également créer votre propre solution. Généralement, vous avez deux approches. Celui qui me convient le mieux est:

    from itertools import imap
def factorial(x):
    return reduce(long.__mul__, imap(long, xrange(1, x + 1)))

print factorial(1000)

    (cela marche aussi pour les grands nombres, alors que le résultat devient long)

    Le second moyen d'atteindre le même:

    def factorial(x):
    result = 1
    for i in xrange(2, x + 1):
        result *= i
    return result

print factorial(1000)
    • +1 pour selfmade efficace non-fonctions récursives
    • Une petite amélioration: vous pouvez commencer à xrange à 2.
    • D'accord, mais seulement quand il s'agit de la deuxième version de la Construction de votre propre de la partie. Si vous devez faire de même dans la première version, vous obtenez "TypeError: reduce() of empty sequence with no initial value" sans faire de gros changements.
    • merci pour cette remarque. Je ne faisais que regarder la 2ème version, quand j'ai fait ce commentaire, qui aurait dû être plus clair :).
    InformationsquelleAutor Tadeck
  5. 7
    def factorial(n):
    if n < 2:
        return 1
    return n * factorial(n - 1)
    InformationsquelleAutor Nishanth
  6. 6

    Si vous utilisez Python2.5 ou plus, essayez

    from operator import mul
def factorial(n):
    return reduce(mul, range(1,n+1))

    pour les nouveaux Python, il n'y a factorielle dans le module math comme indiqué dans d'autres réponses ici

    • Sous-estimé la réponse. Après la langue maternelle, ce qui semble être la plus belle solution.
    InformationsquelleAutor John La Rooy
  7. 4

    Juste une autre méthode pour le calcul de la factorielle à l'aide d'une boucle for - 

    def factorial(n):
    base = 1
    for i in range(n,0,-1):
        base = base * i
    print base
    • Votre dernière ligne devrait être l'impression(de base).
    InformationsquelleAutor rahulm
  9. 3

    Pour des raisons de performance, s'il vous plaît ne pas utiliser la récursivité. Il serait désastreux.

    def fact(n, total=1):
    while True:
        if n == 1:
            return total
        n, total = n - 1, total * n

    De contrôle en utilisant les résultats

    cProfile.run('fact(126000)')
    4 function calls in 5.164 seconds

    À l'aide de la pile est pratique(comme l'appel récursif), mais il a un coût: le stockage de l'information détaillée peut prendre beaucoup de mémoire.

    Si la pile est élevée, cela signifie que l'ordinateur stocke beaucoup d'informations sur les appels de fonction.

    La méthode ne prend constamment la mémoire(comme l'itération).

    Ou à l'Aide de la boucle

    def fact(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

    De contrôle en utilisant les résultats

    cProfile.run('fact(126000)')
    4 function calls in 4.708 seconds

    Ou d'Utiliser builtin fonction de mathématiques

    def fact(n):
    return math.factorial(n)

    De contrôle en utilisant les résultats

    cProfile.run('fact(126000)')
    5 function calls in 0.272 seconds
    • Expliquez votre raisonnement.
    • Je pense que cette boucle a l'air un peu plus propre <!-- langue: python --> def fact(n): ret = 1 tant que n > 1: n, ret = n - 1, ret * n return ret
    InformationsquelleAutor binbjz
  10. 2

    Vous dire:

    def fact(n):
  f = 1
  for i in range(1, n +1):
   f *= i
  return f

    InformationsquelleAutor Jordan
  11. 1
    def factorial(n):
    result = 1
    i = n * (n -1)
    while n >= 1:
        result = result * n
        n = n - 1
    return result

print (factorial(10)) #prints 3628800
    InformationsquelleAutor
  12. 1

    Je sais que cela a été répondu, mais voici une autre méthode avec une inversion de gamme compréhension de liste, la plus facile à lire et plus compact:

        #   1. Ensure input number is an integer by attempting to cast value to int
    #       1a. To accomplish, we attempt to cast the input value to int() type and catch the TypeError/ValueError 
    #           if the conversion cannot happen because the value type is incorrect
    #   2. Create a list of all numbers from n to 1 to then be multiplied against each other 
    #       using list comprehension and range loop in reverse order from highest number to smallest.
    #   3. Use reduce to walk the list of integers and multiply each against the next.
    #       3a. Here, reduce will call the registered lambda function for each element in the list.
    #           Reduce will execute lambda for the first 2 elements in the list, then the product is
    #           multiplied by the next element in the list, and so-on, until the list ends.

    try :
        num = int( num )
        return reduce( lambda x, y: x * y, [n for n in range(num, 0, -1)] )

    except ( TypeError, ValueError ) :
        raise InvalidInputException ( "Input must be an integer, greater than 0!" )

    Vous pouvez le voir une version complète du code à l'intérieur de ce gist: https://gist.github.com/sadmicrowave/d4fbefc124eb69027d7a3131526e8c06

    InformationsquelleAutor sadmicrowave
  13. 1

    Voici ma essayer

    >>> import math
>>> def factorial_verbose(number):
...     for i in range(number):
...             yield f'{i + 1} x '
...
>>> res = ''.join([x for x in factorial_verbose(5)])
>>> res = ' '.join([res[:len(res)-3], '=', str(math.factorial(5))])
>>> res
'1 x 2 x 3 x 4 x 5 = 120'
    • Levy, quel plaisir de peu de chose
    InformationsquelleAutor Pedro Rodrigues
  14. 1

    Une ligne, rapide et un grand nombre travaille aussi:

    #use python3.6.x for f-string
fact = lambda x: globals()["x"] if exec(f'x=1\nfor i in range(1, {x+1}):\n\tx*=i', globals()) is None else None
    InformationsquelleAutor Jundullah
  15. 0

    Beaucoup de ces méthodes sont très bons, mais je dirais que votre meilleur pari est de toujours utiliser le construit en fonction. Toutefois, il existe quelques très facilement réalisable par vous-même si vous voulez voir ce qui se passe. Vite, je suis venu avec est le même que beaucoup d'entre eux ici.

    def factorial(n):
    x = 1
    li = list(range(1, n + 1))
    for each in li:
        x = x * each
    print(x)

    C'est plutôt efficace du code, l'avantage étant qu'une liste est créée si vous wan pas à manipuler des données dans la liste même si je ne suis pas sûr pourquoi vous voulez vraiment.

    Edit: juste vu que j'ai posté sur une vieille chose. Désolé.

    • Depuis la version de python n'est pas précisé dans la question, cette réponse peut être améliorée - xrange pour python 2, et range pour python 3 - depuis une personne pourrait prendre range en python 2, qui serait inefficace
    InformationsquelleAutor Kieran Lavelle