Saltar al contenido
Editor

Código Python limpio: comentarios, docstrings y PEP 8

Principiante15 min4 ejercicios90 XP

Esta lección es una traducción del original en inglés.Read in EnglishAvisar de un error de traducción

0/4 ejercicios

Imagina que abres un libro de cocina en el que cada receta está garabateada con mala letra, sin títulos, sin lista de ingredientes y sin espacio entre los pasos. Podrías descifrarlo con el tiempo, pero sería un suplicio. Con el código pasa lo mismo.

Los programadores profesionales pasan mucho más tiempo leyendo código que escribiéndolo. Algunos estudios sugieren que la proporción es de unos 10 a 1. Por eso, hacer que tu código sea fácil de leer es una de las habilidades más valiosas que puedes aprender.

En este tutorial aprenderás a escribir código Python que otras personas (y tu yo del futuro) disfruten de verdad al leer. Veremos los comentarios, los docstrings, las convenciones de nombres y PEP 8, la guía de estilo oficial de Python.

¿Por qué importa el código limpio?

Piensa en una habitación desordenada. Sabes que tus cosas están ahí, en algún sitio, pero encontrar algo te lleva una eternidad. El código limpio es como una habitación ordenada: cada cosa tiene su lugar y encuentras rápido lo que necesitas.

Si escribes código hoy y vuelves a él dentro de dos semanas, habrás olvidado qué hace la mitad. Un código claro y bien organizado funciona como un mapa para tu yo del futuro.

El código limpio también importa cuando trabajas con otras personas. En un equipo, todos necesitan entender el código de los demás. El código desordenado frena a todo el equipo.

Código desordenado frente a código limpio: mismo resultado, experiencia muy distinta
# Which version would you rather read?
# Version A
x = 3.14159
y = 10
z = x * y * y
print(z)
# Version B
pi = 3.14159
radius = 10
circle_area = pi * radius * radius
print(f"Area of circle: {circle_area}")
Salida
314.159
Area of circle: 314.159

Las dos versiones calculan lo mismo. Pero la versión B te dice qué hace el código sin necesidad de más explicaciones. Los nombres de las variables son la documentación.

Cómo escribir buenos comentarios en Python

Ya sabes que los comentarios empiezan con # y que Python los ignora. Pero saber cuándo y cómo usarlos es lo que distingue el código de un principiante del código profesional.

Un buen comentario explica por qué se hace algo, no qué hace el código. Si tu código es lo bastante claro, el "qué" debería verse con solo leerlo.

❌ Malos comentarios (explican lo obvio)
# Set x to 5
x = 5

# Add 1 to x
x = x + 1

# Print x
print(x)
✓ Buenos comentarios (explican el porqué)
# Start with 5 retries (server sometimes drops first request)
retry_count = 5

# Move to next attempt
retry_count = retry_count + 1

print(retry_count)

¿Notas la diferencia? Los malos comentarios repiten lo que el código ya dice. Los buenos te cuentan por qué existe el código y te dan un contexto que el código por sí solo no te da.

¿Cuándo conviene agregar comentarios al código Python?

Agrega un comentario cuando el código hace algo sorprendente o poco evidente. Si alguien que lee tu código diría "espera, ¿por qué?", ahí es donde va un comentario.

Comentarios que de verdad ayudan
# Good reasons to comment:
price = 9.99
tax = price * 0.0825 # Texas sales tax rate (8.25%)
# Multiply by 100 to avoid floating-point rounding errors
price_in_cents = int(price * 100)
# TODO: Replace with database lookup once API is ready
user_name = "Guest"
Salida
(sin salida)

Usa también los comentarios para notas TODO: recordatorios de cosas que piensas corregir o mejorar más adelante. La mayoría de los editores de código resaltan los comentarios TODO para que sean fáciles de encontrar.

¿Cuándo es mejor evitar los comentarios?

Si sientes la necesidad de escribir un comentario que explique qué hace el código, suele ser señal de que el propio código debería ser más claro. A menudo, con mejores nombres de variables ya no hace falta ningún comentario.

❌ El comentario esconde código poco claro
# Calculate the final price with 20% discount
p = x - (x * 0.2)
✓ El código claro no necesita comentario
discount_rate = 0.20
final_price = original_price - (original_price * discount_rate)

¿Qué son los docstrings en Python?

Un docstring es una cadena especial que describe qué hace una función, una clase o un módulo. Va justo al principio del cuerpo de la función, entre comillas triples (""").

Piensa en un docstring como el manual de instrucciones que viene con un producto. No necesitas abrir el producto para saber qué hace: te basta con leer el manual.

Una función con un buen docstring
def calculate_tip(bill_amount, tip_percent):
"""Calculate the tip amount for a restaurant bill.
Args:
bill_amount: The total bill in dollars.
tip_percent: The tip percentage (e.g., 20 for 20%).
Returns:
The tip amount in dollars.
"""
return bill_amount * (tip_percent / 100)
# Using the function
tip = calculate_tip(50.00, 20)
print(f"Tip: ${tip:.2f}")
# You can view any function's docstring with help()
help(calculate_tip)
Salida
Tip: $10.00
Help on function calculate_tip in module __main__:

calculate_tip(bill_amount, tip_percent)
    Calculate the tip amount for a restaurant bill.

    Args:
        bill_amount: The total bill in dollars.
        tip_percent: The tip percentage (e.g., 20 for 20%).

    Returns:
        The tip amount in dollars.

Cuando llamas a help() con una función, Python muestra su docstring. Así es también como las funciones integradas como print() y len() muestran su documentación.

Para funciones cortas y sencillas basta con un docstring de una línea. En las funciones más complejas, describe los argumentos y lo que devuelve la función.

Un docstring sencillo de una línea
# Simple function - one-line docstring is fine
def square(n):
"""Return the square of a number."""
return n * n
print(square(7))
print(square(12))
Salida
49
144

Convenciones de nombres en Python: cómo nombrar variables

Elegir buenos nombres es una de las partes más difíciles de programar. Un buen nombre de variable es como una buena etiqueta en una caja de almacenaje: sabes exactamente qué hay dentro sin abrirla.

Python usa un estilo llamado snake_case para los nombres de variables y funciones. Las palabras van en minúsculas y separadas por guiones bajos.

Las convenciones de nombres de Python en acción
# snake_case - the Python way
user_name = "Alice"
total_price = 29.99
is_logged_in = True
max_retry_count = 3
# Use these in practice
print(f"User: {user_name}")
print(f"Total: ${total_price}")
print(f"Logged in: {is_logged_in}")
print(f"Max retries: {max_retry_count}")
Salida
User: Alice
Total: $29.99
Logged in: True
Max retries: 3

Estas son las principales convenciones de nombres que siguen los programadores de Python:

Convenciones de nombres para cada cosa
# Variables and functions: snake_case
player_score = 100
def calculate_average(numbers):
"""Return the average of a list of numbers."""
return sum(numbers) / len(numbers)
# Constants: UPPER_SNAKE_CASE
MAX_SPEED = 120
PI = 3.14159
DATABASE_URL = "localhost:5432"
# Classes: PascalCase (you'll learn classes later)
# class PlayerCharacter:
# class ShoppingCart:
print(f"Player score: {player_score}")
print(f"Max speed: {MAX_SPEED}")
print(f"Pi: {PI}")
Salida
Player score: 100
Max speed: 120
Pi: 3.14159

Cómo elegir nombres de variables con significado

El nombre de una variable debe describir lo que el valor representa, no de qué tipo es. El objetivo es que tu código se lea como una frase.

❌ Nombres vagos o crípticos
x = "Alice"
n = 25
f = True
temp = 3
data = 98.6
my_list = ["math", "science"]
✓ Nombres descriptivos y con significado
student_name = "Alice"
student_age = 25
is_enrolled = True
max_attempts = 3
body_temperature = 98.6
course_list = ["math", "science"]

Los nombres de una sola letra como x, n e i están bien en fórmulas matemáticas cortas o en bucles pequeños. Pero para todo lo demás, usa un nombre de verdad que explique para qué sirve.

¿Qué es PEP 8? Lo básico de la guía de estilo de Python

PEP 8 es la guía de estilo oficial de Python. PEP significa "Python Enhancement Proposal" (propuesta de mejora de Python), y la número 8 es la que trata del estilo al escribir código. Es como un código de vestimenta para el código Python: todos siguen las mismas reglas, así que cualquier código Python te resulta familiar.

No necesitas memorizar todas las reglas. Estas son las que más importan cuando estás empezando.

Cómo usar la indentación en Python (4 espacios)

Python usa la indentación para agrupar el código. Lo estándar son 4 espacios por nivel. Nunca mezcles tabuladores y espacios: elige uno (los espacios) y no lo cambies.

Indentación correcta de 4 espacios
# Correct: 4 spaces for each indentation level
def greet(name):
"""Print a greeting message."""
if name:
message = f"Hello, {name}!"
print(message)
else:
print("Hello, stranger!")
greet("Alice")
greet("")
Salida
Hello, Alice!
Hello, stranger!

Cómo usar las líneas en blanco en el código Python

Las líneas en blanco son como los cambios de párrafo en una redacción. Separan ideas distintas y hacen que tu código sea más fácil de recorrer con la vista.

Usar líneas en blanco para separar secciones
# Two blank lines before a function definition
def calculate_area(width, height):
"""Calculate the area of a rectangle."""
return width * height
def calculate_perimeter(width, height):
"""Calculate the perimeter of a rectangle."""
return 2 * (width + height)
# Use the functions
area = calculate_area(5, 3)
perimeter = calculate_perimeter(5, 3)
print(f"Area: {area}")
print(f"Perimeter: {perimeter}")
Salida
Area: 15
Perimeter: 16

Usa dos líneas en blanco antes y después de las definiciones de funciones del nivel superior. Usa una línea en blanco para separar las secciones lógicas dentro de una función.

Cómo usar espacios alrededor de los operadores en Python

Pon un espacio a cada lado de operadores como =, +, -, == y !=. Así tu código se lee mucho mejor de un vistazo.

❌ Sin espacios (difícil de leer)
total=price*quantity+tax
is_valid=age>=18 and name!=""
result=x**2+y**2
✓ Espacios alrededor de los operadores (fácil de leer)
total = price * quantity + tax
is_valid = age >= 18 and name != ""
result = x**2 + y**2

Errores de estilo comunes en Python y cómo corregirlos

Veamos los errores de estilo más comunes que cometen los principiantes y cómo corregirlos. Son cambios pequeños que mejoran mucho la legibilidad.

❌ Comparar directamente con True/False/None
if is_active == True:
    print("Active")

if result == None:
    print("No result")
✓ La forma pythónica
if is_active:
    print("Active")

if result is None:
    print("No result")

No compares con True o False usando ==. Usa la variable directamente. Con None, usa siempre is None en lugar de == None.

❌ Estilo incoherente
userName = "Alice"      # camelCase
total_Price = 29.99     # mixed style
def CalculateTotal():   # PascalCase for function
    pass
✓ snake_case en todo el código
user_name = "Alice"     # snake_case
total_price = 29.99     # snake_case
def calculate_total():   # snake_case
    pass

Elige un estilo y sé coherente. En Python, ese estilo es snake_case para variables y funciones. Mezclar estilos hace que tu código parezca caótico.

❌ Demasiadas líneas en blanco o ninguna
def add(a, b):
    return a + b
def subtract(a, b):
    return a - b
def multiply(a, b):
    return a * b
✓ Dos líneas en blanco entre funciones
def add(a, b):
    return a + b


def subtract(a, b):
    return a - b


def multiply(a, b):
    return a * b

Linters de Python: herramientas que revisan tu estilo automáticamente

No tienes que memorizar todas las reglas de PEP 8. Unas herramientas llamadas linters pueden revisar automáticamente si tu código tiene problemas de estilo. Piensa en un linter como un corrector ortográfico, pero para el estilo del código.

Estos son los linters de Python más populares:

  • `flake8`: detecta incumplimientos de PEP 8 y errores comunes. Ideal para principiantes.
  • `pylint`: más exhaustivo. También da sugerencias sobre la calidad del código.
  • `ruff`: el recién llegado. Es muy rápido y reúne muchas herramientas en una.
  • `black`: un formateador automático. No se limita a avisarte: corrige tu estilo automáticamente.
  • La mayoría de los editores de código (como VS Code) pueden ejecutar linters en segundo plano y subrayar los problemas de estilo mientras escribes. Es como tener a un entrenador de estilo sentado a tu lado.


    Ejercicios de práctica

    ¡Hora de practicar! Estos ejercicios te ayudarán a adquirir el hábito de escribir código Python limpio y legible.

    Ejercicio 1: agrega comentarios y un docstring
    Escribe el código

    Escribe una función llamada celsius_to_fahrenheit que reciba una temperatura en grados Celsius y devuelva el valor en Fahrenheit.

    La fórmula es: fahrenheit = celsius * 9/5 + 32

    Tu función debe incluir:

  • Un docstring que describa lo que hace
  • Un comentario que explique la fórmula
  • Después, imprime el resultado de convertir 100 grados Celsius. La salida debe ser:

    212.0
    # Write your function with a docstring and comment
    Ejercicio 2: corrige los malos nombres de variables
    Corrige el error

    Este código funciona, ¡pero los nombres de las variables son pésimos! Nadie sabe qué significan x, y, z y a.

    Cambia el nombre de las variables para que tengan significado y usa snake_case. El código calcula el sueldo semanal de un trabajador. La salida debe quedar exactamente igual:

    Weekly pay: $450.0
    With overtime: $562.5
    x = 15.0
    y = 30
    z = x * y
    a = 5
    b = x * 1.5 * a
    print(f"Weekly pay: ${z}")
    print(f"With overtime: ${z + b}")
    Ejercicio 3: reescribe código desordenado con el estilo PEP 8
    Escribe el código

    El código de abajo está desordenado. Reescríbelo siguiendo las reglas de PEP 8:

    def calcArea(W,H):
      result=W*H
      return result
    def calcPerimeter(W,H):
      result=2*(W+H)
      return result
    w=8
    h=5
    print(f"Area: {calcArea(w,h)}")
    print(f"Perimeter: {calcPerimeter(w,h)}")

    Corrige estos problemas:

  • Los nombres de las funciones deben ir en snake_case
  • Usa 4 espacios para la indentación
  • Agrega espacios alrededor de los operadores y después de las comas
  • Agrega dos líneas en blanco entre las definiciones de funciones
  • Usa nombres de variables con significado
  • La salida debe ser:

    Area: 40
    Perimeter: 26
    # Rewrite the messy code below following PEP 8 rules
    Ejercicio 4: refactoriza y limpia este código
    Mejora el código

    Esta función funciona, pero está desordenada. Refactorízala para que quede limpia y profesional:

    def d(p,r):
      a=p*r/100
      t=p-a
      return t
    print(d(200,15))

    Tu versión refactorizada debe:

  • Dar a la función un nombre con significado (calcula un precio con descuento)
  • Usar nombres de parámetros descriptivos
  • Agregar un docstring que explique lo que hace la función
  • Usar el espaciado correcto de PEP 8 (indentación de 4 espacios, espacios alrededor de los operadores)
  • Dejar dos líneas en blanco antes de la llamada a la función
  • La salida debe ser:

    170.0
    # Refactor the messy code into clean, professional Python

    Resumen: lo que aprendiste sobre código Python limpio

    Ya conoces los hábitos que distinguen el código de un principiante del código profesional. Aquí tienes una referencia rápida:

    ConceptoRegla claveEjemplo
    Comentarios (#)Explica el porqué, no el qué# Texas tax rate (8.25%)
    Docstrings (""")Describe lo que hace una función"""Convert Celsius to Fahrenheit."""
    Nombres de variablesDescriptivos, en snake_casetotal_price, is_valid
    ConstantesUPPER_SNAKE_CASEMAX_SPEED = 120
    IndentaciónSiempre 4 espaciosdef greet(): y luego 4 espacios
    Líneas en blanco2 entre funcionesSeparan las secciones lógicas
    OperadoresEspacios alrededor de =, +, etc.x = a + b
    PEP 8La guía de estilo oficial de PythonLa coherencia manda

    Escribir código limpio no consiste en lucirse. Consiste en ser amable con tus compañeros de equipo, con tu yo del futuro y con cualquiera que lea tu código. Empieza a crear estos hábitos ahora y te servirán durante toda tu carrera en la programación.

    ¿Qué sigue?

    ¡Terminaste la sección de fundamentos de Python! Ya tienes una base sólida de lo esencial de Python. A continuación pasarás al control de flujo, donde aprenderás a hacer que tus programas tomen decisiones con instrucciones if y repitan acciones con bucles.

    Tutoriales relacionados

    ¿Te sirvió este tutorial?

    Sugerir una mejora