Função para fatorial em Python

Como faço para calcular um fatorial de um número inteiro em Python?

A maneira mais fácil é usar math.factorial(disponível no Python 2.6 e acima):

import math
math.factorial(1000)

Se você quiser / tiver que escrever você mesmo, poderá usar uma abordagem iterativa:

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

ou uma abordagem recursiva :

def factorial(n):
    if n < 2:
        return 1
    else:
        return n * factorial(n-1)

Observe que a função fatorial é definida apenas para números inteiros positivos; portanto, você também deve verificar isso n >= 0e aquilo isinstance(n, int). Caso contrário, aumente um ValueErrorou um, TypeErrorrespectivamente. math.factorialvai cuidar disso para você.

No Python 2.6 e superior, tente:

import math
math.factorial(n)

Não é realmente necessário, pois esse é um tópico tão antigo. Mas eu fiz aqui é outra maneira de calcular o fatorial de um número inteiro usando um loop while.

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

Solução existente

A solução mais curta e provavelmente a mais rápida é:

from math import factorial
print factorial(1000)

Construindo seu próprio

Você também pode criar sua própria solução. Geralmente você tem duas abordagens. O que melhor me convém é:

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

print factorial(1000)

(funciona também para números maiores, quando o resultado se torna long)

A segunda maneira de conseguir o mesmo é:

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

print factorial(1000)

def factorial(n):
    if n < 2:
        return 1
    return n * factorial(n - 1)

Se você estiver usando o Python2.5 ou mais antigo, tente

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

para Python mais recente, há fatorial no módulo de matemática, conforme indicado em outras respostas aqui

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

Usando um forloop, contando de trás para frente n:

def factorial(n):
    base = 1
    for i in range(n, 0, -1):
        base = base * i
    print(base)

Por razões de desempenho, não use recursão. Seria desastroso.

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

Verifique os resultados em execução

cProfile.run('fact(126000)')

4 function calls in 5.164 seconds

O uso da pilha é conveniente (como chamada recursiva), mas tem um custo: o armazenamento de informações detalhadas pode consumir muita memória.

Se a pilha estiver alta, significa que o computador armazena muitas informações sobre chamadas de função.

O método ocupa apenas memória constante (como iteração).

Ou usando o loop for

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

Verifique os resultados em execução

cProfile.run('fact(126000)')

4 function calls in 4.708 seconds

Ou Usando a função matemática integrada

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

Verifique os resultados em execução

cProfile.run('fact(126000)')

5 function calls in 0.272 seconds

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

Aqui está a minha tentativa

>>> 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'

Uma linha, números rápidos e grandes também funciona:

#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

Eu sei que isso foi respondido, mas aqui está outro método com uma compreensão de lista de intervalo reverso, tornando o intervalo mais fácil de ler e mais compacto:

    #   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!" )

Você pode ver uma versão completa do código nesta lista: https://gist.github.com/sadmicrowave/d4fbefc124eb69027d7a3131526e8c06

Outra maneira de fazer isso é usar o np.prodmostrado abaixo:

def factorial(n):
    if n == 0:
        return 1
    else:
         return np.prod(np.arange(1,n+1))

O fatorial de um número inteiro positivo n, denotado por n !, é o produto de todos os números inteiros positivos menores ou iguais a n.

Fórmula :n! = n * (n-1) * (n-2) * (n-3) * (n-4) * ....... * 1

Existem vários métodos para encontrar o fatorial em python usando a função / biblioteca incorporada etc. Aqui, criei uma função definida pelo usuário com referência à definição básica de fatorial.

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

print(factorial(4))

Também podemos implementar a função fatorial usando a recursivetécnica mostrada abaixo. Mas esse método é eficiente apenas para valores inteiros pequenos. Como na recursão, a função é chamada repetidamente e requer um espaço de memória para manter a pilha, o que não é uma abordagem eficiente ou otimizada para que valores inteiros grandes encontrem o fatorial.

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

print(factorial(4))

def factorial(n):
mul = 1
for i in range( 1, n + 1):
    mul *= i
print(factorial(6))

No código abaixo, estou inserindo o número cujo fatorial eu quero calcular. Depois disso, multiplico o número -> cujo fatorial queremos calcular com números a partir de 1,2, ...., (número cujo fatorial Eu quero calcular -1)

    f = int(input("Enter a number whose factorial you want to calculate = "))#Number 
                                           #whose factorial I want to calculate                              
for i in range(1,f): #assume I have taken f as 5
    f=f*i # In 1st iteration f=5*1 => 5 , in second iteration f = 5*2 => 10, 3rd 
          #iteration f = 10*3 =>30, 4th iteration f = 30*4 =>120  
print(f) #It will print the updated value of "f" i.e 120