Функция для факториала в Python

Как мне вычислить факториал целого числа в Python?

Самый простой способ - использовать math.factorial(доступно в Python 2.6 и выше):

import math
math.factorial(1000)

Если вы хотите / должны написать это самостоятельно, вы можете использовать итеративный подход:

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

или рекурсивный подход:

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

Обратите внимание, что функция факториала определена только для натуральных чисел, поэтому вы должны также проверить это n >= 0и это isinstance(n, int). Если это не так, поднимите ValueErrorили TypeErrorсоответственно. math.factorialпозабочусь об этом за вас.

На Python 2.6 и выше попробуйте:

import math
math.factorial(n)

Не действительно необходимо, так как это такая старая тема. Но я сделал здесь еще один способ вычислить факториал целого числа, используя цикл while.

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

Существующее решение

Самое короткое и, вероятно, самое быстрое решение:

from math import factorial
print factorial(1000)

Создай свой

Вы также можете создать собственное решение. Обычно у вас есть два подхода. Тот, который подходит мне лучше всего:

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

print factorial(1000)

(это работает также для больших чисел, когда результат становится long)

Второй способ достижения того же:

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)

Если вы используете Python2.5 или старше, попробуйте

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

для более нового Python есть факториал в математическом модуле, как указано в других ответах здесь

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

Используя for-loop, считая от n:

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

Из соображений производительности, пожалуйста, не используйте рекурсию. Это было бы катастрофично.

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

Проверьте результаты бега

cProfile.run('fact(126000)')

4 function calls in 5.164 seconds

Использование стека удобно (например, рекурсивный вызов), но оно обходится дорого: хранение подробной информации может занимать много памяти.

Если стек высок, это означает, что компьютер хранит много информации о вызовах функций.

Метод занимает только постоянную память (как итерация).

Или Использование для цикла

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

Проверьте результаты бега

cProfile.run('fact(126000)')

4 function calls in 4.708 seconds

Или используя встроенную функцию математики

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

Проверьте результаты бега

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

Вот моя попытка

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

Также работает одна строка, быстрые и большие числа:

#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

Я знаю, что на этот вопрос ответили, но вот еще один метод с пониманием обратного списка диапазонов, который делает диапазон более легким для чтения и более компактным:

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

Вы можете увидеть полную версию кода в этом списке: https://gist.github.com/sadmicrowave/d4fbefc124eb69027d7a3131526e8c06

Другой способ сделать это - использовать np.prodпоказанное ниже:

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

Факториал положительного целого числа n, обозначенного через n !, является произведением всех натуральных чисел, меньших или равных n.

Формула :n! = n * (n-1) * (n-2) * (n-3) * (n-4) * ....... * 1

Есть несколько способов найти факториал в Python с помощью встроенной функции / библиотеки и т. Д. Здесь я создал пользовательскую функцию со ссылкой на базовое определение факториала.

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

print(factorial(4))

Мы также можем реализовать функцию факториала, используя recursiveтехнику, как показано ниже. Но этот метод эффективен только для небольших целочисленных значений. Поскольку в рекурсии функция вызывается повторно и требует места в памяти для поддержки стека, что не является эффективным или оптимизированным подходом для больших целочисленных значений для поиска факториала.

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

В приведенном ниже коде я беру ввод числа, чей факториал я хочу вычислить. После этого я умножаю число ->, чей факториал мы хотим вычислить, на числа, начинающиеся с 1,2, ...., (число, чей факториал Хочу посчитать -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