Curso Intensivo de Python (3.ª edición)

Para ti si estás cansado de guardar tutoriales y seguir sin construir nada. Este libro te lleva de cero a programas reales con una ruta clara, práctica y sin humo.

Para estudiantes, freelancers, emprendedores y profesionales que quieren usar Python para automatizar, analizar datos, crear apps o dejar de depender de “alguien técnico”.

Para quien sospecha que la tecnología ya divide el mundo entre espectadores y creadores… y quiere estar del lado que construye.

Habilidades:

Python, lógica, debugging, datos, APIs, Django y despliegue.

Nivel: Principiante

Requisitos:

Computadora, internet y ganas de practicar sin rendirte.

Eric Matthes fue profesor de ciencias, matemáticas y programación en preparatoria. Actualmente es autor de tiempo completo y vive en Alaska.

Ha escrito programas desde que tenía cinco años y también es autor de Python Flash Cards, publicado por No Starch Press.

Su enfoque combina claridad pedagógica, práctica constante y proyectos reales. Por eso Python Crash Course se ha convertido en una referencia global para quienes quieren aprender programación sin perderse en teoría innecesaria.

Introducción: cómo empezar con Python

• Para quién es este libro y qué puedes esperar aprender.
• Por qué Python es uno de los lenguajes más útiles para empezar.
• Cómo aprovechar los recursos en línea del libro.
• Cómo pasar de cero a escribir tus primeros programas reales.

Parte I: Fundamentos de programación

• Aprenderás los conceptos base que sostienen cualquier habilidad de programación.
• Escribirás código claro, ordenado y funcional desde el inicio.
• Practicarás con ejercicios progresivos para construir confianza técnica.
• Entenderás cómo piensa un programa, no solo cómo copiar instrucciones.

Capítulo 1: Primeros pasos

• Configurar tu entorno de programación.
• Instalar y usar Python en Windows, macOS o Linux.
• Trabajar con VS Code como editor de código.
• Instalar la extensión de Python para VS Code.
• Ejecutar tu primer programa: Hello World.
• Resolver problemas comunes de instalación y ejecución.
• Ejecutar programas desde la terminal.

Capítulo 2: Variables y tipos de datos simples

• Entender qué ocurre cuando ejecutas un programa.
• Crear y usar variables.
• Evitar errores comunes de nombres.
• Trabajar con cadenas de texto.
• Cambiar mayúsculas, minúsculas y formatos con métodos.
• Usar variables dentro de textos.
• Agregar saltos de línea, tabulaciones y limpiar espacios.
• Trabajar con números enteros, decimales y constantes.
• Escribir comentarios útiles.
• Conocer el Zen de Python.

Capítulo 3: Introducción a las listas

• Entender qué es una lista.
• Acceder a elementos dentro de una lista.
• Comprender por qué las posiciones empiezan en 0.
• Modificar, agregar y eliminar elementos.
• Organizar listas de forma permanente o temporal.
• Ordenar, invertir y medir la longitud de una lista.
• Evitar errores de índice.

Capítulo 4: Trabajo con listas

• Recorrer listas completas con bucles for.
• Evitar errores de indentación.
• Crear listas numéricas con range().
• Hacer estadísticas simples con listas de números.
• Usar list comprehensions para escribir código más elegante.
• Trabajar con segmentos de listas.
• Copiar listas correctamente.
• Usar tuplas para datos que no cambian.
• Aplicar buenas prácticas de estilo con PEP 8.

Capítulo 5: Condicionales if

• Escribir condiciones simples y compuestas.
• Comparar textos y números.
• Evaluar si un valor está o no dentro de una lista.
• Usar expresiones booleanas.
• Crear estructuras if, if-else y if-elif-else.
• Trabajar con múltiples condiciones.
• Aplicar condicionales a listas.
• Validar usuarios, frutas favoritas, colores de alienígenas y otros ejercicios prácticos.

Capítulo 6: Diccionarios

• Crear y usar diccionarios.
• Acceder a valores mediante claves.
• Agregar, modificar y eliminar pares clave-valor.
• Usar get() para acceder a valores de forma segura.
• Recorrer diccionarios con bucles.
• Ordenar claves y trabajar con valores únicos.
• Anidar listas dentro de diccionarios y diccionarios dentro de diccionarios.
• Modelar información real: personas, mascotas, ciudades, lugares favoritos y más.

Capítulo 7: Entrada del usuario y bucles while

• Capturar información del usuario con input().
• Escribir instrucciones claras para el usuario.
• Convertir entradas a números con int().
• Usar el operador módulo.
• Crear bucles while.
• Permitir que el usuario decida cuándo salir.
• Usar banderas, break y continue.
• Evitar bucles infinitos.
• Trabajar con listas y diccionarios dentro de bucles.
• Crear encuestas, menús y flujos interactivos.

Capítulo 8: Funciones

• Definir y llamar funciones.
• Pasar información mediante argumentos y parámetros.
• Usar argumentos posicionales, argumentos con nombre y valores predeterminados.
• Devolver valores con return.
• Crear funciones que devuelven diccionarios.
• Usar funciones con bucles while.
• Pasar listas a funciones.
• Modificar listas dentro de funciones sin perder control.
• Usar argumentos arbitrarios.
• Crear perfiles de usuario, pedidos, autos y otros modelos simples.
• Guardar funciones en módulos.
• Importar módulos completos o funciones específicas.
• Escribir funciones con estilo limpio y profesional.

Capítulo 9: Clases

• Entender la programación orientada a objetos.
• Crear y usar clases.
• Comprender el método __init__().
• Crear instancias a partir de una clase.
• Trabajar con atributos y métodos.
• Establecer valores predeterminados.
• Modificar atributos de objetos.
• Usar herencia.
• Sobrescribir métodos de una clase padre.
• Usar instancias como atributos.
• Modelar objetos del mundo real.
• Importar clases desde otros archivos.
• Trabajar con la biblioteca estándar de Python.
• Crear dados, loterías, usuarios, administradores, restaurantes y autos eléctricos.

Capítulo 10: Archivos y excepciones

• Leer contenido desde archivos.
• Trabajar con rutas relativas y absolutas.
• Procesar líneas de un archivo.
• Analizar archivos grandes.
• Buscar información dentro de textos.
• Escribir información en archivos.
• Crear registros y libros de visitas.
• Manejar errores con try-except.
• Evitar que un programa se cierre por errores inesperados.
• Decidir qué errores mostrar y cuáles manejar silenciosamente.
• Trabajar con múltiples archivos.
• Guardar y leer datos con JSON.
• Refactorizar código para hacerlo más claro.

Capítulo 11: Pruebas de código

• Instalar pytest con pip.
• Probar funciones con tests unitarios.
• Entender casos de prueba.
• Ejecutar pruebas que pasan y pruebas que fallan.
• Responder correctamente a errores de prueba.
• Agregar nuevos tests conforme crece el programa.
• Probar clases.
• Usar distintos tipos de aserciones.
• Trabajar con fixtures.
• Crear código más seguro, confiable y fácil de mantener.

Parte II: Proyectos reales

• Aplicarás lo aprendido en proyectos completos y tangibles.
• Construirás un videojuego, visualizaciones de datos y una aplicación web.
• Usarás bibliotecas profesionales del ecosistema Python.
• Pasarás de estudiar conceptos a crear productos funcionales.

Capítulo 12: Una nave que dispara balas

• Planear tu primer proyecto de videojuego.
• Instalar y usar Pygame.
• Crear una ventana de juego.
• Responder a entradas del teclado y el mouse.
• Controlar la velocidad de fotogramas.
• Crear una clase de configuración.
• Agregar una nave a la pantalla.
• Crear la clase Ship.
• Refactorizar métodos del juego.
• Mover la nave de izquierda a derecha.
• Limitar el movimiento dentro de la pantalla.
• Permitir salida rápida del juego.
• Ejecutar el juego en pantalla completa.
• Crear balas, dispararlas y eliminarlas cuando salgan de la pantalla.
• Limitar la cantidad de disparos activos.

Capítulo 13: ¡Alienígenas!

• Crear el primer alienígena del juego.
• Definir la clase Alien.
• Construir una flota completa de enemigos.
• Crear filas y columnas de alienígenas.
• Hacer que la flota se mueva.
• Cambiar dirección cuando los alienígenas llegan al borde.
• Detectar colisiones entre balas y alienígenas.
• Recrear la flota cuando el jugador la destruye.
• Aumentar la velocidad del juego.
• Detectar choques entre alienígenas y la nave.
• Terminar la partida cuando corresponde.
• Crear una experiencia de juego completa con lógica real.

Capítulo 14: Puntuación

• Agregar un botón de inicio al juego.
• Crear una clase Button reutilizable.
• Reiniciar el juego correctamente.
• Ocultar el cursor durante la partida.
• Agregar niveles de dificultad.
• Modificar la velocidad conforme avanza el juego.
• Mostrar puntuación en pantalla.
• Crear un marcador completo.
• Actualizar puntos cuando destruyes enemigos.
• Registrar puntuaciones máximas.
• Mostrar nivel y número de naves restantes.
• Expandir y refactorizar el videojuego.

Capítulo 15: Generación de datos

• Instalar y usar Matplotlib.
• Crear gráficas de líneas simples.
• Personalizar etiquetas, grosores y estilos.
• Corregir visualizaciones.
• Graficar puntos con scatter().
• Calcular datos automáticamente.
• Personalizar marcas, colores y mapas de color.
• Guardar gráficas automáticamente.
• Crear caminatas aleatorias.
• Visualizar movimiento molecular y patrones aleatorios.
• Instalar y usar Plotly.
• Simular lanzamientos de dados.
• Crear histogramas interactivos.
• Analizar resultados de múltiples dados.
• Practicar visualización de datos con bibliotecas modernas.

Capítulo 16: Descarga de datos

• Trabajar con archivos CSV.
• Leer encabezados y posiciones de datos.
• Extraer información específica de conjuntos de datos.
• Crear gráficas de temperatura.
• Usar el módulo datetime.
• Graficar fechas y periodos largos.
• Comparar múltiples series de datos.
• Sombrear áreas en gráficas.
• Aplicar revisión de errores.
• Descargar y analizar tus propios datos.
• Trabajar con formato GeoJSON.
• Descargar datos de terremotos.
• Crear mapas mundiales interactivos.
• Representar magnitudes con tamaños y colores.
• Agregar textos emergentes y escalas de color.
• Explorar datos de incendios, terremotos y fenómenos globales.

Capítulo 17: Trabajo con APIs

• Entender qué es una API y cómo usarla.
• Trabajar con Git y GitHub.
• Solicitar datos mediante llamadas API.
• Instalar y usar Requests.
• Procesar respuestas de una API.
• Trabajar con diccionarios de respuesta.
• Resumir repositorios populares de GitHub.
• Monitorear límites de uso de una API.
• Visualizar repositorios con Plotly.
• Agregar tooltips personalizados y enlaces clicables.
• Explorar la API de Hacker News.
• Crear visualizaciones con datos reales de internet.

Capítulo 18: Primeros pasos con Django

• Configurar un proyecto con Django.
• Escribir una especificación inicial.
• Crear y activar un entorno virtual.
• Instalar Django.
• Crear un proyecto web.
• Configurar una base de datos.
• Ver el proyecto en el navegador.
• Crear una aplicación dentro del proyecto.
• Definir modelos.
• Activar modelos y aplicar migraciones.
• Usar el sitio de administración de Django.
• Trabajar con la shell de Django.
• Crear páginas web con URLs, vistas y plantillas.
• Usar herencia de plantillas.
• Construir páginas para temas y entradas individuales.

Capítulo 19: Cuentas de usuario

• Permitir que los usuarios ingresen datos.
• Agregar nuevos temas y nuevas entradas.
• Editar información existente.
• Configurar cuentas de usuario.
• Crear una app de cuentas.
• Diseñar página de inicio de sesión.
• Permitir cierre de sesión.
• Crear página de registro.
• Permitir que cada usuario sea dueño de sus datos.
• Restringir acceso con @login_required.
• Conectar datos a usuarios específicos.
• Proteger páginas y entradas privadas.
• Construir una aplicación web más segura y funcional.

Capítulo 20: Estilo y despliegue de una aplicación

• Dar estilo a una app creada con Django.
• Usar django-bootstrap5.
• Aplicar Bootstrap para mejorar la interfaz.
• Modificar plantillas base.
• Diseñar una página de inicio más atractiva.
• Estilizar formularios, páginas de login, temas y entradas.
• Preparar una app para despliegue.
• Crear una cuenta en Platform.sh.
• Instalar herramientas de línea de comandos.
• Crear archivo requirements.txt.
• Agregar archivos de configuración.
• Modificar ajustes para producción.
• Usar Git para rastrear archivos del proyecto.
• Crear un proyecto en Platform.sh.
• Subir la aplicación y verla en línea.
• Refinar el despliegue.
• Crear páginas de error personalizadas.
• Continuar el desarrollo después del despliegue.

¿Sirve si empiezo desde cero? Sí. Arranca desde lo básico y te lleva, paso a paso, hasta proyectos reales. Cero humo, código real.

¿Necesito saber matemáticas avanzadas? No. Necesitas lógica, práctica y constancia. El libro construye tu mente técnica desde fundamentos.

¿Está actualizado para Python 3? Sí. Cubre Python 3.x e incluye herramientas actuales como VS Code, pytest, Django, Plotly y Matplotlib.

¿Puedo usarlo en Windows, Mac o Linux? Sí. Incluye instalación y configuración para Windows, macOS y Linux. Sin excusas de sistema operativo.

¿Cuánto tiempo necesito para avanzar? Puedes avanzar en sesiones cortas. La clave no es correr: es escribir código todos los días, aunque sea poco.

¿Incluye ejercicios prácticos? Sí. Cada tema trae ejercicios para dejar de “entender en teoría” y empezar a dominar con las manos.

¿Voy a crear proyectos reales o solo teoría? Proyectos reales: un juego 2D, visualizaciones de datos, uso de APIs y una app web desplegada online.

¿Sirve para conseguir trabajo? Sí ayuda. No promete empleo mágico, pero sí una habilidad vendible: programar, resolver y construir.

¿Explica cómo resolver errores? Sí. Enseña troubleshooting, excepciones, pruebas con pytest y criterio para no rendirte ante el primer bug.

¿Enseña análisis de datos? Sí. Trabajas con datos, gráficas, CSV, GeoJSON, APIs, Matplotlib y Plotly. Datos que dejan de estar mudos.

¿Incluye desarrollo web? Sí. Aprendes Django, usuarios, formularios, bases de datos básicas y despliegue de una app online.

¿Puedo aprender sin profesor? Sí. Está diseñado para autodidactas con ruta clara. El profesor no desaparece: se vuelve el libro.

¿Qué diferencia tiene frente a videos gratis? Estructura. YouTube te da piezas sueltas; este libro te da carretera, señales y destino.

¿Necesito una computadora potente? No. Con una computadora común puedes aprender, ejecutar código y crear los proyectos del libro.

¿El libro usa herramientas profesionales? Sí. Usa VS Code, Git, pytest, Pygame, Matplotlib, Plotly, APIs y Django. Herramientas de mundo real.

¿Sirve para adolescentes o adultos? Sí. Si puedes leer, practicar y tolerar errores, puedes avanzar. La edad no programa: la disciplina sí.

¿Qué podré construir al terminar? Juegos, visualizaciones, scripts, proyectos con APIs y una app web. Pasas de usuario a creador.