Как возвести число в степень в Python?
Возведение в степень — популярная операция в программировании. Кажется, что она довольно простая и получить результат можно быстро. Это действительно так, если знать тонкости работы с функциями. В статье расскажем об основных способах возведения числа в степень в Python — каждый из них имеет свои особенности.
Степень числа отражает то, сколько раз оно умножается само на себя. Мы знакомы с этим понятием со школы — степень использовалась в различных уравнениях, задачах и примерах. Оказывается, никуда без этой операции и в программировании. В Питоне есть разные методы для возведения числа в квадрат или куб — рассмотрим каждый из них по порядку, начиная с самого простого.
Оператор **
В Python оператор** создан специально для возведения в степень — его ставят между основанием и числом степени. Функционал ** расширяет возможности привычного оператора умножения * — вот только второй знак указывает на то, сколько раз первый оператор должен быть умножен сам на себя.
# Переменная «a» равна двум в четвёртой степени
Станьте Python-разработчиком, пройдя курсы по специальности. Собрали лучшие варианты с сайта tutortop:
- «Python-разработчик с нуля» от Skypro
- «Разработчик на Python» от Eduson Academy
- «Бэкенд-разработчик на Python» от SF Education
- «Стань Python-разработчиком и получи работу за рубежом» от Mathshub
Сейчас мы дарим 10 000 ₽ на обучение в любой из школ-партнёров, представленных на сайте tutortop, а также курсы стоимостью 20 000 ₽.
Получите онлайн-курсы стоимостью 20 000 ₽ абсолютно бесплатно и промокод 10 000 ₽ на обучение.
Нажимая на кнопку «Получить», я соглашаюсь на обработку моих персональных данных.
Спасибо! Мы получили вашу заявку. Скоро с вами свяжемся.
Функция pow()
В Python есть не только оператор **, но и функция pow(). Вам нужно передать в неё два аргумента — первый из них будет числом для возведения в степень, а второй — число степени:
# Переменная «a» равна пяти в третьей степени
Есть похожая функция math.power() — принцип работы одинаковый, но она возвращает результат в типе данных float. Это значит, что значение числа всегда будет с плавающей точкой, даже если вы передадите целые числа. Pow() же может вернуть число с плавающей точкой в том случае, если идентичным был хотя бы один из аргументов. Пример:
# Переменная «a» равна пяти в третьей степени
К этому модулю относится и логарифмирование. Логарифмом числа «b» по основанию «a» зовётся такой показатель степени, в который следует возвести «a», чтобы получить «b»:
# найдём логарифм 625 по основанию 25
# 625 — основание логарифма, а 25 — аргумент
log = math.log(625, 25)
Модуль numpy
В этом варианте будем использовать библиотеку под названием numpy. Этот модуль не входит в стандартную библиотеку Python — его дополнительно нужно установить. Перейдите в терминал или командную строку, пропишите pip install numpy, нажмите Enter и ждите инсталляции.
В numpy есть функция power() — именно она позволяет возводить числа в степень. С аргументами здесь всё схоже с pow(), первый — это основание, а второй — значение степени. Вместо numpy.power пишут numpy as np:
import numpy as np
# Вывод результата 2 в 5 степени
Скорость работы с большими числами
Интересно сравнить скорость работы разных методов возведения числа в степень, чтобы выбрать оптимальный для выполнения различных задач. Допустим, нам нужно возвести число 2 в степень 134890678:
print(‘** за’, time.process_time() — start, ‘ms’)
val = pow(2, 134890678)
print(‘pow() за’, time.process_time() — start, ‘ms’)
val = math.pow(2, 134890678)
print(‘math.pow() за’, time.process_time() — start, ‘ms’)
val = np.power(2, 134890678)
print(‘np.power() за’, time.process_time() — start, ‘ms’)
оператор ** за 0.0009847609999837914 ms
pow() за 0.013787384000011116 ms
np.power() за 0.09736091600001373 ms
OverflowError: math range error
Сложнее всего оказалось функции math.pow() — она вернула ошибку OverflowError. При работе с ней стоит помнить, что она не всегда справляется с большими значениями степени. Помните, что результаты во многом зависят от устройства и платформы, на которой проводится тестирование. Здесь оператор ** справился с задачей быстрее всех, но часто бывает так, что numpy не оставляет другими шанса на победу.
Главные мысли
Возведение в степень — операция, которую часто используют в программировании. Мы рассмотрели три основных способа возведения в степень в Python — это оператор **, функции pow(), math.pow() и numpy.power(). Самым простым и понятным, а к тому же быстрым оказался метод использования оператора **. Но не стоит забывать, что необходимо учитывать устройство и платформу, на которой вы пишете код. Не забывайте про читаемость и возможность дальнейшей поддержки.
** (степень)
Оператор работает с двумя операндами: числом, которое требуется возвести в степень и числом, являющимся степенью, в которую нужно возвести.
Числовые типы операндов сначала приводятся в общему типу, после возвращается результат этого типа.
+py2.2. Если оба операнда являются целыми и второй из них отрицательный, то они будут сначала конвертированы в числа с плавающей запятой. В предыдущих версиях возбуждалось исключение.
+py3.0 При возведении отрицательного числа в дробную степень получается комплексное число. В предыдущих версиях возбуждалось ValueError.
10 ** 2 # 100
10 ** -2 # 0.01
pow(-1, 2) # 1
# но из-за того, что возведение в степень приоритетнее
# минуса перед первым операндом:
-1 ** 2 # -1
(-1) ** 2 # 1
-2 ** 2.5 # -5.656854249492381
0 ** -3 # ZeroDivisionError
Python возведение в степень
Статьи
Автор Admin На чтение 2 мин Просмотров 3к. Опубликовано 23.12.2022
Введение
В ходе статьи рассмотрим три способа возведения числа в степень на 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
Курс по созданию GUI на Python
Заключение
В ходе статьи мы с Вами рассмотрели целых три способа возведения чисел в степень на Python. Надеюсь Вам понравилась статья, желаю удачи и успехов!
Возведение в степень на Python
В программировании возведение числа в степень — одна из самых распространенных операций. В языке Python для этого есть несколько способов, каждый из которых имеет свои особенности. В данной статье мы рассмотрим методы возведения в степень в Python.
Даниил Фам
Исполнительный директор
20 апреля 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