Sabemos que al considerar una función $f(x)$ podemos graficar ésta dando algunos valores representativos a la variable independiente $x$ para ver el comportamiento de $f(x)$. Por ejemplo, considerando la función $f(x)=x^{2}$ podemos considerar los valores
lo cual nos brinda algunas parejas ordenadas que podemos graficar. A continuación graficaremos los puntos obtenidos, para ello importaremos el módulo necesario, que en este caso es matplotlib.pyplot; notemos que después de importar el módulo colocamos as el cual nos permite asignar un alias cuando ocupemos sentencias referentes a dicho módulo (el alias puede ser cualquiera, en nuestro caso colocamos mplot.). Después necesitaremos de dos sentencias básicas: mplot.plot() para graficar y mplot.show() para mostrar la gráfica creada. Dentro de los parámetros de mplot.plot() colocamos las coordenadas $(x,y)$ del punto que deseamos graficar seguido de marker="" para el tipo de marcador que deseamos utilizar; asimismo podemos agregar el color que deseamos utilizando color=""
import matplotlib.pyplot as mplot
mplot.plot(-2,4, marker="o", color="r")
mplot.plot(-1,1, marker="o", color="g")
mplot.plot(0,0, marker="v", color="c")
mplot.plot(1,1, marker="^", color="b")
mplot.plot(2,4, marker="*", color="m")
mplot.show()
Ahora bien, todos los puntos los pondremos en un sólo formato con marker="o" y de color negrocolor="k". Dibujaremos ahora los ejes cartesianos, para ello emplearemos un bucle while.
mplot.plot(x,0, marker = "_", color = "k"), recordemos que sobre el eje $x$ el valor de la ordenada $y$ es cero. Después dibujaremos repetidamente ese punto haciendo que el valor de $x$ aumente para que, de este modo, pueda dibujarse la línea.mplot.plot(0,y, marker = "_", color = "k"). Es preciso colocar un incremento dentro del bucle para que éste no sea un bucle infinito, además, el incremento será muy pequeño para realizar el dibujo de muchísimos puntos que a nuestra vista parecerán una línea.# eje y
# inicialiamos la variable y
y = -1
# empleamos el bucle sobre el rango de valores en que estará el eje
while y <= 4 and y >= -1:
mplot.plot(0,y, marker="|", color="k")
y += 0.05
# ---------------------------------------------------------------------
# eje x
x = -2
while x <= 2 and x >= -2:
mplot.plot(x,0, marker="_", color="k")
x += 0.05
# ---------------------------------------------------------------------
mplot.plot(-2,4, marker="o", color="k")
mplot.plot(-1,1, marker="o", color="k")
mplot.plot(0,0, marker="o", color="k")
mplot.plot(1,1, marker="o", color="k")
mplot.plot(2,4, marker=".", color="k")
mplot.show()
Ahora, emplearemos la misma idea de cómo dibujamos los ejes para dibujar la gráfica de la función $f(x)=x^{2}$. Para evitar confución entre el manejo de la variables, reservaremos exclusivamente x y y para los ejes. De tal manera, si deseamos graficar $f(x)=y$, emplearemos el ajuste de las variables como $f(u)=v$. Así, la función que deseamos graficar es $f(u)={u^{2}}$:
# eje x
y = -1
while y <= 4 and y >= -1:
mplot.plot(0,y, marker="|", color="k")
y += 0.05
# ---------------------------------------------------------------------
# eje x
x = -2
while x <= 2 and x >= -2:
mplot.plot(x,0, marker="_", color="k")
x += 0.05
# ---------------------------------------------------------------------
# puntos obtenidos anteriormente
mplot.plot(-2,4, marker="o", color="r")
mplot.plot(-1,1, marker="o", color="r")
mplot.plot(0,0, marker="o", color="r")
mplot.plot(1,1, marker="o", color="r")
mplot.plot(2,4, marker="o", color="r")
# dibujo de la función f(u)=u^2
u = -2
while u <= 2 and u >= -2:
mplot.plot(u,u ** 2, marker=".", color = "k")
u += 0.05
mplot.show()
Nótese que aún no conseguimos que la función tome la forma de una curva, continúa viéndose como muchos puntos consecutivos. Para marker="." tenemos el tipo de marcador punto como puede verse en el gráfico anterior, dado que éstos puntos se ven un poco gruesos utilizaremos en cambio marker="," el cual marca un tipo de pixel.
# eje x
y = -1
while y <= 4 and y >= -1:
mplot.plot(0,y, marker="|", color="k")
y += 0.05
# ---------------------------------------------------------------------
# eje x
x = -2
while x <= 2 and x >= -2:
mplot.plot(x,0, marker="_", color="k")
x += 0.05
# ---------------------------------------------------------------------
# puntos obtenidos anteriormente
mplot.plot(-2,4, marker="o", color="r")
mplot.plot(-1,1, marker="o", color="r")
mplot.plot(0,0, marker="o", color="r")
mplot.plot(1,1, marker="o", color="r")
mplot.plot(2,4, marker="o", color="r")
# dibujo de la función f(u)=u^2
u = -2
while u <= 2 and u >= -2:
mplot.plot(u,u ** 2, marker=",", color = "k")
u += 0.005
mplot.show()
Podemos graficar otras funciones como:
# eje x
y = -3
while y <= 5 and y >= -3:
mplot.plot(0,y, marker="|", color="k")
y += 0.05
# ---------------------------------------------------------------------
# eje x
x = -2
while x <= 2 and x >= -2:
mplot.plot(x,0, marker="_", color="k")
x += 0.05
# ---------------------------------------------------------------------
# Algunos puntos
mplot.plot(0,1, marker="o", color="r")
mplot.plot(-0.5,0, marker="o", color="r")
# dibujo de la función f(u)=u^2
u = -2
while u <= 2 and u >= -2:
mplot.plot(u,2 * u + 1, marker=",", color = "b")
u += 0.005
mplot.show()
Ahora bien para acceder a más funciones matemáticas importaremos el módulo math y graficaremos las funciones $f(x)=sen(x)$, $g(x)=\sqrt{x}$ y $h(x)=ln(x)$:
import math
# ---------------------------------------------------------------------
# eje x
y = -1.5
while y <= 1.5 and y >= -1.5:
mplot.plot(0,y, marker="|", color="k")
y += 0.05
# ---------------------------------------------------------------------
# eje x
x = -2
while x <= 2 and x >= -2:
mplot.plot(x,0, marker="_", color="k")
x += 0.05
# ---------------------------------------------------------------------
# dibujo de la función f(u)=sen(u)
u1 = -2
while u1 <= 2 and u1 >= -2:
mplot.plot(u1,math.sin(u1), marker=",", color = "b")
u1 += 0.005
# dibujo de la función g(u)=sqrt(u)
u2 = 0
while u2 <= 2 and u2 >= -2:
mplot.plot(u2,math.sqrt(u2), marker=",", color = "r")
u2 += 0.005
# dibujo de la función h(u)=ln(u)
u3 = 0.5
while u3 <= 2 and u3 >= -2:
mplot.plot(u3,math.log(u3), marker=",", color = "m")
u3 += 0.005
mplot.show()
Podemos dibujar una circunferencia
# eje x
y = -2
while y <= 2 and y >= -2:
mplot.plot(0,y, marker="|", color="k")
y += 0.05
# ---------------------------------------------------------------------
# eje x
x = -2
while x <= 2 and x >= -2:
mplot.plot(x,0, marker="_", color="k")
x += 0.05
# ---------------------------------------------------------------------
# dibujo de la función f(u)=sen(u)
u4 = -1
while u4 <= 1 and u4 >= -1:
mplot.plot(u4, math.sqrt(1 - u4 ** 2), marker=".", color = "b")
u4 += 0.005
u5 = -1
while u5 <= 1 and u5 >= -1:
mplot.plot(u5, - math.sqrt(1 - u5 ** 2), marker=".", color = "b")
u5 += 0.005
mplot.show()
El método anterior plantea un problema pues al realizar muchas iteraciones el tiempo de copilación aumentará. De hecho, el método empleado anteriormente es más ilustrativo que útil; a continuación utilizaremos el módulo sympy. Para ello
from sympy import symbols
from sympy.plotting import plot
Ahora, recordemos que utilizamos x en Python como una variable a la cual podemos asignarle un valor e ir cambiando ese valor, pero en todo momento el valor que pueda tomar x debe estar declarado. Sin embargo, sabemos que en matemáticas podemos utilizar la variable $x$ que represente un número cualquiera sin especificar cuál es. Para trabajar con variables matemáticas en Python utilizaremos symbols(""). Por ejemplo, si deseamos considerar a x como una variable matemática hacemos que
x = symbols("x")
Notemos que estamos trabajando con x sin haber declarado un valor previo como lo haciamos si deseabamos trabajar con la variable x dentro de Python. Ahora si podemos utilizar x como una variable del álgebra, por ejemplo podemos efectuar cálculos como $x+x$, $x\cdot x$, etcétera. En efecto
print(x + x + x)
print(x + 2)
print(x * x * 2)
3*x x + 2 2*x**2
Ahora bien, podemos graficar funciones de una manera más sencilla, por ejemplo
x = symbols("x")
plot(x ** 2, (x, -2, 2), title="Función cuadrática", line_color="red")
<sympy.plotting.plot.Plot at 0x209042b8388>
donde dentro de plot() colocamos primero la función a graficar y después, entre paréntesis, colocamos el símbolo referente a la variable independiente matemática, seguido del intervalo donde graficaremos. Podemos graficar más funciones en un mismo plano:
plot(x ** 2, x + 1,(x, -2, 2))
<sympy.plotting.plot.Plot at 0x20903b9dac8>
o también agrupar las funciones a graficar junto con sus valores referentes al dominio de graficación entre paréntesis, esto es
plot( (x ** 2, (x, -2, 2)), (x + 1, (x, 0, 3)), line_color = "red" )
<sympy.plotting.plot.Plot at 0x20626d0f148>
En realidad el tercer método es una afinación del primer método, de tal manera volveremos a utilizar el módulo matplotlib y además agregaremos el módulo numpy. Bien, lo primero que necesitamos para graficar una función es definir el dominio de graficación, para ello utilizamos
import matplotlib.pyplot as mplot
import numpy as np
# definimos el rango adecuado
x = np.arange(-1,1, 0.01)
donde el rango de graficación será en el intervalo sobre $x$ de $[-1,1)$ con un incremento de $0.01$. Prosigamos graficando la función $f(x)=x^{3}$, para ello
x = np.arange(-1,1, 0.01)
# definimos la función f(x)=y
y = x ** 3
# creamos la gráfica
mplot.plot(x, y)
# agregamos algunos puntos
mplot.plot(0,0, marker="o", color="r")
mplot.plot(1,1, marker="o", color="r")
mplot.plot(-1,-1, marker="o", color="r")
# mostramos la cuadrícula en el gráfico (opcional)
mplot.grid()
# mostramos la gráfica
mplot.show()
Otro ejemplo:
# Definimos el rango de graficación
x = np.arange(-5,5, 0.01)
# definimos la función f(x)=y
y = np.sin(x)
# creamos la gráfica
mplot.plot(x, y)
# mostramos la cuadrícula en el gráfico (opcional)
mplot.grid()
# mostramos la gráfica
mplot.show()
Podemos agregar más funciones a la gráfica, por ejemplo
# Definimos el rango de graficación
x = np.arange(-5,5, 0.01)
# definimos la primer función y1
y1 = np.sin(x)
# definimos la segunda función y2
y2 = np.cos(x)
# creamos la gráfica
mplot.plot(x, y1)
mplot.plot(x, y2)
# mostramos la cuadrícula en el gráfico (opcional)
mplot.grid()
# mostramos la gráfica
mplot.show()
Podemos cambiar el dominio de graficación de cada función:
# Definimos el rango de graficación de la primer función
x1 = np.arange(-3,3, 0.01)
# Definimos el rango de graficación de la segunda función
x2 = np.arange(0,3, 0.01)
# definimos la primer función y1
y1 = x1 ** 2
# definimos la segunda función y2
y2 = 2 * x2
# creamos la gráfica
mplot.plot(x1, y1)
mplot.plot(x2, y2)
# mostramos un punto
mplot.plot(2,4, marker = "o", color = "k")
# mostramos la cuadrícula en el gráfico (opcional)
mplot.grid()
# mostramos la gráfica
mplot.show()
Ahora, es posible agregar el título de un gráfico correspondiente, esto lo conseguimos utilizando labe="" dentro de mplot.plot() y para que dicho título se muestre usamos mplot.legend():
x1 = np.arange(-3,3, 0.01)
x2 = np.arange(0,3, 0.01)
y1 = x1 ** 2
y2 = 2 * x2
# creamos la gráfica con los títulos correspondientes (podemos utilizar látex)
mplot.plot(x1, y1, label = "$f(x)=x^{2}$")
mplot.plot(x2, y2, label = "$g(x)=2x$")
# mostramos un punto
mplot.plot(2,4, marker = "o", color = "k", label = "$P(2,4)$")
# mostramos la cuadrícula en el gráfico (opcional)
mplot.grid()
# mostramos la gráfica con los títulos
mplot.legend()
mplot.show()
