class: center, middle, inverse, title-slide .title[ #
Introducción a Python
] .subtitle[ ##
Clase 6d: Lambda functions y decoradores
] .author[ ### Daniel Miles Touya
Máster en Análisis de Datos · UdelaR-Uvigo
] .date[ ### 24 abril 2026 ] --- --- class: inverse, middle .huge[Clase 7] <br> ## Módulos y paquetes --- # Guía de lectura .smallest[ Hasta ahora: - sabemos funciones - sabemos objetos ] -- .div_bloque[ Problema nuevo: > ¿cómo organizamos código grande? ] --- # Qué es un módulo .div_bloque[ Un módulo = un fichero .py ] -- .smallest[ Contiene: - funciones - variables - clases ] --- # Importar un módulo ```python import os print(type(os)) ``` -- .smallest[ <class 'module'> ] --- # Idea clave .div_bloque[ Un módulo es un objeto. ] --- # Acceso con punto ```python import os print(os.getcwd()) ``` -- .smallest[ módulo.función() ] --- # Tres formas de importar .smallest[ Forma 1: ] ```python import os ``` -- .smallest[ Forma 2: ] ```python from os import getcwd ``` -- .smallest[ Forma 3: ] ```python from os import * ``` --- # Diferencia clave .div_bloque[ Qué entra en el namespace ] --- ```python import os print("os" in globals()) print("getcwd" in globals()) ``` --- ```python from os import getcwd print("getcwd" in globals()) ``` --- # Peligro .div_bloque[ Nunca usar import * ] -- .smallest[ Sobrescribe nombres sin aviso ] --- # Ejemplo peligroso ```python join = "texto" from os.path import * print(join) ``` -- .div_bloque.small[ .hi-red[Problema:] join cambia sin aviso ] --- # Sintaxis con punto .div_bloque[ os.path.join ] -- .smallest[ Es solo acceso a atributos ] --- ```python import os print(type(os)) print(type(os.path)) print(type(os.path.join)) ``` --- # Idea clave .div_bloque[ No es sintaxis especial ] -- .smallest[ objeto → atributo → atributo ] --- # Alias ```python import pandas as pd import numpy as np ``` -- .smallest[ Estándar universal ] --- # Por qué importa .div_bloque[ Todo el mundo usa pd y np ] -- .smallest[ incluida la IA ] --- # Mini ejercicio 1 .smallest[ ¿Qué entra en globals()? ] ```python import os from os import getcwd ``` --- # Mini ejercicio 2 .smallest[ ¿Qué imprime? ] ```python join = "hola" from os.path import * print(join) ``` --- # Mini ejercicio 3 .smallest[ Descompón: ] ```python os.path.join("a", "b") ``` --- # Paquetes .div_bloque[ Un paquete = carpeta con módulos ] --- # Estructura .smallest[ Ejemplo: ] ``` proyecto/ main.py utilidades/ __init__.py limpieza.py ``` --- # Importar módulo propio ```python from utilidades import limpieza ``` --- # Idea clave .div_bloque[ Igual que librerías externas ] --- # sys.path .div_bloque[ Dónde busca Python módulos ] -- ```python import sys print(sys.path) ``` --- # Error típico .div_bloque[ ModuleNotFoundError ] -- .smallest[ El módulo no está en sys.path ] --- # __name__ == "__main__" ```python if __name__ == "__main__": print("ejecutando script") ``` --- # Idea clave .div_bloque[ Ejecutar ≠ importar ] --- # Qué debes entender .smallest[ - qué es un módulo - cómo importar - namespace - paquetes - errores típicos ] -- .div_bloque[ .hi-blue[Idea final:] > Los módulos organizan y reutilizan código. ] --- # Parte II · El módulo como objeto class: inverse, middle .huge[Todo es un objeto] <br> ## También los módulos --- # Idea clave .div_bloque[ Un módulo es un objeto Python. ] -- .smallest[ Igual que: - listas - funciones - números ] --- # Tipo de un módulo ```python import os import math print(type(os)) print(type(math)) ``` -- .smallest[ <class 'module'> ] --- # Comparación ```python print(type(42)) print(type("hola")) print(type([1,2,3])) print(type(os)) ``` -- .smallest[ Todos son objetos ] --- # Identidad ```python import os print(id(os)) ``` -- .smallest[ Dirección en memoria ] --- # Importar dos veces ```python import os import os as os2 print(os is os2) ``` -- .smallest[ True ] --- # Idea clave .div_bloque[ Python reutiliza el mismo módulo. ] --- # Atributos del módulo .div_bloque[ Un módulo tiene atributos. ] --- ```python import os print(os.__name__) print(os.__file__) ``` --- # __name__ .smallest[ Nombre del módulo ] ```python print(os.__name__) # "os" ``` --- # __file__ .smallest[ Ruta del fichero ] ```python print(os.__file__) ``` --- # __doc__ .smallest[ Documentación ] ```python import math print(math.__doc__) ``` --- # dir() .div_bloque[ Ver todo lo que contiene ] --- ```python import os print(dir(os)) ``` -- .smallest[ Funciones, variables, submódulos ] --- # Acceso a atributos ```python import os print(os.getcwd) print(type(os.getcwd)) ``` -- .smallest[ Función dentro del módulo ] --- # Equivalencia clave .div_bloque[ Módulo.función = objeto.atributo ] --- ```python lista = [1,2,3] lista.append(4) os.getcwd() ``` -- .smallest[ MISMO mecanismo ] --- # Módulos como variables ```python import os m = os print(m.getcwd()) ``` -- .smallest[ Es el mismo objeto ] --- # Mini ejercicio 1 .smallest[ Predice: ] ```python import math print(type(math)) print(math.__name__) ``` --- # Mini ejercicio 2 .smallest[ ¿Qué devuelve? ] ```python import os print(dir(os)[:5]) ``` --- # Mini ejercicio 3 .smallest[ ¿Qué imprime? ] ```python import os f = os.getcwd print(f()) ``` --- # Error típico .div_bloque[ Pensar que módulo ≠ objeto ] -- .smallest[ Sí es un objeto ] --- # Leer código IA .div_bloque[ Cuando veas: ] ```python pd.DataFrame(...) ``` -- .smallest[ - pd → módulo - DataFrame → atributo ] --- # Idea profunda .div_bloque[ Los módulos tienen su propio namespace ] --- # Qué debes entender .smallest[ - módulo como objeto - atributos (__name__, __file__) - dir() - acceso con punto ] -- .div_bloque[ .hi-blue[Idea final:] > Un módulo es un objeto con atributos y funciones. ] --- # Parte III · Módulos esenciales class: inverse, middle .huge[Herramientas básicas] <br> ## Librerías estándar --- # Idea clave .div_bloque[ Python incluye muchas herramientas. ] -- .smallest[ No hace falta programarlo todo. ] --- # Módulo math .div_bloque[ Funciones matemáticas ] --- ```python import math print(math.sqrt(16)) print(math.log(10)) print(math.pi) ``` -- .smallest[ 4.0 2.302... 3.1415... ] --- # Mini ejercicio .smallest[ Calcula: ] ```python math.sqrt(25) math.log(1) ``` --- # Módulo random .div_bloque[ Aleatoriedad ] --- ```python import random print(random.random()) print(random.randint(1, 10)) ``` -- .smallest[ Número aleatorio entre 1 y 10 ] --- # Mini ejercicio .smallest[ Genera: - número entre 0 y 1 - entero entre 5 y 15 ] --- # Módulo os .div_bloque[ Sistema operativo ] --- ```python import os print(os.getcwd()) print(os.listdir()) ``` -- .smallest[ directorio actual archivos en carpeta ] --- # Mini ejercicio .smallest[ Lista archivos y cuenta cuántos hay ] --- # Módulo sys .div_bloque[ Control del entorno ] --- ```python import sys print(sys.path) print(sys.version) ``` --- # Mini ejercicio .smallest[ ¿Qué contiene sys.path? ] --- # Módulo datetime .div_bloque[ Fechas y tiempo ] --- ```python from datetime import datetime now = datetime.now() print(now) print(now.year) ``` --- # Mini ejercicio .smallest[ Imprime: - año actual - mes actual ] --- # Módulo statistics .div_bloque[ Estadística básica ] --- ```python import statistics data = [1, 2, 3, 4] print(statistics.mean(data)) print(statistics.median(data)) ``` --- # Mini ejercicio .smallest[ Calcula media y mediana de: [10, 20, 30] ] --- # Idea clave .div_bloque[ No reinventar la rueda. ] --- # Patrón de uso .smallest[ 1. importar 2. explorar con dir() 3. usar funciones ] --- # Ejemplo completo ```python import math val = math.sqrt(9) + math.log(10) print(val) ``` --- # Leer código IA .div_bloque[ Cuando veas: ] ```python import math ``` -- .smallest[ → funciones matemáticas disponibles ] --- # Error típico .div_bloque[ Olvidar importar ] -- ```python sqrt(16) ``` -- .div_bloque.small[ .hi-red[Error:] NameError ] --- # Qué debes entender .smallest[ - qué hace cada módulo - cuándo usarlo - cómo acceder a funciones ] -- .div_bloque[ .hi-blue[Idea final:] > Python ya tiene muchas herramientas listas para usar. ] --- # Parte IV · pandas y numpy class: inverse, middle .huge[Análisis de datos] <br> ## numpy · pandas --- # Motivación .div_bloque[ Python “base” no es suficiente para datos. ] -- .smallest[ Necesitamos herramientas más potentes. ] --- # numpy .div_bloque[ Cálculo numérico eficiente ] --- ```python import numpy as np a = np.array([1, 2, 3]) print(a) print(a * 2) ``` -- .smallest[ [1 2 3] [2 4 6] ] --- # Idea clave .div_bloque[ Operaciones vectorizadas ] -- .smallest[ Sin bucles ] --- # Mini ejercicio .smallest[ Predice: ] ```python a = np.array([1, 2, 3]) print(a + 10) ``` --- # pandas .div_bloque[ Trabajo con datos tabulares ] --- ```python import pandas as pd df = pd.DataFrame({ "nombre": ["Ana", "Luis"], "edad": [20, 25] }) print(df) ``` --- # Idea clave .div_bloque[ Un DataFrame es como una tabla ] --- # Selección de columnas ```python print(df["edad"]) ``` --- # Operaciones ```python df["edad"] = df["edad"] + 1 print(df) ``` --- # Mini ejercicio .smallest[ Añade una columna: ] ```python df["edad2"] = df["edad"] * 2 ``` --- # Conexión con funciones .div_bloque[ Se usan funciones constantemente ] --- ```python df["edad"].apply(lambda x: x + 1) ``` --- # Idea clave .div_bloque[ Todo lo anterior se usa aquí ] -- .smallest[ - funciones - lambda - módulos ] --- # numpy vs pandas .smallest[ numpy: - arrays - cálculo rápido ] -- .smallest[ pandas: - tablas - análisis de datos ] --- # Ejemplo combinado ```python import numpy as np import pandas as pd data = np.array([1, 2, 3]) df = pd.DataFrame({"x": data}) print(df) ``` --- # Mini ejercicio 2 .smallest[ Predice: ] ```python df = pd.DataFrame({"x": [1, 2, 3]}) print(df["x"] * 2) ``` --- # Error típico .div_bloque[ Olvidar importar con alias ] -- ```python pd.DataFrame(...) ``` -- .div_bloque.small[ .hi-red[Error:] NameError si no importas ] --- # Convención .div_bloque[ Siempre: ] ```python import numpy as np import pandas as pd ``` --- # Leer código IA .div_bloque[ Cuando veas: ] ```python df.apply(lambda x: ...) ``` -- .smallest[ → función aplicada a datos ] --- # Qué debes entender .smallest[ - qué es numpy - qué es pandas - operaciones básicas - conexión con funciones ] -- .div_bloque[ .hi-blue[Idea final:] > numpy y pandas permiten trabajar con datos de forma eficiente. ] --- # Extra · Visualización con matplotlib class: inverse, middle .huge[Gráficos] <br> ## matplotlib --- # Motivación .div_bloque[ No solo analizamos datos: > también los visualizamos ] --- # Qué es matplotlib .div_bloque[ Librería para hacer gráficos. ] -- .smallest[ Muy usada en: - análisis de datos - machine learning ] --- # Importación estándar ```python import matplotlib.pyplot as plt ``` -- .div_bloque.small[ Convención universal: plt ] --- # Ejemplo básico ```python import matplotlib.pyplot as plt x = [1, 2, 3] y = [2, 4, 6] plt.plot(x, y) plt.show() ``` --- # Idea clave .div_bloque[ Siempre: 1. crear gráfico 2. mostrar con plt.show() ] --- # Gráfico de puntos ```python plt.scatter(x, y) plt.show() ``` --- # Etiquetas ```python plt.plot(x, y) plt.xlabel("x") plt.ylabel("y") plt.title("Mi gráfico") plt.show() ``` --- # Mini ejercicio 1 .smallest[ Crea un gráfico de: x = [1,2,3] y = [1,4,9] ] --- # Mini ejercicio 2 .smallest[ Cambia: - título - etiquetas ] --- # Conexión con pandas ```python df["edad"].plot() plt.show() ``` -- .smallest[ pandas usa matplotlib por debajo ] --- # Error típico .div_bloque[ Olvidar plt.show() ] -- .smallest[ No aparece el gráfico ] --- # Idea clave .div_bloque[ Visualizar = entender datos ] --- # Qué debes entender .smallest[ - qué es matplotlib - estructura básica - tipos de gráficos - conexión con pandas ] -- .div_bloque[ .hi-blue[Idea final:] > matplotlib permite visualizar datos de forma sencilla. ]