Saltar al contenido principal
InicioTutorialesPython

Exponentes en Python: Guía completa para principiantes

Domina los exponentes en Python utilizando diversos métodos, desde funciones integradas hasta potentes bibliotecas como NumPy, y aprovéchalos en situaciones reales para profundizar en su comprensión.
abr 2024  · 9 min leer

La exponenciación es fundamental en diversas áreas de la programación, del análisis de datos al diseño de algoritmos. Entre sus aplicaciones se incluyen el análisis de patrones exponenciales en grandes conjuntos de datos como las tendencias de las redes sociales y la realización de cálculos matemáticos como el interés compuesto o los tipos de interés.

Además, la exponenciación desempeña un papel crucial en el machine learning (ML) y la inteligencia artificial (IA), especialmente en redes neuronales y reconocimiento de imágenes. Por lo tanto, comprender cómo realizar cálculos con exponentes de forma eficaz en Python es esencial.

En esta guía exploraremos diferentes métodos para realizar la exponenciación en Python. Examinaremos las funciones integradas, las funciones del módulo matemático y las de la biblioteca Numpy. Cada método tiene sus ventajas.

Además, nos adentraremos en un caso práctico para comprender mejor los usos de la exponenciación.

Exponentes en Python

Python ofrece varias formas de calcular exponentes:

  • **: El operador doble asterisco (**) es la opción más sencilla y básica para la exponenciación. Por ejemplo, x ** y calcula x elevado a y.
  • pow(): Esta función integrada usa dos argumentos: la base y el exponente. Devuelve el resultado de elevar la base al exponente. También permite un tercer argumento opcional para la exponenciación modular. Ejemplo: pow(x, y).
  • math.pow(): Esta función del módulo math es similar a pow(), pero siempre devuelve un resultado de coma flotante. Usa dos argumentos, que pueden ser flotantes o enteros. Ejemplo: math.pow(x, y).
  • math.exp(): Otra función del módulo math, que devuelve la exponencial natural de un número, es decir, e elevado a la potencia del argumento. Ejemplo: math.exp(argument).
  • np.power(): Esta función de la biblioteca NumPy está diseñada para trabajar con matrices. Realiza la exponenciación elemento por elemento. Ejemplo: np.power(array, exponent).

Conceptos básicos de exponentes en Python

El operador doble asterisco (**) es la forma más sencilla que tiene Python de calcular la exponenciación. Este operador eleva el operando izquierdo (base) a la potencia del operando derecho (exponente). También se llama operador potencia u operador exponente.

Si quieres mejorar tus conocimientos de programación en Python y aprender a programar como un auténtico programador, consulta el curso Programación en Python.

Exponente positivo

En este fragmento de código, mostramos cómo calcular la exponenciación utilizando exponentes positivos. Por ejemplo, 2 elevado a 3 se calcula como 2 × 2 × 2, que es 8. Del mismo modo, -10 elevado a 4 se calcula como -10 × -10 × -10 × -10, que es 10 000.

base = 2
exponent = 3
print(base**exponent)  # Output: 8

base = -10
exponent = 4
print(base**exponent)  # Output: 10000

Exponente negativo

Este código calcula el resultado de elevar una base a un exponente negativo. Por ejemplo, 5 elevado a -2 es igual a 0,04. Del mismo modo, 25 elevado a -5 es un valor muy pequeño representado en notación científica (1,024e-07).

base = 5
exponent = -2
print(base**exponent) # 0.04

base = 25
exponent = -5
print(base**exponent) # 1.024e-07

Elevar un número a un exponente negativo equivale a tomar el recíproco del número elevado al exponente positivo.

image9.png

En Python, el operador ** devuelve ZeroDivisionError si elevas 0,0 a una potencia negativa, porque cualquier número dividido entre cero es indefinido.

base = 0
exponent = -5
print(base**exponent)

La salida es:

image6.png

Exponente de coma flotante

Los ejemplos de código muestran que Python calcula correctamente el resultado de elevar una base positiva como 2 a un exponente fraccionario como 1,5. Sin embargo, utilizar una base negativa con un exponente fraccionario da como resultado un número complejo.

base = 2
exponent = 1.5
print(base**exponent) # 2.8284271247461903

base = -0.25
exponent = 1.25
print(base**exponent) # (-0.12500000000000003-0.125j)

Profundiza: Funciones integradas

Python proporciona diferentes funciones integradas para calcular exponentes, pero nos centraremos en dos: pow() y math.pow(). A primera vista, estas funciones pueden parecer similares, pero tienen algunas diferencias significativas. Profundicemos en cada función.

pow()

La función pow() usa dos argumentos obligatorios: base y exponente. Opcionalmente, pow() acepta un tercer argumento para calcular el módulo del valor exponencial. La sintaxis es la siguiente: pow(base, exp, mod), donde "mod" representa el módulo. Esta función devuelve el resto de la exponenciación.

Exponenciación básica

Para cálculos básicos, basta con proporcionar la base y el exponente a la función, que funciona de forma similar al operador **.

r = pow(2, 3)
print(r) # 8

r = pow(4, -10)
print(r) # 2.56e-06

Exponenciación de coma flotante

En el código siguiente, utilizamos números de coma flotante tanto para las bases como para los exponentes, algunos de los cuales son negativos. Este enfoque funciona de forma similar al operador **.

r = pow(3.5, 2)
print(r)  # 12.25

r = pow(3.5, -2)
print(r)  # 0.08163265306122448

r = pow(3.5, 3.2)
print(r)  # 55.08301986166747

r = pow(-3.5, -3.3)
print(r)  # (-0.009414432347757688+0.012957854474952653j)

r = pow(-3.5, 3.3)
print(r)  # (-36.698070584660925-50.510560868902246j)

Nota: Si se trata de exponenciación básica sin necesidad de cálculos modulares, el operador ** es una solución más concisa y legible que la función pow().

Exponenciación modular

El parámetro de módulo opcional de la función pow() es muy valioso cuando se trabaja con exponenciación modular. Esto es especialmente útil en criptografía o al tratar con números grandes, ya que la exponenciación modular ofrece una mayor eficiencia. Por ejemplo, al calcular 3 elevado a 4 módulo 5, el resultado es 1, ya que 81 módulo 5 es igual a 1.

r = pow(3, 4, 5)
print(r)  # 1

r = pow(123, 456, 789)
print(r)  # 699

r = pow(2, -3, 7)
print(r)  # 1

r = pow(-13, 8, 62)
print(r)  # 7

Quizá te preguntes por qué utilizar pow() directamente para la exponenciación modular es más eficiente que pow(base, exp) % mod o (base**exp) % mod. La función pow() integrada está diseñada específicamente para esta operación, mientras que los demás métodos realizan cálculos intermedios innecesarios. Esto puede suponer una diferencia significativa en el rendimiento, especialmente con valores grandes.

import timeit

start_pow_mod = timeit.default_timer()
pow(500000000, 3000, 4000)
stop_pow_mod = timeit.default_timer()

pow_mod_time = stop_pow_mod - start_pow_mod

print("Time using pow(base, exp, mod): ", pow_mod_time)

start_pow_other = timeit.default_timer()
pow(500000000, 3000) % 4000
stop_pow_other = timeit.default_timer()

pow_other_time = stop_pow_other - start_pow_other

print("Time using pow(base, exp) % mod:", pow_other_time)


start_aestrisk = timeit.default_timer()
(500000000**3000) % 4000
stop_aestrisk = timeit.default_timer()

aestrisk_time = stop_aestrisk - start_aestrisk

print("Time using (base ** exp) % mod: ", aestrisk_time)


print(
    f"Speed comparison: pow(base, exp, mod) was {pow_other_time / pow_mod_time} times faster than pow(base, exp) % mod and {aestrisk_time/pow_mod_time} times faster than (base ** exp) % mod"
)

La salida es:

image4.png

La función pow() puede provocar diferentes errores dependiendo de la situación.

# Trying to take the modulo of complex numbers raises a ValueError.
print(pow(2 + 3j, 4, 5))  # ValueError: complex modulo

# Taking the third argument is not allowed if the second argument is negative.
print(pow(10, -11, 4))  # ValueError: base is not invertible for the given modulus

# If the first or second argument is a float, the third argument is not allowed.
print(pow(2.4, 3, 4))  # TypeError: pow() 3rd argument not allowed unless all arguments are integers

# Passing any argument as a string results in a TypeError.
print(pow(2, 4, '3'))  # TypeError: unsupported operand type(s) for pow(): 'int', 'int', 'str'

math.pow()

La función math.pow(x, n) eleva x a n. math.pow() convierte los argumentos en flotantes y devuelve el resultado como exponenciación precisa de coma flotante. Esta precisión resulta crucial en campos como el análisis de datos y la computación científica, donde la exactitud es primordial.

Este es el código sencillo. La función math.pow() devuelve un valor de coma flotante, mientras que la función pow() devuelve un valor entero.

import math
print(math.pow(6, 3))  # 216.0
print(pow(6, 3))  # 216

La función math.pow() no acepta números imaginarios.

image1.png

math.pow() no acepta bases negativas con exponentes fraccionarios, ya que aparecerá ValueError.

image3.png

Aprovechar las bibliotecas para la exponenciación avanzada

Para manejar tareas de exponenciación avanzada, como hallar el valor exponencial de un número o calcular la exponenciación elemento por elemento en matrices, puedes aprovechar dos funciones: np.power() y math.exp().

np.power()

En Python, la exponenciación no se limita a las funciones integradas. Python dispone de una potente biblioteca llamada NumPy, que permite una gran variedad de operaciones matemáticas con matrices. A veces, debes usar exponenciación en matrices enteras, y aquí es donde entra np.power(). Se ha diseñado para la exponenciación elemento por elemento en matrices.

import numpy as np
r = np.power([2, 4, 8], 2)
print(r)  # [4, 16, 64]

r = np.power([2, 4, 8], [1, 2, 3])
print(r)  # [4 64 4096]

r = np.power([[2, 3, 4], [5, 6, 7]], [1, 2, 3])
print(r) # [[2 9 64] [5 36 343]]

La función np.power() no acepta un exponente negativo.

import numpy as np
r = np.power([2, 4, 8], -2)
print(r)

La salida es:

image5.png

Si intentas elevar un número negativo a una potencia no entera, NumPy devolverá un valor NaN (no un número).

image7.png

math.exp()

La función math.exp(x) calcula el valor exponencial de x, que equivale a elevar el número e e a x. El número e es aproximadamente igual a 2,71828, y en notación matemática esta operación se representa como e^x.

import math
x = 2
r = math.exp(x)
print("Exponential of", x, ":", r) # 7.38905609893065

Una característica importante de math.exp(x) es su adaptabilidad. Puede manejar números positivos, negativos e incluso números de coma flotante.

import math
print(math.exp(-2))  # 0.1353352832366127
print(math.exp(-2.5))  # 0.0820849986238988
print(math.exp(2.5))  # 12.182493960703473

Aplicaciones prácticas y ejemplos

La exponenciación es una operación fundamental en matemáticas con numerosas aplicaciones en el análisis de datos y la computación científica.

Si quieres dominar los fundamentos del análisis de datos con Python, consulta el curso Introducción a Python para la ciencia de datos.

Supongamos que tienes un archivo CSV que contiene datos sobre principal, tipo de interés y periodo de inversión para varias filas. Puedes calcular el interés compuesto de cada fila utilizando cualquiera de los métodos comentados anteriormente.

Principal,Rate,Years
1000,0.05,5
2000,0.03,10
1500,0.08,3
3000,0.06,7
2500,0.04,9
1800,0.07,4
2200,0.025,6
3500,0.09,2
2800,0.035,8
4000,0.02,5

Aquí tienes el código:

import csv


def compound_interest(principal, rate, years):
    return principal * (1 + rate) ** years


# Read data from CSV file

data = []
with open("data.csv", newline="") as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        row["Compound Interest"] = compound_interest(
            float(row["Principal"]), float(row["Rate"]), int(row["Years"])
        )
        data.append(row)
# Write data to a new CSV file with compound interest column

output_file = "data.csv"
fieldnames = ["Principal", "Rate", "Years", "Compound Interest"]

with open(output_file, mode="w", newline="") as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    for row in data:
        writer.writerow(row)
print("Compound interest calculations saved to", output_file)

El resultado es:

image2.png

¡Estupendo! Has calculado el interés compuesto de todas las filas y lo has almacenado en una columna aparte. Puedes utilizar estos datos para análisis posteriores. Del mismo modo, hay cientos de otros casos de uso en los que se utiliza mucho la exponenciación, como el modelado del crecimiento de la población a lo largo del tiempo.

Conclusión

En esta guía, hemos explorado cinco métodos diferentes para calcular exponentes en Python, cada uno de los cuales ofrece ventajas únicas. Puedes utilizarlos para muchas situaciones prácticas, como hallar el interés compuesto, modelar el crecimiento de la población y mucho más.

Operador doble asterisco (**): Sencillo y directo para el uso diario.

pow(): Versátil con un truco opcional de "módulo".

math.pow(): Resultados precisos como números de coma flotante.

np.power(): Potente para manejar matrices con comprobación de errores.

math.exp(): Herramienta dedicada para calcular el valor exponencial.

Si quieres desarrollar tus habilidades estadísticas y aprender a recopilar, analizar y extraer conclusiones exactas de los datos utilizando Python, consulta el curso Introducción a la estadística en Python.

Temas

Comienza hoy tu andadura en Python

Course

Introduction to Statistics in Python

4 hr
99K
Grow your statistical skills and learn how to collect, analyze, and draw accurate conclusions from data using Python.
See DetailsRight Arrow
Start Course
Ver másRight Arrow
Relacionado

blog

Cómo aprender Python desde cero en 2024: Guía del experto

Descubre cómo aprender Python, sus aplicaciones y la demanda de conocimientos de Python. Comienza hoy tu andadura en Python ​con nuestra guía completa.
Matt Crabtree's photo

Matt Crabtree

19 min

tutorial

Tutorial de Excel en Python: La guía definitiva

Aprende a leer e importar archivos Excel en Python, a escribir datos en estas hojas de cálculo y a encontrar los mejores paquetes para hacerlo.
Natassha Selvaraj's photo

Natassha Selvaraj

30 min

tutorial

Matrices en Python

Matrices en Python con ejemplos de código. Aprende a crear e imprimir matrices con Python NumPy hoy mismo.
DataCamp Team's photo

DataCamp Team

3 min

tutorial

Tutorial de funciones de Python

Un tutorial sobre funciones en Python que cubre cómo escribir funciones, cómo invocarlas y mucho más.
Karlijn Willems's photo

Karlijn Willems

14 min

tutorial

Tutorial sobre el uso de XGBoost en Python

Descubre la potencia de XGBoost, uno de los marcos de machine learning más populares entre los científicos de datos, con este tutorial paso a paso en Python.
Bekhruz Tuychiev's photo

Bekhruz Tuychiev

16 min

tutorial

21 herramientas esenciales de Python

Conozca las herramientas esenciales de Python para el desarrollo de software, raspado y desarrollo web, análisis y visualización de datos y aprendizaje automático.
Abid Ali Awan's photo

Abid Ali Awan

6 min

See MoreSee More