Возведение в степень в Python: полное руководство

Возведение в степень — очень важная операция в различных областях программирования, от анализа данных до разработки алгоритмов. Также оно играет важную роль в машинном обучении (ML) и искусственном интеллекте (AI), особенно в нейронных сетях и распознавании изображений. Поэтому важно научиться эффективно выполнять вычисления с экспонентами в Python.

В этом руководстве мы рассмотрим различные методы возведения в степень в Python. Мы познакомим вас с соответствующими функциями — как встроенными, так и функциями из модуля math и библиотеки Numpy. Каждый метод имеет свои преимущества.

Содержание

• Как возводить числа в степень в Python
• Основы возведения в степень в Python
• Углубляемся: встроенные функции
• Использование библиотек для продвинутого возведения в степень
• Применение на практике
• Заключение

Как возводить числа в степень в Python

Python предлагает несколько способов вычисления экспонент:

• Оператор **. Это самый простой и базовый вариант для возведения в степень. Например, x ** y вычисляет x, возведенное в степень y.
• pow(). Эта встроенная функция принимает два аргумента — основание и показатель степени — и возвращает результат возведения основания в степень. Она также допускает наличие третьего аргумента для возведения в степень по модулю. Пример: pow(x, y).
• math.pow(). Эта функция из модуля math аналогична pow(), но всегда возвращает результат с плавающей точкой. Она принимает два аргумента, оба из которых могут быть числами с плавающей точкой или целыми числами. Пример: math.pow(x, y).
• math.exp(). Еще одна функция из модуля math. Она возвращает натуральную экспоненту числа, то есть число e, возведенное в степень, указанную в аргументе. Пример: math.exp(argument).
• np.power(). Эта функция из библиотеки NumPy предназначена для работы с массивами или матрицами. Она выполняет поэлементное возведение в степень. Пример: np.power(array, exponent).

Основы возведения в степень в Python

Оператор возведения в степень (**) — самый простой способ вычисления экспоненты в Python. Этот оператор возводит левый операнд (основание) в степень, указанную в правом операнде (экспонента).

Положительный показатель степени

В этом фрагменте кода мы показываем, как возвести число в степень с положительным показателем степени. Например, 2 в степени 3 вычисляется как 2 × 2 × 2, что дает 8. Аналогично, -10 в степени 4 вычисляется как -10 × -10 × -10 × -10, что дает 10000.

base = 2
exponent = 3
print(base**exponent)  # Вывод: 8

base = -10
exponent = 4
print(base**exponent)  # Вывод: 10000

Отрицательный показатель степени

Этот код вычисляет результат возведения основания в отрицательную степень. Например, 5 в степени -2 равно 0,04. Аналогично, 25 в степени -5 дает очень маленькое значение, представленное в научной нотации (1,024e-07).

base = 5
exponent = -2
print(base**exponent) # 0.04

base = 25
exponent = -5
print(base**exponent) # 1.024e-07

Возведение числа в отрицательную степень эквивалентно возведению числа, обратного этому числу, в положительную степень.

В Python оператор ** возвращает ZeroDivisionError, если вы возводите 0,0 в отрицательную степень, потому что любое число, деленное на ноль, является неопределенным.

base = 0
exponent = -5
print(base**exponent)

Вывод:

Показатель степени с плавающей точкой

Следующие примеры кода показывают, что Python правильно вычисляет результат возведения положительного основания, такого как 2, в дробную степень, такую как 1,5. Однако использование отрицательного основания с дробной степенью приводит к получению комплексного числа.

base = 2
exponent = 1.5
print(base**exponent) # 2.8284271247461903

base = -0.25
exponent = 1.25
print(base**exponent) # (-0.12500000000000003-0.125j)

Углубляемся: встроенные функции

Python предоставляет различные встроенные функции для вычисления экспонент, но мы сосредоточимся на двух: pow() и math.pow(). На первый взгляд эти функции могут показаться похожими, но между ними есть несколько существенных отличий.

pow()

Функция pow() принимает два обязательных аргумента: основание и показатель степени. Она также может принимать третий аргумент для вычисления остатка от деления по модулю числа, полученного после возведения в степень. Синтаксис следующий: pow(base, exp, mod), где mod представляет модуль. Эта функция возвращает остаток от возведения в степень.

Базовое возведение в степень

Для базовых вычислений просто укажите основание и показатель степени в функции, которая работает аналогично оператору **.

r = pow(2, 3)
print(r) # 8

r = pow(4, -10)
print(r) # 2.56e-06

Возведение в степень с плавающей точкой

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

r = pow(3.5, 2)
print(r)  # 12.25

r = pow(3.5, -2)
print(r)  # 0.08163265306122448

r = pow(3.5, 3.2)
print(r)  # 55.08301986166747

r = pow(-3.5, -3.3)
print(r)  # (-0.009414432347757688+0.012957854474952653j)

r = pow(-3.5, 3.3)
print(r)  # (-36.698070584660925-50.510560868902246j)

Примечание: если вам нужно просто возвести число в степень, оператор ** является более лаконичным и читаемым решением по сравнению с функцией pow().

Возведение в степень по модулю

Дополнительный параметр modulus функции pow() очень ценен при работе с возведением в степень по модулю. Такие операции осуществляются в криптографии или при работе с большими числами, поскольку возведение в степень по модулю обеспечивает повышенную эффективность. Например, при вычислении 3 в степени 4 по модулю 5 результат равен 1 (деление 81 на 5 по модулю равно 1).

r = pow(3, 4, 5)
print(r)  # 1

r = pow(123, 456, 789)
print(r)  # 699

r = pow(2, -3, 7)
print(r)  # 1

r = pow(-13, 8, 62)
print(r)  # 7

Вероятно, вам интересно, почему непосредственное возведение в степень по модулю с помощью pow(base, exp, mod) эффективнее, чем pow(base, exp) % mod или (base**exp) % mod. Встроенная функция pow() специально разработана для этой операции, в то время как другие методы выполняют ненужные промежуточные вычисления. Это может существенно повлиять на производительность, особенно при работе с большими значениями.

import timeit

start_pow_mod = timeit.default_timer()
pow(500000000, 3000, 4000)
stop_pow_mod = timeit.default_timer()

pow_mod_time = stop_pow_mod - start_pow_mod

print("Time using pow(base, exp, mod): ", pow_mod_time)

start_pow_other = timeit.default_timer()
pow(500000000, 3000) % 4000
stop_pow_other = timeit.default_timer()

pow_other_time = stop_pow_other - start_pow_other

print("Time using pow(base, exp) % mod:", pow_other_time)


start_aestrisk = timeit.default_timer()
(500000000**3000) % 4000
stop_aestrisk = timeit.default_timer()

aestrisk_time = stop_aestrisk - start_aestrisk

print("Time using (base ** exp) % mod: ", aestrisk_time)


print(
    f"Speed comparison: pow(base, exp, mod) was {pow_other_time / pow_mod_time} times faster than pow(base, exp) % mod and {aestrisk_time/pow_mod_time} times faster than (base ** exp) % mod"
)

Вывод:

Функция pow() может вызывать различные ошибки в зависимости от ситуации.

# Trying to take the modulo of complex numbers raises a ValueError.
print(pow(2 + 3j, 4, 5))  # ValueError: complex modulo

# Taking the third argument is not allowed if the second argument is negative.
print(pow(10, -11, 4))  # ValueError: base is not invertible for the given modulus

# If the first or second argument is a float, the third argument is not allowed.
print(pow(2.4, 3, 4))  # TypeError: pow() 3rd argument not allowed unless all arguments are integers

# Passing any argument as a string results in a TypeError.
print(pow(2, 4, '3'))  # TypeError: unsupported operand type(s) for pow(): 'int', 'int', 'str'

math.pow()

Функция math.pow(x, n) возводит x в степень n. Функция math.pow() преобразует аргументы в числа с плавающей точкой и возвращает результат в виде точного возведения в степень. Такая точность имеет решающее значение в таких областях, как анализ данных и научные вычисления.

Вот простой код. Функция math.pow() возвращает значение с плавающей точкой, тогда как функция pow() возвращает целое значение.

import math
print(math.pow(6, 3))  # 216.0
print(pow(6, 3))  # 216

Функция math.pow() не принимает мнимые числа.

math.pow() не принимает отрицательные основания с дробными показателями степени, так как это вызовет ошибку ValueError.

Использование библиотек для продвинутого возведения в степень

Для решения сложных задач возведения в степень, таких как нахождение экспоненциального значения числа или вычисление возведения в степень по элементам в массивах или матрицах, можно использовать две функции: np.power() и math.exp().

np.power()

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

Иногда необходимо выполнять операции возведения в степень над целыми массивами, и здесь на помощь приходит функция np.power(), предназначенная для возведения в степень элементов массивов.

import numpy as np
r = np.power([2, 4, 8], 2)
print(r)  # [4, 16, 64]

r = np.power([2, 4, 8], [1, 2, 3])
print(r)  # [4 64 4096]

r = np.power([[2, 3, 4], [5, 6, 7]], [1, 2, 3])
print(r) # [[2 9 64] [5 36 343]]

Функция np.power() не принимает отрицательный показатель степени.

import numpy as np
r = np.power([2, 4, 8], -2)
print(r)

Вывод:

Если вы попытаетесь возвести отрицательное число в нецелую степень, NumPy вернет значение NaN (Not a Number, не число).

math.exp()

Функция math.exp(x) вычисляет экспоненциальное значение x, которое эквивалентно возведению числа Эйлера e в степень x. Число Эйлера приблизительно равно 2,71828, и в математической нотации эта операция обозначается как e^x.

import math
x = 2
r = math.exp(x)
print("Exponential of", x, ":", r) # 7.38905609893065

Важной особенностью math.exp(x) является ее адаптивность. Она может обрабатывать положительные числа, отрицательные числа и даже числа с плавающей точкой.

import math
print(math.exp(-2))  # 0.1353352832366127
print(math.exp(-2.5))  # 0.0820849986238988
print(math.exp(2.5))  # 12.182493960703473

Применение на практике

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

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

Principal,Rate,Years
1000,0.05,5
2000,0.03,10
1500,0.08,3
3000,0.06,7
2500,0.04,9
1800,0.07,4
2200,0.025,6
3500,0.09,2
2800,0.035,8
4000,0.02,5

Вот код:

import csv


def compound_interest(principal, rate, years):
    return principal * (1 + rate) ** years


# Read data from CSV file

data = []
with open("data.csv", newline="") as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        row["Compound Interest"] = compound_interest(
            float(row["Principal"]), float(row["Rate"]), int(row["Years"])
        )
        data.append(row)
# Write data to a new CSV file with compound interest column

output_file = "data.csv"
fieldnames = ["Principal", "Rate", "Years", "Compound Interest"]

with open(output_file, mode="w", newline="") as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    for row in data:
        writer.writerow(row)
print("Compound interest calculations saved to", output_file)

Результат:

Отлично! Вы рассчитали сложные проценты для всех строк и сохранили их в отдельной колонке. Эти данные можно использовать для дальнейшего анализа.

Существуют сотни других случаев, в которых широко используется возведение в степень, например, для моделирования роста населения во времени.

Заключение

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

• Оператор ** прост и понятен, идеально подходит для повседневного использования.
• pow() — универсальный способ возведения в степень с дополнительным «модульным» трюком.
• math.pow() обеспечивает точные результаты в виде чисел с плавающей точкой.
• np.power() — мощный инструмент для работы с массивами с проверкой ошибок.
• math.exp() — специальный инструмент для вычисления экспоненциального значения.

Перевод статьи «Exponents in Python: A Comprehensive Guide for Beginners».