Configuración de Visual Studio Code para Python, Ciencia de Datos y Machine Learning

Ultima actualización 20 / Mar / 2026

Introducción

Visual Studio Code (VS Code) es un editor de código fuente gratuito, ligero y muy extensible desarrollado por Microsoft. Es uno de los editores más populares para desarrollo de software gracias a su amplio ecosistema de extensiones y a su capacidad de personalización.

Sin embargo, instalar VS Code no es suficiente: para sacarle el máximo provecho al trabajar con Python, Ciencia de Datos y Machine Learning es necesario configurarlo correctamente. Una buena configuración permite:

• Calidad de código: activar linters y formateadores automáticos que detectan errores y mantienen un estilo consistente en el código.
• Pruebas unitarias: integrar el runner de pruebas directamente en el editor para ejecutarlas y ver los resultados sin salir de VS Code.
• Debugging: configurar el depurador para poder inspeccionar el estado del programa paso a paso con las variables de entorno correctas.

Las configuraciones de VS Code se almacenan en la carpeta .vscode/ en la raíz del proyecto. Tener estos archivos versionados junto al código garantiza que todo el equipo (o cualquier colaborador futuro) use exactamente la misma configuración.

Configuración general — settings.json

El archivo settings.json contiene las preferencias del editor para el proyecto. Estas configuraciones sobreescriben las preferencias globales del usuario cuando se trabaja dentro del proyecto.

{
  "[python]": {
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.fixAll": "explicit",
      "source.organizeImports": "explicit"
    },
    "editor.defaultFormatter": "charliermarsh.ruff",
    "editor.rulers": [100]
  },
  "notebook.formatOnSave.enabled": true,
  "notebook.defaultFormatter": "charliermarsh.ruff",
  "notebook.codeActionsOnSave": {
      "notebook.source.fixAll": "explicit",
      "notebook.source.organizeImports": "explicit"
  },
  "[markdown]": {
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.fixAll.markdownlint": "explicit"
    }
  },
  "files.exclude": {
    "**/__pycache__": true
  },
  "python.languageServer": "None",
  "editor.formatOnPaste": true,
  "notebook.lineNumbers": "on",
  "editor.inlineSuggest.enabled": true,
  "editor.formatOnType": true,
  "git.autofetch": true,
  "python.terminal.activateEnvInCurrentTerminal": true,
  "python.testing.pytestArgs": [
    "tests"
  ],
  "python.testing.unittestEnabled": false,
  "python.testing.pytestEnabled": true,
  "[jsonc]": {
    "editor.defaultFormatter": "vscode.json-language-features"
  },
  "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
  "markdownlint.config": {
    "MD007": {"indent": 4}
  },
  "ruff.configuration": "--config=.code_quality/ruff.toml",
  "ruff.format.preview": true,
  "mypy-type-checker.args": [
    "--config-file=.code_quality/mypy.ini"
  ]
}

Explicación de cada sección

[python] — Configuración para archivos Python

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

• editor.formatOnSave: formatea el archivo automáticamente cada vez que se guarda.
• source.fixAll: aplica todas las correcciones automáticas disponibles al guardar (elimina imports no usados, corrige errores de estilo, etc.).
• source.organizeImports: ordena y agrupa los imports siguiendo las convenciones de Python (stdlib, terceros, locales).
• editor.defaultFormatter: usa Ruff como formateador por defecto. Ruff es un linter y formatter extremadamente rápido escrito en Rust que reemplaza a Flake8, isort, Black y otros.
• editor.rulers: muestra una línea vertical en la columna 100 para indicar el límite de longitud de línea recomendado.

Configuración de Jupyter Notebooks

"notebook.formatOnSave.enabled": true,
"notebook.defaultFormatter": "charliermarsh.ruff",
"notebook.codeActionsOnSave": {
    "notebook.source.fixAll": "explicit",
    "notebook.source.organizeImports": "explicit"
}

Aplica las mismas reglas de formateo y organización de imports que en los archivos .py, pero dentro de los notebooks de Jupyter (.ipynb). Esto mantiene la calidad del código también en la fase exploratoria.

[markdown] — Configuración para archivos Markdown

"[markdown]": {
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.markdownlint": "explicit"
  }
}

• Activa el formateo automático al guardar archivos .md.
• Aplica las correcciones de markdownlint al guardar, garantizando que la documentación cumple las convenciones de estilo Markdown.

files.exclude — Ocultar archivos innecesarios

"files.exclude": {
  "**/__pycache__": true
}

Oculta las carpetas __pycache__ en el explorador de archivos de VS Code. Estas carpetas contienen el bytecode compilado de Python y no son relevantes para el desarrollo.

python.languageServer — Servidor de lenguaje

"python.languageServer": "None"

Desactiva el servidor de lenguaje de Python integrado (Pylance). Se usa "None" cuando se prefiere confiar en Ruff y Mypy para el análisis estático, evitando duplicar diagnósticos o conflictos entre herramientas.

Configuración general del editor

"editor.formatOnPaste": true,
"editor.inlineSuggest.enabled": true,
"editor.formatOnType": true,
"notebook.lineNumbers": "on"

• editor.formatOnPaste: formatea el código pegado automáticamente para adaptarlo al estilo del proyecto.
• editor.inlineSuggest.enabled: activa las sugerencias de autocompletado inline (tipo GitHub Copilot u otras fuentes de sugerencias).
• editor.formatOnType: formatea el código a medida que se escribe.
• notebook.lineNumbers: muestra los números de línea en los notebooks de Jupyter.

git.autofetch — Sincronización automática de Git

"git.autofetch": true

VS Code obtiene automáticamente los cambios remotos de Git en segundo plano, manteniendo el estado del repositorio actualizado sin necesidad de ejecutar git fetch manualmente.

python.terminal — Activación automática del entorno virtual

"python.terminal.activateEnvInCurrentTerminal": true

Activa automáticamente el entorno virtual de Python (.venv) cuando se abre una terminal integrada en VS Code. Esto evita tener que activar el entorno manualmente cada vez.

Configuración de pruebas con pytest

"python.testing.pytestArgs": ["tests"],
"python.testing.unittestEnabled": false,
"python.testing.pytestEnabled": true

• pytestEnabled: habilita pytest como framework de pruebas.
• unittestEnabled: desactiva el runner de unittest para evitar conflictos.
• pytestArgs: le indica a VS Code que busque las pruebas en la carpeta tests/.

[jsonc] — Formateador para archivos JSON con comentarios

"[jsonc]": {
  "editor.defaultFormatter": "vscode.json-language-features"
}

Usa el formateador de JSON nativo de VS Code para archivos .jsonc (JSON with Comments), como el propio settings.json o launch.json.

python.defaultInterpreterPath — Intérprete de Python

"python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python"

Apunta al intérprete de Python dentro del entorno virtual del proyecto (.venv), garantizando que VS Code use siempre el entorno correcto con las dependencias del proyecto instaladas.

Configuración de Markdownlint

"markdownlint.config": {
  "MD007": {"indent": 4}
}

Personaliza la regla MD007 de markdownlint para requerir una indentación de 4 espacios en las listas anidadas de Markdown.

Configuración de Ruff

"ruff.configuration": "--config=.code_quality/ruff.toml",
"ruff.format.preview": true

• ruff.configuration: indica a la extensión de Ruff dónde encontrar su archivo de configuración (.code_quality/ruff.toml), en lugar de buscar en la raíz del proyecto.
• ruff.format.preview: habilita las reglas de formateo en modo preview (características nuevas que aún no son estables).

Configuración de Mypy

"mypy-type-checker.args": [
  "--config-file=.code_quality/mypy.ini"
]

Le indica a la extensión de Mypy dónde encontrar su archivo de configuración (.code_quality/mypy.ini). Mypy es el type checker estático de Python que verifica las anotaciones de tipos.

Configuración de debugging — launch.json

El archivo launch.json define las configuraciones de debugging que aparecen en el panel “Run and Debug” de VS Code.

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Python: Current File",
      "type": "debugpy",
      "request": "launch",
      "program": "${file}",
      "console": "integratedTerminal",
      "cwd": "${workspaceFolder}",
      "env": {
        "PYTHONPATH": "${cwd}",
        "VERBOSITY": "DEBUG"
      }
    }
  ]
}

Explicación

• version: versión del schema de launch.json. La versión 0.2.0 es la estándar actual.
• name: nombre que aparece en el selector de configuraciones de debug (Python: Current File).
• type: usa debugpy, el depurador oficial de Python para VS Code.
• request: launch indica que VS Code lanzará el programa (en contraposición a attach, que se conecta a un proceso ya en ejecución).
• program: ${file} ejecuta el archivo Python que está actualmente abierto en el editor.
• console: integratedTerminal muestra la salida en el terminal integrado de VS Code, lo que permite interacción con el programa si es necesario.
• cwd: establece el directorio de trabajo en la raíz del proyecto (${workspaceFolder}), evitando problemas con rutas relativas.
• env: define variables de entorno para la sesión de debug:
  • PYTHONPATH: apunta a la raíz del proyecto para que Python pueda importar módulos locales correctamente.
  • VERBOSITY: establece el nivel de logging en DEBUG para obtener información detallada durante el debugging.

Extensiones recomendadas — extensions.json

El archivo extensions.json contiene una lista de extensiones recomendadas para el proyecto. Cuando alguien abre el proyecto en VS Code, el editor sugiere instalarlas automáticamente.

{
  "recommendations": [
    "alefragnani.project-manager",
    "bierner.emojisense",
    "charliermarsh.ruff",
    "davidanson.vscode-markdownlint",
    "editorconfig.editorconfig",
    "github.copilot-chat",
    "github.vscode-github-actions",
    "GitHub.vscode-pull-request-github",
    "KevinRose.vsc-python-indent",
    "mechatroner.rainbow-csv",
    "ms-python.mypy-type-checker",
    "ms-python.python",
    "ms-python.vscode-pylance",
    "ms-toolsai.jupyter",
    "oderwat.indent-rainbow",
    "redhat.vscode-yaml",
    "streetsidesoftware.code-spell-checker",
    "tamasfe.even-better-toml",
    "usernamehw.errorlens",
    "vivaxy.vscode-conventional-commits",
    "vscode-icons-team.vscode-icons"
  ]
}

Descripción de cada extensión