Python Medio · Teoría
22 lecciones originales con ejemplos breves, puntos clave y referencias para profundizar.
Una list comprehension construye una lista declarando transformación, recorrido y filtros en una expresión legible.
cuadrados = [n * n for n in range(6) if n % 2 == 0]Las comprehensions de diccionario generan pares clave-valor; las de conjunto eliminan duplicados según hash e igualdad.
longitudes = {texto: len(texto) for texto in ["sol", "luna"]}
iniciales = {texto[0] for texto in ["sol", "senda"]}Las funciones son objetos: pueden asignarse, almacenarse en colecciones, recibirse como argumentos y devolverse. lambda crea una función anónima limitada a una expresión y resulta útil para criterios breves, no para ocultar lógica compleja.
operaciones = [str.lower, lambda texto: texto.strip()]
resultado = operaciones[0]("PYTHON")El unpacking distribuye elementos de un iterable entre destinos. Un único nombre con * recoge la parte variable en una lista.
primero, *centro, ultimo = [1, 2, 3, 4]
combinada = [0, *centro, 5]Un parámetro *args reúne argumentos posicionales restantes en una tupla. Permite adaptar una función sin perder el orden de llamada.
def sumar(*valores):
return sum(valores)**kwargs reúne argumentos por palabra clave en un diccionario. Al llamar, ** expande un mapping con claves de texto válidas.
def configurar(**opciones):
return opciones.get("tema", "claro")map transforma elementos de forma perezosa y filter conserva los que cumplen un predicado. zip recorre iterables en paralelo hasta que termina el más corto; enumerate añade posiciones sin gestionar un contador manual.
nombres = ["Ada", "Lin"]
puntos = [8, 9]
filas = list(enumerate(zip(map(str.upper, nombres), puntos), start=1))Python busca nombres en los ámbitos local, enclosing, global y builtins. global permite reasignar un nombre del módulo y nonlocal reasigna uno del ámbito envolvente más cercano; ambas declaraciones deben usarse con moderación porque introducen estado compartido.
total = 0
def registrar():
global total
total += 1
def contador():
valor = 0
def avanzar():
nonlocal valor
valor += 1
return valor
return avanzarCada módulo tiene su propio espacio de nombres. import modulo conserva visible el origen; from modulo import nombre enlaza un miembro concreto y los imports relativos se resuelven respecto del paquete actual.
import math
from pathlib import Path
print(math.isqrt(81), Path("datos"))Una clase define cómo construir objetos y qué comportamiento comparten. self es la instancia receptora y se pasa de forma implícita al llamar un método.
class Contador:
def __init__(self, inicio=0):
self.valor = inicio
def avanzar(self):
self.valor += 1
return self.valorUn atributo de clase se comparte durante la búsqueda; asignar el mismo nombre en una instancia crea normalmente un atributo propio que lo sombrea.
class Documento:
categoria = "texto"
uno = Documento()
uno.categoria = "informe"La herencia permite especializar comportamiento. super delega según el orden de resolución de métodos, no significa simplemente llamar al padre textual.
class Mensaje:
def texto(self): return "base"
class Alerta(Mensaje):
def texto(self): return super().texto().upper()@dataclass genera métodos como __init__ y __repr__ a partir de campos anotados. field controla valores predeterminados y fábricas.
from dataclasses import dataclass
@dataclass(frozen=True)
class Punto:
x: int
y: intproperty ofrece sintaxis de atributo con lógica de lectura o escritura. El almacenamiento debe usar otro nombre para evitar recursión.
class Temperatura:
def __init__(self, celsius): self._celsius = celsius
@property
def celsius(self): return self._celsiusiter obtiene un iterador y next solicita valores hasta StopIteration. Un iterable puede crear recorridos independientes; un iterador conserva estado.
valores = iter([10, 20])
print(next(valores))Una función con yield devuelve un generador. Cada next reanuda su marco hasta el siguiente yield, conservando variables locales.
def pares(limite):
for n in range(limite):
if n % 2 == 0:
yield nUn decorador recibe el objeto definido y devuelve el objeto que quedará enlazado al nombre. functools.wraps conserva metadatos de la función envuelta.
from functools import wraps
def registrar(funcion):
@wraps(funcion)
def wrapper(*args, **kwargs):
return funcion(*args, **kwargs)
return wrapperwith usa __enter__ y __exit__ para delimitar adquisición y liberación. La limpieza ocurre incluso si el bloque lanza una excepción.
class Recurso:
def __enter__(self): return self
def __exit__(self, exc_type, exc, tb): return Falsepathlib representa rutas y open debe usarse con with. Especificar encoding evita depender de la configuración local; las rutas recibidas deben validarse contra una carpeta permitida.
from pathlib import Path
ruta = Path("notas.txt")
with ruta.open("w", encoding="utf-8") as archivo:
archivo.write("hola")json.dumps serializa datos compatibles y json.loads analiza texto JSON. JSON no preserva tuplas, claves no textuales ni objetos arbitrarios.
import json
texto = json.dumps({"activo": True})
dato = json.loads(texto)Las anotaciones describen contratos para herramientas y lectores; Python no las impone automáticamente en runtime. Las uniones usan | y collections.abc contiene protocolos de uso común.
from collections.abc import Iterable
def total(valores: Iterable[int]) -> int:
return sum(valores)raise crea o vuelve a propagar una excepción y raise ... from ... conserva una causa explícita. except puede manejar tipos concretos; else separa el camino correcto y finally garantiza limpieza, pero no debe ocultar un error con un return.
def cargar_entero(texto):
try:
return int(texto)
except ValueError as error:
raise ValueError("formato de entero inválido") from error
finally:
print("intento finalizado")