Pow python: Функция Python Pow ()

Возведение в степень | Кодкамп

Квадратный корень: math.sqrt () и cmath.sqrt

math модуль содержит math.sqrt() -функции , который может вычислить квадратный корень из любого числа (которые могут быть преобразованы в float ) , и результат всегда будет float :

import math

math.sqrt(9)                # 3.0
math.sqrt(11.11)            # 3.3331666624997918
math.sqrt(Decimal('6.25'))  # 2.5

 

math.sqrt() функция вызывает ValueError , если результат будет complex :

math.sqrt(-10)              
 

ValueError: ошибка математического домена

math.sqrt(x) быстрее , чем math.pow(x, 0.5) или x ** 0.5 , но точность результатов является то же самое. cmath модуль очень похож на math модуля, за исключением того , что можно вычислить комплексные числа , и все его результаты в виде + би исключением. Он может также использовать .sqrt() :

import cmath

cmath.sqrt(4)  # 2+0j
cmath.sqrt(-4) # 2j

 

Что с j ? j является эквивалентом квадратного корня из -1. Все числа можно записать в виде a + bi или в этом случае a + bj. реальная часть числа , как 2 в 2+0j . Так как она не имеет мнимую часть, b равно 0. b представляет собой часть мнимой части числа , как 2 — в 2j . Поскольку нет никакой реальной части в этом, 2j также можно записать в виде 0 + 2j .

Экспонирование с использованием встроенных функций: ** и pow ()

Возведение может быть использован с помощью встроенного pow -функции или ** оператора:

2 ** 3    # 8
pow(2, 3) # 8

Для большинства (все в Python 2.x) арифметических операций тип результата будет типом более широкого операнда. Это не верно для ** ; следующие случаи являются исключениями из этого правила:

Основание: int , показатель: int < 0 :

2 ** -3
# Out: 0.125 (result is a float) 

Это также верно для Python 3.x.

Перед Python 2.2.0, это поднял ValueError .

Основание: int < 0 или float < 0 , показатель: float != int

(-2) ** (0.5)  # also (-2.) ** (0.5)# Out: 0.125 (result is a float) 
Out: (8.659560562354934e-17+1.4142135623730951j) (result is complex)

operator модуль содержит две функции, которые эквивалентны ** -оператора:

import operator
operator.pow(4, 2)      # 16
operator.__pow__(4, 3)  # 64

 

или можно напрямую вызвать __pow__ метод:

val1, val2 = 4, 2
val1.__pow__(val2)      # 16
val2.__rpow__(val1)     # 16
# in-place power operation isn't supported by immutable classes like int, float, complex:
# val1.__ipow__(val2)    

Экспонирование с использованием математического модуля: math.pow()

math модуль содержит другой math.pow() функцию. Разница в встроено pow() -функции или ** оператора является то , что результат всегда float :

import math
math.pow(2, 2)    # 4.0
math.pow(-2., 2)  # 4.0

 

Что исключает вычисления со сложными входами:

math.pow(2, 2+0j) 
 

Ошибка типа: невозможно преобразовать сложное в плавающее

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

math.pow(-2, 0.5)
 

ValueError: ошибка математического домена

Экспоненциальная функция: math.exp () и cmath.exp ()

Как math и cmath модуль содержит число Эйлера: е и использовать его с встроено pow() -функции или ** -оператором работает в основном как math.exp() :

import math

math.e ** 2  # 7.3890560989306495
math.exp(2)  # 7.38905609893065

import cmath
cmath.e ** 2 # 7.3890560989306495
cmath.exp(2) # (7.38905609893065+0j)

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

Магические методы и возведение в степень: построение, математика и математика

Предположим, у вас есть класс, который хранит чисто целочисленные значения:

class Integer(object):
    def __init__(self, value):
        self.value = int(value) # Cast to an integer

    def __repr__(self):
        return '{cls}({val})'.format(cls=self.__class__.__name__,
                                     val=self.value)

    def __pow__(self, other, modulo=None):
        if modulo is None:
            print('Using __pow__')
            return self.__class__(self.value ** other)
        else:
            print('Using __pow__ with modulo')
            return self.__class__(pow(self.value, other, modulo))

    def __float__(self):
        print('Using __float__')
        return float(self.value)

    def __complex__(self):
        print('Using __complex__')
        return complex(self.value, 0)

 

Использование встроенной pow функции или ** оператор всегда вызывает __pow__ :

Integer(2) ** 2                 # Integer(4)
# Prints: Using __pow__
Integer(2) ** 2.5               # Integer(5)
# Prints: Using __pow__
pow(Integer(2), 0.5)            # Integer(1)
# Prints: Using __pow__  
operator.pow(Integer(2), 3)     # Integer(8)
# Prints: Using __pow__
operator.__pow__(Integer(3), 3) # Integer(27)
# Prints: Using __pow__

 

Второй аргумент __pow__() метод может подаваться только с помощью builtin- pow() или путем непосредственного вызова метода:

pow(Integer(2), 3, 4)           # Integer(0)
# Prints: Using __pow__ with modulo
Integer(2).__pow__(3, 4)        # Integer(0) 
# Prints: Using __pow__ with modulo  

 

В то время как math -функции всегда преобразовать его в float и использовать флоат-вычисления:

import math

math.pow(Integer(2), 0.5) # 1.4142135623730951
# Prints: Using __float__

 

cmath -функции попытаться преобразовать его в complex , но может также Откат к float , если нет явного преобразования в complex :

import cmath

cmath.exp(Integer(2))     # (7.38905609893065+0j)
# Prints: Using __complex__

del Integer.__complex__   # Deleting __complex__ method - instances cannot be cast to complex

cmath.exp(Integer(2))     # (7.38905609893065+0j)
# Prints: Using __float__ 

Ни math , ни cmath будет работать , если также __float__() -метод отсутствует:

del Integer.__float__  # Deleting __complex__ method

math.sqrt(Integer(2))  # also cmath.exp(Integer(2))
 

Ошибка типа: требуется плавающее число

Модульное возведение в степень: pow() с 3 аргументами

Обеспечение pow() с аргументами 3 pow(a, b, c) оценивает модульного возведения в степень а б мод C:

pow(3, 4, 17)   # 13

# equivalent unoptimized expression:
3 ** 4 % 17     # 13

# steps:
3 ** 4          # 81
81 % 17         # 13

 

Для встроенных типов использование модульного возведения в степень возможно только в том случае, если:

• Первый аргумент является int
• Второй аргумент является int >= 0
• Третий аргумент является int != 0

Эти ограничения также присутствуют в Python 3.x

Например, можно использовать 3-аргумент форму pow определить модульную обратную функцию:

def modular_inverse(x, p):
    """Find a such as  a·x ≡ 1 (mod p), assuming p is prime."""
    return pow(x, p-2, p)

[modular_inverse(x, 13) for x in range(1,13)]
# Out: [1, 7, 9, 10, 8, 11, 2, 5, 3, 4, 6, 12]

 

Корни: n-корень с дробными показателями

В то время как math.sqrt функция предусмотрена для конкретного случая квадратных корней, это часто бывает удобно использовать оператор возведения в степень ( ** ) с дробными показателями для выполнения п-корневые операции, как кубические корни.

Обратное возведение в степень является возведением в степень по взаимности экспоненты. Таким образом, если вы можете кубизировать число, указав его в показателе степени 3, вы можете найти корень куба в числе, указав его в показателе 1/3.

>>> x = 3
>>> y = x ** 3
>>> y
27
>>> z = y ** (1.0 / 3)
>>> z
3.0
>>> z == x
True 

Вычисление больших целочисленных корней

Несмотря на то, что Python изначально поддерживает большие целые числа, получение n-го корня очень больших чисел может привести к сбою в Python.

 x = 2 ** 100
cube = x ** 3
root = cube ** (1.0 / 3)

 

OverflowError: long int слишком велико для преобразования в float

При работе с такими большими целыми числами вам нужно будет использовать пользовательскую функцию для вычисления n-го корня числа.

def nth_root(x, n):
    # Start with some reasonable bounds around the nth root.
    upper_bound = 1
    while upper_bound ** n <= x:
        upper_bound *= 2
    lower_bound = upper_bound // 2
    # Keep searching for a better result as long as the bounds make sense.
    while lower_bound < upper_bound:
        mid = (lower_bound + upper_bound) // 2
        mid_nth = mid ** n
        if lower_bound < mid and mid_nth < x:
            lower_bound = mid
        elif upper_bound > mid and mid_nth > x:
            upper_bound = mid
        else:
            # Found perfect nth root.
            return mid
    return mid + 1

x = 2 ** 100
cube = x ** 3
root = nth_root(cube, 3)
x == root
# True

Интерактивный учебник языка Python

Занятие 8. Функции и рекурсия

Задача «Возведение в степень»

Условие

Дано действительное положительное число a и целое неотрицательное число n. Вычислите aⁿ не используя циклы, возведение в степень через ** и функцию math.pow(), а используя рекуррентное соотношение aⁿ=a⋅a^n-1.

Решение оформите в виде функции power(a, n).

Во всех задачах считывайте входные данные через input() и выводите ответ через print().

Тесты

2
3

8

2
2

4

2
1

2

2
4

16

2
5

32

2
6

64

2
7

128

2
8

256

2
9

512

2
10

1024

2
15

32768

2
0

1

3
1

3

3
2

9

3
3

27

3
4

81

3
5

243

3
10

59049

3
0

1

1.1414
2

1.30279

1.5
10

57.665

Сигнатура функции — Python

Функция pow(), возводящая число в какую-нибудь степень, принимает два параметра: какое число возводить и в какую степень возводить. Если вызывать pow() без параметров, то Python выдаст следующее: «TypeError: pow expected at least 2 arguments, got 0». Интерпретатор сообщает, что функция ожидает 2 параметра, а вы вызвали её без параметров.

Тот, кто создавал функцию pow(), сделал её функцией с двумя обязательными параметрами, поэтому pow() невозможно вызвать с другим количеством параметров.

Более того, параметрами pow() могут быть только числа. Попытка передать в неё, например, пару строк приведет к следующей ошибке: «TypeError: unsupported operand type(s) for ** or pow(): ‘str’ and ‘str'». Результат вызова функции — тоже всегда число.

Другая функция может иметь другое число параметров и другие типы параметров. Например, может существовать функция, которая принимает три параметра: число, строку и еще одно число.

Откуда мы знаем, сколько каких параметров нужно функции pow() и какого типа будет «возврат»? Мы заглянули в сигнатуру этой функции. Сигнатура определяет входные параметры и их типы, а так же выходной параметр и его тип. Про функцию pow() можно почитать в официальной документации Python или в неофициальной документации на русском языке. Обычно документация для функции имеет вид:

  pow(x, y[, z])

  Возвращает x в степени y; если z присутствует, возвращает x в степени y, по модулю z.

Первая строка здесь, это сигнатура функции. Следом идёт пояснение, для чего функция нужна. Документация позволяет понять сколько аргументов у функции и какого они типа, возвращает ли что-то функция и если да, то какой тип будет иметь возвращаемое значение.

Задание

Теперь ваша очередь посмотреть на сигнатуру функции в документации и разобраться, как её использовать. Можете читать документацию на русском языке, но программист обязан уметь читать документацию на английском. Используйте словари или переводчики при необходимости. Лучше сразу привыкать и подтягивать навыки чтения на английском, иначе будут сложности в будущем.

В Python есть функция hex(). Изучите её сигнатуру на странице документации.

Напишите программу, которая использует функцию hex() с переменной number и выводит результат на экран.

Определения

Нашли ошибку? Есть что добавить? Пулреквесты приветствуются https://github.com/hexlet-basics

Квадратный корень в Python 3 — Извлечение кубических и n-ой степени

Под извлечением корня из какого-либо числа чаще всего подразумевают нахождение решение уравнения x в степени n = value, соответственно для квадратного корня, число n — это два, для кубического — 3. Чаще всего под результатом и числом подразумеваются вещественные числа.

В программировании нахождение корней используется очень часто. Разберемся, как и какими методами можно эффективно извлекать корни из числа. Вначале рассмотрим, какие способы есть в Python, и определим самый эффективный. Потом более подробно разберём, как можно найти не только квадратный корень из числа, но и кубический, и потом корень n степени.

Способы извлечения корня

В языке программирования Python 3 существует три способа извлечения корней:

• Использование функции sqrt из стандартной математической библиотеки math.
• Операция возведения в степень **
• Применение функции pow(x, n)

Чтобы воспользоваться первым способом, необходимо вначале импортировать sqrt из модуля math. Это делается с помощью ключевого слова import: from math import sqrt. При помощи этой функции можно извлекать только квадратный корень из числа. Приведем пример:

from math import sqrt
x = sqrt(4)
print(x)

2.0

Если же нам нужно вычислить в Python корень квадратный из суммы квадратов, то можно воспользоваться функцией hypot из модуля math. Берется сумма квадратов аргументов функции, из нее получается корень. Аргументов у функции два.

from math import hypot
x = hypot(4,3)
print(x)

5.0

Еще одним, чуть более универсальным методом, будет использование возведения в степень. Известно, что для того, чтобы взять корень n из числа, необходимо возвести его в степень 1/n. Соответственно, извлечение квадратного корня из числа 4 будет выглядеть так:

n = 2
x = 4**(1./n)
print(x)

2.0

Обратите внимание, что в Python 2 необходимо ставить точку после единицы, иначе произойдет целочисленное деление, и 1/n == 0, а не нужной нам дроби. В Python 3 можно не ставить точку.

Последний метод использует функцию pow(value, n). Эта функция в качестве аргумента value возьмет число, которое необходимо возвести в степень, а второй аргумент будет отвечать за степень числа. Как и в предыдущем методе, необходимо использовать дробь, для того, чтобы получить корень числа.

x = pow(4, 0.5)
print(x)

2.0

Какой метод быстрее?

Для того, чтобы определить какой же метод предпочтительнее использовать, напишем программу. Замерять время выполнения будем с помощью метода monotonic библиотеки time.

from time import monotonic
from math import sqrt
iterations = 1000000
start = monotonic()
for a in range(iterations):
    x = sqrt(4)
print("sqrt time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = 4 ** 0.5
print("** time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = pow(4, 0.5)
print("pow time: {:>.3f}".format(monotonic() - start) + " seconds")

sqrt time: 0.266 seconds
** time: 0.109 seconds
pow time: 0.453 seconds

Как видно, самое быстрое решение — использовать **. На втором месте метод sqrt, а pow — самый медленный. Правда, метод sqrt наиболее нагляден при вычислении в Python квадратных корней.

Таким образом, если критична скорость, то используем **. Если скорость не критична, а важна читаемость кода, то следует использовать sqrt.

Квадратный корень

Для извлечения квадратного корня самым наглядным способом, правда не самым быстрым, будет использование sqrt из модуля math.

from math import sqrt
x = sqrt (value)

Но можно использовать и трюки с возведением в степень 1/2, что тоже будет приводить к нужному результату.

x = value ** (0.5) или x = pow(value, 0.5).

Кубический корень

Для извлечения кубического корня в Python 3 метод sqrt не подойдет, поэтому воспользуйтесь возведением в степень 1/3:

x = value ** (1./3) или x=pow(value, 1/3).

Корень n-степени

Корень n-степени из числа в Python извлекается можно получить двумя способами с помощью возведения в степень 1.0/n:

• С помощью оператора **.
• Используя функцию pow.

Как было проверено выше, оператор ** быстрее. Поэтому его использовать более целесообразно. Приведем пример вычисления кубических корней в Python 3 с помощью этих двух методов:

n = 4.
x = 16.0 ** (1./n)
print(x)
x = pow(16.0, 1./n)
print(x)

2.0
2.0

Корень отрицательного числа

Рассмотрим, как поведут себя функции, если будем брать корень из отрицательного числа.

from math import sqrt
x = sqrt(-4)

File "main.py", line 2, in 
    x = sqrt(-4)
ValueError: math domain error

Как видим, функция sqrt выдаёт исключение.

Теперь посмотрим, что будет при использовании других методов.

x = -4 ** 0.5
print(x)
x = pow(-4, 0.5)
print(x)

-2.0
(1.2246467991473532e-16+2j)

Как видно из результата, оператор ** не выдает исключения и возвращает некорректный результат. Функция pow работает корректно. В результате получаем комплексное число 2j, что является верным.

Вывод

В Python существуют два универсальных способа для извлечения корня из числа. Это возведение в необходимую степень 1/n. Кроме того, можно воспользоваться функцией из математического модуля языка, если необходимо извлечь квадратный корень числа.

Все эти методы имеют свои преимущества и недостатки. Самый наглядный это sqrt, но подходит только для квадратный корней из числа. Остальные методы не такие элегантные, но легко могут извлечь корень нужной степени из числа. Кроме того оператор ** оказался наиболее быстрым при тестировании.

Необходимо также помнить про целочисленное деление, неправильное использование которого может приводить к ошибке в вычислении.

Python. Модуль math. Степенные и логарифмические функции. Примеры

Содержание

Поиск на других ресурсах:

1. Функция math.exp(x). Экспонента в степени x

Функция math.exp(x) возводит число e в степень x. Функция возвращает результат вещественного типа. Аргумент x может быть целого или вещественного типа. Значение экспоненты: e = 2.718281… служит основой натурального логарифма.

В Python Функция math.exp(x) может быть заменена другими выражениями

1. math.e**x – здесь math.e – константа, равная значению экспоненты.
2. pow(math.e, x) – здесь pow() – встроенная функция языка Python.

Пример.

# Функция math.exp(x)
import math

y = math.exp(1) # y = 2.718281828459045

x = 0.0
y = math.exp(x) # y = 1.0

x = 3.85
y = math.exp(x) # y = 46.993063231579285

  ⇑

2. Функция math.expm1(x). Экспонента от x минус 1

Функция math.expm1(x) вычисляет значение выражения exp(x)-1. При вычислении значения некоторого y, вызов функции

y = math.expm1(x)

можно заменить выражением

y = math.exp(x)-1

Однако, использование функции math.expm1(x) даст более точный результат вычисления. Это и есть основное назначение данной функции.

Пример.

# Функция math.expm1(x)
import math

x = 1.0
y = math.expm1(x) # y = 1.718281828459045

y = math.expm1(0.0) # y = 0.0

  ⇑

3. Функция math.log(x). Натуральный логарифм

Функция math.log(x) предназначена для вычисления натурального логарифма числа с заданным основанием.
Общая форма функции следующая

math.log(x [, base])

где

• x – аргумент, для которого вычисляется логарифм;
• base – основание логарифма. Этот параметр функции необязательный. Если параметр base отсутствует, то за основу берется число e = 2.718281…

Если попробовать вызвать функцию log(0.0), то интерпретатор Python выдаст ошибку

ValueError: math domain error

поскольку логарифм нуля не существует.

Пример.

# Функция math.log(x)
import math

x = 1.0
y = math.log(x) # y = 0.0

  ⇑

4. Функция math.log1p(x). Логарифм для значений, приближенных к нулю

Функция log1p(x) возвращает натуральный логарифм от 1+x. Основой логарифма есть экспонента e = 2.718281… Функция необходима в случаях, когда значение аргумента x приближается к нулю. Как известно, логарифм нуля не существует. Во избежание исключительной ситуации введена данная функция.

Пример.

# Функция math.log1p(x)
import math

x = 0.0000001
y = math.log1p(x) # y = 9.999999500000032e-08

  ⇑

5. Функция math.log2(x). Логарифм с основанием 2

Функция math.log2(x) введена начиная с версии Python 3.3 и возвращает логарифм от аргумента x с основанием 2. Функция введена с целью повышения точности вычислений по сравнению с функцией math.log(x, 2). Аргумент x может быть как целого, так и вещественного типа.

Пример.

# Функция math.log2(x)
import math

x = 2
y = math.log2(x) # y = 1.0

x = 16
y = math.log2(x) # y = 4.0

  ⇑

6. Функция math.log10(x). Десятичный логарифм

Функция math.log10(x) возвращает логарифм от x с основанием 10 (base = 10). Функция дает более точный результат по сравнению с вызовом функции math.log(x, 10). Аргумент x может быть как целого, так и вещественного типа.

Пример.

# Функция math.log10(x)
import math

x = 10
y = math.log10(x) # y = 1.0

x = 100
y = math.log10(x) # y = 2.0

x = 10.00001
y = math.log10(x) # y = 1.0000004342942648

  ⇑

7. Функция math.pow(x, y). Возведение в степень

Функция math.pow(x, y) выполняет возведение x в степень y. Аргументы x, y могут быть целого и вещественного типа. Операнды комплексного типа не поддерживаются.

Особенности вычисления результата:

• результат pow(1.0, y) всегда будет равен 1.0;
• результат pow(0.0, y) всегда будет равен 1.0.

В отличие от операции ** (возведение в степень), функция math.pow(x, y) целочисленные операнды приводит к вещественному типу float.

Пример.

# Функция math.pow(x, y)
import math

# для целочисленных операндов
x = 3
y = 4
z = math.pow(x, y) # z = 81.0 - вещественный результат

# для операндов вещественного типа
x = 2.5
y = 1.5
z = math.pow(x, y) # z = 3.952847075210474

# отрицательные числа
x = -2
y = -3
z = math.pow(x, y) # z = -0.125

x = -2.0
y = 3.0
z = math.pow(x, y) # z = -8.0

# оператор **
z = (-2) ** 3 # z = -8 - результат целого типа

  ⇑

8. Функция math.sqrt(x). Корень квадратный

Функция math.sqrt(x) вычисляет квадратный корень от аргумента x. Функция возвращает результат вещественного типа. Значение x может быть положительным или нулевым. Если значение x отрицательное, то интерпретатор выдаст сообщение об ошибке

math domain error

Пример.

# Функция math.sqrt(x)
import math

# для целых чисел
x = 81
y = math.sqrt(x) # y = 9.0

x = -0.0
y = math.sqrt(x) # y = -0.0

x = 2.0
y = math.sqrt(x) # y = 1.4142135623730951

  ⇑

Связанные темы

  ⇑

pow () в Python — GeeksforGeeks

Python предлагает вычислять степень числа и, следовательно, может облегчить задачу вычисления степени числа. Он имеет множество приложений в повседневном программировании.

Наивный метод вычисления мощности:

Python3

Выход:

 Значение 3 ** 4: 81 

Использование функции Pow ()

1.float pow (x, y): Эта функция вычисляет x ** y . Эта функция сначала преобразует свои аргументы в число с плавающей запятой, а затем вычисляет степень.

Синтаксис: float pow (x, y)

Параметры:

x: Число, мощность которого необходимо вычислить.

г: Значение увеличено для вычислительной мощности.

Возвращаемое значение:

Возвращает значение x ** y в формате float.

Python3

Выход:

 Значение 3 ** 4: 81.0 

2. float pow (x, y, mod): Эта функция вычисляет (x ** y)% mod . Эта функция сначала преобразует свои аргументы в число с плавающей запятой, а затем вычисляет степень.

Синтаксис: float pow (x, y, mod)

Параметры:

x: Число, мощность которого необходимо вычислить.

г: Значение увеличено для вычислительной мощности.

mod: Значение, с которым необходимо рассчитать модуль.

Возвращаемое значение:

Возвращает значение (x ** y)% mod в формате float.

Python3

Выход:

 Значение (3 ** 4)% 10: 1 

Примеры реализации в pow ():

Python3

Выход:

 Положительный x и положительный y: 64
Отрицательный x и положительный y: -64
Положительный x и отрицательный y: 0.015625
Отрицательный x и отрицательный y: -0,015625 

Эта статья предоставлена ​​ Manjeet Singh . Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью с помощью provide.geeksforgeeks.org или отправить ее по электронной почте на [email protected]. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.
Пожалуйста, напишите комментарий, если вы обнаружите что-то неправильное, или если вы хотите поделиться дополнительной информацией по теме, обсужденной выше.

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .

Python pow () — JournalDev

Функция Python pow () обычно принимает два числовых аргумента и возвращает их мощность.

Python pow ()

Синтаксис функции Python pow ():

 
pow (x, y [, z])
  

• Если указаны только два аргумента, то возвращается x в степени y.В этом случае это могут быть целые числа, числа с плавающей запятой и комплексные числа. Форма с двумя аргументами pow (x, y) эквивалентна использованию оператора мощности: x ** y.
• Если предоставлено три аргумента, то возвращается x в степени y по модулю z. Он вычисляется более эффективно, чем при использовании pow (x, y)% z.
• Если z присутствует, x и y должны быть целочисленного типа, а y должен быть неотрицательным.

Давайте рассмотрим несколько примеров функции pow ().

Python pow () с целыми числами

 
печать (pow (10, 2))
печать (pow (-10, 3))
print (pow (10, 2, 3))
  

Выход:

 
100
-1000
1
  

Python pow () с поплавками

 
print (pow (100; -1))

print (pow (100.0, 2))
  

Выход:

 
0,01
10000,0
  

pow () с целыми числами в другом формате

 
print (pow (0b11, 2)) # 0b11 = 3
печать (pow (0b11, 2, 2))

print (pow (0o11, 2)) # 0o11 = 9
print (pow (0o11, 2, 2))

print (pow (0xF, 2)) # 0xF = 15
print (pow (0xF, 2, 2))
  

Выход:

 
9
1
81 год
1
225
1
  

pow () с комплексными числами

 
печать (pow (2 + 3j, 2))
  

Выход: (-5 + 12j)

сценарии исключения pow ()

1.  
   print (pow (2 + 3j, 2, 3))
     

   Ошибка: ValueError: комплексный модуль

2.  
   print (pow (100.0, 2, 3))
     

   Ошибка: TypeError: pow () 3-й аргумент не разрешен, если все аргументы не являются целыми числами

3.  
   print (pow (100, -1, 2))
     

   Ошибка: ValueError: pow () 2-й аргумент не может быть отрицательным, если указан 3-й аргумент

pow () vs math.pow ()

Математический модуль Python также имеет функцию pow (), но встроенный in function более мощный, потому что мы можем выполнять операцию по модулю также после power.Кроме того, нам не нужно импортировать математический модуль для одной функции.

Вы можете получить полный скрипт Python и другие примеры Python в нашем репозитории GitHub.

Ссылка: Официальная документация

Метод Python pow () — AskPython

Функция Python pow () — одна из наиболее часто используемых встроенных функций в программировании на Python. Он широко используется для вычисления значения a в степени n или, более конкретно, a ⁿ .Это очень полезная функция при выполнении некоторых сложных математических вычислений, а иногда и для других операций. Итак, давайте углубимся в функцию pow () в Python .

Использование функции Python pow ()

В функцию pow () можно передать всего три аргумента . Синтаксис для pow () приведен ниже,

.

pow (а, н, б)

Где,

• a — это число, степень которого мы вычисляем, или базовое число ,
• n — это то, сколько в степень a должно быть увеличено, или экспоненциальная часть ,
• b — это число, с которым будет рассчитан модуль an.5)% 5 Или 32% 5 = 2 .

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

  у = pow (4, -2,6)
  печать (у)
   

  Выход:

  Отслеживание (последний вызов последний):
    Файл "C: /Users/sneha/Desktop/test.py", строка 2, в 
      у = pow (4, -2,6)
  ValueError: pow () 2-й аргумент не может быть отрицательным, если указан 3-й аргумент
   

  математика.pow () против встроенного pow () в Python

  Помимо того, что math.pow () не имеет встроенной операции модуля, как встроенный pow () , так и предварительно определенный math.pow () имеют некоторые большие различия. .

  Функция pow () сравнительно на быстрее для большого набора значений. С другой стороны, для использования math.pow () пользователь должен сначала импортировать модуль mat h.

  Даже по математике.Метод pow () выдает ошибку при вычислении результатов для некоторых комплексных чисел. Что не делает метод pow () .

  Список литературы

  Функция Python pow () — w3resource

  Последнее обновление 28 февраля 2020 12:27:20 (UTC / GMT +8 часов)

  Функция pow ()

  Функция pow () используется для получения значения x в степени y (xy). Если z присутствует, верните x в степень y по модулю z (вычисляется более эффективно, чем pow (x, y)% z).

  Версия:

  (Python 3.2.5)

  Синтаксис:

   pow (x, y [, z])
   

  Параметр:

  Имя	Описание	Обязательно / Дополнительно
  x	Номер (база), на который необходимо подать питание.	Требуется
  y	Число (показатель степени), которое должно быть запитано x.	Требуется
  z	Число, которое должно использоваться для операции модуля.	Дополнительно

  Пример: функция Python pow ()

    # положительный a, положительный b (a ** b)
  печать (pow (4, 4))
  
  # отрицательный a, положительный b
  печать (pow (-4, 4))
  
  # положительный a, отрицательный b (a ** - b)
  печать (pow (4, -4))
  
  # отрицательный a, отрицательный b
  print (pow (-4, -4))
    

  Выход:

   256
  256
  0,003
  
  0,003
  
   

  Изображение:

  Пример: Python pow () с тремя аргументами (x ** y)% z

    а = 3
  b = 5
  с = 7
  печать (pow (a, b, c))
    

  Выход:

   5
   

  Редактор кода Python:

  Предыдущая: ord ()
  Следующая: print ()

  Проверьте свои навыки Python с помощью викторины w3resource

  Python: советы дня

  Распаковать аргументы функции с помощью оператора splat

  Пример:

  Тест

   def (p, q, r):
  печать (p, q, r)
  
  test_Dict = {'p': 2, 'q': 4, 'r': 6}
  test_List = [20, 40, 60]
  
  тест (* test_Dict)
  тест (** test_Dict)
  test (* test_List)
   

  Выход:

   p q r
  2 4 6
  20 40 60
   

  Как рассчитать с показателями в Python?
  · Kodify

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

  # Вычислить показатели на языке программирования Python

  В математике показатель степени числа говорит, сколько раз это число многократно умножается само на себя (Википедия, 2019). Обычно мы выражаем эту операцию как b ⁿ , где b — это основание, а n — это показатель степени или степени . Мы часто называем этот тип операции «b в степени n», «b в степени n» или, вкратце, «b в n» (Википедия, 2019).

  Python имеет три способа возведения значений в степень:

  • Оператор ** . Чтобы запрограммировать 2 ⁵ , мы выполняем 2 ** 5 .
  • Встроенная функция pow () . 2 ³ закодировано становится pow (2, 3) .
  • Функция math.pow () . Чтобы вычислить 3 ⁵ , мы выполняем math.pow (3, 5) .

  Поскольку каждый подход дает правильный ответ, не стесняйтесь выбирать любой. Если вы не уверены, используйте pow () , если вам нужен целочисленный результат и математика.pow () для результата с плавающей запятой.

  Давайте подробнее рассмотрим каждый вариант, который предлагает Python.

  # Вычислить показатели Python с помощью оператора

  **

  Первый способ возвести число в степень — использовать оператор Python ** (Matthes, 2016). Этот оператор также называется степенным оператором (Sweigart, 2015) или степенным оператором (Python Docs, n.d. c).

  Оператор ** работает с двумя значениями, как обычное умножение на * .На этот раз, однако, мы возводим его левый аргумент в степень правого аргумента (Python Docs, n.d. c). Допустим, мы хотим вычислить 3 ³ . Мы делаем это с ** следующим образом:

  Оператор ** возвращает ZeroDivisionError , когда мы возводим 0,0 в отрицательную степень. И когда мы возводим отрицательное число в дробную степень, оно возвращает комплексное число (Python.org, n.d. c).

  # Пример: возведение в степень в Python с помощью

  **

  Давайте посмотрим, как мы можем использовать оператор ** в программе Python.0,125 = «, eExp, sep =» «)
  

  Здесь мы сначала создаем пять различных переменных. Мы называем их значениями A от до valueE . У них есть положительные, отрицательные значения и значения с плавающей запятой.

  Затем мы возводим каждую переменную в определенную степень с помощью оператора ** . Эти показатели варьируются от -5 до 4. Мы сохраняем результаты в новых переменных (от aExp до eExp ).

  Последний бит кода выводит исходное и возведенное в степень значение с помощью функции Python print () .0,125 = (0,7768869870150186 + 0,3217971264527913j)
  

  # Вычислить показатели Python с помощью функции

  pow ()

  Другой способ возведения в степень значений — встроенная функция pow () (Python.org, n.d. a). Эта функция принимает два аргумента. Первый — это основание или число, которое мы хотим возвести в определенную степень. Второй — это показатель степени. pow () всегда вычисляет точную целочисленную степень.

  Итак, чтобы вычислить 3 ² , мы используем функцию pow () следующим образом:

  pow () также может принимать три аргумента.В этом случае третий аргумент указывает модуль возведения в степень (Python Docs, n.d. a). Это возвращает остаток от возведения в степень. Использование pow () таким образом более эффективно, чем эквивалент pow (base, exp)% mod .

  Кстати, функция pow () возвращает комплексное число, когда мы используем его с нецелой степенью. Это отличается от функции math.pow () , которая в этом случае ошибается.

  # Пример: возвести числа в степень с помощью

  pow ()

  Давайте посмотрим на программу Python, которая использует функцию pow () .0,125 = «, eExp, sep =» «)
  

  Сначала мы создаем пять различных переменных. Они бывают положительными, отрицательными и имеют значение с плавающей запятой. Мы называем эти переменные valueA от до valueE .

  Затем мы возводим каждую переменную в определенную степень. Для этого мы вызываем функцию pow () с двумя аргументами. Первый — это значение, которое нужно возвести в степень, второй — показатель степени. Мы помещаем результат, что pow () возвращает в переменные с aExp по eExp .0,125 = (0,7768869870150186 + 0,3217971264527913j)
  

  # Возвести числа в степень с помощью Python

  math.pow ()

  Функция Python math.pow () предоставляет еще один способ умножить число несколько раз на себя. Для этого функция принимает два аргумента: базовое число и показатель степени (Python Docs, n.d. b).

  Так почему еще один способ возвести значения в степень? Отличие math.pow () от заключается в том, что он преобразует оба аргумента в значения с плавающей запятой (Python Docs, n.d. б). В результате функция всегда возвращает число с плавающей запятой. (Для точных целочисленных степеней используйте функцию pow () или оператор ** , описанный выше.)

  Быстрый пример math.pow () :

    import math
  
  math.pow (3, 2)
  # Возвращает: 9.0
    

  Вот как math.pow () обрабатывает необычные случаи. math.pow (1.0, x) и math.pow (x, 0.0) всегда возвращают 1.0 . Это происходит, даже когда x равно нулю или NaN (Python.org, н.д. б).

  Кроме того, math.pow () вызывает исключение ValueError , когда: оба аргумента конечны, первый аргумент отрицательный, или второй аргумент не является целым числом (Python Docs, n.d. b).

  # Пример: возвести числа в степень с помощью

  math.pow ()

  Чтобы увидеть, как на практике работает функция math.pow () , давайте рассмотрим следующий пример программы. Следующий код возводит 5 различных значений в разную степень с помощью математики .-45 = ", eExp, sep =" ")


  Прежде чем мы сможем использовать функцию math.pow () , мы должны импортировать модуль math . Затем мы создаем пять различных переменных, каждая из которых имеет числовое значение. Мы называем их значениями A от до valueE .

  Затем мы возводим каждую переменную в определенную степень. Для этого мы вызываем math.pow () с двумя аргументами. Первая — это переменная, которую мы создали ранее. Второй — положительный или отрицательный показатель степени. Мы сохраняем результат функции в новых переменных, от aExp до eExp .-45 = -1,2379400392853803e + 27
  

  # Обработать список или массив: вычислить показатель степени для каждого значения

  В приведенных выше примерах мы каждый раз увеличивали одно значение до определенного показателя. Но что, если мы хотим возвести в степень список или массив значений? Давай выясним.

  # Возведение значений списка в степень с пониманием списка Python

  Один из способов поднять каждое значение списка до определенной степени — с пониманием списка. Это требует совсем немного кода и работает эффективно.

  Вот как мы это делаем:

    # Некоторые случайные значения
  значения = [
      12, 89, -12,5, 0,443,
      1310, 3110, 125, 54
  ]
  
  # Возвести каждое число в степень 3
  экспоненты = [pow (значение, 3) для значения в значениях]
  
  # Выводим оба списка
  print ("Исходный список: \ n", значения)
  print («Возведенный в степень 3: \ n», экспоненты)  

  Этот код сначала составляет список целых чисел и чисел с плавающей запятой (названные значениями ). Его содержимое может иметь как положительные, так и отрицательные значения.

  Затем составляем список рассуждений.Здесь функция pow () поднимает каждую переменную value в степень 3 . Эта переменная value — это то, что генерирует для значения в значениях . Этот встроенный цикл для проходит через каждый элемент в списке значений и делает значение этого элемента доступным через переменную value .

  Вот так наше понимание списка обрабатывает весь список, выполняя pow () для каждого элемента.Мы помещаем полученные значения в список экспонент для использования в дальнейшем.

  Последний бит кода имеет функцию print () , отображающую как исходный список ( значений, ), так и числа, возведенные в 3-ю степень ( экспонент ). Вот что отображается:

    Исходный список:
   [12, 89, -12,5, 0,443, 1310, 3110, 125, 54]
  Возведены в степень 3:
   [1728, 704969, -1953,125, 0,086938307, 22480, 30080231000, 1953125, 157464]
    

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

    # Увеличьте каждое число до 3 и замените
  # числа в исходном списке значений
  values ​​= [pow (значение, 3) для значения в значениях]
    

  # Увеличить значения до степени с помощью цикла Python

  for

  Цикл for — еще один вариант обработки каждого значения в списке или массиве. Для этого требуется немного больше кода, чем понимание списка, но цикл для делает возможным более продвинутое поведение.Кроме того, когда код сложен, цикл для легче читать.

  Вот как мы повышаем значения до определенного значения с помощью обычного цикла для :

    # Некоторые случайные значения
  значения = [
      12, 89, -12,5, 0,443,
      1310, 3110, 125, 54
  ]
  
  # Экспоненты
  полномочия = [
      2, 3, 4, 5,
      1,5, -3, 2, 0,5
  ]
  
  результаты = []
  
  # Прокрутите значения и поднимите
  # каждый до указанной мощности
  для i значение в enumerate (values):
      results.append (pow (значение, мощности [i]))
  
  # Выходные данные
  print ("Исходные значения: \ n", значения)
  print ("Показатели: \ n", степени)
  print ("Результат: \ n", результаты)  

  Эта мини-программа составляет три списка.Первый, values ​​, содержит числа, которые мы хотим возвести в определенную степень. Второй ( степени, ) имеет разные показатели. В третьем списке ( результатов ) мы собираем результаты возведения в степень. Этот список начинается пустым.

  Затем делаем петлю на . Этот цикл перебирает все числа в списке значений . С помощью функции Python enumerate () мы делаем доступными как значение списка, так и его индекс (в переменных value и i ).С этим последним у нас есть значение для индексации списка степеней . Таким образом мы сопоставляем каждое значение (из списка значений ) с его соответствующей экспонентой (из списка степеней ).

  Внутри цикла мы добавляем новое значение в список results с его методом append () . Чтобы вычислить это значение, мы используем встроенную в Python функцию pow () с двумя аргументами. Первый — это число из списка значений . Другой, powers [i] , выбирает показатель степени из списка powers .(Поскольку оба списка имеют одинаковую длину, мы можем сопоставить значения в одном со значениями в другом.)

  После завершения цикла мы заполнили список результатов результатами возведения в степень. Далее мы отображаем три списка с помощью функции Python print () :

    Исходные значения:
   [12, 89, -12,5, 0,443, 1310, 3110, 125, 54]
  Показатели:
   [2, 3, 4, 5, 1,5, -3, 2, 0,5]
  Исход:
   [144, 704969, 24414,0625, 0,017061555810443, 47414,03800563711, 3,32444255497e-11, 15625, 7.3484692283495345]
    

  Если вам не нужно сохранять исходный список, вы также можете перезаписать его значения с результатом в степени. Для этого мы также можем использовать функцию enumerate () . Вот пример:

    # Прокрутите исходный список значений и
  # возвести каждое число в степень (заменяя оригинал)
  для индекса значение в enumerate (values):
      значения [индекс] = pow (значение, 5)
    

  # Сводка

  Возведение в степень ( b ⁿ ) — это математическая операция, которая умножает число ( b ) определенное количество раз ( n ) на себя.Есть три способа запрограммировать такое поведение в Python.

  Оператор степени ( ** ) возводит левое значение в степень второго значения. Например: 2 ** 3 .

  Встроенная функция pow () делает то же самое: она возводит свой первый аргумент в степень своего второго аргумента. Вот так: pow (2, 3) .

  Функция math.pow () также выполняет возведение в степень, но без точных целочисленных степеней и всегда возвращает значение с плавающей запятой.Чтобы использовать эту функцию, мы делаем: math.pow (2, 3) .

  Источники

  Маттес, Э. (2016). Ускоренный курс Python: практическое проектное введение в программирование . Сан-Франциско, Калифорния: Пресса без крахмала.

  Python.org (без даты а). Встроенные функции . Получено 22 октября 2019 г. с https://docs.python.org/3.8/library/functions.html

  Python.org (n.d. b). math — Математические функции . Получено 22 октября 2019 г. с https: // docs.python.org/3.8/library/math.html

  Python.org (без даты c). Выражения . Получено 30 октября 2019 г. с https://docs.python.org/3.8/reference/expressions.html

  Sweigart, A. (2015). Автоматизируйте скучную работу с помощью Python: практическое программирование для начинающих . Сан-Франциско, Калифорния: Пресса без крахмала.

  Википедия (26 октября 2019 г.). Возведение в степень . Получено 30 октября 2019 г. с https://en.wikipedia.org/wiki/Exponentiation

  . Опубликован , 20 декабря 2019 г., .«Все статьи по математике Python

  Как вычислить мощность в Python

  Функция Python pow () вычисляет a ** b . Функция pow () сначала преобразует свои аргументы в число с плавающей запятой, а затем вычисляет мощность. Итак, если вы хотите вычислить мощность, то функция pow () — ваше решение.

  Python pow () Пример

  Python pow () — это встроенная функция, которая возвращает x в степень y. Если задан третий аргумент (z), он возвращает x в степени y по модулю z, i.е., pow (x, y)% z. Функция pow () возвращает значение x в степени y (x ^y ). Если присутствует третий параметр, он возвращает x в степени y по модулю z.

  Синтаксис

  Синтаксис метода pow () следующий.

   pow (a, b, c) 

  Параметр	Описание
  a	Число, основание
  b	Число, показатель степени
  c	Необязательный.Число, модуль

  1. Если указаны только два аргумента, то возвращается a в степени b. В этом случае аргументами могут быть целые числа, числа с плавающей запятой и комплексные числа. Форма pow (a, b) с двумя аргументами эквивалентна использованию оператора мощности: a ** b.
  2. Если предоставлено три аргумента, то возвращается a в степени b по модулю c. Он вычисляется более эффективно, чем при использовании pow (a, b)% c.
  3. Если c присутствует, a и b должны быть целочисленного типа, а b должно быть неотрицательным.

  См. Следующий пример.

   # app.py
  
  данные = pow (4, 3)
  print (data) 

  Смотрите вывод.

   ➜ pyt python3 app.py
  64
  ➜ pyt 

  Давайте передадим третий параметр и посмотрим на результат.

   # app.py
  
  данные = pow (4, 3, 10)
  print (data) 

  Итак, это сначала 4 * 4 * 4, что составляет 64, а затем 64% 10, что равно 4. Вот почему он даст нам результат 4.

   ➜ pyt python3 app.py
  4
  ➜ pyt 

  #Python pow () с числами с плавающей запятой

  Мы также можем вычислить мощность значений с плавающей запятой, используя метод pow ().

  См. Следующий пример кода с плавающей запятой.

   # app.py
  
  печать (pow (11, 2.0))
  
  print (pow (21.0, 2)) 

  Смотрите вывод.

   ➜ pyt python3 app.py
  121,0
  441,0
  ➜ pyt 

  #Python pow () с целыми числами разного формата

  Мы можем вычислить степень целых чисел разного формата, используя метод pow ().

  См. Следующий пример кода.

   # app.py
  
  печать (pow (0b11, 2))
  печать (pow (0b11, 2, 2))
  
  print (pow (0o11, 2))
  print (pow (0o11, 3, 2))
  
  печать (pow (0xF, 2))
  print (pow (0xF, 3, 2)) 

  См. следующий вывод.

   ➜ pyt python3 app.py
  9
  1
  81 год
  1
  225
  1
  ➜ pyt 

  #pow () с комплексными числами

  Мы можем вычислить степень комплексных чисел с помощью метода pow ().

   # app.py
  
  print (pow (11 + 21j, 2)) 

  Смотрите вывод.

   ➜ pyt python3 app.py
  (-320 + 462j)
  ➜ pyt 

  #pow () vs math.pow ()

  Математический модуль Python также имеет функцию pow (), но встроенная функция более мощная, потому что мы можем выполнять операцию по модулю также после включения питания.

  Кроме того, нам не нужно импортировать математический модуль для одной функции.

  Таким образом, предпочтительно использовать встроенную в Python функцию pow () , а не функцию math.pow () .

  math.pow () всегда возвращает значения с плавающей запятой. Поэтому, если вы по какой-то причине хотите убедиться, что в результате вы вернули float, то math.pow () предоставит это преимущество пользователю.

  Наконец, работа с примером Python pow () завершена.

  См. Также

  Python sqrt ()

  Абсолютное значение Python

  Комплекс Python ()

  Показатели в python x.** y против math.pow (x, y)

  Использование оператора мощности ** будет быстрее, так как не будет накладных расходов на вызов функции. В этом можно убедиться, если разобрать код Python:

    >>> dis.dis ('7. ** i')
    1 0 LOAD_CONST 0 (7.0)
                3 LOAD_NAME 0 (i)
                6 BINARY_POWER
                7 RETURN_VALUE
  >>> dis.dis ('pow (7., i)')
    1 0 LOAD_NAME 0 (мощность)
                3 LOAD_CONST 0 (7.0)
                6 LOAD_NAME 1 (i)
                9 CALL_FUNCTION 2 (2 позиционных, 0 пар ключевых слов)
               12 RETURN_VALUE
  >>> dis.dis ('math.pow (7, i)')
    1 0 LOAD_NAME 0 (математика)
                3 LOAD_ATTR 1 (мощность)
                6 LOAD_CONST 0 (7)
                9 LOAD_NAME 2 (i)
               12 CALL_FUNCTION 2 (2 позиционных, 0 пар ключевых слов)
               15 RETURN_VALUE
    

  Обратите внимание, что я использую здесь переменную i в качестве показателя степени, потому что постоянные выражения, такие как 7.** 5 фактически оцениваются во время компиляции.

  На практике эта разница не так уж и важна, как вы можете видеть, посчитав ее:

    >>> из timeit import timeit
  >>> timeit ('7. ** i', setup = 'i = 5')
  0,2894785532627111
  >>> timeit ('pow (7., i)', setup = 'i = 5')
  0,41218495570683444
  >>> timeit ('math.pow (7, i)', setup = 'import math; i = 5')
  0,56550531687
    

  Итак, а pow и math.pow примерно в два раза медленнее, но они все еще достаточно быстры, чтобы это не волновало. Если вы действительно не сможете определить возведение в степень как узкое место, не будет причин выбирать один метод вместо другого, если ясность уменьшается. Это особенно актуально, поскольку pow предлагает, например, интегрированную операцию по модулю.

  ---

  Альфе задал хороший вопрос в комментариях выше:

  timeit показывает, что math.pow медленнее, чем ** во всех случаях.Для чего вообще нужен math.pow () ? Есть ли у кого-нибудь идеи, где тогда это может быть полезно?

  Большое отличие math.pow от встроенного pow и оператора мощности ** состоит в том, что всегда использует семантику с плавающей запятой. Так что, если вы по какой-то причине хотите убедиться, что в результате вы получите обратно float, то math.pow обеспечит это свойство.

  Давайте подумаем о примере: у нас есть два числа, i и j , и мы не знаем, являются ли они числами с плавающей запятой или целыми.j . Итак, какие у нас есть варианты?

  • Мы можем преобразовать хотя бы один из аргументов в число с плавающей запятой, а затем выполнить i ** j .
  • Мы можем выполнить i ** j и преобразовать результат в число с плавающей запятой (экспонентация с плавающей запятой автоматически используется, когда либо i , либо j являются числами с плавающей запятой, поэтому результат тот же).
  • Мы можем использовать math.pow .

  Итак, давайте проверим это:

    >>> timeit ('float (i) ** j', setup = 'i, j = 7, 5')
  0.7610865891750791
  >>> timeit ('i ** float (j)', setup = 'i, j = 7, 5')
  0,7930400942188385
  >>> timeit ('float (i ** j)', setup = 'i, j = 7, 5')
  0,8946636625872202
  >>> timeit ('math.pow (i, j)', setup = 'import math; i, j = 7, 5')
  0,5699394063529439
    

  Как видите, math.pow на самом деле быстрее! И если подумать, накладные расходы, связанные с вызовом функции, теперь тоже исчезли, потому что во всех других альтернативах мы должны вызывать float () .

  ---

  Кроме того, стоит отметить, что поведение ** и pow можно переопределить путем реализации специального метода __pow__ (и __rpow__ ) для настраиваемых типов.

  No related posts.