Formateo con Ruff

Formatea y analiza tu código Python automáticamente. Ruff hace el trabajo sucio para que tú te centres en lo que importa: la lógica.

1. ¿Qué es Ruff?

Ruff es una herramienta de calidad de código escrita en Rust — y eso la hace 10-100x más rápida que las alternativas clásicas como Flake8, Black o isort. Hace tres cosas a la vez:

Linting

Detecta problemas potenciales en tu código: imports no usados, variables no definidas, código inalcanzable, convenciones rotas...

Formateo

Reforma automáticamente el estilo del código — espacios, comillas, longitud de línea, indentación — sin que tengas que pensar en ello.

Ordenar Imports

Organiza los import automáticamente: primero Standard Library, luego paquetes externos, luego imports propios.

2. Instalar Ruff en VS Code

La forma más cómoda de usar Ruff es como extensión de VS Code, que lo ejecuta en tiempo real mientras escribes.

Abre VS Code
Pulsa Cmd+Shift+X (Mac) o Ctrl+Shift+X (Windows/Linux) para abrir el panel de extensiones
Busca "Ruff"
Instala la extensión oficial de Astral (el mismo equipo que creó uv)

También puedes instalarlo como herramienta de línea de comandos para usarlo en scripts de CI/CD:

# Con uv (recomendado)
uv add --dev ruff

# O con pip
pip install ruff

# Verificar instalación
ruff --version

3. Activar "Format on Save"

El verdadero superpoder de Ruff es formatear automáticamente cada vez que guardas un fichero. Configúralo una sola vez y olvidate del estilo para siempre:

Abre los ajustes de VS Code con Cmd+, (Mac) o Ctrl+, (Windows)
Busca "format on save"
Activa la casilla "Editor: Format On Save"
Busca "default formatter"
Selecciona "Ruff" como formateador por defecto para Python

Alternativamente, puedes añadirlo directamente al fichero de configuración de VS Code (.vscode/settings.json):

{
  "[python]": {
    "editor.defaultFormatter": "charliermarsh.ruff",
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.fixAll.ruff": "explicit",
      "source.organizeImports.ruff": "explicit"
    }
  }
}

4. Ruff en Acción: Antes y Después

Este es el tipo de código que escribes cuando tienes prisa. Todo en una línea, sin espacios, imports mezclados y comillas inconsistentes:

Antes (código sin formatear)

import os
def calculate_total(items):
  total=0
  for item in items:
    total+=item['price']*item['quantity']
  return total
shopping_cart=[{'name':'apple','price':0.5,'quantity':6},{'name':'banana','price':0.3,'quantity':8}]
print(calculate_total(shopping_cart))

Después (Ruff formatea automáticamente al guardar)

import os


def calculate_total(items):
    total = 0
    for item in items:
        total += item["price"] * item["quantity"]
    return total


shopping_cart = [
    {"name": "apple", "price": 0.5, "quantity": 6},
    {"name": "banana", "price": 0.3, "quantity": 8},
]
print(calculate_total(shopping_cart))

Ruff ha aplicado automáticamente estas correcciones:

Separó los imports del resto del código con dos líneas en blanco
Añadió espacios alrededor de los operadores (total=0 → total = 0)
Corrigió la indentación a 4 espacios
Unificó las comillas a dobles ('apple' → "apple")
Formateó el diccionario/lista para facilitar la lectura

5. Reglas de Formateo más Comunes

Ruff aplica el estilo PEP 8 — el estándar oficial de Python — más algunas convenciones modernas:

Regla	Mal	Bien
Indentación	`··resultado = 1` (2 espacios)	`····resultado = 1` (4 espacios)
Operadores	`x=1+y`	`x = 1 + y`
Entre funciones	1 línea en blanco	2 líneas en blanco
Longitud de línea	Líneas de más de 88 caracteres	Máximo 88 caracteres
Comillas	`'texto'` mezcladas con `"texto"`	`"texto"` siempre dobles

6. Entender los Errores de Linting

Cuando Ruff detecta un problema, muestra un código de error con una descripción. Aprender a leerlos te hace un desarrollador mucho más autónomo.

# Ruff detecta imports no usados y te avisa
import os    # F401: 'os' imported but unused
import sys   # Se usa abajo

print("Hello from", sys.version)

Errores más frecuentes que verás

F401	Import no utilizado. Elimínalo para mantener el código limpio.
E501	Línea demasiado larga (>88 chars). Divídela en varias.
F821	Variable no definida. Posiblemente un typo en el nombre.
E711	Comparación con `None` usando `==`. Usa `is None` en su lugar.
B006	Argumento mutable por defecto. Un bug clásico en Python que Ruff detecta.

Para cada error, Ruff te indica qué es el problema, por qué importa y cómo corregirlo. Pasa el cursor sobre el subrayado en VS Code para ver la explicación completa.

7. Usar Ruff desde la Terminal

# Ver todos los problemas de linting en un fichero
ruff check main.py

# Ver todos los problemas en el proyecto completo
ruff check .

# Corregir automáticamente los que se puedan
ruff check --fix .

# Formatear un fichero (equivalente a Black)
ruff format main.py

# Formatear todo el proyecto
ruff format .

En proyectos de equipo, añade Ruff en el pipeline de CI/CD para que el código siempre cumpla el estilo. ruff check . devuelve código de error si hay problemas, lo que permite bloquear merges con código sucio.

← Anterior: Ficheros .env Siguiente: ¿Por qué uv? →

¿Listo para convertirte en un Maestro?

Potencia tu carrera con el Máster Completo: Python de la A a la Z. Domina Ciencia de Datos, ML y Deep Learning.

Ver ahora