Conoce <Python🐍>

Conoce tu herramienta antes de comenzar a trabajar con Modelación Financiera en Python 😎.

ene 01, 2024

Tópicos:

Introducción: Por qué Python 🐍 .
Tipos de datos.
Palabras reservadas.
Operadores.
Estructuras de datos.
Funciones.
Clases.
Herencias.
Librerías útiles para empezar.
Ejercicios.

Introducción: Por qué Python 🐍

Python es un lenguaje de alto nivel porque fácil de comprender, instalar y se distingue de otros lenguajes por su flexibilidad en el proceso de escribir un código. Su uso es amplio en el entorno científico, ya que que brinda un número importante de herramientas para preparar, manipular, limpiar y procesar datos. Por otro lado, es un software de código libre lo que hace que sea una alternativa gratuita y exitosa tanto para instituciones educativas, empresas y entidades gubernamentales. Esto significa que el usuario, al tener acceso a las distintas funcionalidades que ofrece este lenguaje de programación puede llegar a desarrollar aplicaciones de cualquier clase.

Tipos de lenguajes de programación

Los lenguajes se diversifican entre los que pueden ser comprensibles por el procesador y los que pueden ser comprensibles por el ser humano–el usuario del computador–. En este sentido, los lengujes de programación se ramifican por:

Lenguajes compilados.

Entiéndase C y sus variantes C++ y C#–los más conocidos. Son aquellos lenguajes que deben pasar por un compilador–mejor conocido como el lenguaje de máquina–el cual es comprensible por el procesador de la computadora. Así pues tendríamos el código fuente, el cual es el programa escrito por el usuario y la versión compilada vendría a ser el lenguaje binario. Para estos casos, al hacer cambios en el código fuente, se debe volver a compilar para obtener un programa nuevo.

Ventajas:

Son lenguajes más rápidos.
Una vez que estén compilados pueden funcionar de manera autónoma sin requerir de un programa que los tenga que interpretar.

Desventajas:

Dependen de la plataforma desde donde se ejecutan, ya que cada procesador trabaja con lenguajes binarios diferentes.

Lenguajes interpretados.

Son aquellos que no necesitan ser compilados. Los programas escrito en esta clase de lenguajes suelen llamarse scripts. En lugar de necesitar un compilador, cuentan con un intérprete que se encarga de leer el código y ejecutarlo en función de las instrucciones que el código fuente tenga. En adelante, si no existe compilación no puede existir un lenguaje binario (lenguaje de máquina). En este grupo de lenguajes

Ventajas:

Son portables entre plataformas–siempre que tengan el intérprete correcto.
No necesitan procesos de compilación si el script se tiene que modificar.

Desventajas:

Son más lentos que los lenguajes compilados–aunque no siempre.
Necesitan de un intérprete.

Tipos de programación aceptados para el desarrollo de proyectos.

Programación imperativa

Es la modalidad más sencilla que subyace en otros paradigmas y es el más usado. Se basa en instrucciones concretas para que un computador cumpla una tarea determinada.

Programación funcional

Es la programación que consiste en instrucciones basadas en algoritmos matemáticos para que el computador cumpla una determinada función.

Programación orientada a objetos (OOP por sus siglas en inglés)

Es el paradigma de programación más común a nuestros días. Bajo esta forma de programar se trabaja con objetos. Estos son estructuras que permiten al programador almacenar y manipular la data de una manera coherente e identificada. Entre los lenguajes más conocidos por esta característica están Visual Basic for Applications (VBA), Python, Perl, Ruby.

El Zen de python

Es una lista de los 20 principios de software que influyen en el diseño del Lenguaje de Programación Python. 19 de ellos los escribió Tim Peters en junio de 1999. El texto es dominio público.

The Case for Timsort. Timsort is a sorting algorithm recently… | by Richard Scheiwe | Medium — Tim Peters, creador el Zen de Python.

# Zen de Python

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those

Tipos de datos

turned on monitor displaying function digital_best_reviews

El lenguaje de programación, Python se maneja con sus propios datos. Estos datos se clasifican en números enteros (int), números enteros largos (long), números en coma flotante (float), números complejos (complex) y None. Con el objeto type( ) puedes determinar con qué tipo de datos estás trabajando.

Enteros.

x = 5

type(x)

int.

Decimales.

y = 5.0

type(y)

float.

Cadenas .

Las cadenas son tipos de datos string. Es información textual. Estos datos deben siempre estar entre comillas.

mensaje = "¿Hola cómo estás?"

type(mensaje)

str.

Fuente: Elaboración propia en Jupyter Notebook.

Palabras reservadas

Son nombres de cadenas o strings que el usuario de Python no puede utilizar para nombrar variables porque están prefabricadas con funciones específicas. En palabras más simples, son acciones predeterminadas cuyos algoritmos están almacenados con esos identificadores o keywords.

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

`#Comentarios🗣️` en Python

Para escribir comentarios en el lenguaje Python solo escribe # antes. En Jupyter, estas líneas se ilustran en color azul 🟦. Veamos el siguiente ejemplo:

# Así se escribe un comentario en Python. Puedes utilizarlo para describir las etapas de un proyecto digital, guiarte en el proceso de construcción de cualquier programa, etc. 

# No interfiere el código, no molesta ni cambiará tus resultados.

Operadores <>

a black and white photo of a lot of numbers

Son símbolos que se utilizan para realizar cálculos en Python.

Operadores matemáticos      Significado.

i + j                       Suma.
i - j                       Resta.
i * j                       Multiplicación.
i / j                       División.
i // j                      Cociente de una división entera.
i % j                       Resto de una división entera.
i ** j                      i elevado a la potencia j.

Operadores lógicos          Significado.

i == j                      i es igual que j.
i!= j                       i es distinto que j.
i > j                       i es mayor que j.
i < j                       i es menor que j.
i >= j                      i es mayor o igual que j.
i <= j                      i es menor o igual que j.

Expresiones booleanas

Sintaxis que explican verdades. El término booleano tiene su origen en George Boole quien sería uno de los fundadores de la computación.

Archivo:PSM V17 D740 George Boole.jpg - Wikipedia, la enciclopedia libre — George Boole. Padre de los operadores lógicos y uno de los precursores de la computación.

El tipo de dato booleano tiene la función de imprimir valores lógicos. Estos pueden ser solo verdadero y falso. El primero tiene valor 1 y el segundo tiene valor 0. El sistema bool es binario. En Python, los datos booleanos corresponden con las palabras reservadas True y False.

verdadero = True
falso = False
print(verdadero + falso)

1

lista_booleana = [True, False, True, True, False, False, False]
for i in lista_booleana:
    print(int(i))

1
0
1
1
0
0
0

lista1= [1,2,3,4,5,6]
lista2=[3,4,2,5,6,7,]
lista1==lista2

False

Estructuras de control

Es aquí en donde la programación comienza a tomar su grado de complejidad y por qué no, diversión 🎉. A partir de la comprensión 🧐 de las expresiones booleanas, podemos trabajar las estructuras de control en Python. No son más que programas cuya respuesta o ejecución se distribuye en función de una expresión booleana. Entre las estructuras de control tenemos bucles 🔂 los cuales abren paso a la repetición de un grupo de instrucciones. Estas a su vez se subdividen en condicionales, while y for.

Estructura `If`

Los condicionales se escriben con la palabra If, la cual traducida al español significa “Sí”. Por ejemplo: “Si tal cosa, entonces tal cosa”. Para hacer esta explicación más fácil presentamos un par de ejemplos con código de Python:

# Ejemplo 1.

# Definimos las variables.

x = 2 #Entrada

if x <= 34 and x > 5:
    
  print("La instrucción es correcta y sigues dando un paso más hacia adelante")

else: 
    print("Sigue intentándolo.")

Salida:
 
Sigue intentándolo.

# Ejemplo 2.

x = 10 #Entrada

if x >0:

   print("x es un número positivo.")

else:

  print("x es un número negativo.")

Salida

 x es un número positivo.

Estructura `While`

While traducido al español significa “mientras”. El bucle se encargará de ejecutar una instrucción mientras una condición esté dada.

While True:
   línea = input("Introducir exit para finalizar: ")
   if línea == "exit":
       break
   print(línea)

Fuente: Elaboración propia en Jupyter Notebook con base en (García Ruiz y Sarasa Cabezuelo, 2018 p. 35).

Estructura `For`

For traducido al español significa “para”. El bucle trabajará sobre una serie de datos.Para que puedas practicar con este bucle empeiza por definir una variable cualquiera, lo mejor es que sea un dato int. o float. Se entiende mejor con una serie de ejemplos a continuación:

x = 20
for i in range(x):
    print(i)

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# Se indicó que las ventas deben registrarse con un impuesto adicional al 17%.


Tasa_impositiva = 0.17
ventas_de_ayer = [100, 200, 150, 300, 400, 500]
for i in ventas_de_ayer:
    print(i * (1 + Tasa_impositiva))


117.0
234.0
175.5
351.0
468.0
585.0

# Ejemplo extraído de (Zumstein, 2021, p.60):

currencies = ["USD", "HKD", "AUD"]

for currency in currencies:
     print currency

USD
HKD
AUD

Estructuras de datos.

Las estructuras de datos abarcan listas, tuplas, sets y diccionarios. Para cada

Listas

La lista es un grupo de valores de cualquier clase. El único requisito en Python para elaborar una lista son los corchetes [ ]. Veamos algunos ejemplos:

letras = ["A","B","C"]
letras

['A', 'B', 'C']

numeros = [1,2,3]
numeros

[1, 2, 3]

Tuplas

Son clases de datos que representan una secuencia de valores –sin importar su clase–cuyo acceso se puede ejecutar por medio de índices enteros. Un tupla se distingue de una lista por su inmutabilidad (no se pueden cambiar sus elementos) y por su comparabilidad. Las tuplas se puede comparar mediante los operadores de comparación comenzando por el primer elemento de cada una.

# Ejemplo extraído de (García Ruiz y Sarasa Cabezuelo, 2018, p. 38)

t = tuple("supercalifrastilisticoespidalidoso")

print(t)

('s', 'u', 'p', 'e', 'r', 'c', 'a', 'l', 'i', 'f', 'r', 'a', 's', 't', 'i', 'l', 'i', 's', 't', 'i', 'c', 'o', 'e', 's', 'p', 'i', 'd', 'a', 'l', 'i', 'd', 'o', 's', 'o')

# Comparación de tuplas

(0,1,2,3)<(4,5,6,7)

True

(0,1,2,3)!=(4,5,6,7)

True

#Los elementos de una tupla se pueden ordenar con la función sorted.
#Por ejemplo

print(sorted((2,1,3,6,7,4,3,5,6,9,8)))

[1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9]

# También se pueden alterar los valores de la tupla.

print(tuple(reversed((2,1,3,6,7,4,3,5,6,9,8))))

8, 9, 6, 5, 3, 4, 7, 6, 3, 1, 2)

Diccionarios

Es una colección de pares clave-valor en donde ambos pueden ser–casi–de cualquier clase. En Python, este par se denota como { key: value }. A cada clave le corresponde un valor y a través de la misma se puede tener acceso su valor asociado. Veamos algunos ejemplos:

# Ejemplo extraído de (García Ruiz y Sarasa Cabezuelo, 2018, pp. 53-54)

dicc = dict()
print(dicc)
{}

# Una vez listo el diccionario, se le pueden añadir elementos.

dicc["primero"] = "Libro"
print(dicc)
{'primero':'libro'}

# Otra forma de construir un diccionario es escribiéndolo de manera directa. Por ejemplo:

ejemplo2 = {"primero":"libro", "segundo": 34, "tercero":(3,4)}
print(ejemplo2)
{'primero':'libro','segundo': 34, 'tercero': (3, 4)}

#para acceder al valor de un diccionario debemos utilizar su clave:

print(ejemplo2["segundo"])
34

Python brinda métodos para trabajar con los diccionarios. Veamos algunos ejemplos:

# La función len devuelve la cantidad de {key: values} que tiene el diccionario. Por ejemplo

print(len(ejemplo2))
3

"primero" in ejemplo2
True

La función dir( ) te permite conocer el directorio que almacena en una lista la cantidad de gestiones que puedes realizar con un objeto de Python. Sigamos con el ejemplo del diccionario ejemplo2:

dir(ejemplo2) 

['__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'clear',
 'copy',
 'fromkeys',
 'get',
 'items',
 'keys',
 'pop',
 'popitem',
 'setdefault',
 'update',
 'values']

Sets

Son colecciones que no tienen elementos duplicados. A continuación, unos ejemplos:

# Ejemplo extraído de (Zumstein, 2021, p.57)

set(["USD","USD","SGD","EUR","USD","EUR"])
{'EUR', 'SGD', 'USD'}


portfolio1 = {"USD","EUR","SGD","CHF"}
portfolio2 = {"EUR","SGD","CAD"}

portfolio1.union(portfolio2)


{'CAD', 'CHF', 'EUR', 'SGD', 'USD'}

Veamos cómo podemos construir estructuras de datos a partir de otras:

Estructura            literal              Constructor

List            |     [1,2,3]          |  list((1, 2, 3))
Dictionary      |     {"a":1, "b":2}   |  dict(a=1, b=2)
Tuple           |     {1, 2, 3}        |  tuple([1, 2, 3])        
Set             |     {1, 2, 3}        |  set((1, 2, 3))

Fuente: Elaboración propia en base a (Zumstein 2021, p. 57)

Funciones

Una función no es más que un grupo de sentencias que realizan una acción específica. Esta, una vez definida, puede invocarse a lo largo del desarrollo del programa–aunque no siempre. Veamos algunos ejemplos:

# Ejemplo extraído de (Sarasa Cabezuelo y García Luis, 2018, p.56).

#función que suma 3 números y devuelve el resultado

def suma_tres(x, y, z):

m1 = x + y
m2 = m1 + z
return m2

Clases

Son la unidad básica de estructuración de programas que siguen un estilo orientado a. objetos. Una clase está formada por un conjunto de atributos y un conjunto de métodos. A su vez, los métodos son funciones que permiten al usuario hacer acciones específicas sobre los atributos de un objeto. Un atributo es una variable que almacena cierta información de una clase. Por ejemplo, obtener el valor del objeto.

# Ejemplos extraídos de (Hijonosa Gutiérrez, 2016, pp.123-144) 

class Producto:
    """Ejemplo de clase con la cantidad y el precio de un producto"""
    def __init__(self, producto, precio, unidades):
        self.producto = producto
        self.precio = precio
        self.unidades = unidades
    def costo_total(self):
        costo = self.precio * self.unidades
        return costo
mi_objeto_producto = Producto("corbata", 35, 67)

print (mi_objeto_producto.producto)
print (mi_objeto_producto.precio)
print (mi_objeto_producto.unidades)
print(mi_objeto_producto.costo_total())

corbata
35
67
2345


class estudiante:
    '''Clase para representar un estudiante'''
    def __init__(self, nom, apell, email):
        self.nombre=nom
        self.apell=apell
        self.email=email
    def __costo_total(self):
        costo = self.precio * self.unidades
        return costo
    
    def nuevo_precio(self, precio):
        self.precio = precio
    def agrega(self, cantidad):
            self.unidades= self.unidades + cantidad
    def saca(self, cantidad):
        if cantidad <= self.unidades:
            self.unidades = self.unidades - cantidad
        else:
            print("No hay suficientes")
    
    def informe(self):
        print("Producto: " + self.producto)
        print("Precio: " + str(self.precio))
        print("Unidades: " + str(self.unidades))
        print("Precio Total: " + str(self.__costo_total()))
         
mi_producto1 = Producto("Pantalón", 100, 6)
mi_producto2 = Producto("Camiseta", 50, 5)

print(mi_producto1.precio)
print(mi_producto2.unidades)
mi_producto2.agrega(5)
print(mi_producto2.unidades)
mi_producto2.informe()

# Ejemplo extraído de (García Ruiz y Sarasa Cabezuelo, 2018, p. 64)

class estudiante:
    '''Clase para representar un estudiante'''
    def __init__(self, nom, apell, email):
        self.nombre=nom
        self.apell=apell
        self.email=email
    def obtener_nombre(self):
        return self.nombre
    def cambiar_nombre(self,nom):
        self.nombre=nom

ejemplo = estudiante("Juan","Santos","jsantos@gmail.com")
print(ejemplo.obtener_nombre())

Juan

ejemplo.cambiar_nombre("Pepe")
print(ejemplo.nombre)

Pepe

Herencias: Extensión de clases.

La herencia es un mecanismo que permite ensamblar nuevas clases en forma de extensión de otras predefinidas. Una clase que se extiende hereda los métodos y atributos de la clase extendida. De esta manera, los puede sobreescribir para cambiar su comportamiento. La forma de indicar la herencia de una clase consiste en utilizar el mismo nombre de la clase sobre la cual se hereda entre paréntesis posteriormente del nombre de la clase nueva. Por consiguiente, para sobreescribir un método heredado, se debe escribir el mismo con el nombre.

# Ejemplos extraídos de (Hijonosa Gutiérrez, 2016, pp.123-144) 

class Animal:
    """Clase base para mostrar la herencia"""
    def __init__(self, nombre, patas):
        self.nombre=nombre
        self.patas=patas
        
    def saluda(self):
        print("El animal llamado "+ str(self.nombre)+ " saluda")

class Perro(Animal):
    """Clase hija para mostrar la herencia"""
    # no hacemos nada
    pass
mi_mascota = Perro("Rufo",4)
mi_mascota.saluda()

El animal llamado Rufo saluda

# Ejemplo extraído de (García Ruiz y Sarasa Cabezuelo, 2018, p. 65)

class Mamifero:
    def __init__(self, sangre):
        self.sangre=sangre
    def tipo_sangre(self):
        print(self.sangre)
class Elefante(Mamifero):
    def tipo_sangre(self):
        print("El tipo de sangre es", self.sangre)
j=Elefante("frio")
j.tipo_sangre()

El tipo de sangre es frio

Para añadir un atributo en el proceso de creación del objeto Elefante solo se escribe un nuevo método __init__ asignado a la clase que ejecutaría en lugar de un __init__heredado. Veamos el siguiente ejemplo:

# Ejemplo extraído de (García Ruiz y Sarasa Cabezuelo, 2018, p. 65)

class Mamifero:
    def __init__(self, sangre):
        self.sangre=sangre
        def tipo_sangre(self):
            print(self.sangre)
class Elefante(Mamifero):
    def __init__(self, sangre, sexo):
        self.sangre=sangre
        self.sexo=sexo
    def tipo_sangre(self):
        print("El tipo de sangre es", self.sangre)
j=Elefante("frio", "hembra")
j.sexo

'hembra'

class Mamifero:
    def __init__(self, sangre):
        self.sangre='caliente'
    def tipo_sangre(self):
        print(self.sangre)
class Elefante(Mamifero):
    def __init__(self, sangre, sexo):
        Mamifero.__init__(self, sangre)
        self.sexo=sexo
    def tipo_sangre(self):
        print("El tipo de sangre es ", self.sangre)
j=Elefante("frio", "hembra")
print(j.sangre, j.sexo)

'caliente hembra'

Ejercicios

Descarga el Navegador Anaconda y así puedas abrir el servidor Jupyter.
Descarga el Navegador Anaconda
Descarga el IDE de Python
Descargar IDE de Python

Descárgate el archivo de la clase y lo abres en Jupyter.
Descarga la clase.

Compartir <Finletra>

Recomiende a un amigo

Regale una suscripción

Deje un comentario

Referencias de consulta 📚.

– Zumstein, F. (2021). Chapter 3: Getting Started with Python. Python for Excel: A modern Environment for Automation and Data Analysis (pp.43-74). O´Reilly.

–García Ruíz, Y. y Sarasa Cabezuelo, A. (2018). Big Data: Análisis de datos con Python. Garceta Grupo Editorial.

Material para que te aprendas Python a profundidad.

Te regalo estas referencias para que estudies Python y comiences a hacerte un experto con mentalidad de programador 🤓.

Descarga Python for Data Analysis

Descarga Data Science from Scratch