Python

Hasta ahora, hemos discutido cómo construir páginas web simples utilizando HTML y CSS, y cómo utilizar Git y GitHub para llevar un registro de los cambios en nuestro código y colaborar con otros.

Hoy, profundizaremos en Python, uno de los dos principales lenguajes de programación que utilizaremos a lo largo de este curso.

Si bien podemos utilizar el operador"+" para combinar cadenas como hicimos anteriormente, en las últimas versiones de Python, existen formas aún más sencillas de trabajar con cadenas, conocidas como"cadenas formateadas" o"f-strings" en resumen.

Para indicar que estamos utilizando cadenas formateadas, simplemente agregamos una f antes de las comillas. Por ejemplo, en lugar de usar "Hello, " + name como hicimos anteriormente, podríamos escribirf"Hello, {name}" para obtener el mismo resultado. Incluso podemos insertar una función en esta cadena si lo deseamos, y convertir nuestro programa anterior en una sola línea:

1name = input("Cómo te llamas? ")
2print(f"Hola, {name}")

Una de las partes más poderosas del lenguaje Python es su capacidad para trabajar con secuencias de datos además de variables individuales.

Hay varios tipos de secuencias que son similares en algunos aspectos, pero diferentes en otros. Al explicar esas diferencias, utilizaremos los términos mutables/inmutables y ordenados/desordenados. Mutable significa que una vez que se ha definido una secuencia, podemos cambiar elementos individuales de esa secuencia, y ordenado significa que el orden de los objetos es importante.

Cadenas

1. Ordenadas: Sí
2. Mutables: No

Ya hemos examinado las cadenas un poco, pero en lugar de solo variables, podemos pensar en una cadena como una secuencia de caracteres. Esto significa que podemos acceder a elementos individuales dentro de la cadena. Por ejemplo:

1name = "Mario"
2print(name[0])
3print(name[1])

imprime el primer carácter(o índice-0) en la cadena, que en este caso es M, y luego imprime el segundo carácter(índice-1), que es"a".

1. Ordenadas: Sí
2. Mutables: No

Las tuplas generalmente se utilizan cuando necesitas almacenar solo dos o tres valores juntos, como los valoresx e ypara un punto. En el código de Python, utilizamos paréntesis:

1point = (12.5, 10.6)
2# Otra tupla
3mitupla = ("manzana", "banana", "frutilla")

Unatuplaes uno de los 4 tipos de datos incorporados en Python que se utilizan para almacenar colecciones de datos. Los otros 3 son List, Set y Dictionary, todos con diferentes características y usos.

Una tupla es una colección que está ordenada y no se puede modificar.

1. Los elementos de una tupla están ordenados, no se pueden cambiar y permiten valores duplicados.
2. Los elementos de una tupla se indexan, el primer elemento tiene el índice[0], el segundo elemento tiene el índice[1], y así sucesivamente.

1. Ordenadas: No
2. Mutables: N/D

Losconjuntosson diferentes de las listas y las tuplas en que son desordenados. También son diferentes porque, mientras puedes tener dos o más elementos iguales dentro de una lista/tupla, un conjunto solo almacenará cada valor una vez. Podemos definir un conjunto vacío utilizando la función"set". Luego, podemos usar"add" y"remove" para agregar y quitar elementos de ese conjunto, y la función"len" para encontrar el tamaño del conjunto. Ten en cuenta que la función"len"funciona en todas las secuencias en Python. También ten en cuenta que, a pesar de agregar 4 y 3 al conjunto dos veces, cada elemento solo puede aparecer una vez en un conjunto.

1# Crear un conjunto vacío:
2s = set()
3
4# Agregar algunos elementos:
5s.add(1)
6s.add(2)
7s.add(3)
8s.add(4)
9s.add(3)
10s.add(1)
11
12# Quitar el 2 del conjunto
13s.remove(2)
14
15# Imprimir el conjunto:
16print(s)
17
18# Encontrar el tamaño del conjunto:
19print(f"El conjunto tiene {len(s)} elementos.")
20
21""" Este es un comentario de varias líneas en Python:
22Salida:
23{1, 3, 4}
24El conjunto tiene 3 elementos.
25"""

1. Ordenadas: No
2. Mutables: Sí

Losdiccionariosde Python, o dicts, serán especialmente útiles en este curso. Un diccionario es un conjunto de pares clave-valor, donde cada clave tiene un valor correspondiente, al igual que en un diccionario, cada palabra(la clave) tiene una definición correspondiente(el valor). En Python, utilizamos llaves(corchetes) para contener un diccionario y dos puntos para indicar claves y valores. Por ejemplo:

1# Definir un diccionario
2casas = {"Harry": "Gryffindor", "Draco": "Slytherin"}
3# Imprimir la casa de Harry
4print(casas["Harry"])
5# Agregar valores a un diccionario:
6casas["Hermione"] = "Gryffindor"
7# Imprimir la Casa de Hermione:
8print(casas["Hermione"])
9
10""" Output:
11Gryffindor
12Gryffindor
13"""

1. Ordenadas: No
2. Mutables: Sí

LosbuclesLos son una parte increíblemente importante de cualquier lenguaje de programación, y en Python, existen dos formas principales:bucles forybucles while. Por ahora, nos centraremos en los bucles for.

• Los buclesforse utilizan para iterar sobre una secuencia de elementos, realizando un bloque de código (sangrado debajo) para cada elemento en una secuencia. Por ejemplo, el siguiente código imprimirá los números del 0 al 5:

1for i in [0, 1, 2, 3, 4, 5]:
2print(i)
3            
4""" Output:
50
61
72
83
94   
105
11"""

• Podemos condensar este código utilizando la función range de Python, que nos permite obtener fácilmente una secuencia de números. El siguiente código produce el mismo resultado que nuestro código anterior:

1for i in range(6):
2    print(i)
3
4""" Output:
50
61
72
83
94
105
11"""

1# Crea una lista:
2nombres = ["Harry", "Ron", "Hermione"]
3
4# Imprime en pantalla cada nombre:
5for nombre in nombres:
6    print(name)
7
8""" Output:nombres
9Harry
10Ron
11Hermione
12"""

1name = "Harry"
2for char in name:
3    print(char)
4
5""" Output:
6H
7a
8r
9r
10y
11"""

Ya hemos visto algunas funciones de Python, comoprinteinput, pero ahora vamos a adentrarnos en escribir nuestras propias funciones. Para comenzar, escribiremos una función que toma un número y lo eleva al cuadrado:

1def square(x):
2return x * x

Observa cómo utilizamos la palabra clave"def"para indicar que estamos definiendo una función, que estamos tomando una única entrada llamada"x" y que utilizamos la palabra clave"return"para indicar cuál debe ser la salida de la función.

Luego podemos "llamar" a esta función de la misma manera en que hemos llamado a otras:
utilizando paréntesis:

1for i in range(10):
2print(f"The square of {i} is {square(i)}")
3            
4""" Output:
5El cuadrado de 0 es 0
6El cuadrado de 1 es 1
7El cuadrado de 2 es 4
8El cuadrado de 3 es 9
9El cuadrado de 4 es 16
10El cuadrado de 5 es 25
11El cuadrado de 6 es 36
12El cuadrado de 7 es 49
13El cuadrado de 8 es 64
14El cuadrado de 9 es 81
15"""

A medida que nuestros proyectos se vuelvan más grandes, será útil poder escribir funciones en un archivo y ejecutarlas en otro. En el caso anterior, podríamos crear un archivo llamado"functions.py"con el código:

1def square(x):
2return x * x

Y otro archivo llamado"square.py"con el código:

1for i in range(10):
2print(f"The square of {i} is {square(i)}")

Sin embargo, cuando intentemos ejecutar"square.py", nos adentraremos en el siguiente error:

Nos encontramos con este problema porque, de forma predeterminada, los archivos de Python no saben acerca de los demás, por lo que debemos importar explícitamente la función"square" desde el módulo"functions" que acabamos de escribir. Ahora, cuando"square.py"se ve así:

1from functions import square
2
3for i in range(10):
4    print(f"The square of {i} is {square(i)}")

Alternativamente, podemos optar por importar el módulo completo"functions" y luego utilizar la notación de punto para acceder a la función"square":

1import functions
2
3for i in range(10):
4    print(f"The square of {i} is {functions.square(i)}")

Existen muchos módulos incorporados en Python que podemos importar, como "math" o "csv", que nos brindan acceso a aún más funciones. Además, podemos descargar aún más módulos para acceder a una funcionalidad adicional. Pasaremos mucho tiempo utilizando el módulo Django, que veremos en la próxima etapa.

LaProgramación Orientada a Objetoses un paradigma de programación, o una forma de pensar acerca de la programación, que se centra en objetos que pueden almacenar información y realizar acciones.

• Clases: Ya hemos visto varios tipos diferentes de variables en Python, pero ¿qué pasa si queremos crear nuestro propio tipo? Una clase en Python es esencialmente una plantilla para un nuevo tipo de objeto que puede almacenar información y realizar acciones. Aquí tienes una clase que define un punto bidimensional:

1class Point():
2# Un método para definir como crear un punto:
3def __init__(self, x, y):
4    self.x = x
5    self.y = y

en en cuenta que en el código anterior, utilizamos la palabra clave"self"para representar el objeto con el que estamos trabajando actualmente."self"debe ser el primer argumento para cualquier método dentro de una clase de Python.

• Ahora, veamos cómo realmente podemos usar la clase de arriba para crear un objeto:

1p = Point(2, 8)
2print(p.x)
3print(p.y)
4
5""" Output:
62
78
8"""

Ahora, veamos un ejemplo más interesante en el que, en lugar de almacenar solo las coordenadas de un punto, creamos una clase que representa un vuelo de aerolínea:

1class Vuelo():
2# Método para crear un vuelo nuevo y su capacidad:
3def __init__(self, capacidad):
4    self.capacidad = capacidad
5    self.pasajeros = []
6            
7    # Método para agregar pasajeros al vuelo:
8def agregar_pasajero(self, nombre):
9    self.pasajeros.append(nombre)

Sin embargo, esta clase tiene una falla, ya que aunque establecemos una capacidad, todavía podríamos agregar demasiados pasajeros. Vamos a mejorarla para que antes de agregar un pasajero, verifiquemos si hay espacio en el vuelo:

1class Vuelo():
2# Método para crear un vuelo nuevo y su capacidad:
3def __init__(self, capacidad):
4    self.capacidad = capacidad
5    self.pasajeros = []
6            
7# Método para agregar pasajeros al vuelo:
8def agregar_pasajero(self, nombre):
9    if not self.asientos_disponibles():
10        return False
11    self.pasajeros.append(nombre)
12    return True
13            
14# Método para devolver el número de los asientos disponibles:
15def acientos_disponibles(self):
16    return self.capacidad - len(self.pasajeros)

Observa que arriba utilizamos la línea"if not self.asientos_disponibles"para determinar si hay o no asientos disponibles. Esto funciona porque en Python, el número 0 puede interpretarse como False, y también podemos usar la palabra clave"not"para indicar lo contrario de la declaración siguiente, por lo que "not True" es False y"not False" es True. Por lo tanto, si "asientos_disponibles"devuelve 0, toda la expresión se evaluará como True.

Ahora, probemos la clase que hemos creado instanciando algunos objetos:

1# Crear un nuevo vuelo con capacidad para 3 pasajeros
2vuelo = Vuelo(3)
3
4# Crear una lista de personas
5personas = ["Harry", "Ron", "Hermione", "Ginny"]
6
7# Intentar añadir a cada persona de la lista al vuelo
8for persona in personas:
9    if vuelo.agregar_pasajero(persona):
10        print(f"Se añadió a {persona} al vuelo con éxito")
11    else:
12        print(f"No hay asientos disponibles para {persona}")
13
14""" Resultado:
15Se añadió a Harry al vuelo con éxito
16Se añadió a Ron al vuelo con éxito
17Se añadió a Hermione al vuelo con éxito
18No hay asientos disponibles para Ginny
19"""

Además de admitir la Programación Orientada a Objetos, Python también admite el Paradigma deProgramación Funcional, en el cual las funciones se tratan como valores, al igual que cualquier otra variable.

Una cosa que es posible gracias a la programación funcional es la idea de un decorador, que es una función de orden superior que puede modificar otra función. Por ejemplo, escribamos un decorador que anuncie cuándo una función está a punto de comenzar y cuándo termina. Luego, podemos aplicar este decorador utilizando el símbolo "@".

1def anunciar(f):
2def envoltorio():
3    print("A punto de ejecutar la función")
4    f()
5    print("Terminado con la función")
6return envoltorio
7        
8@anunciar
9def hola():
10print("¡Hola, mundo!")
11        
12hola()
13        
14""" Resultado:
15A punto de ejecutar la función
16¡Hola, mundo!
17Terminado con la función
18"""

Los decoradores también se pueden usar en las clases para losgettersysetters, para las clases abstractas, usar métdos estáticos, entre otros. Veamos un ejemplo en una clase con los decoradores de getters y setters:

1# Clase con decoradores getters y setters
2class Persona:
3  # Se inicializa una clase con sus atributos
4   def __init__(self, nombre, apellido, edad):
5   self._nombre = nombre
6   self._apellido = apellido
7   self._edad = edad
8            
9   # Decorador para obtener el nombre
10  @property
11  def nombre(self):
12    return self._nombre
13
14  # Decorador para agregar o cambiar el nombre
15  @nombre.setter
16  def nombre(self, nombre):
17    self._nombre = nombre
18
19  @property
20  def edad(self):
21    return self._edad
22
23  @edad.setter
24  def edad(self, edad):
25    self._edad = edad
26
27  def nombre_completo(self):
28    return f"Nombre completo: {self._nombre} {self._apellido}"

Para probar esta clase podemos crear un archivo nuevo llamadotest_persona.pyy creamos los siguientes objetos:

1# Creamos dos objetos para pruebas
2persona = Persona("Manuel", "Calavera", 98)
3persona1 = Persona("Dominic", "Decocco", 38)
4persona.nombre_completo()
5persona1.nombre_completo()
6"""Salida en consola
7Nombre completo: Manuel Calavera
8Nombre completo: Dominic Decocco
9"""
10# Modificar el nombre
11persona.nombre = "Neo"
12persona.nombre_completo()
13"""Salida en consola
14Nombre completo: Manuel Calavera
15Nombre completo: Dominic Decocco
16Nombre completo: Neo Calavera
17"""
18# Obtener edad
19print(persona1.edad)  # en consola: 38

Las funciones lambda proporcionan otra forma de crear funciones en Python. Por ejemplo, si queremos definir la misma función cuadrado que hicimos anteriormente, podemos escribir:

1square = lambda x: x * x

Donde la entrada está a la izquierda de los dos puntos (:) y la salida está a la derecha.

Esto puede ser útil cuando no queremos escribir una función completamente separada para un uso único o pequeño. Por ejemplo, si deseamos ordenar algunos objetos donde inicialmente no está claro cómo deben ordenarse. Imagina que tenemos una lista de personas, pero con nombres y casas en lugar de solo nombres que deseamos ordenar:

1people = [
2  {"name": "Harry", "house": "Gryffindor"},
3  {"name": "Cho", "house": "Ravenclaw"},
4  {"name": "Draco", "house": "Slytherin"}
5]
6              
7people.sort()
8              
9print(people)

Esto, sin embargo nos deja este error:

Esto sucede porque Python no sabe cómo comparar dos diccionarios para verificar si uno es menor que el otro.

Podemos resolver este problema incluyendo un argumento "key" en la función de ordenamiento, que especifica qué parte del diccionario deseamos utilizar para ordenar:

1people = [
2    {"name": "Harry", "house": "Gryffindor"},
3    {"name": "Cho", "house": "Ravenclaw"},
4    {"name": "Draco", "house": "Slytherin"}
5]
6
7def f(person):
8    return person["name"]
9
10people.sort(key=f)
11
12print(people)
13
14""" Output:
15[{'name': 'Cho', 'house': 'Ravenclaw'}, 
16{'name': 'Draco', 'house': 'Slytherin'}, 
17{'name': 'Harry', 'house': 'Gryffindor'}]
18"""

Si bien esto funciona, hemos tenido que escribir una función completa que solo estamos utilizando una vez. Podemos hacer que nuestro código sea más legible utilizando una función lambda:

1people = [
2    {"name": "Harry", "house": "Gryffindor"},
3    {"name": "Cho", "house": "Ravenclaw"},
4    {"name": "Draco", "house": "Slytherin"}
5]
6
7people.sort(key=lambda person: person["name"])
8
9print(people)
10
11""" Output:
12[{'name': 'Cho', 'house': 'Ravenclaw'}, 
13{'name': 'Draco', 'house': 'Slytherin'}, 
14{'name': 'Harry', 'house': 'Gryffindor'}]
15"""

Durante esta conferencia, nos hemos encontrado con varias excepciones diferentes, por lo que ahora veremos algunas nuevas formas de lidiar con ellas.

En el siguiente fragmento de código, tomaremos dos números enteros del usuario e intentaremos dividirlos:

1x = int(input("x: "))
2y = int(input("y: "))
3
4result = x / y
5
6print(f"{x} / {y} = {result}")

En muchos casos, el programa funciona bien:

Sin embargo, nos encontraremos con problemas cuando intentemos dividir por 0:

Podemos manejar este error desordenado utilizando elmanejo de excepciones. En el siguiente bloque de código,intentaremos dividir los dos números,exceptocuando obtengamos unZeroDivisionError :

1import sys
2
3x = int(input("x: "))
4y = int(input("y: "))
5
6try:
7    result = x / y
8except ZeroDivisionError:
9    print("Error: No se puede dividir por 0.")
10    # Salir del programa
11    sys.exit(1)
12
13print(f"{x} / {y} = {result}")

En este caso cuando intentemos esto de nuevo:

Sin embargo, aún nos encontramos con un error cuando el usuario ingresa valores que no son números para x e y:

Podemos resolver este problema de similar manera:

1import sys
2
3try:
4    x = int(input("x: "))
5    y = int(input("y: "))
6except ValueError:
7    print("Error: Entrada no válida.")
8    sys.exit(1)
9
10try:
11    result = x / y
12except ZeroDivisionError:
13    print("Error: No se puede dividir por 0.")
14    # Salir del programa
15    sys.exit(1)
16
17print(f"{x} / {y} = {result}")

¡Eso es todo para esta clase! La próxima clase, usaremos el módulo Django de Python para construir algunas aplicaciones.