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

    Autor: Luis Fernando Apáez Álvarez
    -Curso PyM-
    Clase 3: Introducción a la POO y la librería Matplotlib
    Fecha: 10 de Agosto del 2022

Contenido¶

  • Un vistazo a las funciones definidas por el usuario
    •
  • Definiendo Clases
    •
  • Introducción a la librería Matplotlib
    •

Introducción¶

Python es un lenguaje de programación multiparadigma, es decir que admite varios tipos de "estilos" de programación. Lo anterior nos permite decir que Python es, en particular, un lenguaje orientado a objetos, esto es, dentro de Python podemos utilizar el "estilo" de escribir Clases y Objetos, así como lo vimos en la presentación.

Un ejemplo claro de ello es lo siguiente:

In [2]:
print(type(3))

<class 'int'>

Al utilizar la función type() e imprimir el resultado, vemos que se nos muestra el mensaje <class 'int'>, lo cual nos está diciendo básicamente que el 3 es un objeto de la Clase int (integer). Lo anterior tiene mucho sentido pues se pude considerar una especie de plantilla de los números enteros, lo que involucra, claro, características generales y funcionalidades generales; de esta manera, cada número entero es un objeto o una instancia de esta plantilla. En particular, el 3 es un objeto de la clase int. De manera totalmente análoga podemos decir (o ver) que

In [3]:
# clase de flotantes
print(type(3.1416))
print()

# Clase de cadenas de texto
print(type("Hola Mundo!"))
print()

# Clase de booleanos
print(type(False))

<class 'float'>

<class 'str'>

<class 'bool'>

Continuando con lo dicho en la presentación, en esta primer parte de la sesión trabajaremos con el ejemplo de la Clase Persona. Recordemos que una clase puede entenderse, de manera intuitiva, como una generalización o una especie de plantilla, y los objetos de dicha clase se pueden entender como elementos de la clase que cumplen con las especificaciones dictadas en la plantilla.

De tal manera, construiremos primero la plantilla de la Clase persona, para lo cual requerimos de dos ingredientes:

  • Atributos o características: en nuestra plantilla manejaremos únicamente los atributos de nombre y edad.
  • Funcionalidades o métodos: consideraremos en la plantilla las funcionalidades de hablar y caminar.

Antes de que podamos implementar en código nuestra plantilla de Persona, es necesario dar un vistazo a un tema importante dentro de la programación:

Un vistazo a las funciones definidas por el usuario ¶

Recordemos de las primeras sesiones que dentro de Python existen funciones que por default vienen integradas, por ejemplo

In [1]:
# la puncion type()
# la función print()

print( type(2) )

<class 'int'>

Este tipo de funciones que vienen por default se conocen como funciones predefinidas porque, justamente, ya fueron definidas. Lo anterior nos permite entonces considerar la posibilidad de definir, de manera propia, otro tipo de funciones. En efecto, dentro de Python podemos definir funciones propias (denominadas funciones definidas por el usuario) que realicen algunas acciones que necesitemos o sea de nuestro interés. Antes de ver de lleno este tipo de funciones, recordemos la idea intuitiva sobre las funciones matemáticas.

Una función $f$ puede verse como una especie de máquina, en la cual nosotros ingresaremos algo y la función (o máquina) realiza un proceso de lo que ingresamos para entregarnos un resultado. Un ejemplo de lo anterior puede ser

Programamos%20%281%29.png

En una tortillería vemos que ocurre lo siguiente: se ingresa masa (valor del parámetro) a la máquina(función) y se devuelve (salida) tortillas. De tal manera, las funciones matemáticas actúan como

Programamos.png

Un ejemplo más concreto es la función matemática $f(x)=x^{2}$, donde esta función actúa como:

  • ingresas un número (valor del parámetro), la función lo "procesa" y arroja (salida) dicho número elevado al cuadrado

Por ejemplo, podemos considerar $f(2)=(2)^{2}=4$:

py_32.PNG

De tal manera, las funciones que definiremos dentro de Python poseen la misma idea intuitiva que las funciones matemáticas; esto es, las funciones que definiremos tendrán parámetros y los valores que se ingresen en dichos parámetros serán procesados mediante instrucciones o acciones que nosotros definamos, para finalmente devolver un resultado.

La sintaxis básica para definir una función es:

def <<nombre de tu función>> (<<aqui van tus parametros>>):
    procesamiento o instrucciones a realizar
    utilizando (o no) los parámetros
    return <<salida de la función>>

Entonces, por ejemplo, podemos llevar la función matemática $f(x)=x^{2}$ a código escribiendo lo siguiente

In [4]:
# Definiremos la funcion f(x)=x^{2}:
# x es el unico parametro,
# la funcion debe calcular el parametro elevado
# al cuadrado,
# la funcion debe devolver el resultado anteriormente
# calculado

def elevar_cuadrado(x):
    # calculamos el cuadrado del parametro
    valor_cuadrado = x ** 2
    # devolvemos dicho valor
    return valor_cuadrado

donde:

  • elevar_cuadrdo es el nombre de nuestra función
  • x es el nombre del parámetro de nuestra función
  • valor_cuadrado es una variable que almacena el valor de x ** 2
  • return valor_cuadrado es la instrucción para devolver o regresar el valor calculado anteriormente

Probemos nuestra función con algunos valores:

In [5]:
# mostramos el resultado de elevar 2 al cuadrado
print(elevar_cuadrado(2))

print("-" * 20)

# mostramos el resultado de elevar 5 al cuadrado
print(f"5 elevado al cuadrado es: {elevar_cuadrado(5)}")

4
--------------------
5 elevado al cuadrado es: 25

De manera alternativa también pudimos haber escrito

In [6]:
# Manera compacta: 
# definimos una funcion que se denomine f,
# que reciba como parametro x
# y que nos regrese el valor de x ** 2+
def f(x):
    return x ** 2

# Probamos nuestra funcion
print(f(7))

49

También podemos emplear funciones que no tengan salida, es decir, la cláusula return es opcional

In [8]:
# creamos una funcion para mostrar un mensaje
def mensaje(msj):
    print(msj)
    
# podemos a prueba nuestra funcion
mensaje("Hola")

Hola

En este caso la función anterior no regresó ningún valor, lo que pasó fue que dentro del procesamiento de la función mensaje se ejecutó la función predefinida print(), con lo cual el mensaje que ingresamos en nuestra función fue mostrado. De la misma manera, podemos definir funciones sin parámetros:

In [11]:
# creamos una funcion que salude
def msj_hola():
    print("Hola")
    
# podemos a prueba nuestra funcion
msj_hola()

print("-" * 20)

# O alternativamente
# creamos una funcion que salude
def msj_hola2():
    return "Hola"
    
# podemos a prueba nuestra funcion
print(msj_hola2())

Hola
--------------------
Hola

Definiendo Clases ¶

Ahora bien, nuestra labor será definir la plantilla Persona con las especificaciones que se indicaron antes. Para definir una Clase en Python utilizaremos la palabra reservada class mediante la siguiente estructura:

class <<nombre de la clase>>:
    definimos los atributos de la clase
    .
    .
    .
    definimos los métodos (o funcionalidades) de la clase

donde podemos decir que los métodos (o funcionalidades) de la clase no son más que funciones definidas por el usuario.

Con base en lo anterior podemos definir la Clase Persona como sigue:

In [46]:
# Clase Persona
class Persona:
    # ---------------Atributos----------------
    
    # Definimos los atributos,
    # los atributos no son mas que variables
    # Atributo nombre:
    nombre = ""
    # Atributo edad:
    edad = 0
    # Atributo auxiliar que ocuparemos 
    # en los metodos:
    hablando = False
    # Atributo auxiliar:
    caminando = False
    
    # ----------------Metodos-----------------
    
    # Definimos los metodos
    # Metodo para hablar
    def hablar(self):
        self.hablando = True
    # Metodo para caminar
    def caminar(self):
        self.caminando = True

donde

  • El atributo nombre es una cadena vacía pues este atributo sólo nos sirve, en la plantilla, para indicar que las Personas tienen un nombre, así que cada persona tendrá un nombre distinto (en teoría) y por ello, en cada persona cambiaremos el valor de la variable nombre. Por ejemplo, en vez de "" podemos tener "Luis", "Lola", etcétera.
  • De manera análoga, definimos el atributo (variable) edad inicializándola con el valor de cero.
  • Tenemos además dos variables auxiliares, las cuales ocuparemos en los métodos para simular si una persona está hablando (True) o no (False), o, esta caminando o no. Por ejemplo, si una persona en particular "está hablando", entonces el valor de la variable hablando debe ser True; si no está hablando, entonces el valor correspondiente debe ser el de False.
  • Colocando como parámetro de los métodos la cláusula self, indicamos a Python que dicha función actuará internamente dentro de la clase utilizando propiamente los atributos de la misma. Esto es, al nosotros utilizar como parámetro el self, estamos haciendo una distinción marcada entre métodos (funciones propias de una clase) y las funciones definidas por el usuario. De la misma manera, al escribir self.hablando estamos declarando que la variable a la que nos estamos refiriendo es justamente un atributo de la clase. Si no colocamos el self, entonces Python no sabe identificar si nos estamos refiriendo a un atributo de la clase o a cualquier otra variable, lo cual conduciría a un error en la ejecución.
  • El método hablar() lo que hace es cambiar el valor de la variable hablando de False a True para simular que una persona en especifico está hablando. De manera análoga el funcionamiento del método caminar()

Así, estamos preparados para crear nuestro primer objeto de la clase persona:

In [47]:
# creremos un objeto de la clase persona
# y a dicho objeto lo denominaremos persona1
# (recuerda que '=' significa asignacion)
persona1 = Persona()

# podemos ver la informacion marcada en la
# plantilla de Persona accediento a sus
# atributos

# Para acceder a los atributos de una clase
# utilizamos .<<nombre del atributo>>
# por ejemplo:

# accedemos al valor del atributo nombre de la
# plantilla
print(persona1.nombre)
# accedemos al valor del atributo edad de la
# plantilla
print(persona1.edad)
# accedemos al valor del atributo hablando de la
# plantilla
print(persona1.hablando)

0
False

  • En primera instancia, al escribir persona1 = Persona() estamos creando un objeto de la clase Persona, el cual denominaremos como persona1. Una vez que creamos un objeto y realizamos la asignación a la clase correspondiente (= Persona() en este caso), todas las especificaciones de la clase (atributos y métodos) estarán disponibles para todos los objetos creados.

  • Podemos acceder a dichos atributos y métodos utilizando la sintaxis .<<nombre del atributo o metodo>>, por ejemplo persona1.nombre (que al ser impreso nos arrojó la cadena vacía).

  • Podemos cambiar los valores por defecto que declaramos en los atributos realizando una asignación al nuevo valor, por ejemplo, podemos cambiar la cadena vacía almacenada en el atributo nombre, a la cadena "Luis":

In [48]:
# asignamos "Luis" al atributo 'nombre'
# correspondiente al objeto persona1
persona1.nombre = "Luis"

# imprimimos el cambio
print(persona1.nombre)

Luis

De manera análoga:

In [49]:
# cambiamos el valor del atributo edad
persona1.edad = 24
print(persona1.edad)

24

Ahora, supongamos que la persona comenzará a hablar, por lo cual el valor del atributo hablando debe cambiar de False a True, lo que conseguimos ejecutando el método hablar()

In [50]:
# notamos primero que la persona no esta hablando
# porque justamente el valor del atributo hablando
# es False
print(persona1.hablando)

print("-" * 30)

# mandamos a llamar el metodo hablar()
# para simular que la persona1 esta
# hablando
persona1.hablar()

# veamos que ahora el valor del atributo
# hablando correspondiente a la persona 1
# es el de True
print(persona1.hablando)

False
------------------------------
True

Introducción a la librería Matplotlib ¶

Dentro de Python existen librerías o paquetes los cuales traen consigo nuevas funcionalidades y que sirven a diversos fines. Por ejemplo, hay librerías que nos permiten enfocarnos en el Machine Learning, en el procesamiento del lenguaje natural, en el cálculo numérico, en la visualización, etcétera. Ahora bien, cada librería representa un conjunto de módulos, donde un módulo representa un archivo Python en el cual puede haber funciones, clases, variables, etcétera.

Programamos%20%282%29.png

Así, la librería que veremos a continuación se donimina matplotlib, la cual sirve para las visualizaciones en Python, es decir, nos permite crear diversos gráficos.

Lo primero que debemos hacer es importar dicha librería en nuestro espacio de trabajo (es decir, en nuestra notebook). En especifico, en esta clase trabajaremos con el módulo pyplot para realizar gráficos, por lo cual realizaremos la importación del módulo pyplot de la librería matplotlib. Además, a dicho módulo le daremos un alias para trabajar con él de una manera más sencilla

In [1]:
# as <<nombre>> corresponde a la asignacion de un alias
# En este caso el alias que suele darse a este modulo 
# es el de plt
import matplotlib.pyplot as plt

A partir de ahora, todas las funcionalidades del módulo pyplot están disponibles y podemos acceder a ellas utilizando el prefijo plt. seguido de la funcionalidad que queremos llevar a cabo.

Lo primero que haremos será graficar un punto, para lo cual utilizaremos la función plot() del módulo pyplot. Para llamar a dicha función escribiremos entonces plt.plot(), donde los parámetros serán, por ahora, las coordenadas del punto a graficar. Entonces

In [54]:
# Graficaremos el punto coordenado (1,2)

# Creamos el grafico deseado utilizando la funcion
# plt.plot(1,2)
# Pero ademas, dentro de los parametros especificaremos
# el tipo de marcador o rotulador (marker) con el cual
# nuestro punto sera graficado. 
plt.plot(1,2, marker="o")

# una vez creado el grafico, queremos que
# este se muestre. Para ello emplearemos 
# la función plt.show()
plt.show()

donde podemos ver que marker="o" hace que nuestro punto coordenado tenga la forma, justamente, de un punto. Veamos otros tipos de marcadores, donde en el siguiente código graficaremos más de un punto coordenado

In [58]:
# podemos graficar de forma simultanea
# muchos puntos
plt.plot(1,2, marker="o")
plt.plot(1,4, marker="*")
plt.plot(1,0, marker="v")
plt.plot(1.5,2, marker="8")
plt.plot(1.5,4, marker="s")
plt.plot(1.5,0, marker="x")

# mostramos el grafico
plt.show()

Si quieres consultar más tipos de marcadores puedes ver Matplotlib markers

Adicionalmente, podemos agregar un cuadrículado a nuestro gráfico anterior, para lo cual utilizaremos la función plt.grid()

In [59]:
# podemos graficar de forma simultanea
# muchos puntos
plt.plot(1,2, marker="o")
plt.plot(1,4, marker="*")
plt.plot(1,0, marker="v")
plt.plot(1.5,2, marker="8")
plt.plot(1.5,4, marker="s")
plt.plot(1.5,0, marker="x")

# agregamos un cuadriculado
plt.grid()

# mostramos el grafico
plt.show()

Podemos agregar etiquetas para especificar cada tipo de punto del gráfico anterior, para ello agregaremos un parámetro adicional en la función plt.plot(), el cual es label="etiqueta", donde en etiqueta colocaremos el texto que queramos

In [63]:
# podemos graficar de forma simultanea
# muchos puntos
# Agregaremos etiquetas en cada uno de los puntos
plt.plot(1,2, marker="o", label="punto normal")
plt.plot(1,4, marker="*", label="estrlla")
plt.plot(1,0, marker="v", label="triángulo hacia abajo")
plt.plot(1.5,2, marker="8", label="punto normal")
plt.plot(1.5,4, marker="s", label="cuadrado")
plt.plot(1.5,0, marker="x", label="equis")

# agregamos un cuadriculado
plt.grid()

# esta funcion muestra las etiquetas
# de cada plt.plot()
plt.legend()

# mostramos el grafico
plt.show()

Podemos agregar texto dentro de nuestro gráfico, para lo cual deberemos especificar la coordenada en la cual queremos posicionar dicho texto

In [73]:
# Unos puntos
plt.plot(1,2, marker="o", label="punto normal")
plt.plot(1,4, marker="*", label="estrlla")
plt.plot(1,0, marker="v", label="triángulo hacia abajo")
plt.plot(1.5,2, marker="8", label="punto normal")
plt.plot(1.5,4, marker="s", label="cuadrado")
plt.plot(1.5,0, marker="x", label="equis")

# agregamos texto con la funcion plt.text() como sigue
# en la coordenada (1.2,2.5) agregaremos el texto "Hola Mundo"
# especificando el tamagno de la letra en 12
plt.text(1.2, 2.5, "Hola Mundo", fontsize=12)

# agregamos un cuadriculado
plt.grid()

# esta funcion muestra las etiquetas
# de cada plt.plot()
plt.legend()

# mostramos el grafico
plt.show()

Podemos agregar etiquetas a los ejes $x$ (plt.xlabel()) y $y$ (plt.ylabel()), asimismo, podemos agregar un título (plt.title()) a nuestro gráfico como sigue

In [75]:
# Unos puntos
plt.plot(1,2, marker="o", label="punto normal")
plt.plot(1,4, marker="*", label="estrlla")

# agregamos texto en la coordenad (1,3)
plt.text(1, 3, "Hola Mundo", fontsize=12)

# agregamos un cuadriculado
plt.grid()

# esta funcion muestra las etiquetas
plt.legend()

# agregamos etiquetas a los ejes
plt.xlabel("Eje x")
plt.ylabel("Eje y")

# agregamos un titulo
plt.title("Mi primer gráfico")

# mostramos el grafico
plt.show()

También, podemos cambiar el color de los puntos, lo cual lograremos agregando el parámetro color="nombre del color" a la función plt.plot():

In [78]:
# Unos puntos
# Cambiaremos su color
plt.plot(1,2, marker="o", label="punto normal", color="red")
plt.plot(1,4, marker="*", label="estrlla", color="black")

# agregamos texto en la coordenad (1,3)
plt.text(1, 3, "Hola Mundo", fontsize=12)

# agregamos un cuadriculado
plt.grid()

# esta funcion muestra las etiquetas
plt.legend()

# agregamos etiquetas a los ejes
plt.xlabel("Eje x")
plt.ylabel("Eje y")

# agregamos un titulo
plt.title("Mi primer gráfico")

# mostramos el grafico
plt.show()

Podemos modificar el tamaño de salida del gráfico. Lo anterior lo conseguimos al emplear plt.figure(figsize=(x, y)), donde x indica el tamaño (en pixeles) del largo del gráfico y y indica el tamaño del ancho del gráfico

In [2]:
# cambiaremos el tamagno de salida del grafico
# figsize=(largo, ancho)
plt.figure(figsize=(14, 5))

# Unos puntos
plt.plot(1,2, marker="o", label="punto normal", color="red")
plt.plot(1,4, marker="*", label="estrlla", color="black")
# agregamos texto en la coordenad (1,3)
plt.text(1, 3, "Hola Mundo", fontsize=12)
# agregamos un cuadriculado
plt.grid()
# esta funcion muestra las etiquetas
plt.legend()
# agregamos etiquetas a los ejes
plt.xlabel("Eje x")
plt.ylabel("Eje y")
# agregamos un titulo
plt.title("Mi primer gráfico")
# mostramos el grafico

plt.show()

Finalmente, hay distintos estilos o tipos de graficación, por ejemplo, podemos usar un estilo de gráficación denominado ggplot:

In [83]:
# Podemos configurar cierto tipo de 
# estilo de graficacion
plt.style.use('ggplot')

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

# cambiaremos el tamagno de salida del grafico
# figsize=(largo, ancho)
plt.figure(figsize=(14, 6))
# Unos puntos
plt.plot(1,2, marker="o", label="punto normal", color="red")
plt.plot(1,4, marker="*", label="estrlla", color="black")
# agregamos texto en la coordenad (1,3)
plt.text(1, 3, "Hola Mundo", fontsize=12)
# esta funcion muestra las etiquetas
plt.legend()
# agregamos etiquetas a los ejes
plt.xlabel("Eje x")
plt.ylabel("Eje y")
# agregamos un titulo
plt.title("Mi primer gráfico")
# mostramos el grafico
plt.show()