2. Tus primeros programas en Python

En el Capítulo 1 aprendiste cómo instalar Python, usar la consola interactiva (REPL) y ejecutar archivos de script sencillos. También viste por primera vez errores y tracebacks. Ahora es momento de escribir tus primeros programas reales en Python: programas que muestran información, aceptan entrada de usuarios y producen resultados significativos.

Este capítulo presenta los bloques fundamentales que usarás en casi todos los programas de Python que escribas: la función print() para mostrar salida, los comentarios para documentar tu código, las variables para almacenar datos y la función input() para obtener información de los usuarios. Al final de este capítulo, serás capaz de crear programas interactivos simples pero completos que siguen el patrón clásico de entrada-proceso-salida.

2.1) Imprimir texto con la función print()

La función print() es una de las herramientas más esenciales de Python. Muestra texto (y otra información) en la pantalla, permitiendo que tus programas se comuniquen con los usuarios. Ya has visto print() brevemente en el Capítulo 1, pero ahora la exploraremos en profundidad.

2.1.1) Impresión básica

En su forma más sencilla, print() muestra texto entre comillas. Vamos a crear un archivo de script para ver cómo funciona:

# hello.py
print("Hello, World!")

Cuando ejecutas este script, Python muestra:

Hello, World!

El texto dentro de las comillas—"Hello, World!"—se llama string. Un string es una secuencia de caracteres (letras, números, símbolos, espacios) que Python trata como texto. Exploraremos los strings con mucho más detalle en el Capítulo 5, pero por ahora, piénsalos como la forma de representar texto en Python.

Puedes imprimir cualquier texto que quieras colocándolo dentro de comillas:

# greetings.py
print("Welcome to Python programming!")
print("This is your first real program.")
print("Python makes programming fun and accessible.")

Salida:

Welcome to Python programming!
This is your first real program.
Python makes programming fun and accessible.

Observa que cada sentencia print() produce salida en una línea separada. Python añade automáticamente un salto de línea (newline) después de cada llamada a print(), moviendo el cursor a la siguiente línea.

2.1.2) Imprimir varios elementos

La función print() puede mostrar varios elementos en una sola llamada, separándolos con comas:

# multiple_items.py
print("Python", "is", "awesome!")
print("I", "am", "learning", "to", "code")

Salida:

Python is awesome!
I am learning to code

Cuando separas elementos con comas, print() inserta automáticamente un espacio entre ellos. Esto es conveniente para combinar varias piezas de texto sin tener que añadir espacios manualmente.

También puedes mezclar diferentes tipos de datos. Por ejemplo, puedes imprimir tanto texto como números:

# mixed_output.py
print("The answer is", 42)
print("Python version", 3.12, "is powerful")

Salida:

The answer is 42
Python version 3.12 is powerful

Python convierte automáticamente los números a texto al imprimirlos, así que por ahora no necesitas preocuparte por los detalles técnicos. Aprenderemos más sobre los diferentes tipos de datos en el Capítulo 3.

2.1.3) Comillas simples vs comillas dobles

Python acepta tanto comillas simples (') como comillas dobles (") para los strings. Son completamente intercambiables para texto sencillo:

# quotes.py
print("This uses double quotes")
print('This uses single quotes')
print("Both work exactly the same way")

Salida:

This uses double quotes
This uses single quotes
Both work exactly the same way

Sin embargo, las comillas se vuelven importantes cuando tu texto contiene apóstrofes o comillas. Si tu texto contiene un apóstrofe (que es el mismo carácter que una comilla simple), usa comillas dobles para encerrarlo:

# apostrophes.py
print("It's a beautiful day!")
print("Python's syntax is clean")

Salida:

It's a beautiful day!
Python's syntax is clean

Si intentaras usar comillas simples aquí, Python se confundiría:

# This causes an error:
print('It's a beautiful day!')  # Error! Python sees three separate quotes

El error ocurre porque Python ve el apóstrofe en "It's" como el final del string, dejando "s a beautiful day!" como código no válido.

De forma similar, si tu texto contiene comillas dobles, usa comillas simples para encerrarlo:

# quotations.py
print('She said, "Hello!"')
print('The book is called "Python Basics"')

Salida:

She said, "Hello!"
The book is called "Python Basics"

Guía práctica: Elige un estilo (comillas simples o dobles) y úsalo de forma consistente en tu código. La mayoría de programadores de Python prefieren comillas dobles para los strings habituales, pero cualquier elección está bien. Cambia al otro estilo solo cuando tu texto contenga el carácter de comillas que usas normalmente.

2.1.4) Imprimir líneas en blanco

A veces quieres añadir líneas en blanco a tu salida para hacerla más legible. Puedes hacerlo llamando a print() sin argumentos:

# spacing.py
print("First section of output")
print("More information here")
print()  # Empty line
print("Second section of output")
print("This is separated from the first section")

Salida:

First section of output
More information here
 
Second section of output
This is separated from the first section

La llamada vacía a print() crea una línea en blanco, haciendo que la salida sea más fácil de leer al separar visualmente diferentes secciones.

2.1.5) Caracteres especiales en strings

A veces necesitas incluir caracteres especiales en tu salida que no puedes escribir directamente o que tienen un significado especial en Python. Por ejemplo, ¿cómo creas un salto de línea en medio de un string? ¿O incluyes una tabulación para alinear? Python proporciona secuencias de escape: combinaciones especiales de dos caracteres que empiezan con una barra invertida (\) para representar estos caracteres.

Estas secuencias de escape son especialmente útiles cuando necesitas formatear la salida de formas específicas: crear mensajes de varias líneas, alinear columnas de datos o trabajar con rutas de archivos en Windows. Usarás \n con frecuencia a medida que escribas más programas.

La secuencia de escape más común es \n, que representa un salto de línea:

# newlines.py
print("First line\nSecond line\nThird line")

Salida:

First line
Second line
Third line

El \n le dice a Python que pase a una nueva línea en ese punto del string. Esto es útil cuando quieres crear varias líneas de salida con una sola sentencia print().

Otra secuencia de escape útil es \t, que representa una tabulación (espaciado horizontal):

# tabs.py
print("Name:\tJohn")
print("Age:\t25")
print("City:\tNew York")

Salida:

Name:	John
Age:	25
City:	New York

El \t crea un espaciado consistente, alineando los valores en un formato parecido a columnas.

Si necesitas incluir una barra invertida real en tu salida, usa \\:

# backslash.py
print("The file path is C:\\Users\\Documents")

Salida:

The file path is C:\Users\Documents

Exploraremos las secuencias de escape y el manejo de strings con mucha más profundidad en el Capítulo 5. Por ahora, solo recuerda que \n crea nuevas líneas y \t crea tabulaciones.

2.2) Usar comentarios para explicar el código

A medida que tus programas se vuelven más complejos, se hace importante explicar qué hace tu código, tanto para otras personas que puedan leerlo como para tu yo del futuro. Python proporciona comentarios para este propósito: notas en tu código que Python ignora completamente al ejecutar el programa.

2.2.1) Comentarios de una sola línea

En Python, cualquier texto que siga a un símbolo # en una línea es un comentario. Python ignora todo desde el # hasta el final de esa línea:

# comment_example.py
# This is a comment. Python ignores this line completely.
print("This line runs")  # This comment explains the print statement
# print("This line does NOT run because it's commented out")
print("This line also runs")

Salida:

This line runs
This line also runs

Observa que la segunda sentencia print() no se ejecutó porque la línea entera estaba comentada. Esto es útil cuando quieres desactivar temporalmente código sin borrarlo.

Los comentarios pueden aparecer en su propia línea o al final de una línea de código. Ambos estilos son habituales:

# display_info.py
# Display a welcome message to the user
print("Welcome to the program!")
 
print("Processing data...")  # Inform the user of progress

2.2.2) Cuándo y cómo escribir buenos comentarios

Los comentarios deben explicar por qué estás haciendo algo, no solo qué hace el código. Aquí tienes un ejemplo de mal comentario:

# Bad comment - just repeats what the code obviously does
print("Hello")  # Print "Hello"

Este comentario no aporta ningún valor porque cualquiera que lea el código ya puede ver que imprime "Hello".

Aquí tienes un enfoque mejor:

# Good comment - explains the purpose or context
# Greet the user before requesting their information
print("Hello")

Este comentario explica por qué estamos imprimiendo "Hello": es parte de una interacción más amplia con el usuario.

Guías para escribir comentarios útiles:

1. Explica el propósito: ¿Por qué existe este código? ¿Qué problema resuelve?
2. Aclara la lógica compleja: Si algo no es inmediatamente obvio, explícalo
3. Anota decisiones importantes: Explica por qué elegiste un enfoque en lugar de otro
4. Advierte sobre trampas: Señala cualquier cosa que pueda ser confusa o inesperada
5. Mantenlos actualizados: Actualiza los comentarios cuando cambies el código

Aquí tienes un ejemplo que muestra comentarios efectivos:

# temperature_converter.py
# This program converts temperatures from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
# Display program title
print("Temperature Converter")
print("Fahrenheit to Celsius")
print()
 
# We'll learn how to get user input in section 2.4
# For now, we'll use a fixed temperature value
fahrenheit = 75  # Temperature in Fahrenheit to convert
 
# Perform the conversion using the standard formula
# Subtract 32 first (order matters due to the formula)
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print("Temperature:", fahrenheit, "°F =", celsius, "°C")

Salida:

Temperature Converter
Fahrenheit to Celsius
 
Temperature: 75 °F = 23.88888888888889 °C

Fíjate en cómo los comentarios explican el propósito del programa, la fórmula que se usa y la lógica detrás del cálculo. Hacen que el código sea mucho más fácil de entender, especialmente para alguien que lo ve por primera vez.

2.2.3) Comentarios de varias líneas y docstrings

Para explicaciones más largas, podrías usar varios comentarios de una sola línea:

# multi_line_comments.py
# This program demonstrates a longer explanation
# that spans multiple lines. Each line starts
# with a # symbol.
print("Program starts here")

Python no tiene una sintaxis especial de comentario multilínea como algunos otros lenguajes. Sin embargo, hay un enfoque alternativo usando strings con triple comilla. Aprenderemos más sobre esto en el Capítulo 19 cuando hablemos de docstrings (strings de documentación para funciones), pero aquí tienes un adelanto:

# docstring_preview.py
"""
This is a multi-line string that can serve as a comment.
It's not technically a comment—it's a string that Python
creates but doesn't use. However, it's often used for
longer explanations at the beginning of files.
"""
print("Program starts here")

Por ahora, quédate con # para los comentarios. Exploraremos los strings con triple comilla y sus usos adecuados en capítulos posteriores.

2.2.4) Comentar código para pruebas

Los comentarios también son útiles para desactivar temporalmente código mientras haces pruebas:

# testing.py
print("This always runs")
# print("This is disabled for testing")
print("This also always runs")

Esta técnica se llama "comentar" código. Es útil cuando quieres probar cómo se comporta tu programa sin ciertas líneas, pero no quieres borrar esas líneas de forma permanente.

2.3) Introducción a variables y asignación (vista previa)

Los programas se vuelven mucho más útiles cuando pueden almacenar y manipular datos. Las variables son contenedores con nombre que guardan valores. Piensa en una variable como una caja etiquetada donde puedes guardar información y recuperarla más tarde.

Nota importante: Esta sección ofrece una vista previa de las variables para ayudarte a entender los ejemplos de este capítulo. Exploraremos las variables en profundidad en el Capítulo 3, incluyendo reglas de nombres, tipos de datos y cómo maneja Python las variables internamente. Por ahora, nos centraremos en el concepto básico y su uso.

2.3.1) Crear variables con asignación

Creas una variable usando el operador de asignación (=). El patrón básico es:

variable_name = value

El nombre de la variable va a la izquierda, el valor va a la derecha y el = los conecta:

# variables_basic.py
message = "Hello, Python!"
print(message)

Salida:

Hello, Python!

Esto es lo que ocurre:

1. Python crea una variable llamada message
2. Python almacena el string "Hello, Python!" en esa variable
3. Cuando usamos message en la función print(), Python recupera el valor almacenado y lo muestra

Las variables pueden almacenar diferentes tipos de datos. Aquí tienes algunos ejemplos:

# variable_types.py
greeting = "Welcome!"  # A string (text)
age = 25  # A number (integer)
price = 19.99  # A number with a decimal point (float)
is_student = True  # A boolean (True or False)
 
print(greeting)
print(age)
print(price)
print(is_student)

Salida:

Welcome!
25
19.99
True

Aprenderemos sobre estos diferentes tipos de datos (strings, enteros, floats, booleanos) en el Capítulo 3. Por ahora, solo entiende que las variables pueden contener distintos tipos de información.

2.3.2) Por qué las variables son útiles

Las variables hacen que tu código sea más flexible y fácil de mantener. Compara estos dos enfoques:

Sin variables:

# no_variables.py
print("Welcome, John!")
print("John, your account balance is $1000")
print("Thank you for banking with us, John!")

Con variables:

# with_variables.py
name = "John"
balance = 1000
 
print("Welcome,", name + "!")
print(name, "your account balance is $", balance)
print("Thank you for banking with us,", name + "!")

Ambos programas producen una salida similar, pero la versión con variables tiene ventajas importantes:

1. Actualizaciones fáciles: Para cambiar el nombre, solo necesitas modificar una línea (name = "John") en lugar de tres
2. Menos errores: No puedes equivocarte al escribir el nombre en un sitio y en otro no
3. Más flexible: Más adelante podrás cambiar cómo obtiene su valor name (por ejemplo, preguntando al usuario)

2.3.3) Reasignar variables

Las variables pueden cambiar su valor durante la ejecución del programa. Esto se llama reasignación:

# reassignment.py
score = 0
print("Initial score:", score)
 
score = 10
print("After first update:", score)
 
score = 25
print("After second update:", score)

Salida:

Initial score: 0
After first update: 10
After second update: 25

Cada vez que asignas un nuevo valor a una variable, Python sustituye el valor antiguo por el nuevo. El valor anterior se descarta.

Incluso puedes usar el valor actual de una variable para calcular su nuevo valor:

# updating_values.py
count = 5
print("Starting count:", count)
 
count = count + 1  # Add 1 to count
print("After adding 1:", count)
 
count = count + 10  # Add 10 to count
print("After adding 10:", count)

Salida:

Starting count: 5
After adding 1: 6
After adding 10: 16

Este patrón—count = count + 1—es extremadamente común en programación. Significa "toma el valor actual de count, súmale 1 y guarda el resultado de nuevo en count". Aprenderemos una forma abreviada de hacer esto (count += 1) en el Capítulo 4.

2.3.4) Vista previa de nombres de variables

Los nombres de variables en Python deben seguir ciertas reglas:

• Pueden contener letras, números y guiones bajos (_)
• Deben empezar con una letra o un guion bajo (no con un número)
• No pueden contener espacios ni caracteres especiales como @, $, %, etc.
• No pueden ser palabras clave de Python (palabras reservadas como print, if, for, etc.)

Aquí tienes algunos nombres de variable válidos:

# valid_names.py
user_name = "Alice"
age2 = 30
_private_value = 42
totalPrice = 99.99

Y algunos nombres no válidos:

# These cause errors:
# 2age = 30  # Cannot start with a number
# user-name = "Alice"  # Cannot contain hyphens
# total price = 99.99  # Cannot contain spaces
# print = "Hello"  # Cannot use Python keywords

Buena práctica: Usa nombres descriptivos que indiquen qué representa la variable. user_age es mejor que a, y total_price es mejor que tp. Hablaremos sobre convenciones de nombres en detalle en el Capítulo 3.

2.3.5) Las variables hacen que los programas sean dinámicos

El verdadero poder de las variables se hace evidente cuando las usas para hacer que los programas sean más dinámicos:

# dynamic_greeting.py
name = "Alice"
age = 28
city = "Seattle"
 
print("Personal Information")
print("====================")
print("Name:", name)
print("Age:", age)
print("City:", city)
print()
print("Summary:", name, "is", age, "years old and lives in", city)

Salida:

Personal Information
====================
Name: Alice
Age: 28
City: Seattle
 
Summary: Alice is 28 years old and lives in Seattle

Cambiando los valores de name, age y city al principio del programa, puedes personalizar toda la salida sin modificar las sentencias print(). Esta separación de los datos respecto a la lógica es un principio fundamental de la buena programación.

Mirando hacia adelante: En el Capítulo 3 exploraremos las variables de forma exhaustiva, incluyendo tipos de datos, conversión de tipos, reglas de nombres y cómo gestiona Python las variables internamente. Por ahora, tienes suficiente comprensión para usar variables en programas sencillos.

2.4) Leer entrada desde el teclado con input()

Hasta ahora, todos los datos de nuestros programas estaban codificados directamente en el código. Pero los programas reales a menudo necesitan interactuar con los usuarios, aceptando la información que proporcionan. La función input() de Python hace esto posible.

2.4.1) Entrada básica

La función input() muestra un mensaje (llamado prompt) y espera a que el usuario escriba algo y pulse Enter. Este es el patrón básico:

# basic_input.py
name = input("What is your name? ")
print("Hello,", name + "!")

Cuando ejecutas este programa, esto es lo que ocurre:

What is your name? Alice
Hello, Alice!

Analicémoslo:

1. Python ejecuta input("What is your name? ")
2. Python muestra el prompt: What is your name?
3. El programa se pausa y espera a que el usuario escriba algo
4. El usuario escribe Alice y pulsa Enter
5. Python guarda el texto "Alice" en la variable name
6. El programa continúa, imprimiendo el saludo

El texto que proporcionas a input() es el prompt, lo que el usuario ve antes de escribir. Incluye siempre un espacio al final del prompt (fíjate en el espacio después del signo de interrogación) para separar el prompt de la entrada del usuario, haciéndolo más fácil de leer.

2.4.2) input siempre devuelve un string

Esto es crucial de entender: input() siempre devuelve un string, incluso si el usuario escribe números:

# input_as_string.py
age = input("How old are you? ")
print("You entered:", age)
print("The type is:", type(age))

Cuando ejecutas esto e introduces 25:

How old are you? 25
You entered: 25
The type is: <class 'str'>

Aunque el usuario escribió 25, Python lo guarda como el string "25", no como el número 25. La función type() lo confirma: muestra que age es un string (str), no un entero.

Esto importa cuando quieres hacer cálculos. No puedes hacer operaciones matemáticas directamente con strings:

# This causes an error:
age = input("How old are you? ")
next_year_age = age + 1  # Error! Can't add a number to a string

Esto produce un error porque Python no sabe cómo sumar el número 1 al string "25".

2.4.3) Convertir la entrada a números

Para usar la entrada como número, debes convertirla explícitamente usando int() (para números enteros) o float() (para números decimales):

# input_conversion.py
age_string = input("How old are you? ")
age = int(age_string)  # Convert string to integer
 
next_year = age + 1
print("Next year, you will be", next_year, "years old")

Cuando ejecutas esto e introduces 25:

How old are you? 25
Next year, you will be 26 years old

También puedes combinar la entrada y la conversión en una sola línea:

# input_conversion_compact.py
age = int(input("How old are you? "))
next_year = age + 1
print("Next year, you will be", next_year, "years old")

Esto es más conciso y es el estilo que verás con más frecuencia. Funciona de dentro hacia fuera:

1. input("How old are you? ") obtiene la entrada del usuario como string
2. int(...) convierte ese string en un entero
3. El entero se guarda en la variable age

Aquí tienes un ejemplo usando float() para números decimales:

# float_input.py
price = float(input("Enter the price: $"))
tax_rate = 0.08
tax = price * tax_rate
total = price + tax
 
print("Price: $", price)
print("Tax: $", tax)
print("Total: $", total)

Cuando ejecutas esto e introduces 19.99:

Enter the price: $19.99
Price: $ 19.99
Tax: $ 1.5992
Total: $ 21.5892

Importante: Si el usuario introduce texto que no se puede convertir a número, Python lanzará un error. Por ejemplo, si usas int(input("Enter a number: ")) y el usuario escribe "hello", Python no puede convertir "hello" a un entero y mostrará un mensaje de error. Aprenderemos cómo manejar estas situaciones de forma elegante en el Capítulo 27 cuando estudiemos el manejo de excepciones.

2.4.4) Varias entradas

Los programas a menudo necesitan varios datos del usuario. Simplemente llama a input() varias veces:

# multiple_inputs.py
print("Please enter your information:")
print()
 
first_name = input("First name: ")
last_name = input("Last name: ")
age = int(input("Age: "))
city = input("City: ")
 
print()
print("Summary")
print("=======")
print("Name:", first_name, last_name)
print("Age:", age)
print("Location:", city)

Interacción de ejemplo:

Please enter your information:
 
First name: John
Last name: Smith
Age: 30
City: Boston
 
Summary
=======
Name: John Smith
Age: 30
Location: Boston

Observa cómo el programa solicita cada pieza de información por separado. Esto deja claro al usuario qué debe proporcionar y en qué orden.

2.4.5) Crear prompts informativos

Los buenos prompts hacen que tus programas sean más fáciles de usar. Aquí tienes algunas pautas:

Sé específico sobre lo que quieres:

# Good prompts
name = input("Enter your full name: ")
temperature = float(input("Enter temperature in Fahrenheit: "))
quantity = int(input("How many items do you want to purchase? "))

Incluye el formato o las unidades esperadas:

# format_prompts.py
date = input("Enter date (MM/DD/YYYY): ")
phone = input("Enter phone number (XXX-XXX-XXXX): ")
price = float(input("Enter price in dollars (without $): "))

Usa un lenguaje claro y amistoso:

# friendly_prompts.py
print("Welcome to the Temperature Converter!")
print()
temp = float(input("Please enter a temperature in Fahrenheit: "))

Los prompts claros reducen la confusión del usuario y hacen que tus programas parezcan más profesionales.

2.5) Programas sencillos de entrada-proceso-salida

La mayoría de los programas siguen un patrón común llamado entrada-proceso-salida (Input-Process-Output, IPO):

1. Entrada: Obtener datos del usuario u otra fuente
2. Proceso: Realizar cálculos o transformaciones sobre los datos
3. Salida: Mostrar los resultados

Este patrón es tan fundamental que lo usarás en infinidad de programas a lo largo de tu aprendizaje de programación. Vamos a explorarlo con varios ejemplos completos.

2.5.1) Ejemplo: Convertidor de temperatura

Vamos a crear un programa completo que convierta temperaturas de Fahrenheit a Celsius:

# temperature_converter.py
# This program converts a temperature from Fahrenheit to Celsius
# Formula: C = (F - 32) × 5/9
 
print("Temperature Converter")
print("Fahrenheit to Celsius")
print("=" * 30)  # Print a line of equal signs
print()
 
# INPUT: Get temperature from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# PROCESS: Convert using the formula
celsius = (fahrenheit - 32) * 5 / 9
 
# OUTPUT: Display the result
print()
print("Result:", fahrenheit, "°F =", celsius, "°C")

Interacción de ejemplo:

Temperature Converter
Fahrenheit to Celsius
==============================
 
Enter temperature in Fahrenheit: 75
 
Result: 75.0 °F = 23.88888888888889 °C

Observa cómo el programa sigue claramente el patrón IPO:

• Entrada: Obtener la temperatura en Fahrenheit
• Proceso: Aplicar la fórmula de conversión
• Salida: Mostrar el resultado en Celsius

Los comentarios en el código marcan explícitamente estas tres secciones, haciendo que la estructura del programa sea clara.

2.5.2) Ejemplo: Calculadora de área de rectángulo

Aquí tienes otro ejemplo de IPO que calcula el área de un rectángulo:

# rectangle_area.py
# Calculate the area of a rectangle
# Formula: Area = length × width
 
print("Rectangle Area Calculator")
print("=" * 30)
print()
 
# INPUT: Get dimensions from user
length = float(input("Enter the length: "))
width = float(input("Enter the width: "))
 
# PROCESS: Calculate area
area = length * width
 
# OUTPUT: Display the result
print()
print("A rectangle with length", length, "and width", width)
print("has an area of", area, "square units")

Interacción de ejemplo:

Rectangle Area Calculator
==============================
 
Enter the length: 5.5
Enter the width: 3.2
 
A rectangle with length 5.5 and width 3.2
has an area of 17.6 square units

2.5.3) Ejemplo: Calculadora de total de compra

Este ejemplo calcula un total de compra con impuestos:

# shopping_total.py
# Calculate total cost including tax
 
print("Shopping Total Calculator")
print("=" * 30)
print()
 
# INPUT: Get price and tax rate
price = float(input("Enter item price: $"))
tax_rate = float(input("Enter tax rate (as decimal, e.g., 0.08 for 8%): "))
 
# PROCESS: Calculate tax and total
tax_amount = price * tax_rate
total = price + tax_amount
 
# OUTPUT: Display itemized breakdown
# Note: Comma in print() adds a space after $
print()
print("Purchase Summary")
print("-" * 30)
print("Item price:    $", price)
print("Tax rate:      ", tax_rate * 100, "%")
print("Tax amount:    $", tax_amount)
print("-" * 30)
print("Total:         $", total)

Interacción de ejemplo:

Shopping Total Calculator
==============================
 
Enter item price: $49.99
Enter tax rate (as decimal, e.g., 0.08 for 8%): 0.08
 
Purchase Summary
------------------------------
Item price:    $ 49.99
Tax rate:       8.0 %
Tax amount:    $ 3.9992
------------------------------
Total:         $ 53.9892

2.6) Depuración básica leyendo mensajes de error sencillos

Incluso los programadores con experiencia cometen errores. Aprender a leer y entender los mensajes de error es una habilidad esencial que te ahorrará incontables horas de frustración. Los mensajes de error de Python son en realidad bastante útiles: te dicen qué salió mal y dónde ocurrió el problema.

Los términos "mensaje de error" y "traceback" están relacionados pero son ligeramente distintos: un traceback es el informe completo que muestra Python cuando ocurre un error, incluyendo el tipo de error, la descripción y el recorrido por tu código que llevó al error. El mensaje de error es la última línea del traceback que describe qué salió mal. En conversaciones informales, los programadores suelen usar "mensaje de error" para referirse a todo el traceback.

2.6.1) Entender los mensajes de error

Cuando Python encuentra un error, muestra un traceback, un informe detallado de lo que salió mal. Veamos un ejemplo sencillo:

# error_example.py
print("Starting the program")
print("This line works fine"
print("This line might not be reached")

Cuando intentas ejecutar esto, Python muestra:

  File "error_example.py", line 2
    print("This line works fine"
                                ^
SyntaxError: '(' was never closed

Analicemos lo que nos dice este mensaje de error:

1. Nombre de archivo: error_example.py - El archivo donde ocurrió el error
2. Número de línea: line 2 - Donde Python detectó el problema
3. Fragmento de código: Muestra la línea problemática con un ^ señalando dónde notó el problema Python
4. Tipo de error: SyntaxError - Qué tipo de error ocurrió
5. Descripción: '(' was never closed - Una explicación en lenguaje natural

El error ocurrió porque olvidamos el paréntesis de cierre en la línea 2. Python intentó seguir leyendo la siguiente línea como parte de la misma sentencia print() y se confundió.

2.6.2) Tipos de error comunes para principiantes

Vamos a ver los errores más comunes que encontrarás como principiante y cómo solucionarlos.

SyntaxError: Invalid Syntax

Este es el error más habitual para principiantes. Significa que Python no pudo entender tu código porque no sigue las reglas gramaticales de Python.

Dos puntos faltantes:

# missing_colon.py
name = input("What is your name? ")
if name == "Alice"  # Missing colon
    print("Hello, Alice!")

Error:

  File "missing_colon.py", line 2
    if name == "Alice"
                     ^
SyntaxError: expected ':'

Nota: Aún no hemos aprendido sobre las sentencias if; las veremos en el Capítulo 8. Este ejemplo solo muestra cómo se ve el error.

Comillas no coincidentes:

# mismatched_quotes.py
message = "Hello, world!'
print(message)

Error:

  File "mismatched_quotes.py", line 1
    message = "Hello, world!'
              ^
SyntaxError: unterminated string literal (detected at line 1)

El error ocurre porque el string empieza con comillas dobles (") pero termina con comillas simples ('). Python espera el mismo tipo de comillas al principio y al final.

NameError: Name Not Defined

Este error aparece cuando intentas usar una variable que no existe:

# name_error.py
print("Starting calculation")
result = total + 10  # 'total' was never created
print(result)

Error:

Traceback (most recent call last):
  File "name_error.py", line 2, in <module>
    result = total + 10
             ^^^^^
NameError: name 'total' is not defined

Python te está diciendo que no sabe qué es total porque nunca creaste esa variable. La solución es definir total antes de usarla:

# name_error_fixed.py
print("Starting calculation")
total = 0  # Define the variable first
result = total + 10
print(result)

Causas comunes de NameError:

• Errores tipográficos en nombres de variables (totla en lugar de total)
• Usar una variable antes de asignarle un valor
• Olvidar crear por completo una variable

TypeError: Unsupported Operand Type(s)

Este error aparece cuando intentas realizar una operación con tipos incompatibles:

# type_error.py
age = input("How old are you? ")
next_year = age + 1  # Can't add a number to a string
print("Next year:", next_year)

Error:

Traceback (most recent call last):
  File "type_error.py", line 2, in <module>
    next_year = age + 1
                ~~~~^~~
TypeError: can only concatenate str (not "int") to str

Python te está diciendo que age es un string (porque input() devuelve strings), y no puedes sumar un número a un string. La solución es convertir la entrada a entero:

# type_error_fixed.py
age = int(input("How old are you? "))  # Convert to integer
next_year = age + 1
print("Next year:", next_year)

ValueError: Invalid Literal

Este error aparece cuando intentas convertir un string a número, pero el string no representa un número válido:

# value_error.py
age = int(input("How old are you? "))
print("You are", age, "years old")

Si el usuario escribe texto en lugar de un número:

How old are you? twenty
Traceback (most recent call last):
  File "value_error.py", line 1, in <module>
    age = int(input("How old are you? "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'twenty'

Python te está diciendo que no puede convertir el string "twenty" a entero. El usuario tiene que introducir un número como 20.

Importante: Ahora mismo, si los usuarios introducen datos no válidos, tu programa se bloqueará con un error. Esto es normal en programas para principiantes. En el Capítulo 27 aprenderemos cómo manejar estas situaciones adecuadamente usando manejo de excepciones, permitiendo que tu programa se recupere de los errores y pida al usuario que lo intente de nuevo.

2.6.3) Leer los tracebacks con atención

Cuando ocurre un error, Python muestra un traceback que rastrea el error a través de tu código. Para programas sencillos, el traceback es corto:

# simple_traceback.py
print("Starting program")
name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello,", name)
print("Next year you'll be", age + 1)

Si el usuario introduce una entrada no válida para la edad:

Starting program
Enter your name: Alice
Enter your age: abc
Traceback (most recent call last):
  File "simple_traceback.py", line 3, in <module>
    age = int(input("Enter your age: "))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: 'abc'

El traceback muestra:

1. El nombre del archivo y el número de línea donde ocurrió el error
2. La línea de código que causó el problema
3. El tipo de error y una descripción

Estrategia de lectura: Empieza desde la parte inferior del traceback y ve hacia arriba. La última línea te dice qué salió mal. Las líneas de arriba te muestran dónde en tu código ocurrió el error.

2.6.4) Estrategias comunes de depuración (debugging)

Cuando te encuentres con un error, sigue estos pasos:

1. Lee el mensaje de error con atención

No entres en pánico. El mensaje de error intenta ayudarte. Léelo por completo e intenta entender lo que está diciendo.

2. Mira el número de línea

El mensaje de error te dice en qué línea cree Python que está el problema. Sin embargo, a veces el error real está en la línea anterior. Por ejemplo, un paréntesis de cierre que falta en la línea 2 puede no detectarse hasta que Python lee la línea 3.

3. Revisa los errores habituales

• Comillas que faltan o no coinciden
• Paréntesis o corchetes de cierre que faltan
• Dos puntos que faltan (para sentencias que aprenderemos más adelante como if, for, while)
• Errores tipográficos en nombres de variables
• Olvidar convertir la entrada a números

4. Usa print() para inspeccionar valores

Si no estás seguro de qué está fallando, añade sentencias print() para ver qué valores tienen tus variables:

# debugging_with_print.py
price = input("Enter price: ")
print("DEBUG: price =", price, "type =", type(price))  # Debugging line
 
tax = price * 0.08  # This will cause an error
print("Tax:", tax)

La línea de depuración te muestra que price es un string, no un número, ayudándote a identificar el problema.

5. Comenta código para aislar el problema

Si tienes varias líneas y no estás seguro de cuál está causando el error, comenta líneas hasta que el error desaparezca:

# isolating_error.py
name = input("Enter name: ")
# age = int(input("Enter age: "))  # Commented out for testing
# city = input("Enter city: ")  # Commented out for testing
print("Name:", name)

Una vez que el error desaparece, sabes que el problema está en una de las líneas comentadas.

6. Empieza con una versión simple

Si tu programa no funciona, simplifícalo hasta lo mínimo imprescindible:

# simplified_version.py
# Start with just the basic structure
print("Program starting")
# Add one feature at a time and test

Una vez que la versión simple funciona, añade funcionalidades una a una, probando después de cada adición.

2.6.5) Prevenir errores

Aunque la depuración es importante, prevenir errores desde el principio es aún mejor:

Escribe código de forma incremental

No escribas todo tu programa y lo ejecutes por primera vez al final. Escribe unas pocas líneas, ejecuta el programa, asegúrate de que esas líneas funcionan y luego añade más. De esta manera, cuando aparezca un error, sabes que está en el código que acabas de añadir.

# incremental_development.py
# Step 1: Get input and test
name = input("Enter name: ")
print("DEBUG: Got name:", name)
 
# Step 2: Add more input and test
# age = int(input("Enter age: "))
# print("DEBUG: Got age:", age)
 
# Step 3: Add processing and test
# ... and so on

Usa nombres de variable descriptivos

Los nombres de variables claros te ayudan a evitar errores:

# Clear variable names make errors less likely
user_age = int(input("Enter your age: "))
next_year_age = user_age + 1

Añade comentarios para explicar tu lógica

Los comentarios te ayudan a ti (y a otros) a entender qué debería hacer el código, facilitando detectar cuándo está haciendo algo distinto:

# temperature_with_comments.py
# Get temperature in Fahrenheit from user
fahrenheit = float(input("Enter temperature in Fahrenheit: "))
 
# Convert to Celsius using the standard formula: C = (F - 32) × 5/9
celsius = (fahrenheit - 32) * 5 / 9
 
# Display the result
print(fahrenheit, "°F =", celsius, "°C")

Prueba con diferentes entradas

No pruebes tu programa solo una vez. Intenta con diferentes entradas, incluyendo casos límite:

• Valores normales: 25, 100
• Cero: 0
• Números negativos: -10
• Números decimales: 3.14
• Números muy grandes: 1000000

Esto te ayuda a descubrir problemas antes de que los usuarios se encuentren con ellos.

2.6.6) Cuándo pedir ayuda

A veces encontrarás errores que no podrás resolver por tu cuenta. Antes de pedir ayuda:

1. Lee el mensaje de error con atención: Asegúrate de entender lo que dice
2. Busca el error: Copia el mensaje de error (sin tus nombres de variables concretos) y búscalo en línea. Muchos errores ya han sido encontrados y resueltos por otras personas
3. Revisa tu código con cuidado: Busca errores tipográficos, signos de puntuación que faltan y fallos habituales
4. Crea un ejemplo mínimo: Reduce tu código a la versión más pequeña que todavía produzca el error

Cuando pidas ayuda, proporciona:

• El mensaje de error completo
• El código que produce el error
• Lo que esperabas que pasara
• Lo que realmente pasó
• Lo que ya has intentado

Recuerda: Los errores son una parte normal de la programación. Cada programador, desde principiantes hasta expertos, se encuentra con errores a diario. La diferencia es que los programadores con experiencia han aprendido a leer los mensajes de error de forma eficiente y conocen soluciones comunes. Desarrollarás estas habilidades con la práctica.

Ya has aprendido los bloques fundamentales de la programación en Python: mostrar salida con print(), documentar código con comentarios, almacenar datos en variables, obtener entrada del usuario con input(), seguir el patrón entrada-proceso-salida y depurar errores simples.

Estos conceptos forman la base de todo lo demás que aprenderás en Python. En el próximo capítulo profundizaremos en las variables y exploraremos los tipos de datos básicos de Python, dándote una comprensión más completa de cómo Python almacena y manipula diferentes tipos de información.

Puntos clave de este capítulo:

• Usa print() para mostrar texto y otra información a los usuarios
• Usa comentarios (#) para explicar tu código y documentar tu razonamiento
• Almacena datos en variables usando asignación (=)
• Obtén entrada del usuario con input() y conviértela a números cuando sea necesario
• Estructura los programas usando el patrón entrada-proceso-salida
• Lee los mensajes de error con atención: intentan ayudarte a solucionar los problemas
• Escribe código de forma incremental y haz pruebas frecuentes para detectar errores pronto

Con estas habilidades, ahora puedes escribir programas interactivos simples pero completos. A medida que sigas aprendiendo, construirás sobre estos fundamentos para crear aplicaciones cada vez más sofisticadas.