Возведение в степень питон функция

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.

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

Оператор ** для возведения в степень

Многие разработчики считают, что символ карет ( ^ ) — это оператор возведения числа в степень, ведь именно он обозначает эту операцию в математике. Однако в большинстве языков программирования этот знак выступает в качестве побитового xor .

В Python оператор возведения в степень обозначается двумя символами звездочки ** между основанием и числом степени.

Функциональность этого оператора дополняет возможности оператора умножения * : разница лишь в том, что второй оператор указывает на то, сколько раз первые операнд будет умножен сам на себя.

Чтобы умножить число 5 само на себя 6 раз, используется ** между основанием 5 и операндом степени 6. Вывод:

Проверим оператор с другими значениями.

Инициализируем целое число, отрицательное целое, ноль, два числа с плавающей точкой 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() — самая быстрая.
 
Источник
 
Степень в Python — как возвести?
 
Когда я был студентом, мой преподаватель по методам программирования любил повторять: "В математике все идеи простые". Чаще всего, фраза звучала в момент объяснения новой сложной темы, а потому вызывала определённые внутренние противоречия.
 
С возведением в степень всё не так — это действительно простая операция.
 
История
 
Возведение в степень — частный случай умножения, поэтому данную операцию изначально не рассматривали, как самостоятельную. Но уже в работах Диофанта Александрийского степени отведено особое место. В частности "Отец Алгебры" применял понятия кубов и квадратов числа.
 
Эта операция была известна ещё в древнем Вавилоне, однако современный её вид устоялся лишь в XVII веке.
 
Как умножение позволяет сократить количество символов сложения:
 
Так и степень сокращает запись умножения:
 
 
6 — это основание;
 
2 — показатель степени (это число говорит о том, сколько раз число в основании должно быть умножено само на себя).
 
 
До воцарения числового показателя, были и другие варианты его записи. Математики раннего Возрождения использовали буквы. Например, Q обозначала квадрат, а C — куб. Различные формы записи возведения в степень не обошли и языки программирования.
 
Для АЛГОЛа и некоторых диалектов Бейсика применяется значок ↑. В матлабе, R, Excel-е и Хаскеле используется "циркумфлекс" — ^ или "галочка". Этот символ популярен и вне программирования.
 
Определение
 
В Python возведение в степень записывается при помощи двойной "звёздочки" — " ** "
 
Вторая форма записи — встроенная функция 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)))) >
 
В остальном возведение в рациональную степень работает, как и для целочисленной:
 
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
 
Источник
 
Читайте также:  Html input file api