El Manifiesto del Código Honesto
Has superado el umbral del principiante. Tu código funciona.
Felicidades. Acabas de alcanzar el nivel de la mediocridad funcional.
Tus programas se ejecutan, pero no te engañes, eso no es un logro. Es el requisito mínimo. Es el equivalente a que un carpintero se enorgullezca de que su silla no se desplome al sentarse. No es para celebrarlo, es lo que se espera de él.
Miras tu obra y sientes un vacío. Ves el código de un maestro y no es solo diferente. Es sólido. Tiene intención. Cada línea sirve a un propósito claro. Tu código, en cambio, es el trabajo de un albañil, no de un arquitecto.
No te voy a enseñar trucos para impresionar a tus colegas en una revisión de código. No seas triste.
Te voy a enseñar 37 leyes.
Principios innegociables para abandonar el hábito del aficionado y adoptar la disciplina del artesano. Cada ley está diseñada para destruir una debilidad en tu forma de pensar y reemplazarla con rigor.
No esperes una lectura cómoda. Cada capítulo te obligará a cuestionar tus costumbres, a desaprender lo que creías saber. El objetivo no es añadir más conocimiento a la pila, es purgar la debilidad de tu lógica.
El resultado no será un código más “bonito”. Será un código honesto.
Un código que no esconde su intención detrás de bucles torpes o nombres de variables confusos. Un código que soporta la presión del cambio. Un código construido con honor.
Un código del que, por fin, no tendrás que avergonzarte.
Sección 1: Fundamentos Pythonicos
Bienvenido, iniciado.
Has llegado aquí porque sabes que hay algo más. Escribes código, y funciona. Felicidades.
También funciona un martillo para abrir una nuez, pero el resultado es un desastre. La diferencia entre un artesano y un aficionado no está en el qué, sino en el cómo.
Estos primeros siete trucos son tu iniciación. Son los katas fundamentales. Grábatelos en la memoria, siéntelos en tus dedos. Son el primer paso para dejar de ser un simple escriba de código y convertirte en un maestro del lenguaje.
Truco #1: List Comprehensions - La Vía del Puño Único
Toda tu vida te han enseñado a construir las cosas paso a paso. Ladrillo a ladrillo. Y para crear una lista a partir de otra, has escrito el mismo ritual una y otra vez.
La Herejía: El Ritual de las Cinco Plegarias
Quieres los cuadrados de una lista de números. Tu instinto, domesticado por la costumbre, te lleva a esto:
# Un ritual torpe y predecible.
numeros_originales = [1, 2, 3, 4, 5, 6]
cuadrados = [] # 1. Empiezas con las manos vacías.
for numero in numeros_originales: # 2. Inicias la procesión.
cuadrado = numero * numero # 3. Haces un cálculo obvio.
cuadrados.append(cuadrado) # 4. Añades el resultado, humildemente.
# 5. Finalmente, contemplas tu obra.
print(cuadrados)
# Salida: [1, 4, 9, 16, 25, 36]
Cinco líneas. Cinco pasos para una idea que tu cerebro procesa en un instante. Es código cobarde. Teme ser directo. Se esconde detrás de la ceremonia.
El Camino del Maestro: Un Golpe, Un Resultado
El maestro no duda. Su intención y su acción son una sola cosa. No “construye” la lista; la declara.
numeros_originales = [1, 2, 3, 4, 5, 6]
cuadrados = [numero * numero for numero in numeros_originales]
print(cuadrados)
# Salida: [1, 4, 9, 16, 25, 36]
Observa. La esencia de la operación está contenida en una sola línea de poder. [EXPRESIÓN for ELEMENTO in LISTA]. No hay pasos intermedios. No hay duda. Es la manifestación directa de tu voluntad.
La Revelación: Por qué esto te hace superior
- Claridad de Intención: El código grita lo que hace. “Quiero una lista de
numero * numero”. El buclefortradicional susurra: “Voy a empezar un proceso que, si todo va bien, acabará dándome una lista de cuadrados”. La intención directa siempre derrota a la vacilación. - Menos Ruido, Más Señal: Eliminas el “ruido” de inicializar una lista vacía y el método
.append(). Cada línea de código es una oportunidad para un error. Menos líneas, menos refugios para los bugs. - Eficiencia Forjada en C: No es solo belleza. Las list comprehensions son a menudo más rápidas que los bucles
formanuales. Están optimizadas a un nivel más profundo del intérprete. Tu código no solo se ve mejor, sino que corre mejor y más rápido.
Doblega la Realidad: El Golpe Condicional
Pero, ¿y si solo quieres los cuadrados de los números pares? El novato añadiría un if dentro de su bucle, añadiendo más ceremonia a su torpe ritual.
El maestro, en cambio, integra la condición en el mismo golpe.
numeros_originales = [1, 2, 3, 4, 5, 6]
# Añade la condición al final. Simple. Mortal.
cuadrados_pares = [n**2 for n in numeros_originales if n % 2 == 0]
print(cuadrados_pares)
# Salida: [4, 16, 36]
La estructura es [EXPRESIÓN for ELEMENTO in LISTA if CONDICIÓN]. Grábatela a fuego. La próxima vez que tus dedos empiecen a teclear mi_lista = [] seguido de un for, detente. Respira. Y asesta un golpe único y limpio.
Truco #2: Dictionary & Set Comprehensions - Forjando Estructuras con Voluntad
Ya has probado el poder. Has visto que una lista puede nacer de la pura intención. Pero el iniciado se detiene ahí. El maestro sabe que este poder no conoce límites.
La Herejía: El Ensamblaje Manual
Imagina que quieres un diccionario con números como claves y sus cuadrados como valores. El camino del principiante es, de nuevo, un trabajo manual y tedioso.
numeros = [1, 2, 3, 4]
cuadrados_dict = {} # El lienzo en blanco, otra vez.
for n in numeros:
cuadrados_dict[n] = n * n # Asignación manual, una por una.
print(cuadrados_dict)
# Salida: {1: 1, 2: 4, 3: 9, 4: 16}
Y para un conjunto (set) con las letras únicas de una palabra:
palabra = "disciplina"
letras_unicas = set() # Un saco vacío.
for letra in palabra:
letras_unicas.add(letra) # Añadiendo una a una, como un campesino.
print(letras_unicas)
# Salida: {'d', 'p', 'i', 'c', 'l', 's', 'n', 'a'}
Este código carece de alma. Es el trabajo de un contable, no de un creador.
El Camino del Maestro: Invocar la Estructura
El maestro no “llena” un diccionario o un set. Lo invoca a la existencia, completamente formado.
numeros = [1, 2, 3, 4]
# La sintaxis es casi idéntica. El poder es el mismo.
# {CLAVE: VALOR for ELEMENTO in LISTA}
cuadrados_dict = {n: n*n for n in numeros}
print(cuadrados_dict)
# Salida: {1: 1, 2: 4, 3: 9, 4: 16}
# Para el set, es aún más simple.
# {EXPRESIÓN for ELEMENTO in LISTA}
palabra = "disciplina"
letras_unicas = {letra for letra in palabra}
print(letras_unicas)
# Salida: {'d', 'p', 'i', 'c', 'l', 's', 'n', 'a'}
Las llaves {} le dicen a Python tu intención: forjar un diccionario o un set. La sintaxis clave: valor distingue al diccionario. La ausencia de dos puntos crea el set. Es un lenguaje de poder, sutil y preciso.
La Revelación: Declarar vs. Construir
La diferencia es filosófica. El hereje construye la estructura de datos paso a paso. Está inmerso en el proceso. El maestro declara la estructura de datos final. Está enfocado en el resultado.
Cuando lees {n: n*n for n in numeros}, tu mente ve inmediatamente un diccionario completo. No tiene que simular mentalmente un bucle, una asignación, otra iteración, otra asignación… El código expresa el “qué” (un diccionario de cuadrados), no el “cómo” (un bucle que asigna valores). Este es el pilar del código limpio.
Doblega la Realidad: Creación a partir de Diccionarios Existentes
Este poder no se limita a crear desde listas. Puedes forjar un nuevo diccionario a partir de otro, filtrando y transformando con una precisión quirúrgica.
stock_precios = {'manzana': 1.50, 'platano': 0.75, 'naranja': 2.25, 'kiwi': 0.99}
# Crear un nuevo diccionario solo con las frutas caras (precio > 1.0)
frutas_caras = {fruta: precio for fruta, precio in stock_precios.items() if precio > 1.0}
print(frutas_caras)
# Salida: {'manzana': 1.5, 'naranja': 2.25}
Observa el uso de .items() para acceder a la vez a la clave y al valor. Observa cómo la condición if filtra los elementos con la misma elegancia que en las list comprehensions.
No estás escribiendo código. Estás esculpiendo datos.
Sección 2: Maestría en Estructuras de Datos - Forja tus Armas
Un programador mediocre piensa en los datos como algo que se guarda.
Un maestro entiende que los datos son algo que se maneja.
Las estructuras de datos —listas, diccionarios, sets— no son simples contenedores. Son tus armas. Cada una tiene un filo, un peso y un propósito. Usar la incorrecta es como llevar una lanza a una pelea de cuchillos: torpe, ineficiente y una señal de incompetencia.
En esta sección, aprenderás a elegir el arma correcta para cada combate. Dejarás de aporrear los datos con la herramienta genérica y empezarás a aplicar la técnica precisa que resuelve el problema con una eficiencia y elegancia devastadoras.
Domina estas herramientas y tus datos se doblegarán a tu voluntad.
Truco #8: collections.Counter - El Abacus del Guerrero
Contar cosas.
Una tarea tan fundamental, tan repetitiva, que ver a alguien hacerlo mal es un insulto a la profesión.
La Herejía: El Conteo Manual
Te dan una lista de elementos y te piden que cuentes las ocurrencias de cada uno. El novato, con más entusiasmo que cerebro, construye esto:
# Código que grita "soy nuevo en esto".
votacion = ['gato', 'perro', 'gato', 'gato', 'pez', 'perro', 'hamster', 'gato']
conteo = {}
for animal in votacion:
if animal not in conteo:
conteo[animal] = 1
else:
conteo[animal] += 1
print(conteo)
# Salida: {'gato': 4, 'perro': 2, 'pez': 1, 'hamster': 1}
Este código es un pantano de lógica condicional. El if/else ensucia la intención principal. Estás gestionando el proceso de conteo en lugar de simplemente… contar. Es el equivalente a construir tu propio martillo cada vez que quieres clavar un clavo.
El Camino del Maestro: El Golpe que Cuenta
El maestro no gestiona. Ordena. Y para contar, existe una orden específica.
from collections import Counter
votacion = ['gato', 'perro', 'gato', 'gato', 'pez', 'perro', 'hamster', 'gato']
conteo = Counter(votacion)
print(conteo)
# Salida: Counter({'gato': 4, 'perro': 2, 'pez': 1, 'hamster': 1})
Una línea. Una intención. El código no dice “voy a recorrer y contar”. Dice “esto es un conteo de esto otro”. Counter es una subclase de diccionario diseñada para una sola misión. Es un especialista, y el especialista siempre derrota al generalista.
La Revelación: Delega y Vencerás
Tu trabajo no es reinventar las herramientas básicas. Tu trabajo es resolver problemas complejos. Al usar Counter, delegas la tarea trivial y repetitiva de contar a una herramienta optimizada para ello.
- Legibilidad Absoluta:
Counter(votacion)se explica por sí mismo. El bucle manual requiere un análisis mental. - Funcionalidad Añadida: Un objeto
Counterviene con superpoderes. No es un simple diccionario. Por ejemplo, puedes pedir los elementos más comunes con una facilidad insultante.
Doblega la Realidad: Los Más Buscados y la Aritmética de Conjuntos
¿Quieres saber los dos animales más votados? El hereje tendría que ordenar el diccionario por valores, un ritual torpe. El maestro simplemente pregunta:
# Obtener los 2 elementos más comunes.
print(conteo.most_common(2))
# Salida: [('gato', 4), ('perro', 2)]
Además, puedes realizar operaciones matemáticas con ellos. Imagina una segunda votación.
votacion_2 = ['perro', 'perro', 'gato', 'pez', 'pez', 'pez']
conteo_2 = Counter(votacion_2)
# Combina los conteos
conteo_total = conteo + conteo_2
print(conteo_total)
# Salida: Counter({'gato': 5, 'pez': 4, 'perro': 4, 'hamster': 1})
Usar un diccionario manual para esto es una receta para el código basura. Usa Counter. Demuestra que respetas tu tiempo y el de los demás.
Truco #9: collections.defaultdict - El Diccionario que Anticipa tus Deseos
Los KeyError son la plaga de los diccionarios. Son la prueba de que tu código es frágil, de que no anticipa lo desconocido. El código defensivo para evitarlos es a menudo peor que el error mismo.
La Herejía: El Muro de ifs
Quieres agrupar una lista de palabras por su primera letra. El enfoque del principiante es defensivo, temeroso.
palabras = ['gato', 'perro', 'gallina', 'pez', 'gorila', 'paloma']
agrupadas = {}
for palabra in palabras:
primera_letra = palabra[0]
if primera_letra not in agrupadas:
# Crea la entrada por primera vez, con miedo.
agrupadas[primera_letra] = []
# Añade la palabra, ahora que es seguro.
agrupadas[primera_letra].append(palabra)
print(agrupadas)
# Salida: {'g': ['gato', 'gallina', 'gorila'], 'p': ['perro', 'pez', 'paloma']}
Ese bloque if es un monumento a la inseguridad. Cada vez que accedes al diccionario, tienes que preguntar primero: “¿Puedo? ¿Existe ya la clave?”. Este código tartamudea.
El Camino del Maestro: La Red de Seguridad Invisible
El maestro no pregunta. Actúa. Y utiliza una herramienta que convierte el fallo en una oportunidad.
from collections import defaultdict
palabras = ['gato', 'perro', 'gallina', 'pez', 'gorila', 'paloma']
# Un diccionario que, si una clave no existe, la crea llamando a list().
agrupadas = defaultdict(list)
for palabra in palabras:
# No hay `if`. No hay miedo. Simplemente actúa.
agrupadas[palabra[0]].append(palabra)
print(agrupadas)
# Salida: defaultdict(<class 'list'>, {'g': ['gato', 'gallina', 'gorila'], 'p': ['perro', 'pez', 'paloma']})
defaultdict(list) crea un diccionario con una regla: si intentas acceder a una clave que no existe, créala automáticamente y asigna como su valor el resultado de llamar a list(), es decir, una lista vacía [].
La Revelación: Escribe Código Optimista
El código del hereje es pesimista: asume que la clave no existe y siempre comprueba.
El código del maestro es optimista: asume que la clave existe (o que se creará sobre la marcha) y actúa directamente.
Esto elimina una capa entera de lógica condicional. Tu código se centra en la acción (append(palabra)) en lugar de en la preparación (if key not in...). El flujo de pensamiento es ininterrumpido. El resultado es un código más limpio, más corto y dramáticamente más legible.
Doblega la Realidad: Más Allá de las Listas
El poder de defaultdict no se limita a list. Puedes pasarle cualquier “fábrica” de valores por defecto.
defaultdict(int): Perfecto para contar. Si la clave no existe, se crea con un valor de0.conteo_letras = defaultdict(int) for letra in "abracadabra": conteo_letras[letra] += 1 # Salida: defaultdict(<class 'int'>, {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})defaultdict(set): Para agrupar elementos únicos.defaultdict(lambda: "desconocido"): Usa una funciónlambdapara valores por defecto personalizados.
defaultdict no es solo una comodidad. Es una filosofía. Es la decisión de escribir código que fluye en lugar de código que tropieza.
Truco #10: zip - El Arte de la Marcha Sincronizada
Tienes dos (o más) listas relacionadas. Nombres y edades. Productos y precios. Y necesitas procesarlas en paralelo.
La Herejía: El Índice Torpe
El programador sin entrenamiento recurre a su única herramienta conocida: el índice numérico. Y forja una abominación.
nombres = ['Ana', 'Luis', 'Eva']
edades = [28, 34, 41]
# ¡NO HAGAS ESTO!
for i in range(len(nombres)):
nombre = nombres[i]
edad = edades[i]
print(f"{nombre} tiene {edad} años.")
Este código es un accidente esperando a ocurrir.
- Es feo:
nombres[i]yedades[i]es ruido visual. - Es frágil: ¿Qué pasa si
edadestiene un elemento menos quenombres? El código explotará con unIndexError. - No es Pythonico: Python te da herramientas elegantes para evitar este tipo de contabilidad manual. Ignorarlas es una falta de respeto.
El Camino del Maestro: El Enlace Directo
El maestro no se preocupa por los índices. Se preocupa por las correspondencias. Y para eso, usa zip.
nombres = ['Ana', 'Luis', 'Eva']
edades = [28, 34, 41]
for nombre, edad in zip(nombres, edades):
print(f"{nombre} tiene {edad} años.")
zip toma dos o más iterables y los “acremalla”, produciendo tuplas con los elementos correspondientes de cada uno. Es directo, es limpio y es seguro.
La Revelación: Abstracción del Mecanismo
zip abstrae el mecanismo de la iteración paralela. Ya no te preocupas por contadores, rangos o índices. Te centras en el resultado: pares de elementos relacionados.
Seguridad:
zipse detiene en cuanto el iterable más corto se agota. No hayIndexError. Es inherentemente seguro.Escalabilidad: ¿Necesitas una tercera lista? Simplemente añádela a la llamada de
zip.ciudades = ['Madrid', 'Lima', 'México DF'] for nombre, edad, ciudad in zip(nombres, edades, ciudades): print(f"{nombre} ({edad}) vive en {ciudad}.")Hacer esto con índices manuales es aún más doloroso.
Doblega la Realidad: El Descremallado (Unzip)
La belleza de zip es simétrica. Si puedes “acremallar”, también puedes “descremallar”.
pares = [('Ana', 28), ('Luis', 34), ('Eva', 41)]
# El asterisco (*) desempaqueta los pares dentro de zip
nombres, edades = zip(*pares)
print(nombres) # Salida: ('Ana', 'Luis', 'Eva')
print(edades) # Salida: (28, 34, 41)
Este es un idioma de alto nivel. Con zip(*...), estás diciendo:
“Toma esta lista de pares, y rótalos en dos secuencias separadas”.
Es una operación de transposición de matrices, expresada con una claridad y concisión asombrosas.
Deja de usar índices para iterar. Es el lenguaje de las cavernas. Usa zip y habla como un maestro.
Sección 3: Funciones de Alto Impacto - El Motor de tu Lógica
Las funciones son los verbos de tu código. Son las unidades de acción.
Un novato escribe funciones que son como herramientas baratas de un solo uso: rígidas, frágiles y limitadas. Hacen una cosa y nada más. El maestro, en cambio, forja funciones que son como motores de precisión: flexibles, potentes y reutilizables.
En esta sección, dejarás de escribir simples recetas de código. Aprenderás a construir mecanismos lógicos que se adaptan, que se expanden y que pueden ser combinados para crear sistemas complejos. Entender estas técnicas es la diferencia entre construir una cabaña de madera y diseñar un rascacielos. Ambas te dan cobijo, pero solo una demuestra maestría.
Truco #15: Argumentos Flexibles con *args y **kwargs - La Red que Todo lo Atrapa
Tu función necesita sumar números. Pero, ¿cuántos? ¿Dos, tres, veinte? El iniciado comete el pecado de la rigidez.
La Herejía: Múltiples Funciones para una Sola Idea
El enfoque del aficionado es ingenuo y repetitivo. O bien crea una función para cada caso, o espera que los datos le lleguen en una torpe lista.
# Un diseño rígido y vergonzoso.
def sumar_dos(a, b):
return a + b
def sumar_tres(a, b, c):
return a + b + c
# O esta otra abominación:
def sumar_lista(numeros):
total = 0
for n in numeros:
total += n
return total
sumar_lista([1, 2, 3, 4])
Este código te obliga a empaquetar tus datos antes de pasarlos. Es un paso extra, un estorbo que ensucia la llamada a la función. No fluye.
El Camino del Maestro: La Función Universal
El maestro crea una función que no pregunta cuántos argumentos. Simplemente los acepta.
def sumador_universal(*args):
print(f"He recibido estos argumentos posicionales: {args}")
total = 0
for n in args:
total += n
return total
print(sumador_universal(1, 2, 3, 4, 5))
# Salida:
# He recibido estos argumentos posicionales: (1, 2, 3, 4, 5)
# 15
El asterisco * es la clave. Le dice a Python: “Coge todos los argumentos posicionales que me pasen, desde aquí hasta el final, y empaquétalos en una tupla llamada args”.
Y para los argumentos con nombre, existe un poder gemelo: **kwargs.
def procesar_datos(**kwargs):
print(f"He recibido estos argumentos de palabra clave: {kwargs}")
for clave, valor in kwargs.items():
print(f"Procesando {clave} = {valor}")
procesar_datos(nombre="Arturo", id=112, ciudad="Madrid", status="Activo")
# Salida:
# He recibido estos argumentos de palabra clave: {'nombre': 'Arturo', 'id': 112, 'ciudad': 'Madrid', 'status': 'Activo'}
# Procesando nombre = Arturo
# Procesando id = 112
# Procesando ciudad = Madrid
# Procesando status = Activo
Los dos asteriscos ** le dicen a Python: “Coge todos los argumentos de palabra clave (nombre='valor') y empaquétalos en un diccionario llamado kwargs”.
La Revelación: Construyes Funciones Adaptables, no Rígidas
*argsy**kwargs(los nombres son convenciones, podrías usar*numerosy**opciones) liberan tus funciones de la tiranía de una firma fija.- Flexibilidad: Creas APIs y utilidades que pueden ser usadas en una multitud de situaciones sin tener que reescribirlas.
- Decoradores y Proxies: Son la espina dorsal de los decoradores y de cualquier función que necesite pasar argumentos a otra función sin conocerlos de antemano.
Doblega la Realidad: El Desempaquetado Inverso
El poder fluye en ambas direcciones. Si * y ** pueden empaquetar argumentos, también pueden desempaquetarlos al llamar a una función.
def reporte(nombre, edad, ciudad):
print(f"INFORME: {nombre}, {edad} años, de {ciudad}.")
# Tienes los datos en una lista y un diccionario.
datos_lista = ['Elena', 31, 'Barcelona']
datos_dict = {'nombre': 'Carlos', 'edad': 45, 'ciudad': 'Valencia'}
# El hereje haría esto:
reporte(datos_lista[0], datos_lista[1], datos_lista[2])
# El maestro hace esto:
reporte(*datos_lista) # Desempaqueta la lista en argumentos posicionales.
reporte(**datos_dict) # Desempaqueta el dict en argumentos de palabra clave.
Esta técnica es sublime. Separa la preparación de los datos de la ejecución de la función. Es limpia, es expresiva y es la marca de alguien que domina el flujo del lenguaje.
Truco #16: Funciones como Ciudadanos de Primera Clase - La Lógica como Arma Arrojadiza
En lenguajes menores, las funciones son entidades de segunda clase. Existen, pero no se las puede tratar como a los datos. Están ancladas a su definición. En Python, las funciones son libres.
La Herejía: La Escalera del if/elif/else
Necesitas una calculadora que pueda sumar o restar.
El novato, pensando de forma rígida, construye una estructura de control para decidir qué código ejecutar.
def calcular(operacion, a, b):
if operacion == 'sumar':
return a + b
elif operacion == 'restar':
return a - b
else:
print("Operación no válida")
return None
Este código es un bloque monolítico. Si quieres añadir “multiplicar”, tienes que profanar la función calcular añadiendo otro elif. La función se vuelve un vertedero de lógica condicional. Viola el principio de Abierto/Cerrado (abierto a la extensión, cerrado a la modificación).
El Camino del Maestro: Pasa la Acción, no la Orden
El maestro entiende que una función es un objeto, como un número o una cadena. Puede ser pasada como argumento.
def sumar(a, b):
return a + b
def restar(a, b):
return a - b
def calcular(funcion_a_ejecutar, a, b):
# Simplemente ejecuta la función que te han pasado.
return funcion_a_ejecutar(a, b)
# Pasa la función sumar, no la cadena "sumar".
resultado_suma = calcular(sumar, 10, 5)
resultado_resta = calcular(restar, 10, 5)
print(f"Suma: {resultado_suma}, Resta: {resultado_resta}")
# Salida: Suma: 15, Resta: 5
La función calcular se ha vuelto agnóstica. No sabe nada de sumas o restas. Su única misión es ejecutar la lógica que le pasen. Es un cascarón puro, un ejecutor de estrategias.
La Revelación: Desacopla la Invocación de la Implementación
Cuando tratas a las funciones como ciudadanos de primera clase, alcanzas un nivel superior de abstracción.
- Desacoplamiento:
calcularya no depende desumarorestar. Puedes definirmultiplicaren otro archivo y pasársela acalcularsin que esta se entere. Tu código se vuelve modular y extensible. - Código Expresivo: Escribes código que opera sobre acciones, no solo sobre datos. Esto es la puerta de entrada a la programación funcional.
Doblega la Realidad: El Despachador (Dispatcher)
Puedes llevar esto al extremo y eliminar por completo la estructura if/elif/else usando un diccionario donde las claves son las órdenes y los valores son las acciones.
def multiplicar(a, b):
return a * b
# Un mapa de cadenas a funciones.
operaciones = {
'sumar': sumar,
'restar': restar,
'multiplicar': multiplicar
}
def despachador(operacion, a, b):
# Busca la función en el diccionario y ejecútala.
# Usa .get() para manejar casos no válidos con elegancia.
func = operaciones.get(operacion)
if func:
return func(a, b)
else:
raise ValueError("Operación no válida")
print(despachador('multiplicar', 6, 7)) # Salida: 42
Este patrón es infinitamente extensible. Para añadir una nueva operación, solo tienes que añadir una nueva función y una nueva entrada en el diccionario. El despachador no se toca. Es roca sólida.
Sección 4: Iteración Inteligente - El Corazón Rítmico del Código
La iteración es el latido de tus programas. Es el pulso que bombea datos a través de la lógica.
Un aficionado escribe bucles que son arrítmicos y torpes. Consumen memoria sin piedad, se repiten sin elegancia y manejan la lógica de control con la sutileza de un martillo. Sus bucles son ruido.
El maestro, en cambio, compone. Sus bucles son rítmicos, eficientes y precisos. Entiende que iterar no es solo repetir, es fluir.
Esta sección te enseñará a dominar ese flujo. Aprenderás a encadenar secuencias sin esfuerzo, a manejar la combinatoria con una sola orden y a escribir bucles que expresan su propósito con una claridad devastadora. Deja de hacer ruido. Es hora de encontrar el ritmo.
Truco #21: itertools.chain - Forjando una Sola Corriente
Tienes varias listas, varias secuencias, y necesitas procesarlas como si fueran una sola. El instinto del principiante es la fuerza bruta.
La Herejía: El Muro de Contención de Memoria
El novato ve dos listas y piensa en una más grande. Su primer impulso es unirlas, creando un nuevo y monstruoso objeto en memoria.
# Un acto de derroche y brutalidad.
heroes = ['Aragorn', 'Gimli', 'Legolas']
villanos = ['Sauron', 'Saruman', 'Ella-Laraña']
# Crea una TERCERA lista en memoria.
todos_personajes = heroes + villanos
for personaje in todos_personajes:
print(personaje)
# O peor, repite el código.
for heroe in heroes:
print(heroe)
for villano in villanos:
print(villano)
La primera opción es un crimen contra la memoria RAM.
Si heroes y villanos tuvieran un millón de elementos cada una, acabas de duplicar la memoria necesaria sin razón. La segunda opción es un crimen contra el principio DRY (Don’t Repeat Yourself). Es código perezoso.
El Camino del Maestro: El Flujo Ininterrumpido
El maestro no crea copias. Crea una visión, una secuencia lógica que enlaza los iterables originales sin mover un solo dato.
from itertools import chain
heroes = ['Aragorn', 'Gimli', 'Legolas']
villanos = ['Sauron', 'Saruman', 'Ella-Laraña']
# chain() no crea una nueva lista. Crea un iterador inteligente.
personajes_enlazados = chain(heroes, villanos)
for personaje in personajes_enlazados:
print(personaje)
chain forja un iterador que consume el primer iterable hasta agotarlo, y luego, sin detenerse, empieza a consumir el segundo, y así sucesivamente.
No hay duplicación. No hay desperdicio.
La Revelación: Itera sobre Vistas, no sobre Copias
La diferencia es la misma que entre leer el índice de dos libros y fotocopiar ambos libros para luego graparlos. chain es el índice. El operador + son las fotocopias.
- Eficiencia de Memoria: Es la ventaja más obvia y crítica. Puedes encadenar secuencias de gigabytes de tamaño con un coste de memoria casi nulo.
- Acepta Cualquier Iterable:
chainfunciona con listas, tuplas, generadores, sets… cualquier cosa sobre la que puedas iterar. El operador+es mucho más restrictivo.
Doblega la Realidad: Aplanar con chain.from_iterable
A veces tus secuencias están dentro de otra secuencia, como una lista de listas. El maestro tiene un kata específico para esto.
equipos = [
['Aragorn', 'Gimli', 'Legolas'],
['Frodo', 'Sam'],
['Saruman', 'Grima']
]
# El hereje usaría un bucle anidado.
# for equipo in equipos:
# for miembro in equipo:
# print(miembro)
# El maestro aplana la estructura con una sola orden.
for miembro in chain.from_iterable(equipos):
print(miembro)
chain.from_iterable toma un iterable de iterables y lo convierte en un solo flujo. Es el arma definitiva para aplanar estructuras de datos de forma eficiente.
Truco #22: itertools.combinations y permutations - La Danza de la Combinatoria
Necesitas encontrar todos los posibles pares de un grupo de elementos. O todos los tríos. O todas las posibles secuencias.
La Herejía: El Laberinto de Bucles Anidados
Sin el conocimiento adecuado, el programador se lanza a construir un laberinto de bucles for anidados. Para encontrar pares, escribe dos bucles. Para tríos, escribe tres.
# Un intento valiente pero profundamente erróneo de encontrar pares.
items = ['A', 'B', 'C', 'D']
pares = []
for i in range(len(items)):
for j in range(i + 1, len(items)):
pares.append((items[i], items[j]))
print(pares)
# Salida: [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]
Este código funciona, pero es un desastre. Es difícil de leer, propenso a errores de índice (off-by-one errors) y una pesadilla de mantener.
¿Y si ahora necesitas tríos? ¿Añadirás otro nivel de anidamiento, hundiéndote más en la locura?
El Camino del Maestro: Invocar el Oráculo Matemático
El maestro no escribe algoritmos de combinatoria. Los invoca desde la librería estándar, donde han sido forjados por expertos y optimizados en C.
from itertools import combinations, permutations
items = ['A', 'B', 'C', 'D']
# Combinaciones: El orden NO importa.
pares_combinaciones = list(combinations(items, 2))
print(f"Combinaciones de 2: {pares_combinaciones}")
# Permutaciones: El orden SÍ importa.
pares_permutaciones = list(permutations(items, 2))
print(f"Permutaciones de 2: {pares_permutaciones}")
Salida:
Combinaciones de 2: [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]
Permutaciones de 2: [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'A'), ('B', 'C'), ('B', 'D'), ('C', 'A'), ('C', 'B'), ('C', 'D'), ('D', 'A'), ('D', 'B'), ('D', 'C')]
La intención es explícita. “Dame combinaciones”. “Dame permutaciones”. El código es una declaración, no un enrevesado proceso manual.
La Revelación: Declara tu Intención, no tu Algoritmo
- Corrección Garantizada: La lógica combinatoria es sutil y es fácil equivocarse.
itertoolste da la implementación correcta, siempre. - Legibilidad:
combinations(items, 2)es infinitamente más claro que dos bucles anidados con gestión de índices. - Rendimiento: Estas funciones están escritas en C y son increíblemente rápidas. Cualquier cosa que escribas en Python puro será órdenes de magnitud más lenta.
Doblega la Realidad: La Diferencia Crucial
Elige tu arma con sabiduría.
combinations: Úsalo cuando el orden no importa. Un equipo de(Ana, Luis)es el mismo que(Luis, Ana). Ideal para formar grupos, equipos o pares de lucha.permutations: Úsalo cuando el orden es crucial. Un podio de(Oro: Ana, Plata: Luis)es diferente de(Oro: Luis, Plata: Ana). Ideal para rankings, alineaciones o contraseñas.
Entender esta diferencia es la marca de alguien que piensa en el problema antes de aporrear el teclado.
Truco #24: Bucle for-else - El Grito Final del Bucle
Buscas un elemento en una lista. Si lo encuentras, haces algo y te detienes. Si recorres la lista entera y no lo encuentras, haces otra cosa.
La Herejía: La Bandera de la Derrota
El método del novato es usar una variable “bandera” (flag). Una pequeña y triste variable que lleva la cuenta de si la búsqueda tuvo éxito.
# Un patrón torpe que ensucia el código con estado innecesario.
numeros = [1, 5, 9, 13, 17]
valor_a_buscar = 11
encontrado = False # La bandera.
for n in numeros:
if n == valor_a_buscar:
print(f"¡Encontrado el {valor_a_buscar}!")
encontrado = True
break
if not encontrado:
print(f"El {valor_a_buscar} no está en la lista.")
Esta bandera encontrado es un estorbo. Es estado manual que tienes que recordar inicializar, cambiar y comprobar. Contamina el espacio de nombres y complica una lógica simple.
El Camino del Maestro: La Consecuencia Natural
Python ofrece una sintaxis elegante y a menudo ignorada que elimina la necesidad de la bandera por completo: el bloque else en un bucle for.
numeros = [1, 5, 9, 13, 17]
valor_a_buscar = 11
for n in numeros:
if n == valor_a_buscar:
print(f"¡Encontrado el {valor_a_buscar}!")
break
else:
# Este bloque solo se ejecuta si el bucle termina de forma natural (sin break).
print(f"El {valor_a_buscar} no está en la lista.")
El else no pertenece al if. Pertenece al for. Su significado es:
“Si este bucle ha completado todas sus iteraciones y nunca fue interrumpido por un break, entonces ejecuta este código”.
La Revelación: for ... no-break
Piensa en for/else como for/then. Es una construcción que vincula una acción a la finalización completa de una iteración.
- Elimina el Estado: Destierra las variables bandera de tu código. Menos estado que gestionar significa código más simple y menos propenso a errores.
- Expresa la Intención: La estructura
for/elsedice exactamente lo que significa: “Busca. Si la búsqueda fracasa (el bucle se agota), haz esto”. La intención está integrada en la sintaxis del lenguaje.
Doblega la Realidad: La Prueba del Número Primo
El ejemplo canónico de la belleza del for/else es la función para determinar si un número es primo.
def es_primo(n):
if n < 2:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
# Encontramos un divisor, no es primo.
print(f"{n} no es primo, es divisible por {i}.")
break
else:
# El bucle terminó sin encontrar divisores. Es primo.
print(f"{n} es un número primo.")
es_primo(13) # Salida: 13 es un número primo.
es_primo(15) # Salida: 15 no es primo, es divisible por 3.
Sin la cláusula else, necesitarías una bandera es_primo_flag. Con ella, la lógica es pura, limpia y auto-documentada.
Sección 5: Secretos de la Programación Orientada a Objetos - El Arte de Dar Vida al Código
Muchos aprenden a escribir class y creen que entienden la Programación Orientada a Objetos (POO).
Es un error de novato.
Ven las clases como simples carpetas para agrupar variables y funciones. Un desastre de concepto.
Una clase bien forjada no es una carpeta. Es un ser. Es una entidad con su propio estado, su propio comportamiento y sus propias reglas.
El maestro no escribe clases que son sacos de datos pasivos; esculpe objetos que son agentes activos, inteligentes y autosuficientes.
En esta sección, trascenderás la sintaxis y aprenderás el arte. Descubrirás cómo controlar el acceso a los atributos sin la verbosidad de otros lenguajes, cómo dar a tus objetos una voz para que se describan a sí mismos y cómo optimizarlos para que sean ligeros y eficientes. Es hora de dejar de escribir contenedores de datos y empezar a crear vida.
Truco #27: @property - El Atributo que Piensa
La gestión de atributos es un campo de batalla. O los dejas públicos y desprotegidos, o sigues los dogmas de otros lenguajes, construyendo feas jaulas de código.
La Herejía: Anarquía Pública o la Prisión de Getters/Setters
El principiante comete uno de dos pecados. El primero es la anarquía:
class Usuario:
def __init__(self, edad):
self.edad = edad
user = Usuario(25)
user.edad = -90 # Válido. Desastroso. No hay control.
El segundo pecado, a menudo importado de Java o C++, es construir una prisión de métodos get_ y set_.
# Un código verboso y alienígena en Python.
class Usuario:
def __init__(self, edad):
self._edad = edad
def get_edad(self):
return self._edad
def set_edad(self, valor):
if valor < 0:
raise ValueError("La edad no puede ser negativa")
self._edad = valor
user = Usuario(25)
user.set_edad(30)
print(user.get_edad())
Este código es un insulto a Python.
Es torpe, obliga al usuario a usar llamadas a métodos para algo que conceptualmente es un simple atributo y grita “no entiendo la filosofía de este lenguaje”.
El Camino del Maestro: Empieza Simple, Evoluciona con Poder
El camino Pythonico es confiar. Empiezas con un atributo público y simple. Cuando la necesidad de control aparece, la introduces con magia, sin cambiar la interfaz pública.
class Usuario:
def __init__(self, edad):
self._edad = edad # Atributo "privado" por convención
@property
def edad(self):
"""Este es el 'getter'. Se accede como user.edad"""
print("(Accediendo al valor...)")
return self._edad
@edad.setter
def edad(self, valor):
"""Este es el 'setter'. Se usa como user.edad = valor"""
print(f"(Estableciendo valor a {valor}...)")
if valor < 0:
raise ValueError("La edad no puede ser negativa")
self._edad = valor
user = Usuario(25)
user.edad = 30 # Llama al setter
print(user.edad) # Llama al getter
# user.edad = -10 # Lanzaría ValueError
Para el mundo exterior, user.edad sigue siendo un atributo. No saben —ni les importa— que detrás de esa simple asignación o acceso se esconde lógica de validación.
Has evolucionado tu clase sin romper el contrato con quienes la usan.
La Revelación: Protege la Interfaz, no los Datos
La filosofía de Python no es construir muros infranqueables (como el private de otros lenguajes), sino crear interfaces limpias y predecibles. @property es la herramienta perfecta para esto.
- Interfaz Limpia: Accedes a los datos de forma natural (
user.edad), no a través de verbosos métodos. - Refactorización Segura: Puedes pasar de un atributo público a una propiedad sin que ningún código que use tu clase se rompa. Es evolución sin revolución.
- Encapsulación Real: La lógica de validación vive dentro de la clase, donde pertenece.
Doblega la Realidad: Atributos de Solo Lectura y Calculados
¿Necesitas un atributo que solo se pueda leer? Simplemente no definas un .setter.
class Circulo:
def __init__(self, radio):
self.radio = radio
@property
def area(self):
"""El área se calcula, no se almacena. Es de solo lectura."""
return 3.14159 * (self.radio ** 2)
c = Circulo(10)
print(c.area) # Se ve como un atributo, pero se calcula al momento.
# c.area = 300 # AttributeError: can't set attribute
Esto es elegancia. Expones un valor calculado como si fuera un simple dato almacenado.
Es intuitivo, limpio y la marca de un verdadero artesano de clases.
Truco #28: __str__ vs __repr__ - El Alma y el ADN del Objeto
Creas un objeto, lo metes en una lista y la imprimes. Y Python te devuelve una basura inútil: [<__main__.MiClase object at 0x10a7f5b50>].
Esto es una señal de incompetencia. Tu objeto no sabe cómo presentarse.
La Herejía: El Objeto Mudo
El error más común es no implementar ninguno de estos métodos “mágicos”. El objeto es mudo. No puede describirse a sí mismo.
class Punto:
def __init__(self, x, y):
self.x = x
self.y = y
p = Punto(10, 20)
print(p) # Salida: <__main__.Punto object at ...> (Inútil)
El objeto existe, pero no tiene voz. Para un desarrollador que depura el código, es un fantasma.
El Camino del Maestro: Dos Voces para Dos Audiencias
Un objeto maestro tiene dos formas de expresarse. Una para el programador y otra para el usuario.
__repr__(self): La representación inequívoca. Su objetivo es ser una descripción completa y sin ambigüedades del objeto, orientada al desarrollador. La regla de oro: el resultado de__repr__debería ser, idealmente, código Python válido que pudiera recrear el objeto.__str__(self): La representación legible. Su objetivo es ser una descripción amigable y limpia del objeto, orientada al usuario final a través deprint()ostr().
class Punto:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
# Para el desarrollador: precisa y recreable.
return f"Punto(x={self.x}, y={self.y})"
def __str__(self):
# Para el usuario: simple y legible.
return f"({self.x}, {self.y})"
Ahora observa el comportamiento:
p = Punto(10, 20)
print(p) # Llama a __str__. Salida: (10, 20)
print(str(p)) # Llama a __str__. Salida: (10, 20)
print(repr(p)) # Llama a __repr__. Salida: Punto(x=10, y=20)
# El contenedor (lista) usa __repr__ para sus elementos. ¡Crucial!
puntos = [Punto(1,2), Punto(3,4)]
print(puntos)
# Salida: [Punto(x=1, y=2), Punto(x=3, y=4)]
La Revelación: Diferentes Contextos, Diferentes Respuestas
Entender la diferencia es fundamental para crear clases usables y depurables.
__repr__es para los desarrolladores: Piensa en ella como el ADN del objeto. La usas en el depurador, en los logs, y es lo que los contenedores muestran. Si solo puedes implementar una, que sea esta.__str__es para los usuarios: Piensa en ella como el “nombre” o la “cara” del objeto. Es la versión bonita. Python es cortés: si llamas aprint()y no hay__str__, usará__repr__como último recurso.
Doblega la Realidad: La Regla del Pulgar
- Siempre implementa
__repr__en tus clases. Hazlo informativo e inequívoco. Tu yo del futuro te lo agradecerá cuando estés depurando a las 3 de la mañana. - Implementa
__str__solo cuando necesites una representación “amigable” que sea diferente de la representación para el desarrollador. Si__repr__ya es lo suficientemente legible, puede que no necesites__str__.
Sección 6: Hacks de Productividad y Código Moderno - El Filo de la Navaja
El oficio del programador no es estático. El lenguaje evoluciona.
Se forjan nuevas herramientas, más afiladas y precisas. Aferrarse a las viejas costumbres no es un signo de lealtad, es un síntoma de pereza intelectual.
Un verdadero maestro no teme lo nuevo; lo examina, lo somete a juicio y, si demuestra ser superior, lo adopta sin dudarlo.
Esta última sección trata sobre ese filo.
Son las técnicas y sintaxis que han surgido en las versiones recientes de Python. Ignorarlas es elegir luchar con una espada de bronce en la era del acero. Dominarlas te dará una ventaja decisiva en velocidad, claridad y robustez.
Truco #33: F-strings Avanzadas - El Arte de la Interpolación
Durante años, formatear cadenas en Python fue un ritual torpe. Un campo de batalla entre distintos estilos, cada uno con sus propias verrugas.
La Herejía: Los Fósiles del Formateo
El novato, o el programador anclado en el pasado, sigue usando métodos arcaicos. La concatenación con +, un método propenso a errores de tipo. El operador %, una reliquia heredada de C, funcional pero torpe. O el método .format(), verboso y visualmente desconectado de la cadena que modifica.
# Un museo de los horrores del formateo.
nombre = "Arturo"
edad = 42
# Concatenación (lenta y frágil)
print("El usuario " + nombre + " tiene " + str(edad) + " años.")
# Operador % (arcaico)
print("El usuario %s tiene %d años." % (nombre, edad))
# Método .format() (verboso)
print("El usuario {} tiene {} años.".format(nombre, edad))
Cualquiera de estos métodos grita:
“O soy nuevo, o no me he molestado en aprender nada en los últimos cinco años”.
El Camino del Maestro: La Expresión Directa
Desde Python 3.6, solo hay una forma correcta de formatear cadenas para el 99% de los casos: las f-strings (cadenas literales formateadas).
nombre = "Arturo"
edad = 42
print(f"El usuario {nombre} tiene {edad} años.")
Observa. La variable está dentro de la cadena. La f inicial activa el mecanismo.
Es conciso, es legible y es, en la mayoría de los casos, el método más rápido. No hay excusa para no usarlo.
La Revelación: El Contexto es el Rey
La superioridad de las f-strings radica en que la expresión a formatear vive exactamente donde se va a usar. No tienes que saltar con la vista al final de la línea para ver un .format(var1, var2) o un % (var1, var2).
La expresión f"Usuario: {nombre}" se lee de forma natural. Reduce la carga cognitiva y hace que el código sea más fácil de escanear. Fin de la discusión.
Doblega la Realidad: El Depurador Oculto y el Formato de Precisión
Las f-strings no son solo para mostrar variables. Puedes meter expresiones complejas y controlar el formato con una precisión quirúrgica.
import datetime
# Expresiones complejas
print(f"El doble de la edad es {edad * 2}.")
# Control de formato (flotante con 2 decimales)
precio = 19.99
print(f"El precio es {precio:.2f} €.")
# Relleno con ceros
numero_factura = 8
print(f"Factura Nº {numero_factura:04d}.") # Salida: Factura Nº 0008.
# Formato de fechas
hoy = datetime.date.today()
print(f"Hoy es {hoy:%d-%m-%Y}.")
# El truco definitivo para depurar (Python 3.8+)
# El signo '=' añade el nombre de la variable y su valor.
print(f"Depurando: {nombre=} {edad=}")
# Salida: Depurando: nombre='Arturo' edad=42
Domina estas micro-sintaxis. Son la diferencia entre usar una herramienta y exprimir todo su potencial.
Truco #34: El Operador Walrus := - Asignación y Condición, un Solo Golpe
Hay un patrón que se repite una y otra vez: obtener un valor, comprobar si ese valor es válido y, si lo es, usarlo.
La Herejía: El Doble Paso
El enfoque tradicional requiere dos pasos. Primero, asignas. Segundo, compruebas.
# Un patrón común al leer un fichero línea a línea.
linea = f.readline()
while linea:
procesar(linea)
linea = f.readline()
# Otro ejemplo: una función que puede devolver None.
resultado = funcion_costosa()
if resultado:
usar(resultado)
Este código es redundante. La llamada a f.readline() o funcion_costosa() aparece dos veces o en una línea separada que rompe el flujo lógico del if o el while.
El Camino del Maestro: El Golpe Combinado
Introducido en Python 3.8, el operador de asignación de expresiones, apodado “walrus” (morsa) por su aspecto :=, permite hacer las dos cosas a la vez.
# Asigna 'linea' Y comprueba si es 'truthy' en la misma expresión.
while linea := f.readline():
procesar(linea)
# Asigna 'resultado' Y comprueba si no es None.
if resultado := funcion_costosa():
usar(resultado)
El valor se asigna a la variable y la expresión completa evalúa a ese mismo valor.
La Revelación: Agrupa la Lógica Relevante
El walrus no es para ahorrar líneas. Es para mejorar el flujo cognitivo. Permite que la obtención de un valor y la decisión sobre ese valor ocurran en el mismo lugar.
En los bucles while que leen de un flujo (ficheros, sockets), o en list comprehensions complejas, este operador puede hacer el código significativamente más claro al reducir la necesidad de declarar variables fuera del contexto donde se usan.
Doblega la Realidad: La Disciplina del Maestro
El poder del walrus es sutil y se presta al abuso. Un maestro lo usa con moderación.
Un aficionado, embriagado por la novedad, lo meterá en todas partes, creando líneas de código ilegibles.
La regla es simple:
Úsalo cuando simplifique una estructura repetitiva (como el while de arriba) o cuando evite una llamada duplicada a una función. Si hace que una línea sea más difícil de leer, es la herramienta incorrecta. La claridad siempre triunfa sobre la concisión críptica. No seas ese programador.
Truco #37: pathlib - El Camino del Objeto
Manejar rutas de ficheros con cadenas de texto es una fuente inagotable de errores y código feo.
La Herejía: La Sopa de Cadenas y os.path
El método arcaico consiste en tratar las rutas como simples strings, usando os.path.join y otras funciones del módulo os para manipularlas.
import os
# Un código torpe y propenso a errores.
dir_actual = os.path.dirname(__file__)
nombre_fichero = "datos.csv"
ruta_completa = os.path.join(dir_actual, "recursos", nombre_fichero)
if os.path.exists(ruta_completa):
with open(ruta_completa, 'r') as f:
# ...
Este enfoque es procedimental, no orientado a objetos. Mezcla datos (la ruta como string) y operaciones (las funciones de os.path) en lugares distintos.
El Camino del Maestro: Trata las Rutas como lo que Son
La forma moderna y correcta de manejar rutas es con el módulo pathlib.
from pathlib import Path
# Un código limpio, intuitivo y orientado a objetos.
dir_actual = Path(__file__).parent
ruta_completa = dir_actual / "recursos" / "datos.csv"
if ruta_completa.exists():
with ruta_completa.open('r') as f:
# ...
Observa la belleza.
La barra / se sobrecarga para unir rutas de forma inteligente y compatible con cualquier sistema operativo. La ruta ya no es un string; es un objeto Path con sus propios métodos.
La Revelación: Objetos sobre Cadenas
pathlib es una filosofía. Es la manifestación del principio de que los datos y las operaciones que actúan sobre ellos deben vivir juntos.
- Intuitivo: Unir rutas con
/es natural. Métodos comoruta.parent,ruta.name,ruta.suffixson auto-explicativos. - Potente: Los objetos
Pathtienen métodos para todo:ruta.is_dir(),ruta.read_text(),ruta.write_text(),ruta.glob('*.txt'). - Robusto: El módulo maneja las diferencias entre sistemas operativos (como
\vs/) de forma transparente.
Doblega la Realidad: Manipulación de Ficheros en una Línea
Con pathlib, muchas operaciones comunes de ficheros se reducen a una sola línea, eliminando la necesidad del with open(...) explícito para tareas simples.
from pathlib import Path
ruta = Path("mi_fichero.txt")
# Escribir en un fichero
ruta.write_text("Hola, mundo.")
# Leer de un fichero
contenido = ruta.read_text()
# Cambiar la extensión de un fichero
nueva_ruta = ruta.with_suffix(".md")
print(nueva_ruta) # Salida: mi_fichero.md
Deja de manipular cadenas. Empieza a manejar objetos Path. Es la marca de un profesional que elige la herramienta correcta y moderna para el trabajo.
El Fin del Aprendizaje
Has llegado a la última página.
Se acabaron las lecciones. Si has venido buscando un diploma, te has equivocado de libro.
La verdad es que estos 37 trucos no te han convertido en un maestro. Solo te han quitado las excusas para seguir siendo un aficionado. Un montón de ladrillos no es una casa, y una colección de técnicas no te convierte en programador. Es el juicio para saber cuándo y cómo colocarlos lo que define al constructor.
A partir de ahora, tu trabajo no es recordar, es entender.
El verdadero aprendizaje empieza cuando cierras este libro y abres tu propio código antiguo. Míralo. Si no sientes una punzada de vergüenza, no has aprendido nada. Analízalo sin piedad, como un ingeniero que inspecciona una estructura agrietada. Encuentra los puntos débiles, la lógica torpe, el código escrito por pereza. Y arréglalo. No porque tengas que hacerlo, sino porque es tu oficio.
Deja de buscar atajos.
La elegancia no nace de la inspiración, nace de la disciplina.
Nace de borrar una solución que funciona pero es confusa, para reescribirla de una forma que sea sólida.
Nace de resistir la tentación de apilar parches y, en su lugar, reforzar los cimientos.
El mundo ya rebosa de código que funciona por casualidad, mantenido a base de fe y parches. Es frágil, es costoso y es una carga para el que viene detrás. Tu deber, ahora que conoces una forma mejor, es no añadir más basura a esa pila.
El trabajo te espera.
¿Cómo has llegado hasta aquí?
Este contenido se envió a la newsletter.
Puedes apuntarte a la lista de email aquí: vamosallio.com