Python desde cero

Cómo se ejecuta Python, qué hace print() y por qué el primer programa de cualquier curso es el mismo desde hace 45 años.

El traceback de Python no es un castigo: es un mapa. Aprende a leerlo de abajo arriba y te ahorra horas de adivinar.

Un programa que no guarda nada no puede hacer nada. Las variables son las cajas con nombre donde guardas los datos de tu programa.

Todo dato en Python tiene un tipo: entero, decimal, texto o booleano. Aprende a distinguirlos con type() y a no mezclarlos.

Sumar, restar, multiplicar y dividir suena trivial hasta que / no da lo que esperabas: división real, entera, resto y potencias.

Los programas deciden con booleanos: comparar con == y combinar con and, or y not. La base de todo if que escribirás.

Por qué 2 + 3 * 4 no es 20: el orden en que Python calcula y cómo convertir entre tipos con int(), float() y str().

Mezclar variables con texto sin pelearte con comas ni concatenaciones: f-strings, formato de decimales y alineación.

Cada letra tiene su posición: leer caracteres sueltos con [0], trozos con [a:b] y darle la vuelta a un texto con [::-1].

Los métodos transforman texto sin tocar posiciones: mayúsculas, minúsculas, quitar espacios, buscar y reemplazar. El cuchillo suizo del texto.

Hacer que el programa elija qué hacer: la lógica de decisión básica con if, elif y else.

No solo True y False: listas vacías, 0, None, cadenas vacías... aprende la regla de los "valores falsy" para escribir condiciones limpias.

Condicional en una línea: valor_si_verdadero if condicion else valor_si_falso. Útil, pero con moderación.

Repetir sin copiar: iterar sobre secuencias con for y generar números con range().

Repetir mientras se cumpla una condición. Ideal cuando no sabes cuántas vueltas darás.

Controlar el flujo dentro del bucle: saltar iteraciones, salir antes y detectar si terminó sin break.

La estructura de datos más usada en Python: ordenada, mutable y admite cualquier tipo mezclado.

append, extend, insert, pop, remove, clear, index, count, sort, reverse, copy: la herramienta completa para manipular listas.

Crear listas en una línea transformando y filtrando: [expr for x in iterable if condicion]. La forma pythonica de mapear y filtrar.

Listas inmutables que protegen tus datos y permiten asignación múltiple: x, y = punto.

Set: colección desordenada, sin duplicados, con operaciones de teoría de conjuntos (unión, intersección, diferencia).

La tabla hash de Python: acceso O(1) por clave, mutable, ordenada (desde 3.7). La estructura más versátil tras la lista.

La unidad de trabajo del programador: encapsular lógica, evitar repetición y dar nombres a las cosas.

Posicionales, nombrados, *args, **kwargs, valores por defecto mutables (la trampa), y keyword-only arguments.

return devuelve valor y sale; sin return devuelve None; múltiples valores = tupla. Diferencia entre imprimir y devolver.

LEGB: Local, Enclosing, Global, Built-in. Por qué x=1 dentro de una función no cambia la x de fuera, y cómo usar global/nonlocal cuando de verdad hace falta.

Funciones flexibles: *args recoge posiciones extra en tupla, **kwargs recoge keywords extra en dict. Desempaquetar al llamar con * y **.

Funciones anónimas (lambda) y funciones que reciben/devuelven funciones: map, filter, sorted(key=...), y el patrón decorador.

Unir condicionales, bucles, listas y funciones en un programa real: una agenda de contactos con menú en consola.

import, from ... import, alias, importar módulos propios. La biblioteca estándar: os, sys, json, random, datetime, pathlib...

Paquetes, __init__.py, estructura src/, tests/, pyproject.toml, venv. De script suelto a proyecto instalable.

try/except/else/finally, capturar excepciones específicas, lanzar excepciones (raise), crear excepciones propias. Que el programa no se caiga.

open() con with, modos (r, w, a, rb, wb), encoding UTF-8, read/readline/readlines, write/writelines, pathlib.Path.read_text/write_text.

Definir clases con class, crear instancias, atributos de instancia vs clase, __init__, representación (repr/str). Modelar conceptos del mundo real.

Funciones dentro de la clase que operan sobre la instancia. self es el primer argumento implícito. Métodos de instancia, de clase (@classmethod) y estáticos (@staticmethod).

Crear subclases que heredan de una clase base. Sobrescribir métodos, llamar al padre con super(), herencia múltiple, MRO. Principio Liskov.

@property para getters/setters elegantes, @setter, @deleter. Métodos dunder: __eq__, __hash__, __len__, __getitem__, __iter__, __call__, __bool__, __enter__/__exit__ (context manager).

Crear secuencias perezosas con yield, el protocolo de iteración y itertools para pipelines de datos eficientes.

Funciones que envuelven otras funciones: sintaxis @, argumentos, functools.wraps, casos de uso reales (timer, cache, retry, validación).

Type hints: sintaxis, genéricos, Union, Optional, TypedDict, Protocol. Herramientas: mypy, pyright. Ventajas: documentación viva, refactor seguro, IDEs inteligentes.

Convenciones: Google, NumPy, Sphinx. Qué documentar: módulos, clases, funciones, argumentos, excepciones, ejemplos. Herramientas: pdoc, Sphinx, mkdocstrings. Doctest: tests en la documentación.

Escribir tests unitarios: unittest (stdlib), pytest (ecosistema). Fixtures, parametrización, mocks, cobertura. Organización: test_*.py, estructura AAA. Buenas prácticas: rápidos, aislados, deterministas.

Módulo logging: niveles, handlers, formatters, filtros, configuración por dict/fileConfig. Structlog para logging estructurado (JSON). Rotación de archivos. Buenas prácticas: qué loguear, niveles, contexto.

Flujo Git profesional: commits atómicos, convenciones, ramas, PRs. Calidad automatizada: ruff (lint+format), pytest (tests), pre-commit hooks. CI/CD básico con GitHub Actions.

El gestor de paquetes de Python: buscar, instalar, actualizar y desinstalar paquetes desde PyPI.

Aislar dependencias por proyecto con venv: crear, activar, desactivar y usar requirements.txt para compartir entornos.

Manipulación orientada a objetos de rutas de archivos: unir, separar, leer, escribir, comprobar existencia y recorrer directorios.

datetime para fechas y horas, timedelta para aritmética temporal, y collections para estructuras avanzadas: Counter, defaultdict, deque, namedtuple.

La librería requests: GET, POST, PUT, DELETE, parámetros, headers, JSON, manejo de errores, timeouts y sesiones.

Patrones reales: autenticación, paginación, rate limiting, reintentos con backoff, validación de respuesta y manejo robusto de errores.

El módulo csv: reader, writer, DictReader, DictWriter. Leer, escribir, filtrar y transformar datos tabulares. Manejo de encoding, delimitadores y comillas.

Serializar/deserializar JSON, pretty-print, claves no-string, datetime. Módulo statistics: media, mediana, moda, desviación, varianza, cuantiles.

Proyecto integrador: CRUD de tareas con prioridades, fechas, categorías, persistencia en JSON, búsqueda, filtrado y estadísticas.

Proyecto avanzado: cliente HTTP robusto con caché en SQLite, rate limiting automático, reintentos, paginación y CLI interactiva.