Содержание:развернуть
- История
- Определение
- Обратные операции
-
Извлечение корня
-
Логарифмирование
- Степень
-
Целочисленная
-
Рациональная
-
Вещественная
- Ноль в степени ноль
Когда я был студентом, мой преподаватель по методам программирования любил повторять: «В математике все идеи простые». Чаще всего, фраза звучала в момент объяснения новой сложной темы, а потому вызывала определённые внутренние противоречия.
С возведением в степень всё не так — это действительно простая операция.
История
Возведение в степень — частный случай умножения, поэтому данную операцию изначально не рассматривали, как самостоятельную. Но уже в работах Диофанта Александрийского степени отведено особое место. В частности «Отец Алгебры» применял понятия кубов и квадратов числа.
Возведение в степень определяется как результат n-кратного умножения числа самого на себя.
Эта операция была известна ещё в древнем Вавилоне, однако современный её вид устоялся лишь в XVII веке.
Как умножение позволяет сократить количество символов сложения:
6 + 6 + 6 + 6 + 6 + 6 = 6 * 6
Так и степень сокращает запись умножения:
- 6 — это основание;
- 2 — показатель степени (это число говорит о том, сколько раз число в основании должно быть умножено само на себя).
До воцарения числового показателя, были и другие варианты его записи. Математики раннего Возрождения использовали буквы. Например, Q обозначала квадрат, а C — куб. Различные формы записи возведения в степень не обошли и языки программирования.
Для АЛГОЛа и некоторых диалектов Бейсика применяется значок ↑. В матлабе, R, Excel-е и Хаскеле используется «циркумфлекс» — ^ или «галочка». Этот символ популярен и вне программирования.
Определение
В Python возведение в степень записывается при помощи двойной «звёздочки» — «**«
a = 2 ** 4
print(a)
> 16
Вторая форма записи — встроенная функция pow():
# первый аргумент — основание, а второй — показатель
b = pow(2, 4)
print(b)
> 16
Обратные операции
Извлечение корня
У возведения в степень две обратные операции. Первая — извлечение корня. Подробнее о корнях в Python вы можете почитать в нашей статье. Отметим лишь, что корень в питоне вычисляется с помощью той же функции pow():
# корень четвёртой степени из 16
root = pow(16, (1/4))
print(root)
> 2.0
Либо с применением оператора «**«:
# корень кубический из 27
cub_root = 27 ** (1/3)
print(cub_root)
> 3.0
Для извлечения квадратного корня справедливы оба вышеуказанных способа, но существует и третий, специализированный. Для его применения требуется импортировать модуль math
:
import math
# квадратный корень из 100
sqr_root = math.sqrt(100)
print(sqr_root)
> 10.0
Логарифмирование
Логарифмирование — вторая обратная операция.
Логарифмом числа «b» по основанию «a» зовётся такой показатель степени, в который следует возвести «a», чтобы получить «b».
Здесь x
— логарифм. Пример из математики — найдем значение выражения:
Легче всего эта запись читается в формате вопроса: «В какую степень нужно возвести 2, чтобы получить 16?». Очевидно, в 4-ю. Следовательно,
В питоне операция нахождения логарифма также заложена в функционал модуля math:
import math
# отыщем логарифм 100 по основанию 10
# 100 — основание логарифма, а 10 — аргумент
log = math.log(100, 10)
print(log)
> 2.0
Степень
Целочисленная
В целочисленную степень можно возводить положительные и отрицательные int
и float
числа:
# int
print(3 ** 9)
> 19683
print(pow(-2, 10))
> 1024
# float
print(3.14 ** 9)
> 29673.367320587102
print(pow(-1.1, 1001))
> -2.7169262098066285e+41
И функция pow()
и оператор «**» умеют возводить комплексные числа:
# complex
a = complex(2, 1)
print(pow(a, 2))
> (3+4j)
print(a ** 2)
> (3+4j)
Показатель степени может быть положительным, отрицательным и нулевым:
# +
print(12 ** 4)
> 20736
# -
print(100 ** -2)
> 0.0001
# 0
print(1231 ** 0)
> 1
Результат не определён, когда 0 возводят в отрицательную степень:
print(0 ** -4)
> ZeroDivisionError: 0.0 cannot be raised to a negative power
Ошибка деления на ноль возникает из-за следующего свойства степени:
Рациональная
Возведение числа в рациональную степень напрямую связано с извлечением корня из этого числа отношением:
Если рациональный показатель отрицательный, а основание равно нулю, то Питон все ещё будет выдавать ошибку:
print(0 ** -(5/4))
> ZeroDivisionError: 0.0 cannot be raised to a negative power
В случае, когда основание меньше нуля, числитель показателя нечётный, а знаменатель, напротив, чётный, результат получается комплексным. Но это свойство рациональных степеней учитывается только в функции pow()
:
print(pow(-5, (5/4)))
> (-5.286856317202822-5.286856317202821j)
print(type(pow(-5, (5/4))))
> <class 'complex'>
В остальном возведение в рациональную степень работает, как и для целочисленной:
print(0 ** (3/2))
> 0.0
print(pow(1, (23/24)))
> 1.0
print(10 ** (6/7))
> 7.196856730011519
Вещественная
В начале автор объявил, что возведение в степень — штука несложная. Так вот, для вещественных степеней это уже не совсем так. Идеи, заложенные в эту операцию, хоть и просты, но их много, и каждая из них достойна собственной статьи. Описать вкратце разложение в ряд Тейлора и численное интегрирование не получится. Это будет не справедливо, как по отношению к вам, так и к математике. Поэтому, выделим главное:
Python умеет возводить в вещественную степень даже вещественные числа (пусть и псевдо)
Сделать такое инструментами математики ой как непросто:
# возведём число Пи в степень e
print(pow(math.pi, math.e))
> 22.45915771836104
Ноль в степени ноль
Дискуссии по поводу значения 0 в степени 0 продолжаются уже больше двух веков. Обычно значение нуля в нулевой степени принято считать неопределённым, но символическое соглашение о том, что «0 в степени 0 равно 1» помогает в записи формул и алгоритмов. Ровно поэтому так сделано и в Python:
print(pow(0, 0))
> 1
print(0 ** 0)
> 1
В этом руководстве разберем процесс возведения в степень в Python.
В математике возведение в степень — это операция, при которой число умножается само на себя несколько раз. Python предоставляет встроенные операторы и функции для выполнения возведения в степень.
Оператор ** для возведения в степень
Многие разработчики считают, что символ карет (^
) — это оператор возведения числа в степень, ведь именно он обозначает эту операцию в математике. Однако в большинстве языков программирования этот знак выступает в качестве побитового xor
.
В Python оператор возведения в степень обозначается двумя символами звездочки **
между основанием и числом степени.
Функциональность этого оператора дополняет возможности оператора умножения *
: разница лишь в том, что второй оператор указывает на то, сколько раз первые операнд будет умножен сам на себя.
print(5**6)
Чтобы умножить число 5 само на себя 6 раз, используется **
между основанием 5 и операндом степени 6. Вывод:
15625
Проверим оператор с другими значениями.
Инициализируем целое число, отрицательное целое, ноль, два числа с плавающей точкой float
, одно больше нуля, а второе — меньше. Степеням же присвоим случайные значения.
num1 = 2
num2 = -5
num3 = 0
num4 = 1.025
num5 = 0.5
print(num1, '^12 =', num1**12)
print(num2, '^4 =', num2**4)
print(num3, '^9999 =', num3**9999)
print(num4, '^-3 =', num4**-3)
print(num5, '^8 =', num5**8)
Вывод:
2 ^12 = 4096
-5 ^4 = 625
0 ^9999 = 0
1.025 ^-3 = 0.928599410919749
0.5 ^8 = 0.00390625
pow() или math.power() для возведения в степень
Также возводить в степень в Python можно с помощью функции pow()
или модуля math, в котором есть своя реализация этого же модуля.
В обе функции нужно передать два аргумента: основание и саму степень. Попробуем вызвать обе функции и посмотрим на результат.
import math
print(pow(-8, 7))
print(math.pow(-8, 7))
print(pow(2, 1.5))
print(math.pow(2, 1.5))
print(pow(4, 3))
print(math.pow(4,3))
print(pow(2.0, 5))
print(math.pow(2.0, 5))
Вывод:
-2097152
-2097152.0
2.8284271247461903
2.8284271247461903
64
64.0
32.0
32.0
Отличие лишь в том, что math.pow()
всегда возвращает значение числа с плавающей точкой, даже если передать целые числа. А вот pow()
вернет число с плавающей точкой, если таким же был хотя бы один из аргументов.
numpy.np() для возведения в степень
В модуле numpy есть своя функция power()
для возведения в степень. Она принимает те же аргументы, что и pow()
, где первый — это основание, а второй — значение степени.
Выведем те же результаты.
print(np.power(-8, 7))
print(np.power(2, 1.5))
print(np.power(4, 3))
print(np.power(2.0, 5))
-2097152
2.8284271247461903
64
32.0
Как получить квадрат числа в Python?
Для возведения числа в квадрат, нужно указать 2
в качестве степени. Встроенной функции для получения квадрата в Python нет.
Например, квадрат числа 6 — 6**2
—> 36.
Сравнение времени работы разных решений
Теперь сравним, сколько занимает выполнение каждой из трех функций и оператора **
. Для этого используем модуль timeit
.
Основанием будет 2, а значением степени — 9999999.
import numpy as np
import math
import time
start = time.process_time()
val = 2**9999999
print('** за', time.process_time() - start, 'ms')
start = time.process_time()
val = pow(2, 9999999)
print('pow() за', time.process_time() - start, 'ms')
start = time.process_time()
val = np.power(2, 9999999)
print('np.power() за', time.process_time() - start, 'ms')
start = time.process_time()
val = math.pow(2, 9999999)
print('math.pow() за', time.process_time() - start, 'ms')
** за 0.078125 ms
pow() за 0.0625 ms
np.power() за 0.0 ms
Traceback (most recent call last):
File "C:ProgramsPythonPython38test.py", line 18, in
val = math.pow(2, 9999999)
OverflowError: math range error
В первую очередь можно обратить внимание на то, что math.pow()
вернула ошибку OverflowError
. Это значит, что функция не поддерживает крупные значения степени.
Различия между остальными достаточно простые, но можно увидеть, что np.power()
— самая быстрая.
In this article, we will show you how to find the power of a number in python. Below are the various methods to accomplish this task −
-
Using for loop
-
Using Recursion
-
Using pow() function
-
Using ** operator
Using for loop
Algorithm (Steps)
Following are the Algorithm/steps to be followed to perform the desired task –.
-
Create a function findPower() that returns the power of a Number. The function accepts number, and exponent value as parameters.
-
Take a variable that stores the result and initialize its value with 1.
-
To obtain the power, multiply the given number by the result exponent. We use the below loop to multiply the exponent number of times
-
Use the for loop, to traverse in the range 1 to given exponent+1.
-
Inside the loop, Multiply the result by the given number
-
Use the return keyword to return the resultant power.
-
Create 2 separate variables for storing input number and exponent values.
-
Call the above-defined findPower() function by passing the input number, and exponent values as arguments to it and print the returned result of function.
-
In the same way, calculating for other numbers
Example
The following program returns the power of a number using the for loop–
def findPower(number, exponent): resultPower =1 for i in range(1, exponent+1): resultPower=resultPower*number return resultPower number = 5 exponent = 3 print("Value of",number,"raised to the power",exponent,"(",number,"^",exponent,") =", findPower(number,exponent)) number = 4 exponent = 0 print("Value of",number,"raised to the power",exponent,"(",number,"^",exponent,") =", findPower(number,exponent))
Output
On executing, the above program will generate the following output −
Value of 5 raised to the power 3 ( 5 ^ 3 ) = 125 Value of 4 raised to the power 0 ( 4 ^ 0 ) = 1
Using Recursion
Algorithm (Steps)
Following are the Algorithm/steps to be followed to perform the desired task –.
-
Create a function findPower() that returns the power of a Number. The function accepts number, power/exponent value as parameters
-
Use the if conditional statement, to check whether the exponent value passed is equal to 0.
-
Return 1 if the condition is true i,e, exponent value is 0.
-
Subtract the exponent value by 1 and return the resultant power using recursive logic.
-
Call the above-defined findPower() function by passing the input number, and exponent values as arguments to it and print the returned result of function.
Example
The following program returns the power of a number using the recursive logic –
def findPower(number, exponent): if exponent == 0: return 1 return number * findPower(number, exponent-1) number = 5 exponent = 3 print("Value of",number,"raised to the power",exponent,"(",number,"^",exponent,") =", findPower(number,exponent))
Output
On executing, the above program will generate the following output −
Value of 5 raised to the power 3 ( 5 ^ 3 ) = 125
Using pow() function
In Python, the pow() function calculates the power of any positive integer.
It returns the value of x to the power of y (x^y).
Syntax
pow(x,y)
Parameters
-
x — It is the numerical value (base value)
-
y — It is the power of numerical value (exponent value)
Algorithm (Steps)
Following are the Algorithm/steps to be followed to perform the desired task –.
-
Create a variable to store the input number.
-
Create another variable to store the exponent/power value.
-
Use the pow() function to print the resultant power of a number i.e, inputNumber ^ inputPower by passing the number, and exponent values as arguments to it and print the resultant power.
Example
The following program returns the power of a number using the pow() function –
inputNumber = 5 inputPower = 3 print("Value of 5 raised to the power 3(5^3)=", pow(inputNumber, inputPower))
Output
On executing, the above program will generate the following output −
Value of 5 raised to the power 3(5^3)= 125
Using ** operator
The exponential operator(**) can be used to calculate the power of a number.
Since importing a module or calling a function is not necessary, this is the most convenient to use.
Algorithm (Steps)
Following are the Algorithm/steps to be followed to perform the desired task –.
-
Create a variable to store the input number.
-
Create a variable to store the exponent/power value.
-
Use the exponential operator(**) to print the resultant power of a number i.e, inputNumber ^ inputPower.
Example
The following program returns the power of a number using the ** operator –
inputNumber = 6 inputPower = 2 print("Value of 6 raised to the power 2(6^2)=", inputNumber**inputPower)
Output
On executing, the above program will generate the following output –
Value of 6 raised to the power 2(6^2)= 36
Conclusion
In this article, we learned four different Python methods for calculating the power of a given number and exponent. We also learned how to calculate power without the use of built-in functions.
На чтение 2 мин Просмотров 1.3к. Опубликовано 23.12.2022
Содержание
- Введение
- Возведение числа в степень оператором **
- Возведение числа в степень функцией pow()
- Возведение числа в степень функцией power()
- Заключение
Введение
В ходе статьи рассмотрим три способа возведения числа в степень на Python.
Возведение числа в степень оператором **
В первом способе воспользуемся оператором **. Принцип работы очень прост, сначала пишем число, которое нужно возвести в степень, ставим оператор, и пишем число степени:
# Переменная "a" равна двум в пятой степени
a = 2**5
Выведем результат:
# Переменная "a" равна двум в пятой степени
a = 2**5
print(a)
# Вывод: 32
Возведение числа в степень функцией pow()
Помимо оператора ** в Python есть функция pow(). В неё нужно передать два аргумента, первым будет являться число, которое нужно возвести в степень, а вторым число степени:
# Переменная "a" равна десяти в третьей степени
a = pow(10, 3)
Выведем результат:
# Переменная "a" равна десяти в третьей степени
a = pow(10, 3)
print(a)
# Вывод: 1000
В стандартной библиотеке Python есть модуль под названием math. В данном модуле существует своя функция для возведения в степень, и называется она pow(). Работает она по тому же принципу, но возвращает итоговый результат в типе данных float:
# Переменная "a" равна десяти в третьей степени
a = pow(10, 3)
print(a)
# Вывод: 1000.0
Возведение числа в степень функцией power()
В данном способе мы будем использовать библиотеку под названием numpy. Так как данный модуль не входит в стандартную библиотеку Python, его нужно установить, для этого нужно перейти в терминал, или же командную строку, прописать pip install numpy, нажать Enter и ждать инсталляции.
В numpy есть функция под названием power(), благодаря как раз таки и можно возводить числа в степень:
import numpy as np
# Вывод результата 4 в 11 степени
print(np.power(4, 11))
# Вывод: 4194304
Заключение
В ходе статьи мы с Вами рассмотрели целых три способа возведения чисел в степень на Python. Надеюсь Вам понравилась статья, желаю удачи и успехов! 🙂
Метод pow() – возвращает x в степени y. Если задан третий аргумент (z), осуществляется возведение числа x в степень y по модулю z, т.е. pow(x, y) % z.
Синтаксис
Ниже приведен синтаксис метода pow() в Python:
import math
math.pow( x, y[, z] )
Примечание. Эта функция недоступна напрямую, поэтому нам нужно импортировать математический модуль, а затем нам нужно вызвать эту функцию, используя математический статический объект.
Параметры
х – число, которое необходимо возвести в степень.
y – степень числа x.
z (необязательно) – число, которое должно использоваться для операции модуля.
Возвращаемое значение
Функция возвращает значение x в степени y.
Пример
В следующем примере показано использование метода pow() в Python.
#!/usr/bin/python
import math # Это импортирует математический модуль
print "math.pow(100, 2): ", math.pow(100, 2)
print "math.pow(100, -2): ", math.pow(100, -2)
print "math.pow(2, 4): ", math.pow(2, 4)
print "math.pow(3, 0): ", math.pow(3, 0)
Когда приведённый выше код выполнится, он даст следующий результат:
math.pow(100, 2): 10000.0
math.pow(100, -2): 0.0001
math.pow(2, 4): 16.0
math.pow(3, 0): 1.0