Saltar al contenido
20 min de lectura

Cómo convertirse en programador

#programación-para-principiantes#cómo-empezar-a-programar

Si querés convertirte en programador, el primer paso no es elegir un framework, mirar otro curso o memorizar sintaxis.

Escribí un programa chico. Después ejecutalo. Después rompelo. Después descubrí por qué se rompió.

Ese ciclo es una mejor introducción a la programación que acumular tutoriales.

Esta guía propone un camino progresivo desde tus primeras líneas de código hasta varios proyectos chicos. Vas a usar Scratch para entender la idea básica de programar, Python para aprender fundamentos, la terminal y Git como herramientas de uso diario, testing como parte de escribir software confiable y AI como mentor cuando te trabes.

El objetivo es empezar a programar, entender qué está haciendo tu código y convertirte progresivamente en alguien que puede resolver problemas con código.

Qué estás aprendiendo realmente

La habilidad es convertir un problema en una secuencia de instrucciones que una computadora pueda ejecutar. Esa secuencia es un algoritmo. Un lenguaje es cómo escribís esa secuencia. Esta guía usa Python.

Vas a practicarlo a través de proyectos cada vez más útiles.

Durante el camino vas a desarrollar cuatro hábitos:

  • Curiosidad: preguntarte por qué el programa se comporta de determinada manera.
  • Aprender por tu cuenta: encontrar la información que necesitás.
  • Leer código: entender código que no escribiste vos.
  • Debugging: investigar por qué el código no se comporta como esperabas.

Más adelante vas a sumar otro hábito:

  • Testing: verificar que el código se comporte como esperás.

Estas habilidades sirven más allá de Python. Python es simplemente la herramienta que vamos a usar para practicarlas.

Antes de Python: entendé qué es programar

Si nunca programaste, empezá con Scratch.

No necesitás pasar semanas ahí.

Con dos o tres sesiones cortas alcanza.

Construí algo simple:

  • Hacé que un personaje se mueva.
  • Pedile algo al usuario.
  • Usá un if.
  • Repetí una acción con un loop.
  • Mantené un puntaje.

Scratch te permite ver la idea básica de programar sin preocuparte todavía por la sintaxis de Python.

Ya estás programando cuando le decís a una computadora:

  1. Hacé esto.
  2. Fijate esta condición.
  3. Repetí esta acción.
  4. Guardá este valor.
  5. Hacé algo diferente según el resultado.

Python va a expresar esas mismas ideas usando texto.

Por eso pasamos de Scratch a Python en lugar de quedarnos ahí.

¿Por qué Python?

Python es un lenguaje de alto nivel, es decir, su sintaxis se acerca relativamente al lenguaje natural, facilitando la lectura del código.

Podés usar Python para:

  • automatización
  • scripts
  • APIs
  • backend
  • análisis de datos
  • machine learning
  • herramientas de línea de comandos

Python te permite concentrarte en conceptos de programación sin tener que entender primero un framework enorme o conceptos de programación de bajo nivel, como la gestión de memoria y CPU.

Vas a aprender variables, condiciones, loops, funciones, listas, errores, archivos y, más adelante, bases de datos.

Esos conceptos te van a ayudar a entender otros lenguajes de programación.

No necesitás aprender varios lenguajes al mismo tiempo.

Quedate con uno el tiempo suficiente para construir cosas.

Tu primera semana

Calculá 45--90 minutos por día.

Te vas a trabar, así que leé el error. Eso también es parte del trabajo.

La primera semana tiene un objetivo:

Pasar de "nunca programé", a "puedo escribir, ejecutar, romper y arreglar un programa chico en Python."

Tus herramientas

Instalá:

En macOS y Linux, usá Terminal.

En Windows, PowerShell alcanza.

También vas a usar un asistente de AI como mentor.

Puede ser ChatGPT, Claude, Gemini o un asistente integrado en tu editor.

Cómo lo usás importa más que cuál elijas.

Si nunca viste código, hacé dos o tres sesiones cortas en Scratch y después volvé a Python.

Esta semana seguí los conceptos iniciales de roadmap.sh/python: sintaxis, variables, control de flujo, funciones y listas.

Dejá archivos, módulos y venv para más adelante.

Escribí primero. Pedí una pista solo si te trabás

  1. Escribí el ejercicio vos y ejecutalo.
  2. Si funciona y podés explicarlo, no abras la AI.
  3. Si después de 20--30 minutos estás trabado, pedí una pista, no el archivo completo.
  4. Incluí el error, lo que esperabas y lo que pasó realmente.
  5. Escribí el cambio vos.
  6. Explicá el arreglo con tus propias palabras.

El objetivo es aprender a resolver problemas, no aprender a pedirle a la AI programas terminados.

Pegá esto en tu sesión de AI

Pegalo una vez. Después empezá el Día 1.

Sos mi mentor de Python. Soy principiante.
Quiero aprender fundamentos de programación, no solamente copiar código que funciona.

Cuando me trabe:

- Preguntame qué esperaba que pasara.
- Preguntame qué pasó realmente.
- Ayudame a leer el error.
- Dame una pista o un próximo paso pequeño.
- No me des la solución completa salvo que te la pida explícitamente.

Cuando expliques algo, diferenciá entre:

- Sintaxis de Python: cómo expresa una idea este lenguaje.
- Conceptos de programación: ideas que también existen en otros lenguajes.

Mantené las explicaciones cortas.

Pedime que te explique la solución con mis propias palabras.

Instalá Python

Entrá a python.org e instalá Python para tu sistema operativo.

Después de instalarlo, abrí la terminal y comprobá que Python funciona:

python --version

Deberías ver una versión de Python 3.x.

Si ese comando no existe, probá python3 --version. Usá el que haya impreso una versión 3.x para el resto de esta guía. En Windows suele ser python; en macOS y Linux suele ser python3.

El REPL de Python

Python también incluye un entorno interactivo llamado REPL.

REPL significa Read--Eval--Print Loop.

Lee el código que escribís, lo evalúa, muestra el resultado y espera la siguiente instrucción.

Iniciálo con:

python

Deberías ver algo parecido a:

>>>

El >>> es el prompt del REPL. Todo lo que escribas después es código Python. Probá:

2 + 2

Python evalúa inmediatamente la expresión:

4

Probá también:

name = "Beginner"
print(name)

Podés experimentar con variables:

score = 100
score + 50

El REPL es útil para experimentar rápidamente con Python sin crear un archivo.

También podés usarlo para probar funciones:

len("Python")

print("Hello, Python!")

numbers = [10, 20, 30]
sum(numbers)
sum(numbers) / len(numbers)

También podés cometer errores y ver el error de inmediato:

10 / 0

Salí con:

exit()

El REPL no es donde vas a construir tus proyectos. Pensalo como un pequeño laboratorio donde podés probar ideas.

Sintaxis de Python y palabras reservadas

Python tiene palabras reservadas: palabras que ya tienen un significado específico dentro del lenguaje.

Por ejemplo:

if
else
for
while
def
return
import

No podés usar estas palabras libremente como nombres de variables o funciones porque Python ya las utiliza para su sintaxis.

No necesitás memorizar todas las palabras reservadas. Las vas a aprender a medida que las uses.

Cuando encuentres una sintaxis que no entiendas, buscala.

W3Schools Python es útil para explicaciones rápidas y la documentación oficial de Python sirve como referencia más profunda.

Todo el código de los ejemplos y ejercicios de esta guía está escrito en inglés. La explicación está en español, pero el código queda en inglés porque Python, sus librerías, la documentación, los mensajes de error y gran parte del ecosistema usan ese idioma.

Día 1: ejecutá tu primer programa

Empezá con algo simple. Vas a crear un directorio, crear un archivo Python dentro, abrirlo en VS Code y ejecutarlo desde la terminal.

Este directorio es el único proyecto que vas a usar en esta guía. Los días siguientes agregan carpetas numeradas al lado de 01-hello.

1. Creá el directorio del proyecto

Abrí la terminal:

mkdir -p how-to-become-a-programmer/01-hello

Entrá al proyecto:

cd how-to-become-a-programmer

Comprobá dónde estás:

pwd

En Windows PowerShell, pwd y ls funcionan como alias. Podés seguir usándolos acá.

Listá los archivos:

ls

Deberías ver 01-hello. Vas a usar estos comandos muchas veces:

  • mkdir: crea un directorio
  • cd: cambia de directorio
  • pwd: muestra el directorio actual
  • ls: lista los archivos

No necesitás memorizarlos hoy. Los vas a aprender usándolos.

2. Abrí el proyecto en VS Code

Si tenés disponible el comando code:

code .

El . significa "el directorio actual".

Si el comando no está disponible, abrí VS Code y seleccioná el directorio how-to-become-a-programmer.

3. Creá tu primer archivo Python

Dentro de 01-hello, creá:

hello.py

El árbol debería verse así:

how-to-become-a-programmer/
└── 01-hello/
    └── hello.py

Agregá:

print("Hello, Beginner.")

Guardá el archivo.

4. Ejecutá el programa

Volvé a la terminal. Comprobá que seguís dentro de how-to-become-a-programmer:

pwd

Ejecutá:

python 01-hello/hello.py

Deberías ver:

Hello, Beginner.

Acabás de escribir y ejecutar un programa.

Ejercicio

Modificá el programa:

message = "Hello, Beginner."
print(message)

Cambiá el mensaje. Agregá otra variable. Imprimí otro valor. Ejecutá el programa después de cada cambio.

El objetivo es acostumbrarte a este ciclo:

Editar
 ↓
Guardar
 ↓
Ejecutar
 ↓
Observar
 ↓
Cambiar
 ↓
Ejecutar otra vez

Ahora rompelo

Borrá una de las comillas:

print("Hello, Beginner.)

Ejecutalo otra vez. Python va a mostrar un error. Leelo.

No necesitás entender cada línea todavía. Buscá la parte importante y fijate dónde Python cree que está el problema.

Corregí la comilla. Ejecutalo otra vez.

Acabás de encontrar y arreglar tu primer bug.

Programar implica leer lo que la computadora te muestra y usar esa información para encontrar el problema.

Día 2: variables e input

Quedate en how-to-become-a-programmer. Creá una carpeta para los próximos ejercicios:

mkdir 02-python-basics

Creá 02-python-basics/variables.py:

name = input("What is your name? ")
print("Hello,", name)

Ejecutalo:

python 02-python-basics/variables.py

Si escribís:

Beginner

deberías obtener:

Hello, Beginner

Acá ya aparecen varios conceptos.

name es una variable. input() obtiene información del usuario. print() muestra información.

Python ejecuta las instrucciones en orden. Probá modificar el programa:

name = input("What is your name? ")
age = input("How old are you? ")
print("Hello,", name)
print("You are", age, "years old.")

Después experimentá. Preguntate:

  • ¿Qué pasa si creo otra variable?
  • ¿Qué pasa si cambio el valor?
  • ¿Qué pasa si intento imprimir una variable antes de asignarle un valor?
  • ¿Qué tipo de dato devuelve input()?

Estás aprendiendo al cambiar el programa y observar qué sucede.

Día 3: decisiones

Los programas empiezan a ser útiles cuando pueden tomar decisiones.

Creá 02-python-basics/decisions.py:

age = int(input("How old are you? "))
if age >= 18:
    print("You are an adult.")
else:
    print("You are under 18.")

Ejecutalo:

python 02-python-basics/decisions.py

Si una condición es verdadera, ejecutá un camino. Si no, ejecutá otro.

Probá cambiar la condición. Después escribí programas chicos por tu cuenta:

  1. Comprobá si un número es positivo o negativo.
  2. Comprobá si un número es par o impar.
  3. Compará dos números.
  4. Pedí una contraseña y comprobá si es correcta.

Escribilos vos. Si te trabás, pedile una pista a la AI.

Día 4: loops, funciones y listas

Los programas muchas veces necesitan repetir cosas. Creá 02-python-basics/loops.py:

for number in range(1, 6):
    print(number)

Ejecutalo:

python 02-python-basics/loops.py

Después creá una lista en el mismo archivo:

names = ["Alice", "Bob", "Charlie"]
for name in names:
    print(name)

Una lista permite mantener varios valores juntos. Ahora poné lógica dentro de una función:

def greet(name):
    print("Hello,", name)

greet("Alice")
greet("Bob")

Estos conceptos son fundamentales:

  • las variables almacenan valores
  • las condiciones toman decisiones
  • los loops repiten trabajo
  • las funciones organizan comportamiento
  • las listas contienen colecciones de valores

No pases rápido porque parezcan conceptos simples. Los vas a usar constantemente.

Días 5–6: construí un juego de adivinar el número

Ahora combiná esas piezas en un programa: un juego de adivinar el número.

mkdir 03-number-guessing-game

how-to-become-a-programmer/
├── 01-hello/
│   └── hello.py
├── 02-python-basics/
│   ├── variables.py
│   ├── decisions.py
│   └── loops.py
└── 03-number-guessing-game/
    └── game.py

Creá 03-number-guessing-game/game.py.

Paso 1: generá un número

Empezá con algo chico:

import random

secret = random.randint(1, 100)
print(secret)

Ejecutalo:

python 03-number-guessing-game/game.py

Deberías ver un número entre 1 y 100. Asegurate de entender qué está haciendo el programa. Después eliminá print(secret).

Paso 2: pedí un intento

Agregá:

guess = int(input("Your guess: "))

Ejecutá el programa otra vez. Si escribís:

50

guess contiene el entero 50.

Paso 3: compará el intento

Agregá:

if guess > secret:
    print("Too high.")
elif guess < secret:
    print("Too low.")
else:
    print("You got it!")

Ejecutalo varias veces.

Paso 4: seguí preguntando

Poné el código dentro de un loop:

while True:
    guess = int(input("Your guess: "))

    if guess > secret:
        print("Too high.")
    elif guess < secret:
        print("Too low.")
    else:
        print("You got it!")
        break

Ejecutalo. Ahora tenés el núcleo del juego.

Paso 5: meté el juego en una función

Pasá el código a una función:

import random

def play_game():
    secret = random.randint(1, 100)

    print("Guess the number between 1 and 100.")

    while True:
        guess = int(input("Your guess: "))

        if guess > secret:
            print("Too high.")
        elif guess < secret:
            print("Too low.")
        else:
            print("You got it!")
            break

if __name__ == "__main__":
    play_game()

Este bloque se ejecuta cuando corrés el archivo. No se ejecuta cuando otro archivo lo importa.

Ejecutalo:

python 03-number-guessing-game/game.py

Ahora rompelo

Eliminá el int():

guess = input("Your guess: ")

Ingresá:

50

Leé el error. ¿Qué tipo de dato tiene guess ahora? Arreglá el programa.

Tu ejercicio

Agregá una feature por vez:

  • Contá la cantidad de intentos.
  • Limitá la cantidad de intentos.
  • Agregá niveles de dificultad.
  • Dale un puntaje al jugador.
  • Permití jugar otra vez.

Antes de agregar una feature, escribí qué debería hacer el programa. Después cambiá la menor cantidad de código posible.

Ejecutalo. Probá el comportamiento nuevo.

Si se rompe, leé el error antes de buscar una respuesta. Ahora tenés un programa chico con requisitos que podés cambiar.

Cuando el contador de intentos funcione, probá dos formas de jugar. Adiviná al azar. Después adiviná partiendo el rango a la mitad: 50, después 25 o 75, y así. Partir a la mitad encuentra cualquier número del 1 al 100 en siete intentos como máximo. Adivinar al azar, no. Ese método es búsqueda binaria. Ya tenés la herramienta para medirlo: el contador de intentos.

Día 7: Git y GitHub

Ahora tenés un juego de adivinar el número. Guardá todo el workspace con Git.

¿Qué problema resuelve Git?

Imaginá que trabajás varias semanas en un proyecto.

Cambiás el código. Algo se rompe. Lo cambiás otra vez. Ahora no recordás qué funcionaba antes.

Git mantiene un historial de tu proyecto. En lugar de crear archivos como:

project-final.py
project-final-2.py
project-final-fixed.py
project-final-really-fixed.py

mantenés un solo proyecto y registrás los cambios importantes en su historial. Cada commit representa un punto de ese historial. Podés ver qué cambió, cuándo cambió y por qué cambió. Eso se vuelve cada vez más útil a medida que crecen los proyectos.

Creá tu primer historial con Git

Quedate en how-to-become-a-programmer. Creá un .gitignore para que Git no trackee archivos generados. .venv/ aparece ahora aunque lo creas más adelante:

.venv/
__pycache__/
*.pyc
*.sqlite

Creá README.md:

Python exercises from the first program to small projects.

Inicializá Git en la raíz del repo:

git init

Decile a Git quién sos. Usá el nombre y el email que querés ver en los commits. GitHub puede mantener el email privado.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Ahora Git está inicializado para ese repositorio. Comprobá el estado:

git status

Deberías ver tus archivos Python como archivos que todavía no están siendo trackeados. Agregalos al área de staging:

git add .

Volvé a comprobar el estado:

git status

Ahora los archivos están preparados para el commit. Creá tu primer commit:

git commit -m "Add number guessing game and week 1 exercises"

El primer commit incluye 01-hello/, 02-python-basics/ y 03-number-guessing-game/. Ese juego es el proyecto que vas a publicar.

El modelo básico es:

Archivos de trabajo
    ↓
git add
    ↓
Cambios en staging
    ↓
git commit
    ↓
Historial del proyecto
    ↓
git push
    ↓
GitHub

Mirá el historial:

git log --oneline

Deberías ver el commit que acabás de crear.

Hacé otro cambio

Agregá un contador de intentos en 03-number-guessing-game/game.py:

import random

def play_game():
    secret = random.randint(1, 100)
    attempts = 0

    print("Guess the number between 1 and 100.")

    while True:
        guess = int(input("Your guess: "))
        attempts += 1

        if guess > secret:
            print("Too high.")
        elif guess < secret:
            print("Too low.")
        else:
            print("You got it in", attempts, "attempts!")
            break

if __name__ == "__main__":
    play_game()

Ejecutalo:

python 03-number-guessing-game/game.py

Creá otro commit:

git add 03-number-guessing-game/game.py
git commit -m "Count attempts in the guessing game"

Mirá el historial otra vez:

git log --oneline

Ahora tenés dos puntos registrados.

Git registra cómo va cambiando tu proyecto con el tiempo.

GitHub

Git y GitHub no son lo mismo.

Git es la herramienta de control de versiones que corre en tu computadora. GitHub es una plataforma donde podés alojar y compartir repositorios Git.

Creá un repositorio vacío en GitHub. No agregues un README todavía. Ya tenés uno en local.

Antes de hacer push, GitHub necesita saber que sos vos. Las contraseñas de la cuenta ya no sirven para Git por HTTPS.

Creá un personal access token. Cuando git push pida una password, pegá el token, no la contraseña de GitHub.

Si ya tenés instalado GitHub CLI, podés correr gh auth login en su lugar.

Conectá tu repositorio local:

git remote add origin https://github.com/YOUR_USER/how-to-become-a-programmer.git

Renombrá tu branch:

git branch -M main

Subilo:

git push -u origin main

Actualizá el repositorio. Tu juego de adivinar el número ya está online. Ese es el proyecto de principiante para mostrar: un juego que escribiste, no un print.

Git después de la primera semana

Git sirve para mucho más que guardar una copia.

Los desarrolladores lo usan para:

  • trabajar sobre el mismo código con un equipo
  • crear branches para nuevas features
  • revisar cambios antes de hacer merge
  • investigar cuándo apareció un bug
  • revertir cambios
  • entender cómo evolucionó un proyecto
  • contribuir a proyectos open source

Los repositorios Git también pueden conectarse con pipelines de CI/CD, donde un cambio puede disparar tests, builds y deployments automáticos.

No necesitás aprender todo eso hoy. Por ahora, adoptá un hábito:

Hacé cambios chicos y creá commits que representen avances concretos.

Recursos útiles sobre Git

Ahora tenés un juego de adivinar el número y su historial online.

Primer mes: convertí ejercicios en proyectos

La primera semana te enseña los bloques básicos de programación.

El primer mes debería enseñarte a combinarlos para construir algo que puedas usar.

No saltes directamente a Django, React, Docker, Kubernetes, AWS o machine learning.

Construí otro proyecto.

Construí un juego de Hangman

Tu próximo proyecto es Hangman. Mismo repo, carpeta nueva.

mkdir 04-hangman

how-to-become-a-programmer/
└── 04-hangman/
    └── game.py

Creá 04-hangman/game.py.

La primera versión tiene que ser lo suficientemente chica como para entenderla en una sesión. El programa elige una palabra, el jugador adivina letras y el programa muestra qué letras ya fueron adivinadas.

Acá tenés el boilerplate inicial:

import random

WORDS = ["python", "terminal", "programming", "debugging"]

def display_word(word, guessed_letters):
    result = []

    for letter in word:
        if letter in guessed_letters:
            result.append(letter)
        else:
            result.append("_")

    return " ".join(result)

def play_game():
    word = random.choice(WORDS)
    guessed_letters = set()

    while True:
        print(display_word(word, guessed_letters))

        guess = input("Guess a letter: ").lower()
        guessed_letters.add(guess)

        if all(letter in guessed_letters for letter in word):
            print("You won!")
            break

if __name__ == "__main__":
    play_game()

Ejecutalo:

python 04-hangman/game.py

Probá letras hasta completar la palabra. Después leé el código antes de cambiarlo. Preguntate:

  • ¿Dónde se elige la palabra?
  • ¿Dónde se guardan las letras adivinadas?
  • ¿Qué devuelve display_word()?
  • ¿Qué hace el while?
  • ¿Qué comprueba all()?
  • ¿Por qué se llama a play_game() al final?

Un set guarda elementos únicos. all(...) es verdadero cuando cada letra de la palabra está en guessed_letters.

No hace falta que entiendas cada línea ahora mismo. Buscá lo que no entiendas.

Por ejemplo:

word = random.choice(WORDS)

random.choice() selecciona un elemento de la lista.

Y:

guessed_letters = set()

crea un set vacío donde guardás las letras que el jugador ya probó.

El boilerplate te da un punto de partida que funciona. No elimina la parte de resolver problemas.

Rompé el programa

Probá cambiar algo a propósito. Por ejemplo, cambiá:

guessed_letters = set()

por:

guessed_letters = []

Ejecutá el programa. Leé el error. Descubrí por qué ese cambio importa. Después restauralo.

Cambiá, ejecutá, observá, leé el error y arreglalo. El mismo ciclo del Día 1.

Trabajando en nuevas features

Tenés una versión que funciona. Ahora sumá requerimientos. Implementá estas features una por una:

  1. Dibujá las partes del cuerpo del ahorcado cuando el jugador comete un error.
  2. Mantené una lista de letras incorrectas.
  3. Agregá un sistema de puntaje.
  4. Permití jugar otra partida.
  5. Validá el input del jugador.

No implementes todo junto.

Elegí una feature. Cambiá el código. Ejecutá el juego. Comprobá el comportamiento. Si algo se rompe, debuggealo. Después hacé un commit:

git add 04-hangman/game.py
git commit -m "Add incorrect letters"
git push

El mismo repo crece. Hacé push cuando una versión funcione. Pasá a la siguiente feature.

Checkpoint del primer mes

Al terminar el primer mes deberías poder:

  • Escribir programas chicos de Python sin copiar cada línea.
  • Explicar variables, condiciones, loops, funciones y listas.
  • Ejecutar programas Python desde la terminal.
  • Usar el REPL para experimentar rápidamente.
  • Entender sintaxis básica de Python y reconocer palabras reservadas comunes.
  • Leer errores básicos de Python.
  • Debuggear un programa chico.
  • Usar Git para crear un historial de cambios.
  • Hacer commits con significado.
  • Publicar un proyecto en GitHub.
  • Agregar una feature a un programa existente.
  • Buscar documentación cuando no sabés algo.
  • Leer partes pequeñas de código escrito por otra persona.
  • Usar AI como guía sin delegarle todo el problema.

No necesitás saber todo.

Deberías poder tomar un problema chico, dividirlo en partes, escribir código, ejecutarlo, investigar qué salió mal y mejorarlo.

De un archivo a varios archivos

Fijate qué cambió durante el primer mes. Empezaste con una carpeta. El repo ahora se ve así:

how-to-become-a-programmer/
├── .gitignore
├── README.md
├── 01-hello/
│   └── hello.py
├── 02-python-basics/
│   ├── variables.py
│   ├── decisions.py
│   └── loops.py
├── 03-number-guessing-game/
│   └── game.py
└── 04-hangman/
    └── game.py

El lenguaje sigue siendo Python. Lo que cambia es la cantidad de trabajo que necesita hacer el programa y cómo lo organizás.

Mes 2: hacé que tus programas sean útiles

Ahora construí programas que resuelvan problemas chicos.

Los proyectos siguen siendo chicos, pero deberían empezar a parecerse a herramientas que podrías usar.

En este mes vas a instalar pytest. Creá un entorno virtual primero para que la instalación no toque el Python del sistema.

Creá un entorno virtual

Un entorno virtual le da a tu proyecto su propio conjunto aislado de paquetes de Python. Crealo en la raíz del repo:

python -m venv .venv

Activálo.

macOS/Linux

source .venv/bin/activate

Windows

.venv\Scripts\activate

El prompt puede mostrar (.venv). Eso significa que pip y pytest usan este intérprete.

Instalá pytest:

python -m pip install pytest

.venv/ ya está en el .gitignore del Día 7.

Diferentes proyectos pueden necesitar diferentes versiones de paquetes externos. Mantener las dependencias aisladas evita que un proyecto interfiera con otro.

Organizador de archivos

Escribí un script que decida dónde pertenece un archivo, y después testeá esa decisión.

mkdir 05-file-organizer

how-to-become-a-programmer/
└── 05-file-organizer/
    ├── organizer.py
    └── test_organizer.py

Empezá con get_category sobre dos nombres de archivo: photo.jpg y report.pdf.

Escribí primero los tests en 05-file-organizer/test_organizer.py:

from organizer import get_category

def test_image_category():
    assert get_category("photo.jpg") == "images"

def test_document_category():
    assert get_category("report.pdf") == "documents"

Después implementá la función en 05-file-organizer/organizer.py:

def get_category(filename):
    if filename.endswith(".jpg"):
        return "images"
    if filename.endswith(".pdf"):
        return "documents"
    return "other"

if __name__ == "__main__":
    print(get_category("photo.jpg"))
    print(get_category("report.pdf"))

Ejecutá los tests desde la raíz del repo:

pytest 05-file-organizer/test_organizer.py

Deberían pasar.

Preguntate:

  • ¿Por qué funciona from organizer import get_category desde el archivo de test?
  • ¿Qué pasa con un nombre que no es ni .jpg ni .pdf?
  • ¿Por qué get_category es una función en lugar de un script que mueve archivos?

Rompelo a propósito. Cambiá "images" por "pictures" y ejecutá pytest otra vez. Leé el error. Restauralo.

Después expandí: más extensiones, y recién ahí mover archivos. Vas a aprender sobre archivos y directorios.

git add 05-file-organizer
git commit -m "Classify jpg and pdf files"
git push

Calculadora de gastos

Creá una carpeta con el CSV, el programa y los tests juntos:

mkdir 06-expense-calculator

how-to-become-a-programmer/
└── 06-expense-calculator/
    ├── calculator.py
    ├── expenses.csv
    └── test_calculator.py

06-expense-calculator/expenses.csv:

date,category,amount
2026-08-01,food,15.50
2026-08-02,transport,8.00
2026-08-03,food,22.00

Escribí primero los tests en 06-expense-calculator/test_calculator.py:

from calculator import calculate_total, totals_by_category

def test_calculate_total():
    assert calculate_total([10, 20, 30]) == 60

def test_calculate_total_with_empty_list():
    assert calculate_total([]) == 0

def test_calculate_total_with_one_price():
    assert calculate_total([50]) == 50

def test_totals_by_category():
    rows = [
        {"category": "food", "amount": "15.50"},
        {"category": "transport", "amount": "8.00"},
        {"category": "food", "amount": "22.00"},
    ]
    totals = totals_by_category(rows)
    assert totals["food"] == 37.5
    assert totals["transport"] == 8.0

Después implementá 06-expense-calculator/calculator.py:

import csv
import os

def calculate_total(prices):
    return sum(prices)

def totals_by_category(rows):
    totals = {}
    for row in rows:
        category = row["category"]
        amount = float(row["amount"])
        totals[category] = totals.get(category, 0) + amount
    return totals

def read_expenses(path):
    with open(path, newline="") as file:
        return list(csv.DictReader(file))

if __name__ == "__main__":
    path = os.path.join(os.path.dirname(__file__), "expenses.csv")
    rows = read_expenses(path)
    prices = [float(row["amount"]) for row in rows]
    print(calculate_total(prices))
    print(totals_by_category(rows))

Ejecutá los tests:

pytest 06-expense-calculator/test_calculator.py

Ejecutá el programa desde la raíz del repo:

python 06-expense-calculator/calculator.py

Deberías ver 45.5 y un diccionario con los totales de food y transport.

El hábito importa más que el framework:

  1. Definí cuál debería ser el comportamiento.
  2. Escribí un test para ese comportamiento.
  3. Implementalo.
  4. Ejecutá el test.
  5. Cambiá el código.
  6. Volvé a ejecutar el test.

Esto introduce la idea básica detrás de test-driven development sin convertir esta guía en un tutorial de TDD.

Ahora rompé calculate_total a propósito. Ejecutá pytest. Leé el error. Arreglá la implementación. Volvé a ejecutar los tests. Ahora testing y debugging trabajan juntos.

git add 06-expense-calculator
git commit -m "Calculate expense totals from CSV"
git push

Todo list desde la terminal

mkdir 07-todo

how-to-become-a-programmer/
└── 07-todo/
    └── todo.py

Creá 07-todo/todo.py. La primera versión lista tareas y las guarda en un archivo para que sobrevivan entre ejecuciones:

import os
import sys

TASKS_FILE = os.path.join(os.path.dirname(__file__), "tasks.txt")

def load_tasks():
    if not os.path.exists(TASKS_FILE):
        return []
    with open(TASKS_FILE) as file:
        return [line.rstrip("\n") for line in file]

def save_tasks(tasks):
    with open(TASKS_FILE, "w") as file:
        for task in tasks:
            file.write(task + "\n")

def list_tasks(tasks):
    if not tasks:
        print("No tasks.")
        return
    for index, task in enumerate(tasks, start=1):
        print(f"{index}. {task}")

def main():
    tasks = load_tasks()
    command = sys.argv[1] if len(sys.argv) > 1 else "list"

    if command == "list":
        list_tasks(tasks)
    elif command == "add":
        task = " ".join(sys.argv[2:])
        tasks.append(task)
        save_tasks(tasks)
        print("Added:", task)
    else:
        print("Usage: python todo.py [list|add <task>]")

if __name__ == "__main__":
    main()

Ejecutalo:

python 07-todo/todo.py add "Learn Python"
python 07-todo/todo.py list

Deberías ver:

1. Learn Python

Ejecutá list otra vez. La tarea sigue ahí porque se escribió en tasks.txt.

Preguntate:

  • ¿Dónde busca load_tasks el archivo?
  • ¿Qué pasa en la primera ejecución, antes de que exista tasks.txt?
  • ¿Por qué add llama a save_tasks?

Rompelo: comentá save_tasks(tasks) y agregá una tarea. Volvé a correr el programa. La tarea desapareció. Restauralo.

Un archivo alcanza para este proyecto. El mes 3 guarda datos estructurados en SQLite.

Features para agregar de a una:

  • Borrar una tarea por número.
  • Marcar una tarea como hecha.
  • Ignorar un add vacío.
git add 07-todo
git commit -m "Save todo list to a file"
git push

Mes 3: bases de datos y datos

Ahora podés combinar varias cosas que aprendiste: archivos, funciones, tests y una librería externa.

Guardá tus datos con SQLite

Construí un programa chico que genere puntajes de juegos y los guarde en una base de datos SQLite.

¿Qué es SQLite?

SQLite es un motor chico de bases de datos.

A diferencia de un servidor de bases de datos como PostgreSQL, SQLite guarda la base de datos en un archivo. Para aprender, esto es útil porque podés trabajar con una base de datos real sin tener que configurar primero un servidor.

Python ya incluye el módulo sqlite3. No necesitás instalar SQLite como paquete de Python.

mkdir 08-score-analyzer

how-to-become-a-programmer/
└── 08-score-analyzer/
    ├── database.py
    ├── analysis.py
    └── test_analysis.py

database.py crea la tabla e inserta las filas de ejemplo. El .gitignore ya ignora *.sqlite, así que Git no va a commitear el archivo de la base. El programa lo crea cuando corrés este script.

Como este script escribe scores.sqlite al lado del código, entrá primero a la carpeta:

cd 08-score-analyzer

Creá database.py:

import sqlite3

connection = sqlite3.connect("scores.sqlite")
cursor = connection.cursor()

cursor.execute("DROP TABLE IF EXISTS scores")
cursor.execute(
    """
    CREATE TABLE scores (
        id INTEGER PRIMARY KEY,
        player TEXT,
        score REAL,
        game TEXT,
        created_at TEXT
    )
    """
)

rows = [
    ("Alice", 820, "guessing", "2026-08-01"),
    ("Bob", 540, "guessing", "2026-08-01"),
    ("Charlie", 910, "hangman", "2026-08-02"),
    ("Alice", 760, "guessing", "2026-08-02"),
    ("Bob", 680, "hangman", "2026-08-03"),
]
cursor.executemany(
    "INSERT INTO scores (player, score, game, created_at) VALUES (?, ?, ?, ?)",
    rows,
)
connection.commit()
connection.close()
print("Saved 5 scores.")

Ejecutalo:

python database.py

Deberías ver Saved 5 scores.

Los programas muchas veces necesitan recordar información después de terminar de ejecutarse.

Analizá los datos con pandas

Instalá pandas y matplotlib en el mismo .venv que creaste en el mes 2. Desde la raíz del repo (hacé cd .. si seguís en 08-score-analyzer):

python -m pip install pandas matplotlib

Creá 08-score-analyzer/analysis.py. Lee la tabla que acabás de crear:

import matplotlib.pyplot as plt
import pandas as pd
import sqlite3

def average_by_player(df):
    return df.groupby("player")["score"].mean()

if __name__ == "__main__":
    connection = sqlite3.connect("scores.sqlite")
    df = pd.read_sql_query(
        "SELECT player, score FROM scores",
        connection,
    )
    connection.close()

    print(df)
    print(df["score"].mean())
    print(df["score"].max())
    print(average_by_player(df))

    average_by_player(df).plot(kind="bar")
    plt.title("Average Score by Player")
    plt.xlabel("Player")
    plt.ylabel("Average Score")
    plt.tight_layout()
    plt.savefig("average_score_by_player.png")

Ejecutalo desde 08-score-analyzer:

cd 08-score-analyzer
python analysis.py

Deberías ver la tabla, unos números y un archivo nuevo average_score_by_player.png. plt.savefig escribe ese archivo. Si estás en un escritorio y querés una ventana, también podés llamar a plt.show().

Esto aparece deliberadamente más adelante. No necesitabas pandas para aprender variables, loops, funciones o debugging. Aprendiste pandas porque tenías puntajes para resumir, no porque un roadmap lo listara.

Testeá average_by_player, una función que escribiste vos, no los internos de pandas. Creá 08-score-analyzer/test_analysis.py:

import pandas as pd
from analysis import average_by_player

def test_average_by_player():
    df = pd.DataFrame(
        {
            "player": ["Alice", "Alice", "Bob"],
            "score": [100.0, 200.0, 50.0],
        }
    )
    result = average_by_player(df)
    assert result["Alice"] == 150.0
    assert result["Bob"] == 50.0

Desde 08-score-analyzer:

pytest test_analysis.py

El guard de __main__ que viste en los días 5–6 es la razón por la que importar analysis no abre la base ni dibuja un gráfico.

cd ..
git add 08-score-analyzer
git commit -m "Store scores in SQLite and chart averages"
git push

Tus primeros tres meses

Tu recorrido ahora se ve así:

Scratch
  ↓
Entender conceptos de programación
  ↓
Python
  ↓
Instalar y ejecutar Python
  ↓
REPL
  ↓
Sintaxis de Python y palabras reservadas
  ↓
Escribir y ejecutar código
  ↓
Terminal
  ↓
Debugging
  ↓
Juego de adivinar el número
  ↓
Git + GitHub
  ↓
Publicar tu trabajo
  ↓
Hangman
  ↓
Trabajar en nuevas features
  ↓
venv
  ↓
Testing + pytest
  ↓
Archivos + CSV
  ↓
Aplicaciones desde la terminal
  ↓
SQLite
  ↓
pandas
  ↓
Análisis de datos

Empezaste con un print().

Tres meses después podés construir un programa, debuggearlo, agregarle features, testear su comportamiento, registrar su historia con Git, guardar datos, analizarlos y visualizar el resultado.

Cada concepto nuevo apareció porque el proyecto lo necesitaba.

Qué estudiar durante el camino

Usá un conjunto chico de buenas referencias.

Python

Usá el tutorial oficial de Python como referencia principal.

Usá W3Schools Python cuando quieras una explicación rápida o un ejemplo.

Usá Think Python cuando quieras una explicación con formato de libro sobre conceptos de programación.

Usá Exercism Python para practicar.

Usá Python Tutor cuando quieras ver la ejecución del código paso a paso.

Testing

Usá la documentación de pytest cuando testing pase a formar parte de tus proyectos.

Empezá con:

  • archivos de tests
  • funciones de test
  • assert
  • ejecutar pytest
  • entender los errores de los tests

Aprendé más cuando tus proyectos lo necesiten.

Roadmap

Usá roadmap.sh/python como mapa, no como una checklist que tenés que completar inmediatamente.

Un roadmap puede mostrarte qué existe. No puede decirte qué necesitás aprender hoy. No abras todas las tecnologías del roadmap.

Seguí el próximo concepto que sea útil para el problema que estás resolviendo.

Git

Usá GitHub Skills para practicar con ejercicios guiados.

Usá Pro Git cuando quieras una referencia más profunda.

Comunidad

Cuando la documentación y la experimentación no alcanzan, preguntale a otros programadores.

Python Discussions es un buen lugar para ver cómo los desarrolladores de Python discuten problemas.

Stack Overflow en español puede ser útil cuando aprendés a formular una pregunta técnica precisa.

La calidad de la pregunta importa. Explicá:

  • Qué intentaste.
  • Qué esperabas.
  • Qué pasó realmente.
  • El código relevante.
  • El error exacto.

Qué hacer después de tres meses

Mirá qué podés construir.

Si te interesa backend, podés explorar APIs y frameworks como FastAPI, Flask o, más adelante, Django.

Si te interesan los datos, profundizá en pandas, NumPy y visualización.

Si te interesa la automatización, seguí construyendo scripts que resuelvan problemas que tenés.

Si te interesa machine learning, primero consolidá Python y los fundamentos de datos y después explorá herramientas como scikit-learn.

También podés aprender desarrollo web con HTML, CSS y JavaScript.

Tené fundamentos suficientes para saber por qué estás eligiendo la próxima herramienta.

Cuando un programa es lento, o un problema es "encontrar esto", "ordenar aquello" o "el camino más corto", ese es el momento de estudiar algoritmos a propósito. No en la semana 1, y no porque un roadmap los listara.

Aprendé a leer código que no escribiste vos

Hay otra habilidad que deberías desarrollar a medida que te resulte más fácil escribir tus propios programas.

Aprendé a leer código escrito por otra persona. Abrí un proyecto chico de Python open source. No intentes entender todo el repositorio. Buscá una función. Leela.

Preguntate:

  • ¿Cuáles son sus entradas?
  • ¿Qué devuelve?
  • ¿Qué variables crea?
  • ¿Qué funciones llama?
  • ¿Qué pasa si algo sale mal?
  • ¿Dónde están sus tests?
  • ¿Qué te dicen esos tests sobre el comportamiento esperado?

Después cambiá algo localmente y ejecutá el programa o sus tests. Estás pasando de:

"Puedo escribir código."

a:

"Puedo entender código."

Programar es, en gran parte, aprender a aprender

Constantemente vas a encontrarte con cosas que no sabés. Te vas a olvidar de la sintaxis. Vas a interpretar mal una API. Vas a recibir un error que nunca viste. La habilidad es saber qué hacer después.

Intentá algo, observá el resultado, leé el error, buscá, formulá una hipótesis, cambiá una cosa, ejecutá otra vez y testealo.

La AI puede ayudarte dentro de este ciclo. Usala para preguntar:

  • "¿Qué debería investigar?"
  • "¿Qué significa este error?"
  • "¿Qué concepto me está faltando?"
  • "¿Podés mostrarme un ejemplo más chico?"
  • "¿Podés revisar mi enfoque sin resolverlo?"
  • "¿Qué debería testear?"

Después escribí la solución vos.

El objetivo

No te convertís en programador cuando terminás un curso de Python.

Empezá chico. Construí algo. Rompelo. Debuggealo. Testealo. Agregale una feature. Guardalo con Git. Publicalo. Después construí algo un poco más difícil.

Tus primeros proyectos tienen que enseñarte algo.

Mañana: abrí 03-number-guessing-game/game.py, agregá una feature, hacé commit y pusheá.

¡Gracias por leer! Espero que te haya resultado útil. Si tenés alguna pregunta, ¡no dudes en escribirme!

Este post va dedicado a mi amigo Elías :)