A continuación se presenta una lista de las funciones y constantes más comunes relacionadas con operaciones matemáticas en Python, principalmente provenientes del módulo math, junto con una breve descripción de cada una:
Constantes:
math.pi: El número π (3.141592653589793...).
math.e: La constante de Euler (2.718281828459045...).
math.tau: Constante τ, equivalente a 2π (6.283185307179586...).
math.inf: Representa el infinito positivo.
math.nan: Representa un valor que no es un número (Not a Number).
Funciones aritméticas básicas:
math.ceil(x): Redondea hacia arriba, al entero más cercano mayor o igual a x.
math.floor(x): Redondea hacia abajo, al entero más cercano menor o igual a x.
math.trunc(x): Trunca x hacia cero, eliminando cualquier parte decimal.
math.fabs(x): Devuelve el valor absoluto de x (en punto flotante).
math.factorial(x): Devuelve el factorial de x, donde x es un entero no negativo.
math.fsum(iterable): Devuelve la suma precisa de un iterable de valores en punto flotante, reduciendo el error de redondeo.
math.prod(iterable) (Python 3.8+): Devuelve el producto de todos los elementos en el iterable.
Funciones de exponentes y logaritmos:
math.exp(x): Devuelve e^x.
math.log(x[, base]): Devuelve el logaritmo de x en la base especificada. Si no se especifica la base, calcula el logaritmo natural (base e).
math.log10(x): Devuelve el logaritmo base 10 de x.
math.log2(x): Devuelve el logaritmo base 2 de x.
math.log1p(x): Devuelve el logaritmo natural de (1 + x) con mayor precisión para valores pequeños de x.
math.pow(x, y): Eleva x a la potencia y (similar al operador **, pero siempre devuelve flotante).
math.sqrt(x): Devuelve la raíz cuadrada de x.
Funciones trigonométricas (argumentos en radianes):
math.sin(x): Seno de x.
math.cos(x): Coseno de x.
math.tan(x): Tangente de x.
math.asin(x): Arcoseno de x.
math.acos(x): Arcocoseno de x.
math.atan(x): Arcotangente de x.
math.atan2(y, x): Arcotangente de y/x, teniendo en cuenta el signo de ambos para determinar el cuadrante.
math.hypot(x, y): Retorna la longitud de la hipotenusa de un triángulo rectángulo con lados x e y, equivalente a sqrt(x² + y²).
Conversiones de ángulos:
math.degrees(x): Convierte x de radianes a grados.
math.radians(x): Convierte x de grados a radianes.
Otras funciones útiles:
math.copysign(x, y): Devuelve x con el signo de y.
math.fmod(x, y): Devuelve el resto de la división de x por y como número flotante.
math.frexp(x): Devuelve la mantisa y el exponente de x, de modo que x = mantisa * 2^exponente.
math.ldexp(mantisa, exponente): Inverso de frexp(). Calcula mantisa * 2^exponente.
math.modf(x): Devuelve la parte fraccionaria y la parte entera de x separadas.
math.isclose(a, b, rel_tol=..., abs_tol=...): Determina si a y b son cercanos entre sí dentro de una tolerancia relativa y/o absoluta.
math.isfinite(x): Verifica si x es un número finito.
math.isinf(x): Verifica si x es infinito.
math.isnan(x): Verifica si x no es un número (NaN).
math.gcd(*integers): Devuelve el máximo común divisor de los enteros dados.
math.comb(n, k) (Python 3.8+): Devuelve el número de combinaciones posibles al elegir k elementos de un conjunto de n, sin repeticiones ni orden (binomial).
math.perm(n, k) (Python 3.8+): Devuelve el número de permutaciones posibles al elegir k elementos de n, donde el orden sí importa.
math.dist(p, q) (Python 3.8+): Calcula la distancia euclidiana entre dos puntos p y q, dados como iterables de coordenadas.
Funciones hiperbólicas
Estas funcionan de forma análoga a las trigonométricas, pero aplicadas a funciones hiperbólicas:
math.sinh(x): Devuelve el seno hiperbólico de x.
math.cosh(x): Devuelve el coseno hiperbólico de x.
math.tanh(x): Devuelve la tangente hiperbólica de x.
math.asinh(x): Devuelve el área seno hiperbólico inverso de x.
math.acosh(x): Devuelve el área coseno hiperbólico inverso de x.
math.atanh(x): Devuelve el área tangente hiperbólica inversa de x.
Funciones de precisión y relaciones con valores flotantes:
math.expm1(x): Devuelve e^x - 1, calculando este valor con mayor precisión para valores muy pequeños de x.
math.gamma(x): Devuelve la función gamma de x, que generaliza el factorial a números reales.
math.lgamma(x): Devuelve el logaritmo natural del valor absoluto de la función gamma de x.
math.erf(x): Devuelve la función error de Gauss evaluada en x.
math.erfc(x): Devuelve la función error complementaria de Gauss evaluada en x.
math.exp2(x) (Python 3.11+): Devuelve 2^x.
math.nextafter(x, y) (Python 3.9+): Devuelve el siguiente número de punto flotante después de x en dirección hacia y.
math.ulp(x) (Python 3.9+): Devuelve la unidad en el último lugar (Unit in Last Place) de x, es decir, el intervalo entre x y el siguiente número representable en coma flotante.
math.remainder(x, y) (Python 3.7+): Devuelve el resto IEEE 754 de x / y.
Otras funciones numéricas integrales:
math.isqrt(x) (Python 3.8+): Devuelve la raíz cuadrada entera de x (trunca el resultado a un entero).
math.lcm(*integers) (Python 3.9+): Devuelve el mínimo común múltiplo de los enteros dados.
2 Que debo conocer para cálculo diferencial
El módulo estándar math de Python no ofrece funciones para cálculo diferencial (derivadas, integrales, límites, etc.). Este tipo de funcionalidad se suele obtener mediante librerías externas, especialmente:
sympy: Una librería de Python para matemáticas simbólicas que permite hacer derivadas, integrales, límites y simplificaciones de expresiones de forma analítica (exacta).
scipy: Proporciona herramientas para el cálculo científico numérico, entre ellas funciones para diferencias finitas, integraciones numéricas, interpolación, entre otras.
A continuación, se presentan las funciones y métodos más comunes en el contexto del cálculo diferencial usando sympy, ya que es la librería más habitual para este propósito:
Derivadas:
sympy.diff(expr, var[, n]): Calcula la derivada de expr con respecto a la variable var.
Ejemplo: diff(x**2, x) da 2*x.
Se puede pasar un argumento n adicional para derivadas de orden superior: diff(x**3, x, 2) da 6.
Límites:
sympy.limit(expr, var, a): Calcula el límite de expr cuando la variable var tiende a a.
Ejemplo: limit(sin(x)/x, x, 0) da 1.
Integración:
sympy.integrate(expr, var): Calcula la integral indefinida de expr con respecto a var.
Ejemplo: integrate(x**2, x) da x^3/3.
sympy.integrate(expr, (var, a, b)): Calcula la integral definida de expr desde a hasta b.
Ejemplo: integrate(x, (x, 0, 1)) da 1/2.
Diferenciación simbólica múltiple:
Puedes derivar con respecto a múltiples variables: diff(x*y, x) da y, diff(x*y, y) da x.
Derivadas parciales de funciones multivariables: diff(x**2*y + y**2, x) da 2*x*y, diff(x**2*y + y**2, y) da x^2 + 2*y.
Otras funciones relacionadas con el cálculo:
sympy.series(expr, var, a, n): Expande expr en una serie alrededor del punto a hasta el orden n. Útil para aproximar funciones y estudiar su comportamiento local (relacionado con el cálculo diferencial).
sympy.dsolve(eq): Resuelve ecuaciones diferenciales simbólicamente (necesita que definas la ecuación usando sympy.Eq y funciones simbólicas).
Si necesitas aproximar derivadas numéricamente (en lugar de derivadas simbólicas exactas), scipy ofrece algunas herramientas:
scipy.misc.derivative(func, x0, dx=1e-6): Aproxima numéricamente la derivada de func en el punto x0 usando diferencias finitas.
scipy.integrate: Contiene funciones como quad, dblquad, nquad, y otras para integrar funciones numéricas sobre diferentes intervalos.
numpy.gradient(arr): Calcula la aproximación numérica del gradiente de un arreglo (útil si tienes datos discretos y quieres aproximar la derivada).
Cálculo diferencial simbólico (exacto): Usar sympy.diff para derivadas, sympy.integrate para integrales, sympy.limit para límites.
Cálculo diferencial numérico (aproximaciones): Usar scipy.misc.derivative o numpy.gradient.
Dado que math no cubre estas operaciones, la recomendación es emplear sympy para cálculo analítico y scipy/numpy para aproximaciones numéricas.
Que debo conocer para gráfica
Para realizar gráficos en 2D y 3D en Python, la biblioteca más común y ampliamente utilizada es Matplotlib. Además, existen otras herramientas que permiten estilos más avanzados o interactividad, como Seaborn, Plotly o Bokeh. A continuación se describen las nociones básicas y librerías más destacadas:
Instalación:
bash
Copiar código
pip install matplotlib
Uso básico (2D):
python
Copiar código
import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y = [2, 4, 1, 8, 7]
plt.plot(x, y, label='Datos')
plt.xlabel('Eje X')
plt.ylabel('Eje Y')
plt.title('Ejemplo de Gráfico 2D')
plt.legend()
plt.show()
Con este ejemplo se crea una gráfica de líneas simple. plt.plot() puede recibir múltiples opciones para controlar color, estilos de línea, marcadores, etc.
Gráficos más comunes en 2D:
plt.plot() para líneas.
plt.scatter() para dispersión.
plt.bar() para barras.
plt.hist() para histogramas.
plt.pie() para diagramas de pastel.
También se pueden crear subplots (plt.subplot()) para colocar múltiples gráficos en una misma ventana.
Graficar en 3D con Matplotlib: Para gráficos en 3D se utiliza el toolkit mplot3d que viene con Matplotlib. Necesitas crear un objeto Axes3D:
python
Copiar código
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# Ejemplo: Superficie sencilla
X = np.linspace(-5, 5, 50)
Y = np.linspace(-5, 5, 50)
X, Y = np.meshgrid(X, Y)
Z = np.sin(np.sqrt(X**2 + Y**2))
ax.plot_surface(X, Y, Z, cmap='viridis')
ax.set_xlabel('Eje X')
ax.set_ylabel('Eje Y')
ax.set_zlabel('Eje Z')
plt.show()
Aquí, plot_surface() traza una superficie 3D. También se dispone de scatter(), plot3D(), contour3D(), etc.
Instalación:
bash
Copiar código
pip install seaborn
Uso básico:
python
Copiar código
import seaborn as sns
import matplotlib.pyplot as plt
# Ejemplo con datos aleatorios
data = [2,4,1,8,7]
sns.lineplot(x=range(len(data)), y=data)
plt.show()
Seaborn se integra con Matplotlib, ofreciendo una apariencia más atractiva y funciones diseñadas para el análisis estadístico (dispersiones, regresiones, distribuciones, etc.).
Plotly:
Permite crear gráficos interactivos que pueden visualizarse en el navegador.
bash
Copiar código
pip install plotly
Ejemplo sencillo:
python
Copiar código
import plotly.express as px
df = px.data.iris()
fig = px.scatter(df, x="sepal_width", y="sepal_length", color="species")
fig.show()
Bokeh:
Similar a Plotly, se usa en el navegador con visualizaciones interactivas.
bash
Copiar código
pip install bokeh
Conocer NumPy:
Muchas veces los datos para graficar están en arreglos NumPy, de modo que saber crear, manipular y filtrar arrays es importante.
Conocer Pandas:
Para datos tabulares, Pandas facilita el manejo y preparación de datos antes de graficarlos. Muchas funciones de Plotly o Seaborn pueden funcionar directamente con DataFrames.
Entender el pipeline de figuras en Matplotlib:
Saber controlar aspectos del gráfico como títulos, ejes, límites, leyendas y estilos a través de las funciones de Matplotlib o su interfaz orientada a objetos (fig, ax = plt.subplots()).
Controlar la estética:
Matplotlib permite cambiar temas (usando plt.style.use('...')), Seaborn dispone de estilos predeterminados (sns.set_theme()), y Plotly tiene templates. Conocer estas opciones ayuda a crear visualizaciones más claras y profesionales.
3D, interactividad y animaciones:
Para 3D, además de Matplotlib, librerías como Mayavi o Plotly pueden proporcionar herramientas más avanzadas o interactivas.
Para animaciones en Matplotlib se usa FuncAnimation del módulo matplotlib.animation.
Para visualizaciones interactivas (zoom, panning), Plotly es una gran opción.
En resumen, para empezar a graficar 2D y 3D en Python, se recomienda familiarizarse con Matplotlib, luego explorar Seaborn para gráficos más estéticos y estadísticos, y finalmente considerar Plotly o Bokeh si se busca interactividad. Con el tiempo, también es útil aprender sobre NumPy y Pandas para preparación de datos.