Curso de Python

Aprende Python paso a paso en tu navegador — un curso en línea gratuito con 68 artículos y 250 ejercicios prácticos. Desde print, variables y tipos de datos hasta if / for / funciones / manejo de excepciones, clases y herencia, métodos especiales y POO, módulos y paquetes para organizar varios archivos, y la librería estándar (datetime / os / re / json / asyncio). Adquiere habilidades de Python listas para producción en el menor tiempo posible, incluso si eres principiante. Sin configuración previa.

0/73テキスト終了（0%）

Fundamentos de Python

Qué aprenderás en este curso de Python — Nivel profesional, en el menor tiempo posible
Una visión general del currículo completo del curso de Python. Recorre qué aprender y en qué orden para construir habilidades de Python a nivel profesional lo más rápido posible — abarcando sintaxis, POO y la biblioteca estándar — además de lo que sigue siendo esencial en la era de la IA: bases sólidas y manejo de errores.
Imprimir y comentarios
Tu primer paso en Python. Una guía para principiantes sobre cómo mostrar texto con print(), escribir comentarios con # y """, e insertar valores con f-strings.
Variables y tipos de datos
Una guía para principiantes sobre variables y tipos de datos en Python — usar int y str, el tipado dinámico y la reasignación, las reglas de nombrado y las palabras reservadas, la convención de constantes y la conversión entre int y str.
Booleanos y construcción de condiciones
Una guía para principiantes sobre el tipo booleano de Python — los dos valores True y False, cómo los operadores de comparación producen booleanos, los operadores lógicos and / or / not, y cómo evitar la confusión clásica entre = y ==.
Números y números de punto flotante (float)
Análisis profundo de los tipos numéricos de Python — int vs float, el operador de potencia ** y las asignaciones compuestas como +=, la diferencia entre / y //, las trampas de precisión de los float, y la conversión con int() y float().
Cómo usar las cadenas de Python (str)
Una guía completa del tipo cadena (str) de Python. Aprende cuándo usar comillas simples, dobles y triples; cómo la indexación y el slicing extraen caracteres; métodos de transformación como upper/lower/replace/strip; y métodos de inspección como count/find/startswith/isdigit, todo con ejercicios prácticos ejecutables.
Conversión entre números y cadenas
Una guía clara para convertir entre números y cadenas en Python. Desde lo básico de str() para transformar números en cadenas y int() / float() para transformar cadenas en números, hasta cómo evitar TypeError / ValueError y cómo convertir una cadena decimal a entero, todo con ejercicios ejecutables.
Cómo usar las listas de Python (list)
Una guía completa del tipo list de Python. Aprende las declaraciones y la indexación, el slicing para extraer rangos, métodos para añadir y eliminar como append/extend/insert/remove/pop, y sort/reverse/count/index, todo con ejercicios ejecutables.
Cómo usar los diccionarios de Python (dict)
Una guía completa del tipo dict de Python. Declarar pares clave-valor, cómo se diferencia [] de .get() al acceder a datos, agregar/actualizar/eliminar entradas, listar datos con keys / values / items y comprobar la existencia de claves con in, todo con ejercicios prácticos ejecutables.
Cómo usar las tuplas de Python (tuple)
Una guía del tipo tuple de Python, centrada en las diferencias con list. Cubre la declaración con paréntesis, qué significa la inmutabilidad, los métodos count / index, cómo desempacar varios valores en una línea, y por qué una tupla puede usarse como clave de dict — todo con ejercicios ejecutables en el navegador.
Cómo usar los conjuntos de Python (set)
Una guía sobre el tipo conjunto (set) de Python. Cubre las dos reglas que lo definen (sin duplicados, sin orden), las operaciones sobre elementos con add / remove / discard / pop / clear, las operaciones de conjuntos (union / intersection / difference / symmetric_difference), y los patrones del mundo real de deduplicación y verificación rápida de pertenencia — todo con ejercicios que puedes ejecutar en el navegador.
Tipos mutables e inmutables
Un recorrido cuidadoso por los tipos mutables e inmutables en Python. La trampa de y = x que hace que dos variables compartan la misma caja, por qué se convierte en un bug, y cómo copy() te da una versión independiente, todo con ejercicios ejecutables en el navegador.
Resumen de tipos en Python — por qué importan los tipos y la puerta a las clases
Un resumen de los tipos de datos vistos en Fundamentos de Python. Recordamos qué es realmente un «tipo», repasamos en una tabla qué tipo encaja con cada uso y damos el primer paso en la POO — definir tu propio tipo con class — todo con diagramas.
Problemas de cierre de Fundamentos de Python — Pon en código lo que aprendiste
Tres ejercicios que reúnen lo que aprendiste en Fundamentos de Python: manejo de cadenas, conversión de tipos, operaciones de conjuntos y mutabilidad. Escribe código, ejecútalo y repasa todo el capítulo de una vez.

Sintaxis de Python

if / elif / else y ramificación avanzada
Una mirada más profunda a la ramificación condicional de Python — lógica de varias ramas con elif / else, la veracidad que cubre las cadenas vacías y 0, el operador ternario, la diferencia entre is y ==, comprobaciones de tipo con isinstance y comprobaciones de elementos con in / not in — todo con ejercicios prácticos ejecutables.
Comprobaciones masivas con all() y any()
Una guía desde cero sobre all() / any() para juzgar los elementos de una lista o tupla de forma masiva. Aprende all() para «¿es todo True?», any() para «¿es al menos uno True?», sus casos de uso típicos y cómo combinarlos con for — todo con ejercicios prácticos ejecutables.
Comprensiones de listas y expresiones de dict / set / generator — Construye colecciones en una línea
Una guía práctica de las comprensiones en Python: comprensiones de lista, dict, set y expresiones generadoras, además del filtrado con if. Incluye ejercicios ejecutables.
Bucles for con range / enumerate / zip
Un recorrido sistemático por la instrucción for de Python. Iterar sobre listas y dicts elemento a elemento, usar range() para bucles de cuenta fija, bucles indexados con enumerate(), iteración paralela sobre varias listas con zip() y control de bucle con break / continue — todo con ejercicios prácticos ejecutables.
Bucles while y cómo evitar bucles infinitos
Una guía desde cero sobre el bucle while de Python. Repetir mientras una condición se mantenga, construir condiciones de terminación para evitar bucles infinitos, salidas forzadas con break y saltos con continue, y cómo elegir entre for y while — todo con ejercicios prácticos ejecutables.
El operador morsa := para asignar y comprobar en una línea
Una guía desde cero sobre el operador morsa := de Python 3.8. Cubre la sintaxis básica para asignar y comprobar en una sola línea, reutilizar el valor comprobado dentro de if, combinar el patrón de extraer y comprobar en while, la trampa de olvidar los paréntesis que asigna el resultado de la comparación, y cuándo usarlo o evitarlo — todo con ejercicios prácticos ejecutables.
Capturar excepciones con try / except
Una guía desde cero sobre el manejo de excepciones de Python con try / except. Cubre la diferencia entre errores de sintaxis y de tiempo de ejecución, la forma básica try / except, capturar el objeto de excepción con as e, capturar varias excepciones por separado, la captura paraguas con Exception y la limpieza con finally — todo con ejercicios prácticos ejecutables.
Lanzar excepciones con raise / clases de excepción personalizadas
Una guía para lanzar tus propias excepciones en Python con raise. Cubre los fundamentos de raise ValueError("mensaje"), el patrón if + raise de validación, y cómo definir una excepción personalizada con class MyError(Exception): para capturarla con precisión milimétrica con try / except — todo con ejercicios prácticos ejecutables.
Definir funciones con def — argumentos, valores de retorno, argumentos por defecto y por palabra clave
Una guía desde cero sobre la definición de funciones de Python con def. Cubre los fundamentos de def y return, los argumentos y los valores de retorno, los argumentos por defecto y los argumentos por palabra clave — todo con ejercicios prácticos ejecutables.
Argumentos de longitud variable *args / **kwargs y múltiples valores de retorno
Aprende *args / **kwargs y los valores de retorno múltiples en el navegador. Los diagramas cubren argumentos posicionales y nombrados, desempaquetado con *list / **dict, y retornos como tupla. Con ejercicios.
Argumentos de función y referencias a objetos — los mutables se modifican dentro de las funciones
Aprende cómo los argumentos de función Python difieren según el tipo. Por qué list/dict se propagan al llamador y int/str no, el patrón .copy() para proteger, y la trampa de los argumentos por defecto mutables.
Funciones internas y clausuras — Dominar el ámbito con global y nonlocal
Ámbito de Python, funciones internas y clausuras: globales vs. locales, global y nonlocal, y cómo devolver una función que recuerda valores externos.
Funciones generadoras con yield — Producir valores uno a uno para ahorrar memoria
Funciones generadoras de Python: yield para devolver valores uno a uno, next() y for, ahorro de memoria frente a una lista y encadenado con yield from.
Funciones de orden superior — Tratar funciones como argumentos y valores de retorno
Recorre las funciones de orden superior de Python en el navegador: asignar funciones a variables, pasarlas como callbacks para intercambiar comportamiento, ramificar entre varios callbacks y retornar una clausura que recuerda su configuración. Incluye ejercicios ejecutables.
Expresiones lambda — Escribir funciones anónimas en una línea
Aprende las expresiones lambda de Python desde cero mientras ejecutas código en el navegador. Cubre la forma básica lambda args: expresión, varios argumentos, expresiones condicionales, argumentos por defecto, el emparejamiento con funciones de orden superior como el key de sorted, y cuándo volver a def — todo con ejercicios ejecutables.
Decoradores — Añadir comportamiento a las funciones con @
Recorre los decoradores de Python en tu navegador, desde lo básico. Cubre la sintaxis @decorador, la forma estándar def → return inner, pasar cualquier argumento con *args / **kwargs, decoradores con argumentos como @repeat(3), y usos reales en frameworks como Flask y pytest. Incluye ejercicios ejecutables.
map() — Aplicar una función a cada elemento de una lista de golpe
Un recorrido ejecutable por la función map() integrada de Python desde cero, en el navegador. Cubre los fundamentos de map(función, iterable), materializar resultados con list(), emparejarla con lambdas y funciones integradas como int, pasar varios iterables a la vez, y elegir entre map() y comprensiones de lista — con ejercicios prácticos en todo momento.
Resumen de la sintaxis de Python — Elegir entre control de flujo y funciones
Un repaso de la sintaxis de Python (control de flujo y funciones). Conecta de forma transversal las ramificaciones condicionales, los bucles, el manejo de excepciones y las aplicaciones de funciones en un mapa claro.
Problemas de cierre de Sintaxis de Python — Combina control de flujo, funciones y excepciones
Tres ejercicios que reúnen lo que aprendiste en Sintaxis de Python — control de flujo, funciones, comprensiones de listas, manejo de excepciones y decoradores — en problemas de repaso.

Programación orientada a objetos en Python

Clases e instancias — Definir tu propio tipo
Aprende las clases e instancias de Python desde cero. Recorre las definiciones de class, el papel de self y el uso de __init__ para establecer atributos, todo con diagramas.
El constructor __init__ y el destructor __del__
Una guía práctica de __init__ y __del__ de Python. Cubre los atributos requeridos, los valores por defecto y el método de limpieza llamado al hacer del y al salir del programa, todo con diagramas.
Variables de clase vs variables de instancia — Dónde viven realmente los valores
Un recorrido con muchos diagramas por las variables de clase vs las variables de instancia en Python. Mira qué se comparte, qué es por instancia y qué hace realmente self.x = ....
Métodos de instancia, de clase y estáticos — Los tres tipos de métodos
Aprende los tres tipos de métodos de Python —de instancia, de clase y estáticos— con diagramas. Recorre el uso de self / cls / sin primer argumento y cuándo elegir cada uno.
Métodos especiales — Enseñar a tu clase cómo se comportan + y print
Recorrido de los métodos especiales (dunder) de Python. Define + con __add__, separa las cadenas de usuario y desarrollador con __str__ / __repr__, redefine == de forma significativa con __eq__, más los usos típicos de __call__, __len__ y __bool__. Incluye práctica.
Herencia de clases — Reutilizar funciones de una clase existente
Recorrido de la herencia de clases en Python. Hereda atributos y métodos con class Hijo(Padre):, sobrescribe métodos en subclases, llama la lógica del padre con super().method() y agrega atributos sobrescribiendo __init__ — el patrón estándar. Incluye práctica.
Herencia múltiple y MRO — Heredar de más de un padre
Recorrido de la herencia múltiple en Python. Combina padres con class Hijo(A, B):, mira cómo el **orden de resolución de métodos (MRO)** elige entre métodos del mismo nombre, verifica el orden con __mro__, recorre la linealización C3 para herencia en diamante y apunta a un padre específico por nombre de clase. Incluye práctica.
Polimorfismo — Mismo nombre de método, comportamiento distinto por tipo
Recorrido del polimorfismo en Python. Sobrescribe el método del padre por subclase para que los llamadores usen un nombre sin importar el tipo, procesa tipos mixtos en un solo bucle, reemplaza ramas if type(...) con POO limpia y aprende **duck typing**. Incluye práctica.
Variables privadas y encapsulación — getter / setter para acceder con seguridad
Recorrido de las variables privadas y la encapsulación en Python. Diferencia entre _name (privacidad por convención) y __name (name mangling), uso de getter/setter para proteger atributos, el estilo refinado con @property / @xxx.setter y la validación dentro del setter. Incluye práctica.
Entrada/salida de archivos — Lee y escribe seguro con with open()
Recorrido de la entrada/salida de archivos en Python. Cómo cambiar entre lectura (r), escritura (w) y adición (a) con with open(), y las diferencias entre read / readlines / readline. Incluye práctica.
Sentencia with y context managers — __enter__ / __exit__ para abrir y cerrar con seguridad
Recorrido de la sentencia with y los context managers de Python. El mecanismo que automatiza adquisición y liberación de recursos, el flujo de recibir el retorno de __enter__ con as, la garantía de limpieza con __exit__, el papel de exc_type / exc_val / traceback ante excepciones y casos reales con archivos y conexiones de BD. Incluye práctica.
Type hints — Deja la intención en el código con : int -> str
Recorrido de los type hints de Python. Cómo eliminar la duda «¿de qué tipo es este argumento?» propia del tipado dinámico, la firma def f(x: int) -> str:, cuándo escribir anotaciones de variable name: str = "Ana" y cuándo no, las verificaciones estáticas con IDE y mypy, y la no aplicación en tiempo de ejecución. Incluye práctica.
Resumen de POO en Python — Agrupar datos y comportamiento en clases
Cierre de la POO en Python. Recorre los fundamentos de las clases, la herencia y el polimorfismo, los métodos especiales (dunder), la sentencia with, la encapsulación y los type hints en toda la serie, con enlaces cruzados a cada artículo.
Problemas de cierre de POO en Python — Pon en código lo que aprendiste
Cuatro ejercicios que reúnen lo que aprendiste en POO de Python: definiciones de clases con métodos especiales, herencia, encapsulación y polimorfismo. Escribe código, ejecútalo y repasa todo el capítulo de una vez.

Python Intermedio

Módulos y paquetes — Importar desde otros archivos
Aprende las diferencias entre módulos, paquetes y librerías de Python y cómo la sentencia import trae funciones desde otros archivos. Cubre librerías estándar vs de terceros, importar tus propios módulos, qué se ejecuta en el momento del import, la comprobación __name__ == "__main__" y la combinación de varios módulos — con ejercicios prácticos ejecutables.
__init__.py e imports relativos — Agrupar archivos en un paquete
Aprende el papel de __init__.py para construir paquetes de Python y cuándo usar imports absolutos vs relativos. Cubre agrupar varios módulos bajo una sola carpeta, reducir la API pública con imports desde el paquete, mezclar correctamente imports absolutos y relativos y una disposición de carpetas de proyecto real — con ejercicios prácticos ejecutables.
Categorías de la biblioteca estándar — Cuándo usar qué
Echa un vistazo panorámico a la biblioteca estándar de Python repartida en 7 categorías. Manejo de fechas, trabajo numérico, E/S de datos, concurrencia — averigua qué importar para cada situación.
sys y argparse — Información de runtime y parseo de argumentos
Aprende los módulos sys y argparse de Python desde cero. Desde leer información del runtime con sys.path / sys.argv / sys.exit hasta construir parsers de argumentos estructurados con argparse — todo práctico.
os y pathlib — Rutas de archivos y operaciones con directorios
Aprende los módulos os.path y pathlib de Python desde cero. Construye rutas independientes del SO, lista y recorre directorios recursivamente, y descompón rutas en piezas con objetos Path — todo práctico.
shutil y tempfile — Operaciones masivas de archivos y archivos temporales
Aprende shutil y tempfile de Python desde cero. Operaciones masivas de archivos con shutil.copy / shutil.move / shutil.rmtree, además de cómo usar archivos temporales de forma segura vía tempfile.NamedTemporaryFile — todo práctico.
datetime y time — Trabajar con fechas, horas y tiempo transcurrido
Aprende los módulos datetime / time / calendar de Python desde cero. Cubre la aritmética de fechas con date / datetime / timedelta, la conversión de cadenas vía strftime / strptime y la medición de tiempo transcurrido con time.perf_counter — todo práctico.
math y statistics — Cálculos puntuales y agregación de datos
Aprende los módulos math y statistics de Python desde cero. Cubre cálculos puntuales con math.sqrt / pi / floor / ceil / log, agregación de datos con statistics.mean / median / mode / stdev, y cómo se reparten responsabilidades los dos módulos — con ejercicios prácticos ejecutables.
decimal y fractions — Aritmética precisa sin errores de float
Aprende los módulos decimal y fractions de Python desde cero. Cubre el problema 0.1 + 0.2 != 0.3 de float, los cálculos monetarios exactos con Decimal (y por qué construyes Decimals desde cadenas), la aritmética con Fraction que se simplifica automáticamente, y cómo elegir entre los tres tipos numéricos — con ejercicios prácticos ejecutables.
random y secrets — Elegir el tipo de aleatoriedad correcto
Aprende los módulos random y secrets de Python desde cero. Cubre las secuencias pseudoaleatorias reproducibles con random.choice / randint / shuffle / sample y seed, los tokens criptográficamente seguros con secrets.token_hex / token_urlsafe, y cuándo usar uno u otro — con ejercicios prácticos ejecutables.
Expresiones regulares re — Búsqueda y reemplazo por patrones
Aprende el módulo re de Python desde cero. Cubre cuándo recurrir a re.match / re.search / re.findall, la combinación de metacaracteres \d / \w / \s / * / + / ?, los grupos de captura con ( ), la sustitución con re.sub, y la reutilización de patrones con re.compile — con ejercicios prácticos ejecutables.
string y textwrap — Constantes de caracteres, plantillas y formato
Aprende los módulos string y textwrap de Python desde cero. Cubre las constantes de caracteres como string.ascii_letters / digits, la sustitución con plantillas estilo $name vía string.Template, eliminar la sangría de cadenas con triple comilla mediante textwrap.dedent, y el ajuste por anchura con fill — con ejercicios prácticos ejecutables.
pprint — Leer dicts y lists anidados con comodidad
Aprende el módulo pprint de Python desde cero. Cubre cómo pprint.pp mantiene legible la estructura anidada de dict / list donde print falla, la conversión a cadena con pformat, las opciones width / indent / sort_dicts, y su uso en la depuración diaria — con ejercicios prácticos ejecutables.
json y csv — Leer y escribir datos estructurados
Aprende los módulos json y csv de Python desde cero. Cubre la conversión entre objetos de Python y cadenas JSON con json.dumps / loads, el formateo con indent y ensure_ascii, la lectura y escritura por posición con csv.writer / reader, y la E/S basada en nombres de columna con DictWriter / DictReader — con ejercicios prácticos ejecutables.
pickle y base64 — Serializar objetos y codificar binarios como texto
Aprende los módulos pickle y base64 de Python desde cero. Cubre la serialización de objetos de Python con pickle.dumps / loads, la conversión entre datos binarios y texto con base64.b64encode / b64decode, cuándo elegir la variante urlsafe, y las advertencias de seguridad de pickle — con ejercicios prácticos ejecutables.
hashlib — Calcular valores hash de los datos
Aprende el módulo hashlib de Python desde cero. Cubre los valores hash de longitud fija con SHA-256, las tres propiedades (determinismo, efecto avalancha, unidireccionalidad), la implementación de detección de manipulación y comprobaciones de integridad, y por qué el almacenamiento de contraseñas no debe depender solo de hashlib — con ejercicios prácticos ejecutables.
collections — Counter / defaultdict / deque / namedtuple
Aprende el módulo collections de Python desde cero. Cubre el conteo con Counter y most_common, el manejo de claves faltantes con defaultdict, las operaciones O(1) en ambos extremos y los búferes circulares vía deque + maxlen, y el acceso por atributo más la conversión a dict con namedtuple — con ejercicios prácticos ejecutables.
itertools y functools — Recetas de iteración y composición de funciones
Aprende los módulos itertools y functools de Python desde cero. Cubre la iteración con combinations / product / chain / accumulate, fijar argumentos con partial, y acelerar llamadas con la memoización de @lru_cache — con ejercicios prácticos ejecutables.
enum y dataclasses — Constantes con nombre y clases de datos
Aprende los módulos enum y dataclasses de Python desde cero. Cubre las constantes con nombre con Enum e IntEnum / auto, la generación automática de __init__ / __eq__ / __repr__ vía @dataclass, y cómo elegir entre field y frozen=True — con ejercicios prácticos ejecutables.
contextlib — Gestión de recursos y with personalizado
Aprende el módulo contextlib de Python desde cero. Cubre cómo escribir tu propia sentencia with fácilmente con @contextmanager y cómo silenciar excepciones específicas con suppress — con ejercicios prácticos ejecutables.
logging — Registrar en lugar de print
Aprende el módulo logging de Python desde cero. Cubre el enrutamiento por nivel y la configuración con basicConfig, el formato unificado vía Formatter, la salida a archivo vía FileHandler, la configuración con yaml + dictConfig, y la rotación con RotatingFileHandler — con ejercicios prácticos ejecutables.
Fundamentos de async / await — Acelera tus programas aprovechando el tiempo de espera
Aprende async y await de Python desde cero. Corrutinas, el bucle de eventos, asyncio.sleep, asyncio.run y await de nivel superior — ilustrado con ejercicios prácticos.
Tasks de asyncio — Ejecución concurrente con gather, Task y Queue
Aprende asyncio en Python para código concurrente: gather para ejecuciones en paralelo, create_task para disparar y esperar después, wait_for para timeouts y Queue para productor / consumidor.
threading y multiprocessing — Hilos, procesos y el GIL
Un recorrido ilustrado por los módulos threading, multiprocessing y subprocess de Python. Cubre hilos vs procesos, la restricción del GIL, el uso de ThreadPoolExecutor y Pool, cómo decidir entre cargas de trabajo I/O-bound, CPU-bound y de comandos externos, y la comparación con bibliotecas vectorizadas como NumPy — con diagramas para organizar los conceptos.
Cierre de la biblioteca estándar de Python — 17 módulos en 7 categorías
Un cierre ilustrado de la serie de la biblioteca estándar de Python. 17 módulos organizados en 7 categorías, qué son las bibliotecas externas, la transición de la estándar a la externa, y las bibliotecas de terceros de referencia por caso de uso.
Cierre del curso de Python — ¡Buen trabajo llegando hasta aquí!
Un artículo para quienes han llegado hasta el final de los cuatro capítulos del curso de Python.