Как возвести в степень в питоне

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

В этом руководстве разберем процесс возведения в степень в 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:\Programs\Python\Python38\test.py", line 18, in val = math.pow(2, 9999999) OverflowError: math range error
В первую очередь можно обратить внимание на то, что math.pow() вернула ошибку OverflowError . Это значит, что функция не поддерживает крупные значения степени.
Различия между остальными достаточно простые, но можно увидеть, что np.power() — самая быстрая.
9.12. Python – Метод math.pow() – возвести число в степень
Метод 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 
Оглавление

1. Python – Самоучитель для начинающих
2. Python – Обзор
3. Python – Установка среды
4. Python – Базовый синтаксис
4.1. Python – Аргументы командной строки
5. Python – Типы переменных
6. Python – Основные операторы
6.1. Python – Арифметические операторы
6.2. Python – Операторы сравнения
6.3. Python – Операторы присваивания: примеры
6.4. Python – Побитовые операторы
6.5. Python – Логические операторы
6.6. Python – Операторы членства
6.7. Python – Операторы идентификации
6.8. Python – Приоритет операторов
7. Python – Условные операторы
7.1. Python – Условие if
7.2. Python – Условные операторы if. else и elif
7.3. Python – Вложенные операторы if
8. Python – Циклы
8.1. Python – Цикл while
8.2. Python – Цикл for
8.3. Python – Вложенные циклы
8.4. Python – Оператор break
8.5. Python – Оператор continue
8.6. Python – Оператор pass
9. Python – Числа
9.1. Python – Метод abs()
9.2. Python – Метод ceil()
9.3. Python – Метод cmp()
9.4. Python – Метод exp()
9.5. Python – Метод fabs()
9.6. Python – Метод floor()
9.7. Python – Метод log()
9.8. Python – Метод log10()
9.9. Python – Метод max()
9.10. Python – Метод min()
9.11. Python – Метод modf()
9.12. Python – Метод pow()
9.13. Python – Метод round()
9.14. Python – Метод sqrt()
9.15. Python – Метод choice()
9.16. Python – Метод randrange()
9.17. Python – Метод random()
9.18. Python – Метод seed()
9.19. Python – Метод shuffle()
9.20. Python – Метод uniform()
9.21. Python – Метод acos()
9.22. Python – Метод asin()
9.23. Python – Метод atan()
9.24. Python – Метод atan2()
9.25. Python – Метод cos()
9.26. Python – Метод hypot()
9.27. Python – Метод sin()
9.28. Python – Метод tan()
9.29. Python – Метод degrees()
9.30. Python – Метод radians()

Какая функция нужна возведения в степень в Python?
Вообще в Python для возведения в степень есть оператор ** . Но если необходима именно функция, то можно воспользоваться встроенной pow() . И в том, и в другом случае, первым указывается основание, второе число - степень.






3 ** 4 # 81 pow(3, 4) # 81 1.5 ** 4 # 5.0625 pow(1.5, 4) # 5.0625 
Возведение в степень на Python
В программировании возведение числа в степень — одна из самых распространенных операций. В языке Python для этого есть несколько способов, каждый из которых имеет свои особенности. В данной статье мы рассмотрим методы возведения в степень в Python.

Даниил Фам

Исполнительный директор

19 апреля 2023







Что такое степень?
Степень показывает сколько раз число умножается само на себя.






2³ = 2 * 2 * 2 = 8 — два в третьей степени.
Существует три метода, возведения цифр в степень:

Легкий
Средний
Сложный

Легкий уровень
Для возведения в степень можно использовать оператор ** .






um = 3 ** 4 # то же самое что и 3 * 3 * 3 * 3 print(um) # 81
Оператор ** — это простой и универсальный способ возведения в степень, который выбирают многие программисты.
Средний уровень
? pow (сокр. power) — функция возведения в степень
pow()
Функция pow() используется для возведения числа степень. Она эквивалентна оператору возведения в степень ** .






chislo, stepen = 10, 3 print(pow(chislo, stepen)) # 1000
math.pow() 
math.pow() является функцией из модуля math , которая также используется для возведения числа в степень, но принимает аргументы типа float и возвращает результат типа float. В отличие от функции pow() , она не поддерживает возможность деления по модулю.  
import math chislo, stepen = 10, 3 print(math.pow(chislo, stepen)) # 1000.0
Разница pow() и math.pow()
Казалось, бы делают они одно и то же, однако есть тонкая разница: 1. pow() может принимать три аргумента: число, степень, остаток от деления
r1 = pow(5, 3) # 5*5*5 = 125 r2 = pow(5, 3, 2) # равносильно (5*5*5) % 2 # то есть остаток от 125 при делении на 2 -> он равен одному print(r1, r2) # 125 1
2. math.pow() использует ограниченную точность






import math number, stepen, ostatok = 13, 100, 2 # (13 в степени 100) остаток деления на 2 print(math.pow(number, stepen) % ostatok) # 0.0 print(pow(number, stepen, ostatok)) # 1
Одинаковые действия, но результаты не совпадают. И это может оказаться критичным. 
3. math.pow() всегда возвращает float
import math print(math.pow(2, 6)) # 64.0 print(pow(2, 6)) # 64
Однако если результат дробный, то оба способа вернут float.
import math print(math.pow(2.1, 6.2)) # 99.48546343115241 print(pow(2.1, 6.2)) # 99.48546343115241
4. math.pow() ломается на больших числах






import math print(pow(2, 9999)) # без ошибок посчитает print(math.pow(2, 9999)) # [Фатальная ошибка] OverflowError: math range error
5. Возможная разница в скорости Напишем код, который измерит скорость выполнения. pow() :
pow1 = """ pow(2, 100) """ elapsed_time1 = timeit(pow1, number=100_000) # запускаем код pow1 100к раз чтобы уменьшить погрешность print(elapsed_time1)
from timeit import timeit pow2 = """ import math math.pow(2, 100) """ elapsed_time2 = timeit(pow2, number=100_000) # запускаем код pow2 100к раз print(elapsed_time2)
Результаты:
 pow(): 0.009468599921092391 math.pow(): 0.01545469998382032
Выходит, что pow() быстрее. Однако помните, многое зависит от устройства и платформы, на которой проводится тестирование. Некоторые сообщают, что у них math.pow() намного быстрее ?, даже если прописать setup="import math" . На другом компьютере и платформе результаты отличаются:






 pow(): 0.013429596998321358 math.pow(): 0.008748997999646235
Здесь math.pow() напротив оказался в полтора раза быстрее.
Продвинутый уровень
? numpy — модуль, который предоставляет общие математические и числовые операции.

Возведение в степень также является математической операцией и поддерживается данным модулем.
import numpy print(numpy.power(2, 30)) # 1073741824
Обычно принято писать «import numpy as np» , упрощая тем самым запись до np.power(2, 30) . 
Если мы создадим последовательность значений через numpy.arrange() , к примеру, то нам открываются некоторые фокусы. Например следующий: 
import numpy as np # input_array arr1 = np.arange(8) exponent = 2 print(arr1) # [0 1 2 3 4 5 6 7] # output_array out = np.power(arr1, exponent) print(out) # [ 0 1 4 9 16 25 36 49]
arr1 : [0 1 2 3 4 5 6 7] Output array : [ 0 1 4 9 16 25 36 49]
С этим arr1 = np.arange(8) теперь можно даже в pow() работать: 
print(pow(arr1, 2)) # [ 0 1 4 9 16 25 36 49]
⚠️ Важно! При работе с ОС Windows возможна ошибка.
Как мы знаем, 2³¹ = 2147483648, тем не менее, numpy.power (2, 31) может выдать -2147483648 . Что уже странно, однако numpy.power (2, 32) вовсе выдаст 0 . Причина проста, хоть и неожиданна и не особо озвучивается: нужно принудительно указать, чтобы получаемое число под капотом переводилось в тип longint (целое число, которое больше чем 2³¹). Поэтому исправляем это следующим образом: 
numpy.power(2, 31, dtype=numpy.longlong) # получим 2147483648, а не -2147483648 numpy.power(2, 32, dtype=numpy.longlong) # получим 4294967296, а не 0
Сравнение скорости работы
Давайте сравним скорость работы разных методов возведения числа в степень и выберем оптимальный для наших задач.
from timeit import timeit # ========== ** ========== pow1 = """ 2**30 """ elapsed_time1 = timeit(pow1, number=100_000) # запускаем код pow1 100к раз чтобы уменьшить погрешность print(elapsed_time1) # ========== pow() ========== pow2 = """ pow(2, 30) """ elapsed_time2 = timeit(pow2, number=100_000) print(elapsed_time2) # ========== math.pow() ========== pow3 = """ math.pow(2, 30) """ elapsed_time3 = timeit(pow3, number=100_000, setup="import math") # запускаем код pow2 100к раз print(elapsed_time3) # ========== numpy.power() ========== pow4 = """ numpy.power(2, 30) """ elapsed_time4 = timeit(pow4, number=100_000, setup="import numpy") # запускаем код pow2 100к раз print(elapsed_time4)
На основе 100000 запусков(number=100_000) получаем следующие результаты:



Место
Метод
Скорость


1
2**30
0.0009847609999837914


2
math.pow(2,30)
0.007375017000015305 


3
pow(2,30)
0.013787384000011116


4
numpy.power(2,30) 
0.09736091600001373 



На порядок быстрее оказался встроенный оператор ** . Перевес по времени выполнения pow() и math.pow() может координально измениться от платформы, на которой выполняется код.
? Вывод: оператор ** самый простой, быстрый и универсальный.
Немного математической магии
При помощи языка Python можно делать математические вычисления. Расмотрим несколько математических трюков. 
Квадратный корень (√)
Корень квадратный — знакомая операция:

√9 = 3 
√81 = 9

Но существует математический трюк, как посчитать корень не запоминая и не путая всякие там sqr/sqrt:
print(9 ** 0.5) # 3.0 print(81 ** 0.5) # 9.0


Похожие публикации:

Wp head где редактировать
Как отключить звук клавиатуры на самсунге
Как прикрепить веб камеру к монитору
Как сделать жирный шрифт в indesign