Tu primer programa en Python: de cero a resolver problemas reales

Ya tienes Python instalado y VS Code configurado. La pantalla está delante de ti, el cursor parpadea, y ahora viene la gran pregunta: ¿qué escribo? No te preocupes. En esta lección vamos a pasar de mirar una pantalla en blanco a escribir programas que resuelven cosas de verdad. Nada de teoría aburrida sin aplicación: cada concepto que aprendas aquí lo usarás desde el primer minuto.

Vamos a empezar con lo básico — print(), variables, operaciones, input() — y al final de la lección habrás creado una calculadora de propinas que funciona. No está mal para tu tercer día con Python.

🧬 Anatomía de un programa Python

Antes de escribir código, quiero que entiendas cómo se estructura un programa en Python. Porque una de las cosas que más desorienta a los principiantes es no saber «qué va dónde». En otros lenguajes como Java necesitas una clase, un método main, importaciones, llaves por todas partes... En Python, la estructura es brutalmente simple:

# Calculadora de IVA
# Versión 1.0

precio = 49.99
iva = 0.21

impuesto = precio * iva
total = precio + impuesto

print(f"Precio: {precio}€")
print(f"IVA (21%): {impuesto:.2f}€")
print(f"Total: {total:.2f}€")

Eso es un programa Python completo. 10 líneas. Sin ceremonias, sin configuración, sin boilerplate. Lo ejecutas y funciona. Vamos a desglosar cada parte.

🖨️ print(): tu primera herramienta

print() es la función más importante cuando empiezas a programar. Hace exactamente lo que su nombre dice: imprime texto en la pantalla. Es tu forma de ver qué está pasando dentro del programa.

# Lo más básico: imprimir texto
print("Hola, Mundo")

# Imprimir números
print(42)
print(3.14159)

# Imprimir varias cosas separadas por espacio
print("Tengo", 25, "años")

# Línea vacía (útil para separar visualmente)
print()

# Imprimir el resultado de una operación
print(2 + 2)       # Muestra: 4
print(10 * 3)      # Muestra: 30

Un par de cosas que debes saber sobre print():

El texto va entre comillas (simples 'texto' o dobles "texto"). Ambas funcionan igual en Python. Yo uso dobles por costumbre, pero es cuestión de preferencia.

Los números van sin comillas. Si pones comillas alrededor de un número, Python lo trata como texto, no como número. Parece un detalle menor, pero es la fuente de muchos errores de principiante.

Puedes separar varios elementos con comas. Python los imprime separados por un espacio automáticamente.

💬 Comentarios: hablar con tu yo del futuro

Los comentarios son líneas que Python ignora completamente. Empiezan con # y sirven para una sola cosa: explicar el código a los humanos. Y el humano más importante al que le estás escribiendo es tu yo de dentro de tres meses, cuando vuelvas a mirar este código y no recuerdes por qué hiciste lo que hiciste.

# Esto es un comentario de línea completa

precio = 49.99  # También puedes comentar al final de una línea

# Los comentarios son para explicar el POR QUÉ, no el QUÉ.
# MAL:  precio = 49.99  # Asigna 49.99 a precio (¡eso ya se ve!)
# BIEN: precio = 49.99  # Precio base sin IVA del plan mensual

Una anécdota que cuento siempre: cuando empecé a programar, nunca ponía comentarios. «El código es obvio», pensaba. Tres semanas después abría un archivo y no entendía nada. Desde entonces, comento todo lo que no es inmediatamente evidente. Te recomiendo hacer lo mismo desde el día uno.

📦 Variables: donde Python guarda las cosas

Una variable es un nombre que le pones a un dato para poder usarlo después. Piénsalo como una etiqueta que pegas en una caja: la caja contiene el valor, y la etiqueta es el nombre que le das para encontrarla.

# Crear variables es así de simple
nombre = "María"
edad = 28
altura = 1.72
es_estudiante = True

# Usar las variables
print(nombre)          # María
print(edad)            # 28
print(es_estudiante)   # True

# Las variables pueden cambiar de valor
edad = 29  # Ahora edad vale 29
print(edad)            # 29

# Puedes asignar varias en una línea
x, y, z = 1, 2, 3

Fíjate en algo que en Python es diferente a muchos otros lenguajes: no declaras el tipo. No escribes int edad = 28 ni String nombre = "María". Python lo deduce solo mirando el valor que le asignas. Esto se llama tipado dinámico y es una de las razones por las que Python es tan rápido de escribir.

Reglas para nombrar variables

🧮 Operaciones: Python como calculadora con superpoderes

Python sabe hacer todas las operaciones matemáticas que necesitas, y algunas que no sabías que necesitabas. Aquí van las fundamentales:

# Operaciones básicas
print(100 + 50)       # 150
print(100 - 50)       # 50
print(100 * 0.21)     # 21.0
print(100 / 3)        # 33.333...

# División entera vs normal (¡ojo aquí!)
print(7 / 2)          # 3.5 (división normal)
print(7 // 2)         # 3   (descarta decimales)
print(7 % 2)          # 1   (el resto de dividir)

# Potencias
print(2 ** 8)         # 256
print(9 ** 0.5)       # 3.0 (raíz cuadrada)

# Python respeta el orden de operaciones
print(2 + 3 * 4)      # 14, no 20 (primero *, luego +)
print((2 + 3) * 4)    # 20 (paréntesis cambian el orden)

Algo que me parece fascinante: el operador ** para potencias. En la mayoría de lenguajes necesitas importar una biblioteca matemática para calcular potencias. En Python es un operador nativo. Pequeños detalles como este hacen que Python se sienta natural.

Y un truco útil: el operador % (módulo) parece inútil al principio, pero es increíblemente práctico. ¿Quieres saber si un número es par? numero % 2 == 0. ¿Quieres hacer algo cada 5 iteraciones en un bucle? i % 5 == 0. Lo usarás más de lo que imaginas.

⌨️ input(): hacer que el programa escuche

Hasta ahora, nuestros programas hacen cosas pero no le preguntan nada al usuario. Son monólogos. Con input(), el programa se convierte en un diálogo.

# Pedir datos al usuario
nombre = input("¿Cómo te llamas? ")
print("¡Hola, " + nombre + "!")

# CUIDADO: input() SIEMPRE devuelve texto (str)
edad_texto = input("¿Cuántos años tienes? ")
print(type(edad_texto))  # <class 'str'> ¡Es texto, no número!

# Para hacer operaciones, hay que convertir a número
edad = int(edad_texto)          # Convertir texto → número entero
print("El año que viene tendrás", edad + 1)

Aquí hay una trampa que pilla a todo el mundo al principio: input() siempre devuelve texto. Aunque el usuario escriba 25, para Python eso es la cadena de texto "25", no el número 25. Si intentas sumar "25" + 1, Python te dará un error. Necesitas convertirlo:

✨ f-strings: mezclar texto y datos como un profesional

Ya has visto que puedes imprimir varias cosas con comas o concatenar con +. Pero hay una forma mucho mejor que se inventó en Python 3.6 y que hoy es el estándar: las f-strings (formatted string literals).

nombre = "Carlos"
edad = 30
salario = 2850.50

# La forma ANTIGUA (funciona, pero es fea)
print("Me llamo " + nombre + " y tengo " + str(edad) + " años.")

# La forma MODERNA (f-strings) — usa SIEMPRE esta
print(f"Me llamo {nombre} y tengo {edad} años.")

# Puedes hacer operaciones dentro de las llaves
print(f"El año que viene tendré {edad + 1} años.")

# Formatear números con decimales
print(f"Salario: {salario:.2f}€")           # 2850.50€
print(f"Salario: {salario:,.2f}€")          # 2,850.50€

# Alinear texto (útil para tablas)
print(f"{'Producto':<20}{'Precio':>10}")
print(f"{'Teclado':<20}{49.99:>10.2f}")
print(f"{'Monitor':<20}{299.00:>10.2f}")

Las f-strings son, en mi opinión, una de las mejores decisiones de diseño de Python moderno. Compara las dos formas de imprimir el mismo texto: la antigua es un lío de comillas, signos + y conversiones con str(). La f-string es casi lenguaje natural. Solo necesitas acordarte de poner la f antes de las comillas y meter las variables entre {llaves}.

🏗️ Tu primer programa completo

Ya tienes todas las piezas. Es hora de juntarlas. Vamos a crear una calculadora de propinas — un programa que le pregunta al usuario el importe de la cuenta, calcula distintos porcentajes de propina y muestra los resultados formateados.

# ================================
# Calculadora de propinas
# Pide el importe y calcula propinas
# al 10%, 15% y 20%
# ================================

# 1. Pedir el importe al usuario
print("=== CALCULADORA DE PROPINAS ===")
print()

cuenta_texto = input("¿Cuánto es la cuenta? (en euros): ")
cuenta = float(cuenta_texto)  # Convertir texto a número decimal

personas_texto = input("¿Cuántas personas sois? ")
personas = int(personas_texto)  # Convertir texto a entero

# 2. Calcular propinas
propina_10 = cuenta * 0.10
propina_15 = cuenta * 0.15
propina_20 = cuenta * 0.20

# 3. Calcular totales
total_10 = cuenta + propina_10
total_15 = cuenta + propina_15
total_20 = cuenta + propina_20

# 4. Mostrar resultados
print()
print(f"Cuenta: {cuenta:.2f}€")
print(f"{'─' * 35}")
print(f"{'Propina':<12}{'Total':<12}{'Por persona'}")
print(f"{'─' * 35}")
print(f"10%: {propina_10:>6.2f}€   {total_10:>7.2f}€   {total_10/personas:>6.2f}€")
print(f"15%: {propina_15:>6.2f}€   {total_15:>7.2f}€   {total_15/personas:>6.2f}€")
print(f"20%: {propina_20:>6.2f}€   {total_20:>7.2f}€   {total_20/personas:>6.2f}€")
print(f"{'─' * 35}")

Si ejecutas este programa e introduces una cuenta de 85€ para 3 personas, verás algo así:

=== CALCULADORA DE PROPINAS ===

¿Cuánto es la cuenta? (en euros): 85
¿Cuántas personas sois? 3

Cuenta: 85.00€
───────────────────────────────────
Propina     Total       Por persona
───────────────────────────────────
10%:   8.50€    93.50€    31.17€
15%:  12.75€    97.75€    32.58€
20%:  17.00€   102.00€    34.00€
───────────────────────────────────

30 líneas de código y tienes una herramienta útil que puedes sacar la próxima vez que vayas a un restaurante. Eso es lo que me gusta de Python: desde el principio puedes crear cosas que sirven para algo.

🐛 Los errores más comunes (y cómo leerlos)

Vas a cometer errores. Muchos. Y eso está bien — es literalmente cómo se aprende a programar. Lo importante es aprender a leer los mensajes de error, porque Python te dice exactamente qué ha ido mal.

Cuando Python te muestra un error, la información más útil está en la última línea (qué tipo de error es) y en la línea que dice File "..." line X (dónde está el error). Ejemplo:

Traceback (most recent call last):
  File "mi_programa.py", line 5, in <module>
    print("Tengo " + 25 + " años")
TypeError: can only concatenate str (not "int") to str

Traducido: «En la línea 5 de mi_programa.py, has intentado concatenar un entero (25) con una cadena de texto, y eso no se puede hacer». La solución: usar una f-string (f"Tengo {25} años") o convertir el número ("Tengo " + str(25) + " años").

✏️ Ejercicios para practicar

La programación se aprende haciendo, no leyendo. Aquí tienes tres ejercicios ordenados de fácil a medio. Intenta resolverlos antes de mirar la solución.

Ejercicio 1: Conversor de temperatura

Escribe un programa que pida al usuario una temperatura en grados Celsius y la convierta a Fahrenheit. La fórmula es: F = C × 9/5 + 32.

# Conversor Celsius → Fahrenheit
celsius_texto = input("Temperatura en Celsius: ")
celsius = float(celsius_texto)

fahrenheit = celsius * 9 / 5 + 32

print(f"{celsius}°C = {fahrenheit:.1f}°F")

Ejercicio 2: Calculadora de IMC

Crea un programa que pida peso (en kg) y altura (en metros) y calcule el Índice de Masa Corporal. La fórmula es: IMC = peso / altura².

# Calculadora de IMC
peso = float(input("Tu peso en kg: "))
altura = float(input("Tu altura en metros (ej: 1.72): "))

imc = peso / altura ** 2

print(f"Tu IMC es {imc:.1f}")

Ejercicio 3: Desglose de monedas

Escribe un programa que pida una cantidad en céntimos (por ejemplo, 347) y calcule cuántas monedas de 2€, 1€, 50c, 20c, 10c, 5c, 2c y 1c necesitas. Pista: usa // y %.

# Desglose de monedas
centimos = int(input("Cantidad en céntimos: "))
original = centimos  # Guardamos el original para mostrar después

monedas_2e = centimos // 200
centimos = centimos % 200

monedas_1e = centimos // 100
centimos = centimos % 100

monedas_50 = centimos // 50
centimos = centimos % 50

monedas_20 = centimos // 20
centimos = centimos % 20

monedas_10 = centimos // 10
centimos = centimos % 10

monedas_5 = centimos // 5
centimos = centimos % 5

monedas_2 = centimos // 2
centimos = centimos % 2

monedas_1 = centimos

print(f"\nDesglose de {original} céntimos ({original/100:.2f}€):")
print(f"  Monedas de 2€:  {monedas_2e}")
print(f"  Monedas de 1€:  {monedas_1e}")
print(f"  Monedas de 50c: {monedas_50}")
print(f"  Monedas de 20c: {monedas_20}")
print(f"  Monedas de 10c: {monedas_10}")
print(f"  Monedas de 5c:  {monedas_5}")
print(f"  Monedas de 2c:  {monedas_2}")
print(f"  Monedas de 1c:  {monedas_1}")

Si has resuelto los tres, especialmente el de monedas, ya estás pensando como un programador. Ese ejercicio usa // y % repetidamente para descomponer un número — un patrón que se repite constantemente en programación.

🚀 Siguiente paso: variables y tipos de datos a fondo

En esta lección has aprendido las herramientas fundamentales: print(), input(), variables, operaciones, f-strings y cómo leer errores. Con esto puedes escribir programas que calculan cosas, interactúan con el usuario y muestran resultados formateados.

En la siguiente lección vamos a profundizar en los tipos de datos de Python: enteros, decimales, cadenas de texto, booleanos y cómo convertir entre ellos. También veremos métodos de cadenas que te permitirán manipular texto como un profesional.

❓ Preguntas frecuentes