Curso de introducción a la programación con Python¶

    Autor: Luis Fernando Apáez Álvarez
    -Curso PyM-
    Proyecto 1: Conocimientos previos
    Fecha: 27 de Agosto del 2022

Proyecto 1¶

Contenido:¶

  1. Librería Tkinter
    2.
    • Etiquetas
      •
    • Botones
      •
    • Grid Manager
      •
    • Cajas de entrada
      •
    • Menús
      •
  2. Librería SymPy
    3.
    • Teoría
      •
    • Símbolos matemáticos
      •
    • Cálculo de límites y derivadas
      •

Librerías que ocuparemos en este proyecto:

  • Tkinter
  • SymPy


Librería Tkinter ¶

Introducción¶

Tkinter es una librería en Python que nos permite crear interfaces gráficas de usuario (también denominadas GUI por sus siglas en inglés), las cuales conforman un entorno visual de imágenes y objetos (o componentes) y que permiten la interacción entre la máquina y los usuarios. De tal manera, esta librería representa una herramienta que puede ser utilizada para desarrollar aplicaciones de escritorio. Mediante esta librería podemos crear interfaces como:

img1

Así, ocuparemos tkinter para crear la interfaz gráfica de nuestro proyecto, por lo cual, primero, abordaremos en los conceptos más básicos sobre dicha librería.





Para comenzar, importaremos la librería necesaria:

In [1]:
import tkinter as tk

Luego, el primer componente que requerimos para nuestra interfaz gráfica es una ventana:

In [4]:
# Creamos un objeto ventana
ventana = tk.Tk()

# Configuramos el tamanio de nuestra ventana:
# sera de 600 px por 400px
ventana.geometry('600x400')

# Colocamos un titulo a nuestra ventana
ventana.title('Nuestra primer ventana')

# Finalmente, mostramos la ventana creada:
ventana.mainloop()

Después de ejecutar el código anterior se nos debe de mostrar la ventana creada, la cual debe ser de la forma:

tk1.PNG

Etiquetas ¶

Vemos que la ventana creada aún no tiene contenido. Lo que haremos a continuación será agregar un texto (o una etiqueta) a dicha ventana, para lo cual utilizaremos el método tk.Label(ventana, text="<texto que queremos mostrar>"), debemos colocar como primer parámetro el nombre de la ventana donde queremos que se muestre el texto, como queremos que el texto se muestra en la ventana que creamos antes, entonces colocamos ventana en dicho parámetro.

In [5]:
# Creamos un objeto ventana
ventana = tk.Tk()
# Configuramos el tamanio de nuestra ventana:
# sera de 600 px por 400px
ventana.geometry('600x400')
# Colocamos un titulo a nuestra ventana
ventana.title('Nuestra primer ventana')

# -------------------------------------------
# -------------------------------------------
# agregamos texto a nuestra ventana
etiqueta1 = tk.Label(ventana, text='Hola Mundo')

# ubicamos dicha etiqueta en la coordenada x=100 
# y y=100 de nuestra ventana, para lo cual utilizamos
# el metodo place()
etiqueta1.place(x=100, y=100)
# -------------------------------------------
# -------------------------------------------

# Finalmente, mostramos la ventana creada:
ventana.mainloop()

tk2.PNG

Botones ¶

Lo que haremos ahora será agregar botones a nuestra ventana, para así comenzar a implementar funcionalidades en nuestra interfaz gráfica. Para utilizar botones, y en realidad muchos otros más componentes, ocuparemos el módulo ttk de la librería tkinter, por lo cual deberemos importar este módulo. Luego, para crear un botón escribimos ttk.Button(ventana, text="<texto del boton>", command=<funcionalidad a realizar>), donde, como ya sabemos, debemos especificar la ventana en la cual queremos agregar nuestro botón; después, el texto que queremos colocar en dicho botón y finalmente la funcionalidad o acción que hará nuestro botón al ser presionado, por el momento nuestro botón no hará nada.

In [6]:
from tkinter import ttk
# -------------------------------------------
# -------------------------------------------

# Creamos un objeto ventana
ventana = tk.Tk()
# Configuramos el tamanio de nuestra ventana:
# sera de 600 px por 400px
ventana.geometry('600x400')
# Colocamos un titulo a nuestra ventana
ventana.title('Nuestra primer ventana')
# agregamos texto a nuestra ventana
etiqueta1 = tk.Label(ventana, text='Hola Mundo')
# ubicamos dicha etiqueta en la coordenada x=100 
# y y=100 de nuestra ventana
etiqueta1.place(x=100, y=100)

# -------------------------------------------
# -------------------------------------------
# Agregamos un boton
boton1 =  ttk.Button(ventana, text='Boton1')
# ubicacion del boton
boton1.place(x=100, y=150)
# -------------------------------------------
# -------------------------------------------

# Finalmente, mostramos la ventana creada:
ventana.mainloop()

tk3.PNG

notamos que la coordenada y conforme aumenta, aumenta en dirección hacía abajo.

Para que nuestro botón realice alguna acción debemos definir previamente una función que ejecute dicha acción. Así, lo que haremos es que nuestro botón, el cual creamos antes, muestre una nueva etiqueta en nuestra ventana

In [7]:
# Creamos un objeto ventana
ventana = tk.Tk()
# Configuramos el tamanio de nuestra ventana:
# sera de 600 px por 400px
ventana.geometry('600x400')
# Colocamos un titulo a nuestra ventana
ventana.title('Nuestra primer ventana')
# agregamos texto a nuestra ventana
etiqueta1 = tk.Label(ventana, text='Hola Mundo')
# ubicamos dicha etiqueta en la coordenada x=100 
# y y=100 de nuestra ventana
etiqueta1.place(x=100, y=100)

# -------------------------------------------
# -------------------------------------------
# Definimos la accion que hara nuestro boton
# mediante la siguiente funcion
def accion1() -> None:
    """Función asociada al boton1 que
    agregará una nueva etiqueta en la ventana"""
    etiqueta2 = tk.Label(ventana, text='Adios Mundo')
    etiqueta2.place(x=100, y=200)
# -------------------------------------------
# -------------------------------------------

# Agregamos un boton.
# Asociamos la accion1 con el boton 1 mediante
# command=accion1
boton1 =  ttk.Button(ventana, text='Boton1', command=accion1)
# ubicacion del boton
boton1.place(x=100, y=150)

# Finalmente, mostramos la ventana creada:
ventana.mainloop()

tk4.PNG

Grid manager ¶

Podemos considerar a nuestra ventana como un plano coordenado, de modo que las posiciones de los componentes, así como lo vimos antes, estarán posicionados mediante coordenadas. Notamos que la manera en que estuvimos colocando las coordenadas de nuestros componentes realmente no era la óptima, pues si quisieramos colocar muchos otros más componentes tendríamos que estar jugando con las coordenadas para colocar todos estos en la posición que deseamos. Una manera más precisa de utilizar las coordenadas es mediante el método grid(row=n, column=m) que divide toda nuestra ventana en filas (n) y columnas (m). Por ejemplo, podemos llegar a considerar nuestra ventana como una cuadrícula de 4 filas por 4 columnas y un sistema coordenado como se muestra a continuación

In [1]:
linea = "-" * 69
print("{:65}".format(linea))
for i in range(4):
    print("|{:^16}|{:^16}|{:^16}|{:^16}|".format(f"({i},{0})", 
                                                 f"({i},{1})",
                                                 f"({i},{2})", 
                                                 f"({i},{3})"))
    print("{:65}".format(linea))

---------------------------------------------------------------------
|     (0,0)      |     (0,1)      |     (0,2)      |     (0,3)      |
---------------------------------------------------------------------
|     (1,0)      |     (1,1)      |     (1,2)      |     (1,3)      |
---------------------------------------------------------------------
|     (2,0)      |     (2,1)      |     (2,2)      |     (2,3)      |
---------------------------------------------------------------------
|     (3,0)      |     (3,1)      |     (3,2)      |     (3,3)      |
---------------------------------------------------------------------

De tal manera, utilizando el sistema coordenado anterior podemos, por ejemplo, colocar un botón en el espacio (2,1), o colocar una etiqueta en el espacio (3,3), etcétera. Ahora bien, nuestras ventanas pueden tener más filas o más columnas, así como menos filas o menos columnas, dependiendo del tamaño con el cual las hayamos configurado (lo cual hacemos, por ejemplo, escribiendo ventana.geometry('600x400')).

Por ejemplo, vamos a crear dos botones y los posicionaremos utilizando el método grid():

In [11]:
# Creamos un objeto ventana
ventana = tk.Tk()
# Configuramos el tamanio de nuestra ventana:
# sera de 600 px por 400px
ventana.geometry('600x400')
# Colocamos un titulo a nuestra ventana
ventana.title('Manejo de Grid')

# -------------------------------------------
# -------------------------------------------
# Definimos la accion1 que hara nuestro boton1
# mediante la siguiente funcion
def accion1() -> None:
    """Función asociada al boton1 que
    que cambiará la etiqueta colocada en
    este botón"""
    # Para cambiar la etiqueta de un boton 
    # utilizamos el metodo config()
    boton1.config(text='Botón 1 presionado')
    
# Definimos la accion2 que hara nuestro boton2
# mediante la siguiente funcion
def accion2() -> None:
    """Función asociada al boton2 que
    que cambiará la etiqueta colocada en
    este botón"""
    # Para cambiar la etiqueta de un boton 
    # utilizamos el metodo config()
    boton2.config(text='Botón 2 presionado')
    
# Creamos los botones:
# Asociamos la accion1 con el boton 1.
# Asociamos la accion2 con el boton 2.

boton1 =  ttk.Button(ventana, text='Boton one', command = accion1)
# ubicacion del boton utilizando el metodo grid
# colocamos el boton en la primer fila y primer columna
boton1.grid(row=0, column=0)

boton2 =  ttk.Button(ventana, text='Boton two', command = accion2)
# ubicacion del boton utilizando el metodo grid
# colocamos el boton en la primer fila y segunda columna
boton2.grid(row=0, column=1)

# Adicionalmente agregamos una etiqueta en la segunda fila y
# segunda columna
etiqueta1 = tk.Label(ventana, text='Genial!')
etiqueta1.grid(row=1, column=1)
# -------------------------------------------
# -------------------------------------------

# Finalmente, mostramos la ventana creada:
ventana.mainloop()

tk5.PNG

Cajas de entrada ¶

Ahora, aprenderemos a crear cajas de entrada en la cual podemos ingresar texto. Un ejemplo muy sencillo de caja de entrada es la que se nos despliega al utilizar la función input()

In [12]:
cj = input("Lo siguiente es una caja de entrada: ")

Lo siguiente es una caja de entrada: Estoy escribiendo dentro de una caja de entrada

Para crear cajas de entrada utilizamos el método Entry() del módulo ttk escribiendo (por ejemplo):

#                        capacidad de | justificacion
#                        caracteres   | del texto ingresado
entrada1 = ttk.Entry(ventana, width=30, justify=tk.CENTER)

además, podemos hacer que el texto que ingresamos en dicha caja se visualice sólo con el caracter * repetidamente, así como observamos cuando ingresamos una contraseña en alguna interfaz gráfica. Para ello sólo debemos agregar un parámetro adicional al método Entry() el cual es show='*'.

In [13]:
# Creamos un objeto ventana
ventana = tk.Tk()
# Configuramos el tamanio de nuestra ventana:
# sera de 600 px por 400px
ventana.geometry('600x400')
# Colocamos un titulo a nuestra ventana
ventana.title('Cajas de entrada')

# -------------------------------------------
# -------------------------------------------
# Creamos una etiqueta en la primer fila y primer
# columna
etiqueta1 = tk.Label(ventana, text='Nombre:')
etiqueta1.grid(row=0, column=0)

# Creamos una primer caja de entrada en la primer fila
# y segunda columna
entrada1 = ttk.Entry(ventana, width=30, justify=tk.CENTER)
entrada1.grid(row=0, column=1)

# Creamos una segunda etiqueta en la segunda fila y primer
# columna
etiqueta2 = tk.Label(ventana, text='Password:')
etiqueta2.grid(row=1, column=0)

# Creamos una segunda caja de entrada en la segunda fila
# y segunda columna. Simulara ser una caja de entrada
# correspondiente a un password
entrada2 = ttk.Entry(ventana, width=30, justify=tk.CENTER, show='*')
entrada2.grid(row=1, column=1)
# -------------------------------------------
# -------------------------------------------

# Finalmente, mostramos la ventana creada:
ventana.mainloop()

tk6.PNG

Menús ¶

Finalmente agregaremos menús desplegables a nuestra ventana, para lo cual importaremos el objeto Menu de la librería tkinter.

In [14]:
from tkinter import Menu

# -------------------------------------------
# -------------------------------------------

# Creamos un objeto ventana
ventana = tk.Tk()
# Configuramos el tamanio de nuestra ventana:
# sera de 600 px por 400px
ventana.geometry('600x400')
# Colocamos un titulo a nuestra ventana
ventana.title('Ventana con un menú')

# -------------------------------------------
# -------------------------------------------
# Creamos nuestro menu en la ventana _ventana_
menu_principal = Menu(ventana)

# Creamos un menu que actue como un submenu del
# menu principal
#                              hace que el submenu se
#                              quede adherido a la ventana
submenu = Menu(menu_principal, tearoff=False)

# Agregamos opciones al submenu
submenu.add_command(label='Nuevo')
submenu.add_command(label='Salir')

# Agregamos el submenu al menu principal:

#                        nombre que le | submenu que 
#                        asignamos al  | agregamos al menu
#                        menu          | principal
menu_principal.add_cascade(label='Menú', menu = submenu)

# Agregamos a nuestra ventana el menu denominado
# menu_principal
ventana.config(menu = menu_principal)

# -------------------------------------------
# -------------------------------------------
# Finalmente, mostramos la ventana creada:
ventana.mainloop()

tk7.1.PNG

tk7.2.PNG

Librería SymPy ¶

Esta librería es ocupada para el uso de matemáticas simbólicas, cuyo objetivo es ser un sistema completo de álgebra computacional (así como Maple o Mathematica). Nosotros ocuparemos esta librería para calcular límites y derivadas de funciones arbitrarias. Antes de ello veremos un breve (muy breve) repaso de tales conceptos.

Teoría ¶

La idea intuitiva de límite coincide con la idea de aproximación. Por ejemplo, cuando intentamos calcular $\lim\limits_{x\rightarrow 3}x^{2}$, intentamos hallar el valor próximo (no igual) de la función $f(x)=x^{2}$ cuando $x$ se aproxima o tiende al valor de 3. Con lo anterior podemos realizar algunas aproximaciones para obtener el valor de dicho límite:

In [3]:
# Definimos la funcion
def f(x):
    return x ** 2

# nos aproximamos al valor de 3 con valores
# muy cercanos tanto menores a este como mayores:
# 2.9, 2.91, ..., 2.99, 3, 3.01, 3.02, ..., 3.1
x_aprox = [ 3 + 0.01 * i for i in range(-10, 11) if 3 + 0.01 * i != 3]

# Despues vemos los valores que toma la funcion 
# de acuerdo a los valores anteriores
for x in x_aprox:
    print(f"f({x})={f(x)}")

f(2.9)=8.41
f(2.91)=8.468100000000002
f(2.92)=8.526399999999999
f(2.93)=8.584900000000001
f(2.94)=8.6436
f(2.95)=8.7025
f(2.96)=8.7616
f(2.97)=8.820900000000002
f(2.98)=8.8804
f(2.99)=8.940100000000001
f(3.01)=9.060099999999998
f(3.02)=9.1204
f(3.03)=9.1809
f(3.04)=9.2416
f(3.05)=9.302499999999998
f(3.06)=9.3636
f(3.07)=9.4249
f(3.08)=9.4864
f(3.09)=9.5481
f(3.1)=9.610000000000001

vemos que, cuando nos acercamos al valor de $x=3$ con valores menores, la función $f(x)$ se aproxima al valor de 9; de manera análoga, cuando nos acercamos al valor de $x=3$ con valores mayores, de nuevo, la función $f(x)$ se aproxima al valor de 9. Concluimos entonces que $\lim\limits_{x\rightarrow 3}x^{2}=9$. Básicamente esa es la idea detrás de los límites, pero el objetivo de esta clase será resolver límites utilizando cierto código en Python mediante la librería SymPy.

Por otra parte, podemos recordar que, para el cálculo de derivadas, podíamos basarnos en fórmulas. Por ejemplo, teníamos la siguiente fórmula

$$ \frac{d}{dx}x^{n} = n x^{n-1}, \ \ \ \ \ n\neq 0 $$

Si consideramos la función $f(x)=x^{2}$, tenemos entonces, utilizando la fórmula anterior, que

$$ \frac{d}{dx}x^{2} = 2x^{2-1}=2x $$

De nuevo, el cálculo de derivadas lo implementaremos mediante la librería SymPy, como lo haremos en seguida.

Símbolos matemáticos ¶

Recordemos que en Python podemos asignarle cualquier nombre a nuestras variables, siguiendo ciertas normas. Así que, sin problema alguno, podemos definir variables con los nombres x, y, etcétera. Notemos que todas las variables que hemos ocupado en Python tienen un valor dado, un valor que previamente, de antemano, conocemos. Asimismo, dentro de matemáticas está la noción de variable, digamos $x$, la cual, en primera instancia, puede representar cualquier número y que de manera certera desconocemos. Por ejemplo, si definimos una variable x en Python, entonces operaciones como

2 * x + 5 * x - 2

seguramente nos darán un número fijo; si por ejemplo x tiene asignado el valor de 0, entonces la operación anterior nos dará como resultado el número fijo 0; si cambiamos el valor de x, la operación anterior nos dará un número fijo distinto. No obstante, en todo momento x debe tener asignado un valor, pues de lo contrario Python nos arrojará un error. De tal manera, con lo anterior no podemos "jugar" con la idea de que x represente a un número cualquiera.

Por ejemplo, recordemos de nuestros cursos básicos de álgebra que:

$$ 2\cdot x + 5\cdot x - 2 = 7\cdot x - 2 $$

es decir, podemos simplificar la expresión algebraica sumando los términos semejantes, donde, en primera instancia, no conocemos el valor de la $x$ pues ésta representa la noción de un número cualquiera, sin embargo, aún así podemos realizar operaciones como la anterior.

Notamos entonces las diferencias entre una variable en Python (la cual siempre tiene un valor asignado) y las variables matemáticas (las cuales pueden representar la idea de un número cualesquiera). De tal manera, para que Python logre diferenciar estos dos tipos de variables, especificaremos a las variables matemáticas como símbolos matemáticos.

Ahora, simplificaremos la expresión $2\cdot x + 5\cdot x - 2$ utilizando Python. Para especificarle a Python que una variable es simbólica utilizaremos el método symbols() de la librería SymPy, donde en el parámetro colocamos una cadena de texto que hace alusión al nombre que tendrá dicha variable matemática. Así, por ejemplo, si queremos definir una variable x que sea simbólica, es decir que sea una variable matemática, escribiremos symbols('x'). Vamos a ello:

In [2]:
# Importamos la libreria necesaria
import sympy as sp

# Definimos una variable denominada x
# a la cual la consideraremos como un simbolo
# matematico
x = sp.symbols('x')

# Definimos una variable denominada y
# a la cual la consideraremos como un simbolo
# matematico
y = sp.symbols('y')

# Veamos en consola el valor de nuestras variables
print(x)
print(y)

x
y

Vemos cómo dichas variables no tienen un valor en particular por lo cual pueden representar la noción de "un número cualquiera", justo como lo hacen las variables matemáticas.

Ahora bien, podemos efectuar operaciones algebraicas como $2x+5x-2=7x-2$:

In [3]:
2 * x + 5 * x - 2
Out[3]:
$\displaystyle 7 x - 2$

O también efectuar el cálculo $(2x+y)^{2}=4x^{2}+4xy+y^{2}$ auxiliándonos del método expand():

In [12]:
( (2 * x + y) ** 2 ).expand()
Out[12]:
$\displaystyle 4 x^{2} + 4 x y + y^{2}$

También $(x+3y)(2y-5x)=-5x^{2}-13xy+6y^{2}$

In [14]:
( (x + 3 * y) * (2 * y - 5 * x) ).expand()
Out[14]:
$\displaystyle - 5 x^{2} - 13 x y + 6 y^{2}$

entre muchas otras más operaciones.

Cálculo de límites y derivadas ¶

Ahora bien, mediante la librería SymPy calcularemos límites y derivadas. Por ejemplo, el siguiente código obtendrá el valor del límite $\lim\limits_{x\rightarrow 3}x^{2}$:

In [46]:
# Creamos un simbolo matematico
x = sp.symbols('x')

# Creamos una funcion matematica (simbolica)
y = x ** 2

# veamos en consola la funcion simbolica anterior
y
Out[46]:
$\displaystyle x^{2}$
In [4]:
# O alternativamente pero menos estetico:
# Creamos un simbolo matematico
x = sp.symbols('x')

# Creamos una funcion matematica (simbolica)
y ='x^2'

# veamos en consola la funcion simbolica anterior
y
Out[4]:
'x^2'

¿Qué pasa si utilizamos la función print() para ver nuestras variables en consola?

In [6]:
# funciones simbolicas
y1 = x ** 2
y2 ='x^2'

print(y1)
print(y2)

x**2
x^2

Podemos intentar obtener una salida más estética utilizando la función display() como sigue:

In [7]:
display(y1)
display(y2)
$\displaystyle x^{2}$ 
'x^2'

la cual sólo sirve para el caso en el que definimos a la función como y = x ** 2. Entrando un poco más en este tema, existe una manera en Python para poder evaluar cadenas de texto, utilizando para ello el método eval() como sigue

In [24]:
cad1 = '1 + 2'

# Podemos evaluar numericamente la cadena anterior
print(eval(cad1))
print()

cad11 = '(5 + 2) * 7'

# Podemos evaluar numericamente la cadena anterior
print(eval(cad11))

3

49
In [16]:
# Definimos una cadena de texto en la cual
# nos gustaria evaluar la x en algun valor en
# especifico
cad2 = 'x ** 2'

# Evaluamos la cadena anterior para x=2, lo 
# cual conseguimos utilizando un diccionario
# como segundo parametro de la funcion eval().
# Esto es, para evaluar x=2 escribimos entonces
# {'x': 2}
print(eval(cad2, {'x': 2}))
print()

# Valuamos x=5
print(eval(cad2, {'x': 5}))

4

25

Ahora, para calcular el valor del límite $\lim\limits_{x\rightarrow 3}y$ utilizaremos el método limit(), donde colocamos como primer parámetro la función en cuestión (en nuestro caso sería y), después la variable independiente (que en nuestro caso sería x) y finalmente el valor al cual tiende x (que en nuestro cao sería el 3)

In [45]:
# calculo del limite
lim = sp.limit(y, x, 3)

# vemos el valor calculado de dicho limite
lim
Out[45]:
$\displaystyle 9$

De tal manere tendremos que $\lim\limits_{x\rightarrow 3}y = \lim\limits_{x\rightarrow 3}x^{2}=9$. Otros ejemplos de cálculos de límites:

  • $\lim\limits_{x\rightarrow 0}sen(x)$. Para utilizar la función matemática $f(x)=sen(x)$ definiremos nuestro símbolo matemático y mediante una cadena de texto 'sin()' como sigue:
In [25]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica
y = 'sin(x)'

# calculo del limite
lim = sp.limit(y, x, 0)

# vemos el valor calculado de dicho limite
lim
Out[25]:
$\displaystyle 0$

Podemos dar una salida más visual e informativa importando la función Markdown del módulo display (de la librería IPython) y creando una función definida por el usuario para poder ver en consola salida de código $\LaTeX$:

In [39]:
# Realizamos la importacion necesaria
from IPython.display import Markdown

# definimos una funcion que ocupara la funcion recien importada
# Markdown()
def printmd(string):
    # Mostramos en salida la cadena de texto ingresada
    # pero en formato Markdown (dentro de Markdown podemos
    # escribir codigo latex)
    display(Markdown(string))
    
# Probamos la funcion anterior.
#         -------------- codigo en latex ----------- 
printmd(r'$$\lim\limits_{x\rightarrow 0}sin(x) = 0$$')
$$\lim\limits_{x\rightarrow 0}sin(x) = 0$$

Continuando, en vez de escribir y = 'sin(x)' podemos utilizar alternativamente

In [41]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica.
# Para utilizar la funcion seno escribimos
# sp.sin(x)
y = sp.sin(x)

# calculo del limite
lim = sp.limit(y, x, 0)

# Vemos el valor calculado de dicho limite.
# Podemos convertir a latex el valor obtenido en la variable
# lim escribiendo sp.latex(lim)
#                                    realizamos una| utilizamos un
#                                    concatenacion | f-string
printmd(r'$$\lim\limits_{x\rightarrow 0}sin(x) =' + f'{sp.latex(lim)}$$')
$$\lim\limits_{x\rightarrow 0}sin(x) =0$$
  • Otro ejemplo es el cálculo de $\lim\limits_{x\rightarrow 0}arccos(x)=\frac{\pi}{2}$:
In [42]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica.
# Para utilizar la funcion arco coseno
# escribimos sp.acos(x)
y = sp.acos(x)

# calculo del limite
lim = sp.limit(y, x, 0)

# Vemos el valor calculado de dicho limite.
# Podemos convertir a latex el valor obtenido en la variable
# lim escribiendo sp.latex(lim)
#                                    realizamos una| utilizamos un
#                                    concatenacion | f-string
printmd(r'$$\lim\limits_{x\rightarrow 0}arccos(x) =' + f'{sp.latex(lim)}$$')
$$\lim\limits_{x\rightarrow 0}arccos(x) =\frac{\pi}{2}$$

vemos cómo se mostró en salida el resultado pi / 2 pero en formato $\LaTeX$

  • Otro ejemplo de cálculo de límite es $\lim\limits_{x\rightarrow 0}\frac{sen(x)}{x}$:
In [43]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica
y = 'sin(x) / x'

# calculo del limite
lim = sp.limit(y, x, 0)

# Vemos el valor calculado de dicho limite.
# Podemos convertir a latex el valor obtenido en la variable
# lim escribiendo sp.latex(lim)
printmd(r'$$\lim\limits_{x\rightarrow 0}\frac{sen(x)}{x} =' + f'{sp.latex(lim)}$$')
$$\lim\limits_{x\rightarrow 0}\frac{sen(x)}{x} =1$$
  • Otro ejemplo de cálculo de límite es $\lim\limits_{x\rightarrow 1}\frac{x^{2}-1}{x-1}$:
In [44]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica
y = (x ** 2 - 1) / (x - 1)

# calculo del limite
lim = sp.limit(y, x, 1)

# Vemos el valor calculado de dicho limite.
# Podemos convertir a latex el valor obtenido en la variable
# lim escribiendo sp.latex(lim)
printmd(r'$$\lim\limits_{x\rightarrow 1}\frac{x^{2}-1}{x-1}=' + f'{sp.latex(lim)}$$')
$$\lim\limits_{x\rightarrow 1}\frac{x^{2}-1}{x-1}=2$$

de donde $\lim\limits_{x\rightarrow 1}\frac{x^{2}-1}{x-1}=2$. Etcétera.

Ahora, para calcular derivadas utilizaremos el método diff(), donde en el primer parámetro colocamos la función a derivar y en el segundo parámetro respecto a qué variable estamos derivando. Por ejemplo, si queremos derivar la función $f(x)=x^{2}$ respecto a la variable $x$ ($\frac{d}{dx}x^{2}$) escribiremos entonces

In [47]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica
y = 'x^2'

# calculo de la derivada
derivada = sp.diff(y, x)

# vemos la derivada calculada:
derivada
Out[47]:
$\displaystyle 2 x$

de donde $\frac{d}{dx}x^{2}=2x$. Nota que en este caso escribimos 'x^2' en vez de simplemente x ** 2, las cuales son equivalentes.

También podemos calcular la derivada de otras funciones:

  • $\frac{d}{dx}sin(x)=cos(x)$
In [41]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica
y = 'sin(x)'

# calculo de la derivada
derivada = sp.diff(y, x)

# vemos la derivada calculada:
derivada
Out[41]:
$\displaystyle \cos{\left(x \right)}$
  • O derivadas más complejas como $\frac{d}{dx}e^{sin^{2}(x)}$. Para manejar la función exponencial como una función simbólica escribimos exp().
In [51]:
# Definimos la variable x como un simbolo
# matematico
x = sp.symbols('x')

# Definimos nuestra funcion matematica
# o simbolica
y = 'exp( (sin(x))^2 )'

# calculo de la derivada
derivada = sp.diff(y, x)

# vemos la derivada calculada:
derivada
Out[51]:
$\displaystyle 2 e^{\sin^{2}{\left(x \right)}} \sin{\left(x \right)} \cos{\left(x \right)}$

De tal manera, con los temas que hemos visto en esta clase estamos preparados para trabajar con el primer proyecto del curso.