Как возвести в степень в питоне
Перейти к содержимому

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

  • автор:

Как возвести число в степень в 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 возведение в степень

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

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

Что такое степень?

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

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *