Exponentes em Python

1. Utilizar ** Operador para fazer exponenciação em Python
2. Utilize pow() ou math.power() para fazer expoente em Python
3. Utilize numpy.np() para fazer expoente em Python
4. Comparação dos tempos de execução para cada solução

Este tutorial irá demonstrar como fazer exponenciações em Python.

Em matemática, a exponenciação é uma operação em que um número é multiplicado várias vezes consigo mesmo.

Python fornece operações e funções integradas para ajudar a realizar a exponenciação.

Utilizar ** Operador para fazer exponenciação em Python

A maioria dos criadores parece pensar que o símbolo do carpete ^ é o operador para obter a potência de um número porque o carpete é utilizado como um símbolo para expoentes em matemática. No entanto, na maioria das linguagens de programação, o símbolo do carpete é reservado para o operador bit-wise xor.

Em Python, o operador do expoente é simbolizado por dois asteriscos consecutivos ** entre o número da base e o número do expoente.

A funcionalidade do operador exponente complementa o comportamento do operador de multiplicação *; a diferença é o segundo operando no operador exponente é para definir o número de vezes que o primeiro operando é multiplicado por si mesmo.

print(5 ** 6)

Para multiplicar o número 5 por si mesmo 6 vezes, utilizar o operador ** entre o operando base 5 e o operando expoente 6.

Resultado:

15625

Vamos testar este operador em diferentes tipos de valores.

Vamos inicializar um número inteiro, um número inteiro negativo, zero, e dois valores float inferiores a 1 e superiores a 1. Depois atribuiremos números inteiros aleatórios como seus expoentes.

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)

Resultado:

2^12= 4096
-5^4= 625
0^9999= 0
1.025^-3= 0.928599410919749
0.5^8= 0.00390625

Utilize pow() ou math.power() para fazer expoente em Python

Outra forma de fazer expoente em Python é utilizar a função pow() concebida para exponenciar valores dada a base e o expoente. O módulo math também tem a sua própria implementação de pow() para o mesmo fim.

Estas duas funções têm 2 argumentos, o primeiro argumento é para o número da base, e o segundo é para o expoente.

Vamos tentar chamar ambas as funções várias vezes com os mesmos argumentos para podermos comparar os seus resultados.

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))

Resultado:

-2097152
-2097152.0
2.8284271247461903
2.8284271247461903
64
64.0
32.0
32.0

A única diferença nos resultados é math.pow() sempre retorna um valor float mesmo que sejam passados argumentos de número inteiro, enquanto que pow() só retorna float se houver pelo menos um argumento float.

Utilize numpy.np() para fazer expoente em Python

O módulo NumPy também tem a sua própria função power() para exponenciação. power() aceita os mesmos argumentos que as funções pow(), onde o primeiro argumento é o valor base e o segundo argumento é o valor exponencial.

Para utilizar NumPy, devemos instalá-lo através de pip ou pip3.

• Python 2:

pip install numpy

• Python 3:

pip3 install numpy

Vamos imprimir o mesmo array de exemplos em pow() utilizando numpy.power().

print(np.power(-8, 7))
print(np.power(2, 1.5))
print(np.power(4, 3))
print(np.power(2.0, 5))

Resultado:

-2097152
2.8284271247461903
64
32.0

power() produz a mesma saída que a função Python integrada pow() onde retornará um número inteiro se não houver argumentos float.

Comparação dos tempos de execução para cada solução

Vamos comparar o tempo necessário para que estas 3 funções e o operador ** funcionem com um grande valor exponencial. Para funções de temporização, importamos o módulo timeit para imprimir o tempo de execução de cada uma das soluções.

O valor da base será 2, e o valor para o expoente será 99999.

import numpy as np
import math
import time

start = time.process_time()
val = 2 ** 99999
print("** took", time.process_time() - start, "ms")

start = time.process_time()
val = pow(2, 99999)
print("pow() took", time.process_time() - start, "ms")

start = time.process_time()
val = np.power(2, 99999)
print("np.power() took", time.process_time() - start, "ms")

start = time.process_time()
val = math.pow(2, 99999)
print("math.pow() took", time.process_time() - start, "ms")

Resultado:

** took 0.0006959999999999744 ms

pow() took 0.00039000000000000146 ms

np.power() took 1.6999999999989246e-05 ms

Traceback (most recent call last):
  File "/Users/rayven/python/timeit.py", line 15, in <module>
    val = math.pow(2,99999)
OverflowError: math range error

A coisa mais óbvia a notar é math.pow() resultará num OverflowError. Isto significa que math.pow() não pode suportar expoentes de grande valor, muito provavelmente devido à forma como este módulo implementou a exponenciação.

A diferença entre os 3 outros métodos é trivial, mas a partir deste exemplo, np.power() é a função mais rápida para realizar a exponenciação.

E se tentarmos reduzir o expoente a 9999? Vejamos o que math.pow() suporta.

** took 1.0000000000010001e-05 ms
pow() took 4.000000000004e-06 ms
np.power() took 2.0000000000020002e-05 ms
math.pow() took 2.9999999999752447e-06 ms