Cómo hacer exponentes en Python

1. Usando el operador ** para hacer la exponenciación en Python
2. Usa pow() o math.power() para hacer el exponente en Python
3. Usando numpy.np() para hacer el exponente en Python
4. Comparando los tiempos de ejecución para cada solución

Este tutorial demostrará cómo hacer exponencias en Python.

En matemáticas, la exponenciación es una operación en la que un número se multiplica varias veces consigo mismo.

Python proporciona operaciones y funciones incorporadas para ayudar a realizar la exponenciación.

Usando el operador ** para hacer la exponenciación en Python

La mayoría de los desarrolladores parecen pensar que el símbolo del cometa ^ es el operador para obtener la potencia de un número porque el cometa se utiliza como símbolo de los exponentes en las matemáticas. Sin embargo, en la mayoría de los lenguajes de programación, el símbolo del cometa está reservado para el operador xor.

En Python, el operador de exponente se simboliza con dos asteriscos consecutivos ** entre la base y el número de exponente.

La funcionalidad del operador de exponente complementa el comportamiento del operador de multiplicación *; la diferencia es que el segundo operando en el operador de exponente es para establecer el número de veces que el primer operando se multiplica por sí mismo.

print(5 ** 6)

Para multiplicar el número 5 por sí mismo 6 veces, usa el operador ** entre el operando base 5 y el operando exponente 6.

Resultado:

15625

Probemos este operador en diferentes tipos de valores.

Inicializaremos un número entero, un número entero negativo, cero, y dos valores float menores que 1 y mayores que 1. Luego asignaremos números enteros aleatorios como sus exponentes.

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

Usa pow() o math.power() para hacer el exponente en Python

Otra forma de hacer exponente en Python es usar la función pow() diseñada para exponenciar valores dados la base y el exponente. El módulo de math también tiene su propia implementación de pow()para el mismo propósito.

Ambas funciones tienen 2 argumentos, el primer argumento es para el número base, y el segundo es para el exponente.

Intentemos llamar a ambas funciones varias veces con los mismos argumentos para poder comparar sus salidas.

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

La única diferencia en los resultados es que math.pow() siempre devuelve un valor float incluso si se pasan argumentos de números enteros, mientras que pow() sólo devolverá float si hay al menos un argumento float.

Usando numpy.np() para hacer el exponente en Python

El módulo NumPy también tiene su propia función power() para la exponenciación. power() acepta los mismos argumentos que las funciones pow(), donde el primer argumento es el valor base y el segundo es el valor de la exponencia.

Para usar NumPy, debemos instalarla a través de pip o pip3.

• Python 2:

pip install numpy

• Python 3:

pip3 install numpy

Imprimamos el mismo conjunto de ejemplos en pow() usando 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() produce la misma salida que la función incorporada de Python pow() donde devolverá un número entero si no hay argumentos float.

Comparando los tiempos de ejecución para cada solución

Comparemos el tiempo que tardan estas 3 funciones y el operador ** en funcionar con un gran valor de exponente. Para las funciones de cronometraje, importaremos el módulo timeit para imprimir el tiempo de ejecución de cada una de las soluciones.

El valor de la base será 2, y el valor del exponente 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

La cosa más obvia a tener en cuenta es que math.pow() resultó en un OverflowError. Esto significa que math.pow() no puede soportar exponentes de gran valor, muy probablemente debido a la forma en que este módulo ha implementado la exponenciación.

La diferencia entre los otros 3 métodos es trivial, pero a partir de este ejemplo, np.power() es la función más rápida para realizar la exponenciación.

¿Y si intentamos reducir la exponencia a 9999? Veamos qué resultados da math.pow().

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