Как найти факториал с помощью цикла

Вступление

По определению, факториал – это произведение положительного целого числа и всех положительных целых чисел, которые меньше или равны данному числу. Другими словами, получение факториала числа означает умножение всех целых чисел от этого числа вплоть до 1.

По правилу 0! = 1

Факториал – это целое число, за которым следует восклицательный знак.

5! обозначает факториал из пяти.

Чтобы вычислить факториал, мы умножаем число на каждое целое число, меньшее его, пока не дойдём до 1:

5! = 5 * 4 * 3 * 2 * 1
5! = 120

Запомните эти простые правила, ведь в этом уроке мы узнаем, как вычислять факториал целого числа с помощью Python, используя циклы и рекурсию. Начнём с вычисления факториала с помощью циклов.

Вычисляем факториал с помощью циклов

Мы можем вычислять факториалы, используя как цикл while, так и цикл for. Общий процесс довольно похож в обоих случаях. Всё, что нам нужно, – это параметр в качестве входных данных и счетчик.

Давайте начнем с цикла for:

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

Возможно, вы заметили, что мы считаем, начиная с 1 до n-числа, в то время как в определении мы описали факториал, как произведение положительного целого числа и всех положительных целых чисел до 1. Но по законам математики:

Проще говоря, (n – (n-1)) всегда равно 1.

Это значит, что не важно, в каком направлении мы считаем. Можем начать с 1 и увеличиваться в направлении n-числа, или он может начинаться с n-числа и уменьшаться в направлении 1. Теперь, когда мы всё объяснили, начнём разбирать функцию, о которой говорили.

Наша функция принимает параметр n, который обозначает число, для которого мы вычисляем факториал. Сначала мы определяем переменную с именем result и присваиваем ей значение 1.

Вы можете спросить, почему 1, а не 0?

Потому что если бы мы присвоили ему 0, то все последующие умножения на 0, естественно, привели бы к 0.

Затем мы начинаем наш цикл for в диапазоне от 1 до n+1. Помните, что диапазон Python остановится перед вторым аргументом. Чтобы включить и последнее число, мы просто добавляем еще 1.

Внутри цикла for мы умножаем текущее значение result на текущее значение вашего индекса i.

Наконец, мы возвращаем конечное значение result. Давайте протестируем нашу функцию и выведем результат:

inp = input("Enter a number: ")
inp = int(inp)

print(f"The result is: {get_factorial_for_loop(inp)}")

Программа предложит пользователю ввести данные. Мы попробуем с 4:

Enter a number: 4
The result is: 24

Можете проверить результат на калькуляторе:

4! = 4 * 3 * 2 * 1 = 24.

Теперь давайте посмотрим, как мы можем вычислить факториал, используя цикл while. Вот наша модифицированная функция:

def get_factorial_while_loop(n):
    result = 1
    while n > 1:
        result = result * n
        n -= 1
    return result

Это очень похоже на цикл for. Только в этот раз, мы движемся от n к 1, что ближе к математическому определению. Протестируем нашу функцию:

inp = input("Enter a number: ")
inp = int(inp)

print(f"The result is: {get_factorial_while_loop(inp)}")

Опять введём 4:

Enter a number: 4
The result is: 24

Хотя считали наоборот, результат получился тот же.

Рассчитывать факториал с помощью цикла легко. Теперь посмотрим, как вычислить факториал с помощью рекурсивной функции.

Вычисляем факториал с помощью рекурсивной функции

Рекурсивная функция – это функция, которая вызывает саму себя. Определение кажется страшным, но потерпите, и вы поймёте, что это значит.

Обычно каждая рекурсивная функция состоит из двух основных компонентов: базового варианта и рекурсивного шага.

Базовые случаи – это самые маленькие примеры задачи. Также это перерыв, случай, который вернет значение и выйдет из рекурсии. С точки зрения факторных функций, базовый случай – это когда мы возвращаем конечный элемент факториала, который равен 1.

Без базового случая или с неправильным базовым случаем ваша рекурсивная функция может выполняться бесконечно, вызывая переполнение.

Рекурсивные шаги, как следует из названия, являются рекурсивной частью функции, где вся задача преобразуется в нечто меньшее. Если рекурсивный шаг не позволяет уменьшить задачу, то рекурсия опять-таки может выполняться бесконечно.

Рассмотрим повторяющуюся часть факториалов:

5! = 5 * 4 * 3 * 2 * 1

Также мы знаем, что:

4 * 3 * 2 * 1 = 4!

Другими словами, 5! = 5 * 4!, 4! = 4 * 3! и так далее.

Таким образом, мы можем сказать, что n! = n * (n-1)!. Это будет рекурсивный шаг нашего факториала!

Факториальная рекурсия заканчивается, когда она достигает 1. Это будет наш базовый случай. Мы вернем 1, если n равно 1 или меньше, покрывая нулевой ввод.

Взглянем на нашу рекурсивную факторную функцию:

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

Как вы видите, блок if воплощает наш базовый вариант, в то время как блок else охватывает рекурсивный шаг.

Протестируем функцию:

inp = input("Enter a number: ")
inp = int(inp)

print(f"The result is: {get_factorial_recursively(inp)}")

В этот раз введём 3:

Enter a number:3
The result is: 6

В итоге тот же результат. Но на этот код более сложный:

Когда мы вводим данные, функция проверит блок if, и, поскольку 3 больше 1, она перейдет к блоку else. В этом блоке мы видим строчку return n * get_factorial_recursively(n-1).

Мы знаем значение n, оно равно 3, но get_factorial_recursively(n-1) еще предстоит его вычислить.

Затем программа вызывает ту же функцию еще раз, но на этот раз наша функция принимает 2 в качестве параметра. Он проверяет блок if, переходит к блоку else и снова встречается с последней строкой. Теперь текущее значение n равно 2, но программа все равно должна вычислить get_factorial_recursively(n-1).

Поэтому он снова вызывает функцию, но на этот раз блок if, или, скорее, базовый класс, успешно возвращает 1 и выходит из рекурсии.

Следуя тому же шаблону, он возвращает каждый результат функции, умножая текущий результат на предыдущий n и возвращая его для предыдущего вызова функции. Другими словами, наша программа сначала доходит до нижней части факториала (который равен 1), затем идёт вверх, умножая на каждом шаге.

Также удаляет функцию из стека вызовов одну за другой, пока не будет возвращен конечный результат n * (n-1).

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

Заключение

В этой статье мы рассмотрели, как вычислять факториалы с использованием циклов for и while. Мы также узнали, что такое рекурсия и как вычислять факториал с помощью рекурсии.

Если вам понравилась рекурсия и вы хотите больше практиковаться, попробуйте вычислить последовательность Фибоначчи с помощью рекурсии! И если у вас есть какие-либо вопросы или мысли по поводу нашей статьи, не стесняйтесь делиться ими в разделе комментариев.

Просмотры: 1 879

Как вычислить факториал в Python?

Считать факториал в Python легко, если вам помогает питоновская программа, щелкающая математические операции, как орешки. Однако, прежде, чем Python порадует нас правильными рассчетами, придется нам порадовать Питона новой порцией отменного кода под названием «Факториал!». Но, сначала краткий математический ликбез:

Что такое факториал числа?

Пишем код на Python для вычисления факториала

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

Рассмотрим несколько вариантов написания кода:

1. Cамый простой вариант. Это будет цикл for, принимающий на вход число n и выводящий в ответ посчитанный факториал. Если число n является нецелым или отрицательным, выведем сообщение об ощибке. В качестве тренировки, после него рекомендую усложнить задачу и заключить цикл в функцию, как во втором варианте.

2. Вариант — это функция для вычисления факториала, которой в качестве аргумента будем передавать число n. Этот вариант является «причесанным» первым вариантом.

3. Вариант — это облагороженный 2-й вариант. Помимо того, что вычисление факториала будет производиться при вызове функции, так еще и программа любезно «попросит» пользователя ввести число, факториал которого нужно рассчитать.

Итак, приступим к реализации задуманных вариантов!

ВАРИАНТ №1: Пишем цикл for для вычисления факториала в Python!

Предлагаю сначала взглянуть на рабочий код. Позже мы рассмотрим каждый шаг подробно:

# число, факториал которого нужно вычислить
num = 5
# начальное значение факториала
factorial = 1

# Если num является натуральным, то
if(num%1==0 and num>=0):
    # Вычисляем факториал числа num
    for i in range(1, num+1):
        factorial = i*factorial
    # Выводим результат на экран
    print(f'{num}! = {factorial}')
# Если num - отрицательное или нецелое число, выводим сообщение об ошибке
else:
    print('Невозможно вычислить факториал нецелого и/или отрицательного числа!')

При значении num=5, результат работы кода выглядит следующим образом:

  <strong>5! = 120</strong>

А при нецелом значении 3.2:

  <strong>Невозможно вычислить факториал нецелого и/или  отрицательного числа!</strong>

Разберем код варианта №1 подробно:

1. Объявляем переменную num и передаем ей число, факториал которого требуется найти:

# число, факториал которого нужно вычислить
num = 5

2. Определяем переменную factorial, в которой будет храниться значение вычисленного факториала. В качестве начального значения устанавливаем «1»

# число, факториал которого нужно вычислить
num = 5
# начальное значение факториала
factorial = 1

3. Проверяем, верно ли задано значение переменной num. Если пользователь ввел нецелое число, тогда остаток от деления этого нецелого числа на единицу будет больше нуля.

Операция «%» в Python позволяет получить остаток от деления первого числа на второе. Например, 5%1 =0, а 5.5%1 = 0.5

Таким образом, чтобы проверить, является ли num, целым, нужно сравнить результат операции num%1 с нулем. Кроме этого, нужно убедиться, что число num не является отрицательным, для этого проверим выполнение неравенства num >= 0:

Добавим проверку перечисленных выше условий:

# число, факториал которого нужно вычислить
num = 5
# начальное значение факториала
factorial = 1

if (num%1==0 and num>=0):
    # здесь будем считать факториал

#Если же num не удовлетворяет перечисленным условиям, выведем сообщение об ошибке: 
else:
    print('Невозможно вычислить факториал нецелого и/или отрицательного числа!')

4. Вычислим значение факториала числа num. Для целого числа i, принимающего целые значения от 1(включительно) до n+1(не включительно), будем вычислять текущее значение факториала на i и присваивать факториалу новое полученное значение. То есть, при расчете 4! будут происходить действия:

при i=1 factorial = 1*1=1
при i=2 factorial = 2*1 = 2
при i =3 factorial = 3*2 = 6
при i =4 factorial = 4*6 = 24

# число, факториал которого нужно вычислить
num = 5
# начальное значение факториала
factorial = 1

if (num%1==0 and num>=0):
    for i in range(1, num+1):
        factorial = i*factorial

#Если же num не удовлетворяет перечисленным условиям, выведем сообщение об ошибке: 
else:
    print('Невозможно вычислить факториал нецелого и/или отрицательного числа!')

5. Вывод результата на экран осуществим в виде строки:

print(f'{num}! = {factorial}')

Такая конструкция (с буквой f перед кавычками) позволяет вывести значение переменной, заключенной в фигурные скобки. В итоге, код приобретет вид:

# число, факториал которого нужно вычислить
num = 5
# начальное значение факториала
factorial = 1

# Если num является натуральным, то
if(num%1==0 and num>=0):
    # Вычисляем факториал числа num
    for i in range(1, num+1):
        factorial = i*factorial
    # Выводим результат на экран
    print(f'{num}! = {factorial}')
# Если num - отрицательное или нецелое число, выводим сообщение об ошибке
else:
    print('Невозможно вычислить факториал нецелого и/или отрицательного числа!')

ВАРИАНТ №2: Создаем функцию для вычисления факториала!

1. Для начала объявим функцию find_factorial(num), которая в качестве аргумента будет принимать число, факториал которого требуется вычислить:

2. Определяем переменную для хранения текущего значения факториала, присваиваем ей значение «1»:

def find_factorial(num):
    # определяем начальное значение факториала
    factorial=1

3. Затем, весь написанный в «Варианте №1» код, начиная с проверки на корректность переменной num, помещаем в функцию find_factorial(num). При этом нужно заменить «print» на «return», так как функция ничего не будет выводить на экран, а будет возвращать полученное значение факториала или сообщение об ошибке:

def find_factorial(num):
    # определяем начальное значение факториала
    factorial=1
    # Если num является натуральным, то
    if(num%1==0 and num >= 0):
        # Вычисляем факториал числа num
        for i in range(1, num+1):
            factorial = i*factorial        
        return (f'{num}! = {factorial}')
    else:
        return ('Невозможно вычислить факториал нецелого и/или отрицательного числа!')

Если какой-то момент в коде для Вас не понятен, перечитайте внимательно приведенный выше детальный разбор кода в «Варианте 1»

4. Осталось только вызвать нашу новую функцию и проверить, корректно ли она работает. Для этого определим число, факториал которого будем считать. Затем вызовем функцию find_factorial() для вычисления факториала числа num. Полученный от функции ответ сохраним в переменной factorial и выведем эту переменную на экран:

def find_factorial(num):
    # определяем начальное значение факториала
    factorial=1
    # Если num является натуральным, то
    if(num%1==0 and num >= 0):
        # Вычисляем факториал числа num
        for i in range(1, num+1):
            factorial = i*factorial        
        return (f'{num}! = {factorial}')
    else:
        return ('Невозможно вычислить факториал нецелого и/или отрицательного числа!')

# Определим число, факториал которого будем считать
num = 6
# Вызовем функцию find_factorial() для вычисления факториала  
factorial = find_factorial(num)
# Выведем полученный от функции ответ на экран
print(factorial)

Наша функция отлично работает и может стать полезным ингредиентом в самописной библиотеке для математических вычислений! Однако, мы можем украсить наш код небольшой изюминкой, чем и займемся при рассмотрении «Варианта №3».

ВАРИАНТ №3: Облагородим код, вычисляющий факториал в Python, строкой пользовательского ввода.

Давайте добавим скрипту интерактивности — вежливо попросим пользователя ввести число, факториал которого нужно вычислить. Затем, после ввода числа и нажатия пользователем клавиши «Enter», обратимся к функции find_factorial() и выведем результат на экран. Для этого требуется лишь заменить строку, в которой мы задавали значение переменной num, следующей строкой:

num = eval(input("Факториал какого числа считаем? "))

Функция input() в Python3 позволяет получить введенную пользователем информацию.

Функция eval() позвляет динамически обновить данные.

В итоге, обновленный работающий код будет выглядеть так:

def find_factorial(num):
    # определяем начальное значение факториала
    factorial=1
    # Если num является натуральным, то
    if(num%1==0 and num >= 0):
        # Вычисляем факториал числа num
        for i in range(1, num+1):
            factorial = i*factorial        
        return (f'{num}! = {factorial}')
    else:
        return ('Невозможно вычислить факториал нецелого и/или отрицательного числа!')

# Ввод числа, факториал которого будем считать
num = eval(input("Факториал какого числа считаем? "))
# Вызовем функцию find_factorial() для вычисления факториала  
factorial = find_factorial(num)
# Выведем полученный от функции ответ на экран
print(factorial)

Мы рассмотрели 3 варианта, от самого простого, до самого «облагороженного», которые можно использовать для решения задачи по вычислению факториала в Python. Несмотря на то, что эта задача является довольно простой, она отлично подходит для тренировки навыков программирования в Python!