Python

Contents
Python en Visual Studio

Información general
Información general de Python
Un paseo por el IDE de Visual Studio
Carga de trabajo Aplicaciones de ciencia de datos y de análisis
Instalación
Instalación
Instalación de intérpretes de Python
Guías de inicio rápido
Creación de una aplicación web con Flask
Creación de un proyecto a partir de una plantilla
Apertura y ejecución de código de Python en una carpeta
Creación de un proyecto a partir del código existente
Creación de un proyecto a partir de un repositorio
Creación de un proyecto a partir de una plantilla de Cookiecutter
Tutoriales
0: Instalar la compatibilidad de Python
1: Creación de un proyecto de Python
2: Escritura y ejecución de código
3: Uso de la ventana interactiva de REPL
4: Ejecución de código en el depurador
5: Instalación de paquetes y administración de entornos de Python
6: Trabajo con Git
Información acerca de Django en Visual Studio
1. Crear un proyecto y una solución
2. Crear una aplicación de Django
3. Servir archivos estáticos y agregar páginas
4. Usar la plantilla de proyecto web de Django
5. Autenticar usuarios
6. Usar la plantilla de proyecto web de Django de sondeos
Información sobre Flask en Visual Studio
1. Crear un proyecto y una solución
2. Crear una aplicación de Flask
3. Servir archivos estáticos y agregar páginas
Conceptos
Proyectos de Python
Proyectos de Python
Plantillas de proyecto web
Plantilla de proyecto web de Django
SDK de Azure para Python
Guías de procedimientos
Administración de entornos de Python
Selección de un intérprete para un proyecto
Uso de requirements.txt para las dependencias
Rutas de acceso de búsqueda
Referencia de ventana de entorno
Configuración de aplicaciones web para IIS
Editar código de Python
Código de formato
Refactorizar código
Usar PyLint
Definir comandos de menú personalizados
Python interactivo (REPL)
Python interactivo (REPL)
Usar REPL de IPython
Depuración
Depuración
Depurar código en equipos remotos de Linux
Publicación en Azure App Service (Linux)
Interacción con C++
Creación de una extensión de C++ para Python
Depuración en modo mixto Python/C++
Símbolos de depuración en modo mixto
Generación de perfiles
Pruebas unitarias
Uso de la extensión Cookiecutter
Referencia
Plantillas de elementos
Opciones
Trabajar con Python en Visual Studio en Windows
13/12/2021 • 14 minutes to read
Python es un lenguaje de programación popular confiable, flexible, fácil de aprender, de uso libre en todos los
sistemas operativos y admitido por una gran comunidad de desarrolladores y muchas bibliotecas gratuitas.
Python es compatible con todos los modos de desarrollo, lo que incluye aplicaciones web, servicios web,
aplicaciones de escritorio, scripting e informática científica, y lo utilizan muchas universidades, científicos,
programadores ocasionales y desarrolladores profesionales. Puede obtener más información sobre el lenguaje
en python.org y Python for Beginners (Python para principiantes).
Visual Studio es un potente IDE de Python en Windows. Visual Studio proporciona compatibilidad con código
abierto para el lenguaje Python a través del desarrollo de Python y las cargas de trabajo de ciencia de
datos (Visual Studio 2017 y versiones posteriores) y la extensión gratuita Herramientas de Python para Visual
Studio (Visual Studio 2015 y versiones anteriores).
Python no se admite actualmente en Visual Studio para Mac, pero está disponible en Mac y Linux a través de
Visual Studio Code (vea las preguntas y respuestas).
Primeros pasos:
Siga las instrucciones de instalación para configurar la carga de trabajo de Python.
Familiarícese con las capacidades de Python de Visual Studio a través de las secciones de este artículo.
Consulte una o varias de las guías de inicio rápido para crear un proyecto. Si no está seguro, comience por
Create a web app with Flask (Crear una aplicación web con Flask).
Consulte una o varias de las guías de inicio rápido para crear un proyecto. Si no está seguro, empiece por
Inicio rápido: Apertura y ejecución de código de Python en una carpeta o Creación de una aplicación web con
Flask.
Siga el tutorial Trabajar con Python en Visual Studio para obtener una experiencia completa.
NOTE
Visual Studio admite la versión 2.7 de Python, así como las versiones 3.5 a 3.7. Aunque es posible usar Visual Studio para
editar el código escrito en otras versiones de Python, no se admiten oficialmente esas versiones y características como
IntelliSense y la depuración podrían no funcionar. La compatibilidad con la versión 3.8 de Python aún está en desarrollo;
consulte los detalles específicos sobre este problema de compatibilidad en GitHub.
Compatibilidad con diversos intérpretes

La ventana Entornos de Python de Visual Studio (se muestra a continuación en una vista amplia y expandida)
proporciona un lugar único para administrar todos los entornos de Python globales, los entornos de conda y los
entornos virtuales. Visual Studio detecta automáticamente las instalaciones de Python en ubicaciones
estándares y le permite configurar las instalaciones personalizadas. Con cada entorno, puede administrar
fácilmente paquetes, abrir una ventana interactiva para ese entorno y tener acceso a carpetas de entorno.
Use el comando Abrir ventana interactiva para ejecutar Python de forma interactiva en el contexto de Visual
Studio. Use el comando Abrir en PowerShell para abrir una ventana de comandos independiente en la carpeta
del entorno seleccionado. Desde esa ventana de comandos puede ejecutar cualquier script de Python.
Para obtener más información:
Referencia de entornos de Python
Edición enriquecida, IntelliSense y comprensión del código

Visual Studio proporciona un editor de Python de primera clase, que incluye colores de la sintaxis,
autocompletar en el código y las bibliotecas, formato de código, ayuda para las firmas, refactorización, detección
de errores y sugerencias de tipos. Visual Studio también proporciona características exclusivas como vista de
clases, ir a definición , buscar todas las referencias y fragmentos de código. La integración directa con la
ventana interactiva lo ayudará a desarrollar rápidamente código Python que ya está guardado en un archivo.
Docs: Editar código de Python
Docs: Código de formato
Docs: Refactorización de código
Docs: Utilizar un linter
Documentos de características generales de Visual Studio: Características del editor de código.
Ventana interactiva
Para cada entorno de Python que Visual Studio conozca, puede abrir fácilmente el mismo entorno (REPL)
interactivo para un intérprete Python directamente dentro de Visual Studio, en lugar de usar un símbolo del
sistema independiente. También puede cambiar fácilmente entre entornos. (Para abrir un símbolo del sistema
independiente, seleccione el entorno que quiera en la ventana Entornos de Python y seleccione el comando
Abrir en PowerShell como se ha explicado anteriormente en Compatibilidad con diversos intérpretes).
Visual Studio también proporciona una estrecha integración entre el editor de código de Python y la ventana
interactiva . Mediante el método abreviado de teclado Ctrl +Entrar , la línea (o el bloque) de código actual
presente en el editor se envía cómodamente a la ventana interactiva y, a continuación, se pasa a la línea (o
bloque) siguiente. El método abreviado Ctrl +Entrar le permite revisar fácilmente el código sin tener que
ejecutar el depurador. Puede también enviar código seleccionado a la ventana interactiva con la misma
pulsación de tecla y pegar fácilmente el código desde la ventana interactiva en el editor. Juntas, estas
capacidades le permiten determinar los detalles de un segmento de código en la ventana interactiva y guardar
fácilmente los resultados en un archivo en el editor.
Visual Studio también es compatible con IPython o Jupyter en REPL, incluidos gráficos en línea, .NET y Windows
Presentation Foundation (WPF).
Ventana interactiva
IPython en Visual Studio
Sistema de proyecto y plantillas de proyecto y de elemento

NOTE
Visual Studio 2019 permite abrir una carpeta que contiene código de Python y ejecutar ese código sin crear archivos de
solución y proyecto de Visual Studio. Para obtener más información, vea Inicio rápido: Apertura y ejecución de código de
Python en una carpeta. Sin embargo, usar un archivo del proyecto trae ventajas, como se explica en esta sección.
Visual Studio lo ayuda a administrar la complejidad de un proyecto a medida que se desarrolla con el tiempo.
Un proyecto de Visual Studio es mucho más que una estructura de carpetas: incluye una descripción de cómo se
utilizan distintos archivos y cómo se relacionan entre sí. Visual Studio lo ayuda a distinguir el código de
aplicación, el código de prueba, las páginas web, JavaScript, los scripts de compilación, etcétera, lo cual,
posteriormente, habilita las características apropiadas para los archivos. Además, una solución de Visual Studio
lo ayuda a administrar varios proyectos relacionados, como por ejemplo, un proyecto de Python y un proyecto
de extensión de C++.
Las plantillas de proyecto y elemento automatizan el proceso de configuración de distintos tipos de proyectos y
archivos, le permiten ahorrar tiempo y evitan que tenga que administrar detalles complejos y propensos a
errores. Visual Studio proporciona plantillas para web, Azure, ciencia de datos, consola y otros tipos de
proyectos, junto con las plantillas para archivos, como clases de Python, pruebas unitarias, configuración web de
Azure, HTML e incluso aplicaciones Django.
Documento: Proyectos de Python
Documento: Referencia de plantillas de elemento
Documento: Plantillas de proyecto de Python
Documento: Creación de una extensión de C++ para Python
Documento de características generales de Visual Studio: Plantillas de proyecto y elemento
Documento de características generales de Visual Studio: Soluciones y proyectos en Visual Studio
Depuración repleta de características

Uno de los puntos fuertes de Visual Studio es su depurador potente. Para Python en particular, Visual Studio
incluye depuración en modo mixto Python/C++, depuración remota en Linux, depuración en la ventana
interactiva y depuración de las pruebas unitarias de Python.
En Visual Studio 2019, puede ejecutar y depurar código sin tener un archivo del proyecto de Visual Studio.
Consulte Inicio rápido: Apertura y ejecución de código de Python en una carpeta para ver un ejemplo.
Docs: Depurar el código de Python
Documento: Depuración en modo mixto Python/C++
Documento: Depuración remota en Linux
Documento de características generales de Visual Studio: Resumen de características del depurador de Visual
Studio
Herramientas de generación de perfiles con informes completos

La generación de perfiles examina cómo se invierte el tiempo en la aplicación. Visual Studio admite la
generación de perfiles con intérpretes basados en CPython e incluye la capacidad de comparar el rendimiento
entre diferentes ejecuciones de generación de perfiles.

Documento: Herramientas de generación de perfiles de Python
Documentos de características generales de Visual Studio: Resumen de las características de generación de
perfiles. (No todas las características de generación de perfiles de Visual Studio están disponibles para
Python).
Herramientas de pruebas unitarias
Detecte, ejecute y administre pruebas en el Explorador de pruebas de Visual Studio y depure fácilmente
pruebas unitarias.

Documento: Herramientas de pruebas unitarias de Python
Documentos de características generales de Visual Studio: Prueba unitaria de su código.
SDK de Azure para Python

Las bibliotecas de Azure para Python simplifican el uso de servicios de Azure desde aplicaciones Windows, Mac
OS X y Linux. Puede usarlas para crear y administrar recursos de Azure, así como para conectarse a servicios de
Azure.
Para obtener más información, vea SDK de Azure para Python y Bibliotecas de Azure para Python.
Preguntas y respuestas
P. ¿Visual Studio para Mac es compatible con Python?
A. No en este momento, pero puede votar a favor de la solicitud en la comunidad de desarrolladores. La
documentación de Visual Studio para Mac identifica los tipos actuales de desarrollo que admite. Mientras tanto,
Visual Studio Code en Windows, Mac y Linux funciona bien con Python a través de las extensiones disponibles.
P. ¿Qué puedo usar para generar la interfaz de usuario con Python?
A. La oferta principal en este área es Qt Project, con enlaces para Python denominados PySide (el enlace oficial)
(vea también las descargas de PySide) y PyQt. En la actualidad, la compatibilidad con Python en Visual Studio no
incluye herramientas específicas para el desarrollo de la interfaz de usuario.
P. ¿Puede un proyecto de Python producir un archivo ejecutable independiente?
A. Por lo general, Python es un lenguaje interpretado, con código que se ejecuta bajo demanda en un entorno
compatible con Python adecuado como Visual Studio y servidores web. En la actualidad, Visual Studio no
proporciona por sí mismo los medios para crear un archivo ejecutable independiente, lo que significa
básicamente un programa con un intérprete de Python insertado. En cambio, la comunidad de Python ha
proporcionado varios medios para crear ejecutables como se describe en StackOverflow. CPython también se
puede insertar en una aplicación nativa, como se describe en la entrada de blog Using CPython's Embeddable
Zip File (Uso del archivo Zip insertable de CPython).
Compatibilidad de características
Las características de Python se pueden instalar en las siguientes ediciones de Visual Studio, tal y como se
describe en la guía de instalación:
Visual Studio 2019 (todas las ediciones)
Visual Studio 2013 Community Edition
Visual Studio 2013 Express para Web, Update 2 o una versión posterior
Visual Studio 2013 Express para escritorio, Update 2 o una versión posterior
Visual Studio 2013 (edición Pro o una versión posterior)
Visual Studio 2012 (edición Pro o una versión posterior)
Visual Studio 2010 SP1 (edición Pro o una versión posterior; se necesita .NET 4.5)
Visual Studio 2015 y las versiones anteriores están disponibles en visualstudio.microsoft.com/vs/older-
downloads/.
IMPORTANT
Las características son totalmente compatibles y se mantienen para la versión más reciente de Visual Studio
exclusivamente. Estas características están disponibles en versiones anteriores, pero no se mantienen de manera activa.
C O M PAT I
B IL IDA D 2013
DE 2013 ESC RITO R 2013 2012 2010 SP 1
PYT H ON 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Administr ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ar varios
intérprete
s
Detección ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
automáti
ca de
intérprete
s
populares
Agregar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
intérprete
s
personali
zados
Entornos ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
virtuales
Pip e ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
instalació
n sencilla
SIST EM A
DE 2013
P RO Y EC T 2013 ESC RITO R 2013 2012 2010 SP 1
OS 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Nuevo ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
proyecto
a partir
de código
existente
Mostrar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
todos los
archivos
Control ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
de código
fuente
Integraci ✔ ✔ ✔ ✔ ✔ ✔ ✔1 ✗
ón de Git
2013
2013 ESC RITO R 2013 2012 2010 SP 1
EDIC IÓ N 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Resalte ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
de
sintaxis
Autocom ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
pletar
Ayuda ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
para la
firma
Informaci ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ón rápida
Examinad ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
or de
objetos o
vista de
clases
Barra de ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
navegaci
ón
Ir a ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
definición
Navegar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
a
2013
2013 ESC RITO R 2013 2012 2010 SP 1
EDIC IÓ N 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Buscar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
todas las
referencia
s
Sangría ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
automáti
ca
Formateo ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
del
código
Refactoriz ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ar -
Cambiar
nombre
Refactoriz ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ar -
Extraer
método
Refactoriz ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ar -
Agregar y
quitar
informe
PyLint ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
VEN TA N A 2013
IN T ERA C 2013 ESC RITO R 2013 2012 2010 SP 1
T IVA 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Ventana ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
interactiv
a
IPython ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
con
gráficos
insertado
s
2013
ESC RITO R 2013 ESC RITO R 2013 2012 2010 SP 1
IO 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Aplicació ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
n de
consola y
Windows
WPF en ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
IronPyth
on (con
diseñador
XAML)
Windows ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
Forms en
IronPyth
on
2013
2013 ESC RITO R 2013 2012 2010 SP 1
W EB 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Proyecto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
web de
Django
Proyecto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
web de
Bottle
Proyecto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
web de
Flask
Proyecto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
web
genérico
2013
2013 ESC RITO R 2013 2012 2010 SP 1
A Z URE 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Impleme ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔2
ntación
en el sitio
web
Impleme ✔ ✔ ✔ ✗ ✔4 ✔4 ✔3 ✗
ntación
en el rol
web
2013
2013 ESC RITO R 2013 2012 2010 SP 1
A Z URE 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Impleme ? ? ? ✗ ✔4 ✔4 ✔3 ✗
ntación
en el rol
de
trabajo
Ejecución ? ? ? ✗ ✔4 ✔4 ✔3 ✗
en el
emulador
de Azure
Depuraci ✔ ✔ ✔ ✗ ✔6 ✔8 ✔8 ✗
ón
remota
Adjuntar ✔ ✔ ✔ ✗ ✔7 ✔7 ✗ ✗
en el
Explorado
r de
servidore
s
P L A N T IL L 2013
A S DE 2013 ESC RITO R 2013 2012 2010 SP 1
DJA N GO 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Depuraci ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
ón
Autocom ✔ ✔ ✔ ✗ ✔5 ✔5 ✔ ✔
pletar
Autocom ✔ ✔ ✔ ✗ ✔5 ✔5 ✗ ✗
pletar
para CSS
y
JavaScript
2013
DEP URA C 2013 ESC RITO R 2013 2012 2010 SP 1
IÓ N 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Depuraci ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ón
Depuraci ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ón sin un
proyecto
2013
DEP URA C 2013 ESC RITO R 2013 2012 2010 SP 1
IÓ N 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Depuraci ✔ ✔ ✔ ✔ ✗ ✔ ✔ ✔
ón -
Adjuntar
a la
edición
Depuraci ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
ón en
modo
mixto
Depuraci ✔ ✔ ✔ ✔ ✗ ✔ ✔ ✔
ón
remota
(Windows
, Mac OS
X y Linux)
Ventana ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
interactiv
a de
depuració
n
GEN ERA C 2013

IÓ N DE 2013 ESC RITO R 2013 2012 2010 SP 1
P ERF IL ES 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Generaci ✔ ✔ ✔ ✗ ✗ ✔ ✔ ✔
ón de
perfiles
2013
2013 ESC RITO R 2013 2012 2010 SP 1
P RUEB A 2017+ 2015 C OMM IO 2013 W EB P RO + P RO + P RO +
Explorado ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
r de
pruebas
Ejecución ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
de la
prueba
Depurar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
prueba
1. La compatibilidad de Git para Visual Studio 2012 está disponible en la extensión Visual Studio Tools para
Git, disponible en Visual Studio Marketplace.
2. La implementación del sitio Web de Azure requiere Azure SDK para .NET 2.1 - Visual Studio 2010 SP1.
Las versiones más recientes no son compatibles con Visual Studio 2010.
3. La compatibilidad con el rol web y de trabajo de Azure requiere el SDK de Azure SDK para .NET 2.3 - VS
2012 o una versión posterior.
4. La compatibilidad con el rol web y de trabajo de Azure requiere el SDK de Azure SDK para .NET 2.3 - VS
2013 o una versión posterior.
5. El editor de plantillas de Django en Visual Studio 2013 tiene algunos problemas conocidos que se
resuelven mediante la instalación de Update 2.
6. Requiere Windows 8 o una versión posterior. Visual Studio 2013 Express para Web no tiene el cuadro de
diálogo Asociar al proceso , pero la depuración remota de sitios web de Azure sigue siendo posible
mediante el comando Adjuntar depurador (Python) en el Explorador de ser vidores . La depuración
remota requiere el SDK de Azure para .NET 2.3 - Visual Studio 2013 o una versión posterior.
7. Requiere Windows 8 o una versión posterior. El comando Adjuntar depurador (Python) del
Explorador de ser vidores requiere el SDK de Azure para .NET 2.3 - Visual Studio 2013 o una versión
posterior.
8. Requiere Windows 8 o una versión posterior.
Bienvenida al IDE de Visual Studio | Python
El entorno de desarrollo integrado de Visual Studio es un panel de inicio creativo para Python (y otros
lenguajes) que se puede usar para editar, depurar y probar código y, después, publicar una aplicación. Un
entorno de desarrollo integrado (IDE) es un programa con numerosas características que se pueden usar para
muchos aspectos del desarrollo de software. Más allá del editor estándar y el depurador que proporcionan la
mayoría de IDE, Visual Studio incluye herramientas de finalización de código, entornos de REPL interactivos y
otras características para facilitar el proceso de desarrollo de software.
En esta imagen se muestra Visual Studio con un proyecto de Python abierto y varias ventanas de herramientas
clave que probablemente usará:
El Explorador de soluciones (parte superior derecha) permite ver, navegar y administrar los archivos
de código. El Explorador de soluciones puede ayudar a organizar el código al agrupar los archivos en
soluciones y proyectos.
Además del Explorador de soluciones , están los entornos de Python , donde se administran los
diferentes intérpretes de Python que hay instalados en el equipo.
También puede abrir y ejecutar código de Python en una carpeta sin crear archivos de solución ni un
proyecto de Visual Studio. Para obtener más información, vea Inicio rápido: Apertura y ejecución de
código de Python en una carpeta.
La ventana del editor (centro), donde es probable que pase la mayor parte del tiempo, muestra el
contenido del archivo. Aquí es donde se edita código de Python, se navega por la estructura del código y
se establecen puntos de interrupción durante las sesiones de depuración. Con Python, también puede
seleccionar código y presionar Ctrl+ENTRAR para ejecutar ese código en una ventana de REPL
interactiva.
La ventana Resultados (parte inferior central) es donde Visual Studio envía notificaciones, como mensajes
de error y de depuración, advertencias, mensajes de estado de publicación, etc. Cada fuente del mensaje
tiene su propia pestaña.
Una ventana de REPL interactiva de Python aparece en la misma área que la ventana Resultados.
Team Explorer (parte inferior derecha) permite realizar el seguimiento de los elementos de trabajo y
compartir código con otros usuarios mediante tecnologías de control de versiones como Git y Control de
versiones de Team Foundation (TFVC).
Ediciones
Visual Studio está disponible para Windows y Mac, pero Python solo es compatible con Visual Studio para
Windows.
Existen tres ediciones de Visual Studio en Windows: Community, Professional y Enterprise. Consulte Comparar
los IDE de Visual Studio para obtener información sobre las características que se admiten en cada edición.
Características de productividad populares

Algunas de las características populares de Visual Studio que ayudan a ser más productivos durante el
desarrollo de software incluyen:
IntelliSense
IntelliSense es un término que define un conjunto de características que muestran información sobre el
código directamente en el editor y, en algunos casos, escriben pequeños fragmentos de código
automáticamente. Es como tener documentación básica insertada en el editor, lo que evita tener que
buscar información escrita en cualquier otro lugar. Las características de IntelliSense varían según el
lenguaje. En el artículo Editar código de Python encontrará los detalles relativos a Python. La siguiente
ilustración muestra cómo IntelliSense muestra una lista de miembros de un tipo:
Refactorización
Si hacemos clic con el botón derecho en un fragmento de código y seleccionamos Acciones rápidas y
refactorizaciones , Visual Studio proporciona operaciones como el cambio inteligente de nombres de
variables, la extracción de una o más líneas de código en un nuevo método, el cambio del orden de los
parámetros de método, etc.
Búsqueda de errores
La detección de errores comprueba si hay errores y problemas comunes en el código de Python, lo cual
fomenta un uso adecuado de patrones de codificación de Python.
Cuadro de búsqueda
Visual Studio puede parecer abrumador a veces con tantas propiedades, opciones y menús. El cuadro de
búsqueda supone una excelente manera de encontrar rápidamente lo que necesita en Visual Studio. Al
empezar a escribir el nombre de lo que está buscando, Visual Studio muestra resultados que llevan
exactamente a donde necesita ir. Si necesita agregar funcionalidad a Visual Studio, por ejemplo, agregar
compatibilidad con otro lenguaje de programación, el cuadro de búsqueda proporciona resultados que
abren el Instalador de Visual Studio para instalar un componente individual o una carga de trabajo.
Subrayados ondulados y Acciones rápidas

Los subrayados ondulados son rayas con formas de onda debajo de las palabras que alertan de errores o
posibles problemas en el código a medida que se escribe. Estas pistas visuales permiten corregir
problemas inmediatamente sin esperar a que el error se detecte durante la compilación o cuando se
ejecute el programa. Si mantiene el cursor sobre un subrayado ondulado, se ve información adicional
sobre el error. También puede aparecer una bombilla en el margen izquierdo con acciones, conocidas
como Acciones rápidas, para corregir el error.
Ir a la definición y verla
La característica Ir a definición lleva directamente a la ubicación donde se define una función o un tipo.
El comando Ver la definición muestra la definición en una ventana, sin tener que abrir un archivo
aparte. El comando Buscar todas las referencias es igualmente una forma útil de detectar aquellas
instancias en las que un identificador determinado se define y utiliza.
Características eficaces de Python

Ejecución de código sin un proyecto
A partir de Visual Studio 2019, puede abrir una carpeta que contiene código de Python para disfrutar de
características como IntelliSense y depuración sin tener que crear un proyecto de Visual Studio para el
código.
Colaboración mediante Visual Studio
Visual Studio Live Share permite editar y depurar en colaboración con otros usuarios en tiempo real,
independientemente del lenguaje de programación que use o los tipos de aplicaciones que compile.
Ventana de REPL interactiva
Visual Studio proporciona una ventana interactiva read-evaluate-print loop (REPL) para cada entorno de
Python, que ofrece mejoras con respecto al REPL obtenido con python.exe en la línea de comandos. En la
ventana Interactiva puede escribir código de Python arbitrario y ver resultados inmediatos.
Depuración
Visual Studio proporciona una experiencia de depuración completa para Python, lo que incluye la
asociación a procesos en ejecución, la evaluación de expresiones en las ventanas Inspección e
Inmediato , la inspección de variables locales, los puntos de interrupción, las instrucciones Depurar paso
a paso por instrucciones/procedimientos/para salir, Establecer instrucción siguiente , etc. También
puede depurar código de Python remoto que se ejecuta en equipos Linux.
Interacción con C++

Muchas de las bibliotecas creadas para Python están escritas en C++ para lograr el mejor rendimiento
posible. Visual Studio proporciona funcionalidades muy completas para desarrollar extensiones de C++,
incluida la depuración en modo mixto.
Cuando se usa un intérprete basado en CPython, se puede evaluar el rendimiento del código de Python
en Visual Studio.
Pruebas unitarias
Visual Studio proporciona compatibilidad integrada para detectar, ejecutar y depurar pruebas unitarias en
el contexto del IDE.
Pasos siguientes
Continúe explorando Python en Visual Studio siguiendo uno de los siguientes tutoriales o inicios rápidos:
Inicio rápido: Crear una aplicación web con Flask
Uso de Python en Visual Studio
Introducción al marco web de Django en Visual Studio
Introducción al marco web Flask en Visual Studio
Vea también
Descubra más características de Visual Studio
Visite visualstudio.microsoft.com
Lea el blog de Visual Studio
Instalación de la compatibilidad con ciencia de
datos en Visual Studio
La carga de trabajo Aplicaciones de ciencia de datos y de análisis, que se selecciona e instala mediante el
instalador de Visual Studio, reúne varios lenguajes y sus correspondientes distribuciones de tiempo de
ejecución:
Python y Anaconda
F# con .NET Framework
R y Microsoft R Client
Python
F# con .NET Framework
R y Python son dos de los principales lenguajes de scripting que se usan para la ciencia de datos. Ambos
lenguajes son fáciles de aprender y son compatibles con un ecosistema completo de paquetes. Estos paquetes
se centran en una amplia gama de escenarios, como la adquisición de datos, limpieza, entrenamiento de
modelos, implementación y trazado. F# también es un lenguaje de .NET eficaz y esencialmente funcional que
resulta adecuado para una amplia variedad de tareas de procesamiento de datos.
Python es un lenguaje de scripting fundamental que se usa para la ciencia de datos. Python es fácil de aprender
y es compatible con un ecosistema completo de paquetes. Estos paquetes se centran en una amplia gama de
escenarios, como la adquisición de datos, limpieza, entrenamiento de modelos, implementación y trazado. F#
también es un lenguaje de .NET eficaz y esencialmente funcional que resulta adecuado para una amplia variedad
de tareas de procesamiento de datos).
Opciones de carga de trabajo
De forma predeterminada, la carga de trabajo instala las opciones siguientes, que se pueden modificar en la
sección de resumen de la carga de trabajo en el instalador de Visual Studio:
Compatibilidad con el lenguaje de escritorio F#
Python:
Compatibilidad con el lenguaje Python
Compatibilidad web con Python
Compatibilidad con el idioma F#
Python:
Compatibilidad con el lenguaje Python
Anaconda3 64 bits, una distribución de Python que incluye completas bibliotecas de ciencia de datos y
un intérprete de Python.
Compatibilidad web con Python
Compatibilidad con plantillas de Cookiecutter
R:
Compatibilidad con el lenguaje R
Compatibilidad del entorno de tiempo de ejecución con herramientas de desarrollo de R
Microsoft R Client (intérprete de R de Microsoft totalmente compatible y admitido por la comunidad,
con bibliotecas de ScaleR para cálculos más rápidos en nodos o clústeres concretos. También puede
usar cualquier R de CRAN).
Integración de SQL Server

SQL Server admite el uso de R y Python para realizar análisis avanzados directamente dentro de SQL Server. La
compatibilidad con R se incluye con SQL Server 2016 y versiones posteriores; la compatibilidad con Python está
disponible en SQL Server 2017 CTP 2.0 y versiones posteriores.
SQL Server admite el uso de Python para realizar análisis avanzados directamente dentro de SQL Server. La
compatibilidad con Python está disponible en SQL Server 2017 CTP 2.0 y versiones posteriores.
Ejecutar este código donde ya se encuentran los datos le ofrece una serie de ventajas:
Eliminación del movimiento de los datos : en lugar de mover datos de la base de datos a la
aplicación o el modelo, puede crear aplicaciones en la base de datos. Esta función elimina las barreras de
seguridad, cumplimiento normativo, gobernanza, integridad y una gran cantidad de problemas similares
relacionados con el movimiento de grandes cantidades de datos. También puede consumir conjuntos de
datos que no se puedan ajustar en la memoria de un equipo cliente.
Implementación sencilla : una vez que tenga listo un modelo, implementarlo en producción es tan
sencillo como insertarlo en un script de T-SQL. Después, cualquier aplicación cliente SQL escrita en
cualquier lenguaje puede aprovechar las ventajas de los modelos y la inteligencia mediante una llamada
de procedimiento almacenado. No se necesitan integraciones específicas del lenguaje.
Rendimiento y escala de nivel empresarial : puede usar funciones avanzadas de SQL Server como
los índices de almacenamiento de tablas y columnas en memoria con las API escalables de alto
rendimiento de los paquetes de RevoScale. La eliminación del movimiento de datos también significa que
se evitan las restricciones de memoria de cliente a medida que crecen los datos o que se quiere aumentar
el rendimiento de la aplicación.
Extensibilidad amplia : puede instalar y ejecutar cualquiera de los paquetes de código abierto más
recientes en SQL Server para compilar aplicaciones completas de IA y aprendizaje profundo en grandes
cantidades de datos en SQL Server. Instalar un paquete en SQL Server es tan sencillo como instalar un
paquete en el equipo local.
Amplia disponibilidad sin costo adicional : hay integraciones de lenguaje disponibles en todas las
ediciones de SQL Server 2017 y versiones posteriores, incluida la edición Express.
Para aprovechar al máximo la integración de SQL Server, use el instalador de Visual Studio para instalar la carga
de trabajo Almacenamiento y procesamiento de datos con la opción SQL Ser ver Data Tools . Esta última
opción habilita SQL IntelliSense, el resaltado de sintaxis y la implementación.

Trabajar con SQL Server y R
Análisis avanzado con R en SQL Server 2016 en bases de datos (blog)
Python en SQL Server 2017: aprendizaje automático mejorado en bases de datos (blog)
Servicios y SDK adicionales

Además de lo que se incluye directamente en la carga de trabajo Aplicaciones de ciencia de datos y de análisis,
el servicio Azure Notebooks y el SDK de Azure para Python también son útiles para la ciencia de datos.
Azure SDK para Python facilita el uso y la administración de los servicios de Microsoft Azure en aplicaciones que
se ejecutan en Windows, Mac y Linux. Para más información, vea SDK de Azure para Python.
Azure Notebooks (actualmente en versión preliminar) proporciona acceso en línea gratuito a Jupyter Notebooks
que se ejecutan en la nube en Microsoft Azure. El servicio incluye blocs de notas de ejemplo de Python, R y F#
para que pueda comenzar. Visite notebooks.azure.com.
Instalación de la compatibilidad con Python en
Visual Studio en Windows
Para instalar la compatibilidad de Python para Visual Studio (también conocida como Herramientas de Python
para Visual Studio o PTVS), siga las instrucciones que aparecen en la sección correspondiente a su versión de
Visual Studio:
Visual Studio 2017 y Visual Studio 2019
Visual Studio 2015
Visual Studio 2013 y anterior
Para probar rápidamente la compatibilidad de Python después de seguir los pasos de instalación, abra la
ventana interactiva de Python ; para ello, presione Alt +I y escriba 2+2 . Si no ve la salida de 4 , revise los
pasos.
TIP
La carga de trabajo de Python incluye la útil extensión Cookiecutter que proporciona una interfaz gráfica de usuario para
detectar plantillas, opciones de plantilla de entrada y crear proyectos y archivos. Para obtener más información, vea Uso
de la extensión Cookiecutter.
NOTE
La compatibilidad con Python no está actualmente disponible en Visual Studio para Mac, pero está disponible en Mac y
Linux a través de Visual Studio Code. Consulte las preguntas y respuestas.
Visual Studio 2019 y Visual Studio 2017

1. Descargue y ejecute el instalador de Visual Studio más reciente. Si tiene Visual Studio ya instalado,
ejecute el Instalador de Visual Studio, seleccione la opción Modificar (consulte Modificar Visual Studio) y
vaya al paso 2.
Instalación de Visual Studio 2019 Community
TIP
La edición Community es para desarrolladores individuales, aprendizaje en el aula, investigación académica y
desarrollo de código abierto. Para otros usos, instale Visual Studio 2019 Professional o Visual Studio 2019
Enterprise.
2. El instalador muestra una lista de las cargas de trabajo, que son grupos de opciones relacionadas para
áreas de desarrollo específicas. Para Python, seleccione la carga de trabajo Desarrollo de Python .
Opcional: si está trabajando con la ciencia de datos, considere también la posibilidad de la carga de
trabajo Aplicaciones de ciencia de datos y de análisis . Esta carga de trabajo incluye compatibilidad
con los lenguajes Python, R y F#. Para más información, vea Carga de trabajo Aplicaciones de ciencia de
datos y de análisis.
NOTE
Las cargas de trabajo de Python y Ciencia de datos solo están disponibles con Visual Studio 2017 versión 15.2 y
posteriores.
Opcional: si está trabajando con la ciencia de datos, considere también la posibilidad de la carga de
trabajo Aplicaciones de ciencia de datos y de análisis . Esta carga de trabajo incluye compatibilidad
con los lenguajes Python y F#. Para más información, vea Carga de trabajo Aplicaciones de ciencia de
datos y de análisis.
3. En la parte derecha del instalador, puede elegir opciones adicionales si lo prefiere. Omita este paso para
aceptar las opciones predeterminadas.
O P C IÓ N DESC RIP C IÓ N
Distribuciones de Python Elija cualquier combinación de las opciones disponibles,

como las variantes de 32 bits y 64 bits de las
distribuciones de Python 2, Python 3, Miniconda,
Anaconda2 y Anaconda3 con las que piensa trabajar. En
todas se incluye el intérprete, el runtime y las bibliotecas
de la distribución. Anaconda, en concreto, es una
plataforma abierta de ciencia de datos que incluye una
gran variedad de paquetes preinstalados. (Puede volver
al instalador de Visual Studio en cualquier momento para
agregar o quitar distribuciones). Nota : Si ha instalado
una distribución fuera del instalador de Visual Studio, no
es necesario comprobar la opción equivalente aquí.
Visual Studio detecta automáticamente las instalaciones
existentes de Python. Vea La ventana Entornos de
Python. Además, si hay una versión más reciente de
Python que la que se muestra en el instalador, puede
instalar esta versión por separado y Visual Studio la
detectará.
Compatibilidad con plantillas de Cookiecutter Instala la interfaz de usuario gráfica de Cookiecutter para
detectar plantillas, opciones de plantilla de entrada y
crear proyectos y archivos. Vea Uso de la extensión
Cookiecutter.
Compatibilidad web con Python Instala herramientas para desarrollo web, incluida la
compatibilidad de edición de HTML, CSS y JavaScript,
junto con plantillas de proyectos que usan los marcos
Bottle, Flask y Django. Vea Plantillas de proyecto web de
Python.
Compatibilidad con IoT de Python Admite el desarrollo de Windows IoT Core con Python.
Herramientas de desarrollo nativo de Python Instala el compilador de C++ y otros componentes

necesarios para desarrollar extensiones nativas para
Python. Vea Creación de una extensión de C++ para
Python. Instale también la carga de trabajo Desarrollo
para el escritorio con C++ para disfrutar de una
compatibilidad plena.
Distribuciones de Python Elija cualquier combinación de las opciones disponibles,

como las variantes de 32 bits y 64 bits de las
distribuciones de Python 2, Python 3, Miniconda,
Anaconda2 y Anaconda3 con las que piensa trabajar. En
todas se incluye el intérprete, el runtime y las bibliotecas
de la distribución. Anaconda, en concreto, es una
plataforma abierta de ciencia de datos que incluye una
gran variedad de paquetes preinstalados. (Puede volver
al instalador de Visual Studio en cualquier momento para
agregar o quitar distribuciones). Nota : Si ha instalado
una distribución fuera del instalador de Visual Studio, no
es necesario comprobar la opción equivalente aquí.
Visual Studio detecta automáticamente las instalaciones
existentes de Python. Vea La ventana Entornos de
Python. Además, si hay una versión más reciente de
Python que la que se muestra en el instalador, puede
instalar esta versión por separado y Visual Studio la
detectará.
Compatibilidad con plantillas de Cookiecutter Instala la interfaz de usuario gráfica de Cookiecutter para
detectar plantillas, opciones de plantilla de entrada y
crear proyectos y archivos. Vea Uso de la extensión
Cookiecutter.
Compatibilidad web con Python Instala herramientas para desarrollo web, incluida la
compatibilidad de edición de HTML, CSS y JavaScript,
junto con plantillas de proyectos que usan los marcos
Bottle, Flask y Django. Vea Plantillas de proyecto web de
Python.
Herramientas de desarrollo nativo de Python Instala el compilador de C++ y otros componentes

necesarios para desarrollar extensiones nativas para
Python. Vea Creación de una extensión de C++ para
Python. Instale también la carga de trabajo Desarrollo
para el escritorio con C++ para disfrutar de una
compatibilidad plena.
4. Después de la instalación, el instalador proporciona opciones para modificar, iniciar, reparar o desinstalar
Visual Studio. El botón Modificar cambia a Actualizar cuando hay actualizaciones de Visual Studio
disponibles para alguno de los componentes instalados. (Después, la opción Modificar está disponible
en el menú desplegable). También puede iniciar Visual Studio y el instalador desde el menú Inicio de
Windows mediante la búsqueda de "Visual Studio".
Solución de problemas
Si encuentra problemas al instalar o ejecutar Python en Visual Studio, pruebe lo siguiente:
Determinar si se produce el mismo error mediante la CLI de Python, es decir, ejecutar python.exe desde un
símbolo del sistema.
Use la opción Reparar en el instalador de Visual Studio.
Reparar o reinstalar Python a través de Configuración > Aplicaciones y características en Windows.
Error de ejemplo : No se pudo iniciar el proceso interactivo: System.ComponentModel.Win32Exception
(0x80004005): Error desconocido (0xc0000135) en
Microsoft.PythonTools.Repl.PythonInteractiveEvaluator.d__43.MoveNext().
Visual Studio 2015

1. Ejecute el instalador de Visual Studio; para ello, vaya a Panel de control > Programas y
características , seleccione Microsoft Visual Studio 2015 y después haga clic en Cambiar .
2. En el instalador, seleccione Modificar .
3. Seleccione Lenguajes de programación > Herramientas de Python para Visual Studio y luego
haga clic en Siguiente :
4. Una vez completada la instalación de Visual Studio, instale un intérprete de Python de su elección. Visual
Studio 2015 solo admite Python 3.5 y versiones anteriores, las versiones más recientes generan un
mensaje similar a Versión 3.6 de Python no compatible ). Si ya tiene instalado un intérprete y Visual
Studio no lo detecta de manera automática, consulte Identificación manual de un entorno existente.
Visual Studio 2013 y anterior

1. Instale la versión adecuada de Herramientas de Python para Visual Studio para su versión de Visual
Studio:
Visual Studio 2013: PTVS 2.2.2 para Visual Studio 2013. En el cuadro de diálogo Archivo > Nuevo
proyecto de Visual Studio 2013 se ofrece un acceso directo a este proceso.
Visual Studio 2010 y 2012: PTVS 2.1.1 para Visual Studio 2010 y 2012
2. Instale un intérprete de Python de su elección. Si ya tiene instalado un intérprete y Visual Studio no lo
detecta de manera automática, consulte Identificación manual de un entorno existente.
Ubicaciones de instalación
De forma predeterminada, la compatibilidad de Python se instala para todos los usuarios de un equipo.
En Visual Studio 2019 y Visual Studio 2017, la carga de trabajo de Python se instala en
%ProgramFiles(x86)%\Microsoft Visual Studio\<VS_version>\
<VS_edition>Common7\IDE\Extensions\Microsoft\Python, donde <VS_version> es 2019 o 2017 y
<VS_edition> es Community, Professional o Enterprise.
En Visual Studio 2015 y versiones anteriores, las rutas de instalación son las siguientes:
32 bits:
Ruta de acceso: %Archivos de programa(x86)%\Microsoft Visual Studio
<VS_ver>\Common7\IDE\Extensions\Microsoft\Herramientas de Python para Visual Studio\
<PTVS_ver>
Ubicación del Registro de ruta de acceso:
HKEY_LOCAL_MACHINE\Software\Microsoft\PythonTools\<VS_ver>\InstallDir
64 bits:
Ruta de acceso: %Archivos de programa%\Microsoft Visual Studio
<VS_ver>\Common7\IDE\Extensions\Microsoft\Herramientas de Python para Visual Studio\
<PTVS_ver>
Ubicación del Registro de ruta de acceso:
HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\PythonTools\
<VS_ver>\InstallDir
donde:
<VS_ver> es:
14.0 para Visual Studio 2015
<PTVS_ver> es un número de versión, como 2.2.2, 2.1.1, 2.0, 1.5, 1.1 o 1.0.
Instalaciones específicas de usuario (1.5 y anteriores)
Herramientas de Python para Visual Studio 1.5 y las versiones anteriores permitían una instalación solo para el
usuario actual, en cuyo caso la ruta de instalación es %LocalAppData%\Microsoft\VisualStudio\
<VS_ver>\Extensions\Microsoft\Herramientas de Python para Visual Studio\<PTVS_ver> , donde <VS_ver> y
<PTVS_ver> se corresponden con las mismas versiones indicadas anteriormente.
De manera predeterminada, la instalación de la carga de trabajo de desarrollo de Python en Visual Studio de

2017 y versiones posteriores también instala Python 3 (64 bits). De manera opcional, puede optar por instalar
versiones de Python 2 y Python 3 de 32 y 64 bits, junto con Miniconda (Visual Studio 2019) o
Anaconda2/Anaconda 3 (Visual Studio 2017), tal como se describe en Instalación.
Como alternativa, puede instalar intérpretes de Python estándar desde el cuadro de diálogo Agregar entorno .
Seleccione el comando Agregar entorno en la ventana Entornos de Python o la barra de herramientas de
Python, seleccione la pestaña Instalación de Python , indique los intérpretes que se van a instalar y seleccione
Instalar .
También puede instalar manualmente cualquiera de los intérpretes que aparecen en la tabla siguiente fuera del
Instalador de Visual Studio. Por ejemplo, si instaló Anaconda 3 antes de instalar Visual Studio, no necesita volver
a instalarlo mediante el instalador de Visual Studio. También puede instalar un intérprete manualmente si, por
ejemplo, hay una versión más reciente disponible que todavía no aparece en el instalador de Visual Studio.
NOTE
Visual Studio admite la versión 2.7 de Python, así como las versiones 3.5 a 3.7. Aunque es posible usar Visual Studio para
editar el código escrito en otras versiones de Python, no se admiten oficialmente esas versiones y características como
IntelliSense y la depuración podrían no funcionar.
NOTE
Visual Studio admite la versión 3.7 de Python. Aunque es posible usar Visual Studio para editar el código escrito en otras
versiones de Python, no se admiten oficialmente esas versiones y características como IntelliSense y la depuración podrían
no funcionar.
Para Visual Studio 2015 y versiones anteriores , debe instalar manualmente uno de los intérpretes.
NOTE
Aunque Visual Studio ofrece instalar la distribución de Anaconda, su uso de esta y de los paquetes adicionales del
repositorio de Anaconda está regido por los términos de servicio de Anaconda. Estos términos pueden requerir que
algunas organizaciones tengan que pagar una licencia comercial a Anaconda o bien configurar herramientas para acceder
a un repositorio alternativo. Consulte la documentación de los canales de Conda para obtener más información.
Visual Studio (todas las versiones) detecta automáticamente cada intérprete de Python instalado y su entorno
mediante la comprobación del registro de acuerdo con PEP 514 - Python registration in the Windows registry
(PEP 514: registro de Python en el Registro de Windows). Las instalaciones de Python se encuentran
normalmente en HKEY_LOCAL_MACHINE\SOFTWARE\Python (32 bits) y
HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Python (64 bits) y, luego, dentro de los nodos para
la distribución, como PythonCore (CPython) y ContinuumAnalytics (Anaconda).
Si Visual Studio no detecta un entorno instalado, consulte Identificación manual de un entorno existente.
Visual Studio muestra todos los entornos conocidos en la ventana Entornos de Python y detecta
automáticamente las actualizaciones de los intérpretes existentes.
IN T ÉRP RET E DESC RIP C IÓ N
CPython Intérprete "nativo" y que se usa con más frecuencia,

disponible en versiones de 32 y 64 bits (se recomienda la
versión de 32 bits). Incluye características más recientes del
lenguaje, máxima compatibilidad con paquetes de Python,
compatibilidad completa con la depuración e
interoperabilidad con IPython. Consulte también: Should I
use Python 2 or Python 3? (¿Debo usar Python 2 o Python
3?). Tenga en cuenta que Visual Studio 2015 y versiones
anteriores no admiten Python 3.6 y pueden generar errores
de tipo Versión 3.6 de Python no compatible . Use la
versión Python 3.5 o anteriores.
IronPython Implementación de .NET de Python, disponible en versiones

de 32 y 64 bits, que proporciona interoperabilidad con C#,
F# y Visual Basic, acceso a las API de .NET, depuración
estándar de Python (pero no depuración en modo mixto de
C++) y depuración mixta de IronPython y C#. IronPython,
sin embargo, no admite entornos virtuales.
Anaconda Plataforma de ciencia de datos abierta con tecnología de

Python que incluye la versión más reciente de CPython y la
mayoría de los paquetes de difícil instalación. Es la opción
recomendable si no puede decidirse.
PyPy Implementación JIT de seguimiento de alto rendimiento de

Python adecuada para programas de ejecución prolongada y
situaciones donde se identifican problemas de rendimiento
pero no puede encontrar otras resoluciones. Funciona con
Visual Studio, pero con compatibilidad limitada para
características de depuración avanzadas.
Jython Implementación de Python en la Máquina virtual Java (JVM).

Es similar a IronPython, donde el código que se ejecuta en
Jython puede interactuar con clases y bibliotecas de Java,
pero no es posible que no pueda utilizar muchas bibliotecas
pensadas para CPython. Funciona con Visual Studio, pero
con compatibilidad limitada para características de
depuración avanzadas.
Los desarrolladores que desean proporcionar nuevas formas de detección para entornos de Python pueden
consultar PTVS Environment Detection (Entorno detección PTVS) en github.com.
Trasladar un intérprete
Si mueve un intérprete existente a una ubicación nueva con el sistema de archivos, Visual Studio no detecta
automáticamente el cambio.
Si originalmente ha especificado la ubicación del intérprete a través de la ventana Entornos de Python ,
edite su entorno con la pestaña Configurar de esa ventana para identificar la ubicación nueva. Vea
Identificación manual de un entorno existente.
Si instaló el intérprete con un programa de instalación, use los pasos siguientes para volver a instalar el
intérprete en la ubicación nueva:
1. Restaure el intérprete de Python a su ubicación original.
2. Desinstale el intérprete mediante el instalador, que borra las entradas del Registro.
3. Vuelva a instalar el intérprete en la ubicación deseada.
4. Reinicie Visual Studio, el que debería detectar automáticamente la ubicación nueva en lugar de la
antigua.
Al seguir este proceso, se asegura de que las entradas del Registro que identifican la ubicación del intérprete,
que Visual Studio usa, se actualizan correctamente. Usar un instalador también controla cualquier otro efecto
secundario que pudiera surgir.
Consulte también
Referencia de ventana Entornos de Python
Inicio rápido: Creación de la primera aplicación web
de Python con Visual Studio
En esta introducción a Visual Studio como un IDE de Python, con una duración de entre 5 y 10 minutos, creará
una sencilla aplicación web Python basada en el marco Flask. El proyecto se crea mediante discretos pasos que
le ayudarán a conocer las características básicas de Visual Studio.
Si todavía no ha instalado Visual Studio, vaya a la página de descargas de Visual Studio para instalarlo de forma
gratuita. En el instalador, asegúrese de seleccionar la carga de trabajo Desarrollo de Python .
gratuita. En el instalador, asegúrese de seleccionar la carga de trabajo Desarrollo de Python .
gratuita. En el Instalador de Visual Studio, seleccione la carga de trabajo Desarrollo de Python y, en los
detalles de instalación, seleccione Compatibilidad web con Python .
<a name="create-the-project">Crear el proyecto

Los pasos siguientes crean un proyecto vacío que actúa como un contenedor para la aplicación:
::: moniker range="vs-2017"
1. Abra Visual Studio 2017.
2. En la barra de menús superior, elija Archivo > Nuevo > Proyecto .
3. En el cuadro de diálogo Nuevo proyecto , escriba "Proyecto web de Python" en el campo de búsqueda
situado en la parte superior derecha, elija Proyecto Web en la lista del medio, asigne un nombre al
proyecto (por ejemplo, "HelloPython") y luego elija Aceptar .
Si no ve las plantillas de proyecto de Python, ejecute el Instalador de Visual Studio , seleccione Más >
Modificar , seleccione la carga de trabajo Desarrollo de Python y, a continuación, elija Modificar .
4. El nuevo proyecto se abre en el panel de la derecha del Explorador de soluciones . En este momento el
proyecto está vacío porque no contiene ningún otro archivo.
::: moniker-end
2. En la pantalla de inicio, seleccione Crear un nuevo proyecto .
3. En el cuadro de diálogo Crear un nuevo proyecto , escriba "Web de Python" en el campo de búsqueda
en la parte superior, elija Proyecto web en la lista del medio y, a continuación, seleccione Siguiente :
Si no ve las plantillas de proyecto de Python, ejecute el Instalador de Visual Studio , seleccione Más >
Modificar , seleccione la carga de trabajo Desarrollo de Python y, a continuación, elija Modificar .
4. En el cuadro de diálogo Configure su nuevo proyecto que sigue, escriba "HelloPython" para Nombre
del proyecto , especifique una ubicación y seleccione Crear . (El valor Nombre de la solución se
establece automáticamente para que coincida con el Nombre del proyecto ).
5. El nuevo proyecto se abre en el panel de la derecha del Explorador de soluciones . En este momento el

2. En la pantalla de inicio, seleccione Crear un nuevo proyecto .
3. En el cuadro de diálogo Crear un proyecto , escriba "Web de Python" en el campo de búsqueda en la
parte superior. Elija Proyecto web en la lista y, a continuación, seleccione Siguiente :
Si no ve las plantillas de proyectos web de Python, seleccione Herramientas > Obtener herramientas
y características para ejecutar el Instalador de Visual Studio. En el Instalador, seleccione la carga de
trabajo Desarrollo de Python y, en Detalles de la instalación , seleccione Compatibilidad web con
Python . Después, seleccione Modificar .
4. En el cuadro de diálogo Configure el nuevo proyecto , escriba "HelloPython" para Nombre del
proyecto , especifique una ubicación y seleccione Crear . El Nombre de la solución se actualiza
automáticamente para coincidir con el Nombre del proyecto .
El nuevo proyecto se abre en el panel de la derecha del Explorador de soluciones . En este momento el
Pregunta: ¿Cuál es la ventaja de crear un proyecto en Visual Studio para una aplicación de
Python?
Respuesta : las aplicaciones de Python suelen definirse usando solo carpetas y archivos, pero esta estructura
sencilla puede resultar engorrosa a medida que aumenta el tamaño de las aplicaciones. Las aplicaciones pueden
contener archivos generados automáticamente, JavaScript para aplicaciones web y otros componentes. Un
proyecto de Visual Studio le ayuda a administrar esta complejidad.
El proyecto, un archivo .pyproj, identifica los archivos de origen y contenido asociados con el proyecto. El
archivo .pyproj contiene información de compilación de cada archivo, mantiene la información para integrarse
con sistemas de control de código fuente y ayuda a organizar la aplicación en componentes lógicos.
Pregunta: ¿Qué es la "solución" que se muestra en el Explorador de soluciones?
Respuesta : una solución de Visual Studio es un contenedor que le ayuda a administrar uno o varios proyectos
relacionados como un grupo. La solución almacena valores de configuración que no son específicos de un
proyecto. Los proyectos de una solución también pueden hacer referencia entre sí. Por ejemplo, la ejecución de
un proyecto de aplicación de Python puede compilar automáticamente un segundo proyecto, como una
extensión de C++ que usa la aplicación de Python.
Instalación de la biblioteca de Flask

En las aplicaciones web de Python casi siempre se usa una de las muchas bibliotecas de Python disponibles para
controlar detalles de bajo nivel como el enrutamiento de solicitudes web y la forma de las respuestas.
Visual Studio proporciona muchas plantillas para aplicaciones web. Usará una de estas plantillas más adelante
en este inicio rápido.
Utilice los pasos siguientes para instalar la biblioteca de Flask en el entorno global predeterminado que
Visual Studio usa para este proyecto.
1. Expanda el nodo Entornos de Python en el proyecto para ver el entorno predeterminado para el
proyecto.
2. Haga clic con el botón derecho en el entorno y seleccione Instalar paquete de Python . Este comando
abre la ventana Entornos de Python por la pestaña Paquetes .
3. Escriba "flask" en el campo de búsqueda y seleccione instalación de PIP flask desde PyPI . Acepte los
mensajes de privilegios de administrador y observe el progreso en la ventana Salida de Visual Studio.
(Se le pedirá confirmación de elevación cuando la carpeta de paquetes del entorno global esté ubicada en
un área protegida, como C:\Archivos de programa).
proyecto.
2. Haga clic con el botón derecho en el entorno y seleccione Administrar paquetes de Python... . Este
comando abre la ventana Entornos de Python en la pestaña Paquetes (PyPI) .
3. En el campo de búsqueda, escriba "flask". Si Flask aparece debajo del cuadro de búsqueda, puede omitir
este paso. En caso contrario, seleccione Comando de ejecución: pip install flask . Acepte los mensajes
de privilegios de administrador y observe el progreso en la ventana Salida de Visual Studio. (Se le pedirá
confirmación de elevación cuando la carpeta de paquetes del entorno global esté ubicada en un área
protegida, como C:\Archivos de programa).
proyecto.
2. Haga clic con el botón derecho en el entorno y seleccione Administrar paquetes de Python . Este
comando abre la ventana Entornos de Python en la pestaña Paquetes (PyPI) .
3. En el campo de búsqueda, escriba "flask". Si Flask aparece debajo del cuadro de búsqueda, puede omitir
este paso. En caso contrario, seleccione Comando de ejecución: pip install flask .
Aparece un aviso de elevación si la carpeta de paquetes del entorno global está en un área protegida,
como C:\Archivos de programa. Acepte las solicitudes de privilegios de administrador. Consulte la
ventana Salida de Visual Studio para ver el progreso.
Una vez instalada, la biblioteca aparece en el entorno en el Explorador de soluciones , lo que significa que
puede usarla en el código de Python.
NOTE
En lugar de instalar las bibliotecas en el entorno global, los desarrolladores suelen crear un "entorno virtual" en el que se
instalan las bibliotecas de un proyecto específico. Las plantillas de Visual Studio normalmente ofrecen esta opción, como
se describe en Inicio rápido: Crear un proyecto de Python desde una plantilla en Visual Studio.
Pregunta: ¿Dónde puedo obtener más información sobre otros paquetes de Python disponibles?
Respuesta : Visite el índice de paquetes de Python.
Agregar un archivo de código

Ahora está listo para agregar un poco de código de Python para implementar una aplicación web básica.
1. Haga clic con el botón derecho en el Explorador de soluciones y seleccione Agregar > Nuevo
elemento .
2. En el cuadro de diálogo que aparece, seleccione Archivo de Python vacío , asígnele el nombre app.py y
seleccione Agregar . Visual Studio abre automáticamente el archivo en una ventana del editor.
3. Copie el siguiente código y péguelo en app.py:
from flask import Flask
# Create an instance of the Flask class that is the WSGI application.

# The first argument is the name of the application module or package,
# typically __name__ when using a single module.
app = Flask(__name__)
# Flask route decorators map / and /hello to the hello function.

# To add other resources, create functions that generate the page contents
# and add decorators to define the appropriate resource locators for them.
@app.route('/')
@app.route('/hello')
def hello():
# Render the page
return "Hello Python!"
if __name__ == '__main__':
# Run the app server on localhost:4449
app.run('localhost', 4449)
1. Haga clic con el botón derecho en el Explorador de soluciones y seleccione Agregar > Nuevo
elemento .
2. En el cuadro de diálogo que aparece, seleccione vacío . En Nombre , escriba app.py y seleccione Agregar .
Visual Studio abre automáticamente el archivo en una ventana del editor.
3. Copie el siguiente código y péguelo en app.py:
# Create an instance of the Flask class that is the WSGI application.

# The first argument is the name of the application module or package,
# typically __name__ when using a single module.
# Flask route decorators map / and /hello to the hello function.

# To add other resources, create functions that generate the page contents
# and add decorators to define the appropriate resource locators for them.
@app.route('/')
def hello():
# Render the page
return "Hello Python!"
if __name__ == '__main__':
# Run the app server on localhost:4449
app.run('localhost', 4449)
Puede haber observado que el cuadro de diálogo Agregar > Nuevo elemento muestra muchos otros tipos de
archivos que puede agregar a un proyecto de Python, como una clase de Python, un paquete de Python, una
prueba unitaria de Python, archivos web.config, etc. En general, estas plantillas de elemento son una excelente
manera de crear rápidamente archivos con código reutilizable útil.
Pregunta: ¿Dónde puedo obtener más información sobre Flask?
Respuesta : Consulte la documentación de Flask, empezando por el inicio rápido de Flask.
Ejecutar la aplicación
1. En el Explorador de soluciones , haga clic con el botón derecho en app.py y después seleccione
Establecer como archivo de inicio en el menú desplegable. Este comando identifica el archivo de
código que se va a iniciar en Python cuando se ejecuta la aplicación.
2. Haga clic con el botón derecho en el proyecto en el Explorador de soluciones y seleccione
Propiedades . Seleccione la pestaña Depurar en el menú Propiedades y establezca la propiedad
Número de puer to en 4449 . Esta configuración garantiza que Visual Studio inicia un explorador con
localhost:4449 para que coincida con los argumentos app.run en el código.
3. Seleccione Depurar > Iniciar sin depurar o presione Ctrl +F5 para guardar los cambios en los
archivos y ejecutar la aplicación.
4. Aparece una ventana de comandos con el mensaje Ejecutando en https://localhost:4449 . Se abre
una ventana del explorador en localhost:4449 y se muestra el mensaje Hello, Python! . La solicitud
GET también aparece en la ventana de comandos con un estado de 200 .
Si un explorador no se abre automáticamente, inicie el explorador que quiera y vaya a localhost:4449 .

Si ve solo el shell interactivo de Python en la ventana de comandos, o si esa ventana parpadea
brevemente en la pantalla, asegúrese de que app.py está establecido como el archivo de inicio.
5. Vaya a localhost:4449/hello para comprobar que el elemento decorador para el recurso /hello
también funciona. Una vez más, la solicitud GET aparece en la ventana de comandos con un estado de
200 . Pruebe también algunas otras direcciones URL para ver que muestran los códigos de estado 404
en la ventana de comandos.
6. Cierre la ventana de comandos para detener la aplicación y, después, cierre la ventana del explorador.
Pregunta: ¿Cuál es la diferencia entre los comandos Iniciar sin depurar e Iniciar depuración?
Respuesta : Iniciar depuración se usa para ejecutar la aplicación en el contexto del depurador de
Visual Studio. Con el depurador, puede establecer puntos de interrupción, examinar variables y recorrer el
código línea a línea. Las aplicaciones se pueden ejecutar más lentamente en el depurador debido a los enlaces
que hacen posible la depuración.
Iniciar sin depurar ejecuta la aplicación directamente, como si la ejecutara desde la línea de comandos, sin
contexto de depuración. Iniciar sin depurar también inicia automáticamente un explorador y navega a la
dirección URL especificada en la pestaña Depurar de las propiedades del proyecto.
Pasos siguientes
Enhorabuena por ejecutar su primera aplicación de Python desde Visual Studio. Ha aprendido los aspectos
básicos sobre el uso de Visual Studio como un IDE de Python.
Implementar la aplicación en Azure App Service
Dado que los pasos realizados en este inicio rápido son bastante genéricos, probablemente se ha dado cuenta
de que se pueden y deben automatizar. Tal automatización es el rol de las plantillas de proyecto de Visual Studio.
Consulte Inicio rápido: Crear un proyecto de Python desde una plantilla para crear una aplicación web similar a
la de este artículo, pero con menos pasos.
Para continuar con un tutorial más completo sobre Python en Visual Studio, incluido el uso de la ventana
interactiva, depuración, visualización de datos y trabajar con Git, vea Tutorial: Introducción a Python en
Visual Studio.
Para explorar más de lo que Visual Studio ofrece, seleccione los siguientes vínculos.
Más información sobre plantillas de proyecto de aplicación web para Python
Más información sobre la depuración de Python
Más información sobre el IDE de Visual Studio en general
Inicio rápido: Crear un proyecto de Python desde
una plantilla en Visual Studio
Después de instalar la compatibilidad con Python en Visual Studio, resulta fácil crear un nuevo proyecto de
Python con diversas plantillas. En este inicio rápido, creará una aplicación sencilla de Flask mediante una
plantilla. El proyecto resultante es similar al proyecto que crea manualmente a través de Inicio rápido: usar
Visual Studio para crear su primera aplicación web Python.
1. Inicie Visual Studio.
2. En la barra de menús superior, seleccione Archivo > Nuevo > Proyecto . Luego, en el cuadro de diálogo
Nuevo proyecto , busque "flask en blanco", seleccione la plantilla Proyecto web de Flask en blanco
en la lista del medio, asigne un nombre al proyecto y seleccione Aceptar :
3. Visual Studio le mostrará un cuadro de diálogo que dice Este proyecto necesita paquetes externos .
Este cuadro de diálogo aparece porque la plantilla incluye un archivo requirements.txt que especifica una
dependencia en Flask. Visual Studio puede instalar automáticamente los paquetes y ofrece la opción de
instalarlos en un entorno virtual. Se recomienda el uso de un entorno virtual frente a la instalación en un
entorno global. Por tanto, seleccione Install into a vir tual environment (Instalar en un entorno
virtual) para continuar.
4. Visual Studio muestra el cuadro de diálogo Agregar entorno vir tual . Acepte el valor predeterminado y
seleccione Crear . A continuación, dé su consentimiento a las solicitudes de elevación.
TIP
Cuando comienza un proyecto, es muy recomendable crear un entorno virtual de inmediato, como la mayoría de
las plantillas de Visual Studio le invitan a hacer. Los entornos virtuales mantienen los requisitos exactos del
proyecto a lo largo del tiempo, a medida que agrega y quita las bibliotecas. Luego puede generar fácilmente un
archivo requirements.txt, que se utiliza para volver a instalar esas dependencias en otros equipos de desarrollo
(como cuando se usa un control de código fuente) y al implementar el proyecto en un servidor de producción.
Para más información sobre los entornos virtuales y sus ventajas, consulte Uso de los entornos virtuales y
Administración de los paquetes necesarios con requirements.txt.
5. Después de que Visual Studio cree ese entorno, busque en el Explorador de soluciones para ver que
tiene un archivo app.py junto con requirements.txt. Abra app.py para ver que la plantilla ha
proporcionado código similar en Inicio rápido: crear su primera aplicación web con Flask, con varias
secciones agregadas. Todo el código que se muestra a continuación se crea mediante la plantilla, por lo
que no necesita pegar nada en app.py.
El código comienza con las importaciones necesarias:

Después está la línea siguiente, que puede resultar útil cuando se implementa una aplicación en un host
web:
wsgi_app = app.wsgi_app
A continuación está el decorador de ruta en una función simple que define una vista:
@app.route('/')
def hello():
"""Renders a sample page."""
return "Hello World!"
Por último está el código de inicio siguiente, que le permite establecer el host y el puerto a través de las
variables de entorno, en lugar de codificarlos de forma rígida. Este código permite controlar fácilmente la
configuración en máquinas de desarrollo y producción sin cambiar el código:
if __name__ == '__main__':
import os
HOST = os.environ.get('SERVER_HOST', 'localhost')
try:
PORT = int(os.environ.get('SERVER_PORT', '5555'))
except ValueError:
PORT = 5555
app.run(HOST, PORT)
6. Seleccione Depurar > Iniciar sin depurar para ejecutar el programa y abrir un explorador en
localhost:5555 .
Pregunta: ¿Qué otras plantillas de Python ofrece Visual Studio?

Respuesta : Con la carga de trabajo de Python instalada, Visual Studio proporciona una variedad de plantillas de
proyecto que incluyen las de los marcos web Flask, Bottle y Django, servicios en la nube de Azure, diferentes
escenarios de aprendizaje automático e incluso una plantilla para crear un proyecto a partir de una estructura
de carpetas existente que contiene una aplicación de Python. Puede acceder a ellas a través del cuadro de
diálogo Archivo > Nuevo > Proyecto seleccionando el nodo de lenguaje Python y sus nodos secundarios.
Visual Studio también proporciona una variedad de plantillas de elemento o archivo para crear rápidamente una
clase de Python, un paquete de Python, una prueba unitaria de Python, archivos web.config, etc. Si tiene abierto
un proyecto de Python, puede acceder a las plantillas de elemento a través del comando de menú Proyecto >
Agregar nuevo elemento . Consulte la referencia sobre plantillas de elemento.
Mediante las plantillas puede ahorrar bastante tiempo al comenzar un proyecto o crear un archivo y también
son una excelente manera de obtener información sobre diferentes tipos de aplicaciones y estructuras de
código. Resulta útil invertir unos minutos en crear proyectos y elementos a partir de las diferentes plantillas
para familiarizarse con lo que ofrecen.
Pregunta: ¿Puedo usar también las plantillas de Cookiecutter?
Respuesta : ¡Sí! De hecho, Visual Studio proporciona integración directa con Cookiecutter. Puede obtener
información sobre esta utilidad en Inicio rápido: crear un proyecto a partir de una plantilla de Cookiecutter.
Pasos siguientes
Tutorial: Uso de Python en Visual Studio
Consulte también
Manually identifying an existing Python interpreter (Identificación manual de un intérprete de Python
existente)
Instalación de la compatibilidad con Python en Visual Studio 2015 y versiones anteriores
Inicio rápido: Apertura y ejecución de código de
Python en una carpeta
Una vez que haya instalado la compatibilidad con Python en Visual Studio 2019, es fácil ejecutar el código de
Python existente en Visual Studio 2019 sin crear un proyecto de Visual Studio.
NOTE
Visual Studio 2017 y las versiones anteriores requieren la creación de un proyecto de Visual Studio para ejecutar el código
de Python, lo que se puede hacer fácilmente mediante una plantilla de proyecto integrada. Consulte Inicio rápido:
Creación de un proyecto de Python a partir del código existente
1. En este tutorial, puede usar cualquier carpeta con código de Python que quiera. Para seguir con el
ejemplo que se muestra aquí, clone el repositorio gregmalcolm/python_koans de GitHub en su equipo
mediante el comando git clone https://github.com/gregmalcolm/python_koans en una carpeta adecuada.
2. Inicie Visual Studio 2019 y, en la ventana de inicio, seleccione Abrir en la parte inferior de la columna
Get star ted (Empezar). De manera alternativa, si ya ejecuta Visual Studio, seleccione en su lugar el
comando Archivo > Abrir > Carpeta .
3. Vaya a la carpeta que contiene el código de Python y elija Seleccionar carpeta . Si usa el código
python_koans, asegúrese de seleccionar la carpeta python3 dentro de la carpeta de clonación.
4. Visual Studio muestra la carpeta en el Explorador de soluciones en lo que se conoce como Vista de
carpetas . Puede expandir y contraer las carpetas con las flechas que aparecen en los bordes izquierdos
de los nombres de las carpetas:
5. Cuando se abre una carpeta de Python, Visual Studio crea varias carpetas ocultas para administrar la
configuración relacionada con el proyecto. Para ver estas carpetas (y cualquier otra carpeta o archivo
oculto, como la carpeta .git), haga clic en el botón de la barra de herramientas Mostrar todos los
archivos :
6. Para ejecutar el código, en primer lugar debe identificar el archivo del programa principal o de inicio. En
el ejemplo que se muestra aquí, el archivo de inicio es contemplate-koans.py. Haga clic con el botón
derecho en ese archivo y seleccione Establecer como elemento de inicio .
IMPORTANT
Si el elemento de inicio no se encuentra en la raíz de la carpeta que abrió, también debe agregar una línea en el
archivo JSON de configuración de inicio, tal como se describe en la sección Establecimiento de un directorio de
trabajo.
7. Para ejecutar el código, presione Ctrl +F5 o seleccione Depurar > Iniciar sin depurar . También puede
hacer clic en el botón de la barra de herramientas que muestra el elemento de inicio con un botón de
reproducción, el que ejecuta el código en el depurador de Visual Studio. En todos los casos, Visual Studio
detecta que el elemento de inicio es un archivo de Python, por lo que ejecuta automáticamente el código
en el entorno de Python predeterminado. (Dicho entorno se muestra a la derecha del elemento de inicio
en la barra de herramientas).
8. La salida del programa aparece en una ventana de comandos independiente:
9. Para ejecutar el código en un entorno distinto, seleccione ese entorno desde el control desplegable en la
barra de herramientas y vuelva a iniciar el elemento de inicio.
10. Para cerrar la carpeta en Visual Studio, seleccione el comando de menú Archivo > Cerrar carpeta .
Establecimiento de un directorio de trabajo

De manera predeterminada, Visual Studio ejecuta un proyecto de Python abierto como una carpeta en la raíz de
la misma carpeta. Sin embargo, el código de proyecto podría suponer que Python se está ejecutando en una
subcarpeta. Por ejemplo, suponga que abre la carpeta raíz del repositorio python_koans y luego establece el
archivo python3/contemplate-koans.py como elemento de inicio. Si luego ejecuta el código, verá un error que
indica que no se encuentra el archivo koans.txt. Este error se produce porque contemplate-koans.py supone que
Python se ejecuta en la carpeta python3 en lugar de la raíz del repositorio.
En tales casos, también debe agregar una línea al archivo JSON de configuración de inicio para especificar el
directorio de trabajo:
1. Haga clic con el botón derecho en el archivo de inicio de Python ( .py) en el Explorador de soluciones y
seleccione Configuración de depuración e inicio .
2. En el cuadro de diálogo Seleccionar depurador que aparece, seleccione Valor predeterminado y
elija Seleccionar .
NOTE
Si Valor predeterminado no aparece como opción, asegúrese de haber elegido un archivo Python .py cuando
seleccionó el comando Configuración de depuración e inicio . Visual Studio usa el tipo de archivo para
determinar las opciones de depurador que se van a mostrar.
3. Visual Studio abre un archivo denominado launch.vs.json, que se encuentra en la carpeta oculta .vs. En
este archivo se describe el contexto de depuración del proyecto. Para especificar un directorio de trabajo,
agregue un valor para "workingDirectory" , como en "workingDirectory": "python3" en el ejemplo de
python-koans:
{
"version": "0.2.1",
"defaults": {},
"configurations": [
{
"type": "python",
"interpreter": "(default)",
"interpreterArguments": "",
"scriptArguments": "",
"env": {},
"nativeDebug": false,
"webBrowserUrl": "",
"project": "python3\\contemplate_koans.py",
"name": "contemplate_koans.py",
"workingDirectory": "python3"
}
]
}
4. Guarde el archivo y vuelva a iniciar el programa, el que ahora se ejecuta en la carpeta especificada.
Pasos siguientes
Vea también
Inicio rápido: Creación de un proyecto de Python a partir del código existente
Inicio rápido: Creación de un proyecto de Python a partir de un repositorio
existente)
Inicio rápido: Crear un proyecto de Python a partir
del código existente
Cuando se ha instalado la compatibilidad con Python en Visual Studio, resulta fácil incorporar el código Python
existente a un proyecto de Visual Studio.
IMPORTANT
El proceso que se describe aquí no mueve ni copia los archivos de código fuente originales. Si quiere trabajar con una
copia, duplique primero la carpeta.
1. Inicie Visual Studio y seleccione Archivo > Nuevo > Proyecto .

2. En el cuadro de diálogo Nuevo proyecto , busque "Python", seleccione la plantilla Desde código de
Python existente , asigne al proyecto un nombre y una ubicación y, después, haga clic en Aceptar .
3. En el asistente que aparece, establezca la ruta de acceso al código existente, así como un filtro para tipos
de archivo, especifique una ruta de acceso de búsqueda que requiera el proyecto y, después, seleccione
Siguiente . Si no sabe cuáles son las rutas de acceso de búsqueda, deje ese campo en blanco.
4. En el siguiente cuadro de diálogo, seleccione el archivo de inicio para el proyecto y, después, Siguiente .
Si quiere, seleccione un entorno; en caso contrario, acepte los valores predeterminados. Tenga en cuenta
que el cuadro de diálogo solo muestra los archivos del directorio raíz; si el archivo que quiere está en una
subcarpeta, deje el archivo de inicio en blanco y establézcalo posteriormente en el Explorador de
soluciones (descrito a continuación).
5. Seleccione la ubicación en la que se va a guardar el archivo del proyecto (un archivo .pyproj en disco). Si
procede, también puede incluir la detección automática de entornos virtuales y personalizar el proyecto
para marcos web diferentes. Si no conoce estas opciones, déjelas con los valores predeterminados.
6. Haga clic en Finalizar . Visual Studio creará el proyecto y lo abrirá en el Explorador de soluciones . Si
quiere mover el archivo .pyproj a otra parte, selecciónelo en el Explorador de soluciones y elija
Archivo > Guardar como . Esta acción actualiza las referencias de archivo en el proyecto pero no mueve
ningún archivo de código.
7. Para establecer otro archivo de inicio, localice el archivo en el Explorador de soluciones , haga clic con
el botón derecho y seleccione Establecer como archivo de inicio .
Si quiere, ejecute el programa presionando Ctrl +F5 or seleccionando Depurar > Iniciar sin depurar .
Pasos siguientes
Consulte también
existente)
Inició rápido: Clonado de un repositorio de código
Cuando haya instalado la compatibilidad con Python en Visual Studio, puede agregar la extensión de GitHub
para Visual Studio. La extensión le permite clonar fácilmente un repositorio de código de Python y crear un
proyecto a partir de allí desde el IDE. Siempre puede clonar repositorios en la línea de comandos y después
trabajar con ellos en Visual Studio.
Instalación de la extensión de GitHub para Visual Studio

Para trabajar con repositorios de GitHub desde VS, debe instalar la extensión de GitHub para Visual Studio. Para
ello, ejecute el instalador de Visual Studio, seleccione Modificar y seleccione la pestaña Componentes
individuales . Desplácese hacia abajo hasta la sección Herramientas de código , seleccione Extensión de
GitHub para Visual Studio y haga clic en Modificar .
Trabajo con GitHub en Visual Studio

2. Seleccione Ver > Team Explorer para abrir la ventana Team Explorer desde la que puede conectarse a
GitHub o Azure Repos, o bien clonar un repositorio. (Si no ve la página Conectar que se muestra a
continuación, seleccione el icono de enchufe en la barra de herramientas superior, que le llevará a esa
página).
3. En Repositorios GIT locales , seleccione el comando Clonar escriba
https://github.com/gregmalcolm/python_koans en el campo de dirección URL, especifique una carpeta para
los archivos clonados y seleccione el botón Clonar .
TIP
La carpeta que especifique en Team Explorer es la carpeta exacta para recibir los archivos clonados. A diferencia
del comando git clone , al crear un clon en Team Explorer no se crea automáticamente una subcarpeta con el
nombre del repositorio.
4. Cuando se complete la clonación, aparecerá el nombre del repositorio en la lista Repositorios GIT
locales . Haga doble clic en ese nombre para ir al panel de repositorio en Team Explorer .
5. En Soluciones , seleccione Nuevo .
6. En el cuadro de diálogo Nuevo proyecto que se muestra, vaya al lenguaje Python (o busque "Python"),
seleccione Desde código de Python existente , especifique un nombre para el proyecto, establezca
Ubicación en la misma carpeta que el repositorio y haga clic en Aceptar . En el asistente que aparece,
seleccione Finalizar .
7. Seleccione Vista > Explorador de soluciones en el menú.
8. En el Explorador de soluciones , expanda el nodo python3 , haga clic con el botón derecho en
contemplate_koans.py y seleccione Establecer como archivo de inicio . Este paso indica a Visual
Studio qué archivo debe utilizar al ejecutar el proyecto.
9. Seleccione Proyecto > Koans Proper ties en el menú, seleccione la pestaña General y establezca
Directorio de trabajo en "python3". Este paso es necesario porque, de forma predeterminada, Visual
Studio establece el directorio de trabajo en la raíz del proyecto en lugar de hacerlo en la ubicación del
archivo de inicio (python3\contemplate_koans.py, que también puede ver en las propiedades del
proyecto). El código de programa busca un archivo koans.txt en la carpeta de trabajo por lo que, si no
cambia este valor, verá un error en tiempo de ejecución.
10. Presione Ctrl +F5 o seleccione Depurar > Iniciar sin depurar para ejecutar el programa. Si ve un
FileNotFoundError para koans.txt, compruebe el directorio de trabajo como se describe en el paso
anterior.
11. Cuando el programa se ejecuta correctamente, muestra un error de aserción en la línea 17 de
python3/koans/about_asserts.py. Este comportamiento es deliberado: el programa está diseñado para
que, con sus correcciones de todos los errores intencionados, se pueda enseñar a Python. (Encontrará
más información en Ruby Koans, en el que se inspira Python Koans).
12. Abra python3/koans/about_asserts.py desde el Explorador de soluciones y haga doble clic en el

archivo. Tenga en cuenta que los números de línea no aparecen de forma predeterminada en el editor.
Para cambiar esta configuración, seleccione Herramientas > Opciones , seleccione Mostrar todas las
configuraciones en la parte inferior del cuadro de diálogo, vaya a Editor de texto > Python >
General y seleccione Números de línea :
13. Para corregir el error, cambie el False argumento de la línea 17 por True . La línea debe indicar lo
siguiente:
self.assertTrue(True) # This should be True

14. Ejecute el programa otra vez. Si Visual Studio le advierte sobre los errores, responda con Sí para
continuar la ejecución de código. Verá entonces que se supera la primera comprobación y el programa se
detiene en el siguiente koan. Siga corrigiendo los errores y ejecutando el programa como quiera.
IMPORTANT
En este inicio rápido, ha creado un clon directo del repositorio python_koans en GitHub. El autor de este repositorio lo
protege de cambios directos, por lo que se produce un error al intentar aplicar cambios. En la práctica, los desarrolladores
bifurcan este repositorio en su propia cuenta de GitHub, efectúan cambios y crean solicitudes de incorporación de
cambios para enviarlos al repositorio original. Cuando tenga su propia rama, use su dirección URL en lugar de la dirección
URL de repositorio original utilizada anteriormente.
Pasos siguientes
Consulte también
existente)
Instalación de la compatibilidad con Python en Visual Studio en Windows
Inicio rápido: Creación de un proyecto a partir de
una plantilla de Cookiecutter
Cuando se ha instalado la compatibilidad con Python en Visual Studio, resulta fácil crear un proyecto a partir de
una plantilla de Cookiecutter, incluidas muchas de las que se publican en GitHub. Cookiecutter proporciona una
interfaz gráfica de usuario para descubrir plantillas, opciones de plantilla de entrada y crear proyectos y
archivos. Se incluye con Visual Studio 2017 y versiones posteriores y puede instalarse por separado en
versiones anteriores de Visual Studio.
1. Para este tutorial rápido, primero debe instalar la distribución de Python Anaconda3, que incluye los
paquetes necesarios de Python para la plantilla de Cookiecutter que se muestra aquí. Ejecute el instalador
de Visual Studio, haga clic en Modificar , expanda las opciones de Desarrollo de Python en el lado
derecho y seleccione Anaconda3 (32 bits o 64 bits). Tenga en cuenta que la instalación puede tardar un
tiempo, según la velocidad de Internet, pero es la manera más sencilla de instalar los paquetes
necesarios.
3. Seleccione Archivo > Nuevo > Desde Cookiecutter . Este comando abre una ventana en Visual Studio
en la que puede buscar plantillas.
4. Seleccione la plantilla Microsoft/python-sklearn-classifier-cookiecutter y, después, haga clic en

Siguiente . (El proceso puede tardar varios minutos la primera vez que use una plantilla en particular, ya
que Visual Studio instala los paquetes de Python necesarios).
5. En el paso siguiente, indique una ubicación para el nuevo proyecto en el campo Crear en y, después,
haga clic en Crear y Abrir proyecto .
6. Una vez completado el proceso, verá el mensaje Archivos creados correctamente con la plantilla... .
El proyecto se abre automáticamente en el Explorador de soluciones.
7. Presione Ctrl +F5 o seleccione Depurar > Iniciar sin depurar para ejecutar el programa.
Pasos siguientes
Vea también
existente)
Instalación de la compatibilidad con Python en
Visual Studio
NOTE
La compatibilidad con Python solo se encuentra disponible actualmente en Visual Studio para Windows. En Mac y Linux, la
compatibilidad con Python está disponible mediante Visual Studio Code.
1. Descargue y ejecute la versión más reciente del Instalador de Visual Studio para Windows. La
compatibilidad con Python está presente en la versión 15.2 y posteriores. Si ya tiene Visual Studio
instalado, ábralo y ejecute el instalador; para ello, seleccione Herramientas > Agregar herramientas
y características .
Instalación de Visual Studio Community
TIP
La edición Community es para desarrolladores individuales, aprendizaje en el aula, investigación académica y
desarrollo de código abierto. Para otros usos, instale Visual Studio Professional o Visual Studio Enterprise.
2. El instalador muestra una lista de las cargas de trabajo, que son grupos de opciones relacionadas para
áreas de desarrollo específicas. Para Python, elija la carga de trabajo Desarrollo de Python y seleccione
Instalar :
3. Para probar rápidamente la compatibilidad con Python, inicie Visual Studio, presione Alt +I para abrir la
ventana interactiva de Python y escriba 2+2 . Si no ve la salida de 4 , revise los pasos.
Paso siguiente
Paso 1: Creación de un proyecto de Python
Consulte también
existente)
Tutorial: Trabajar con Python en Visual Studio
Python es un lenguaje de programación popular confiable, flexible, fácil de aprender y de uso libre en todos los
sistemas operativos. Python es admitido por una gran comunidad de desarrolladores y muchas bibliotecas
gratuitas. El lenguaje admite todo tipo de desarrollo, incluidas las aplicaciones web, los servicios web, las
aplicaciones de escritorio, el scripting y la ciencia computacional. Muchas universidades, científicos,
programadores ocasionales y desarrolladores profesionales usan Python.
Visual Studio proporciona compatibilidad de primera clase con el lenguaje Python. Este tutorial le guiará a
través de los pasos siguientes:
Paso 0: Instalación
Paso 1: Crear un proyecto de Python (este artículo)
Paso 2: Escribir y ejecutar código para ver IntelliSense de Visual Studio en funcionamiento
Paso 3: Crear más código en la ventana interactiva de REPL
Paso 4: Ejecutar el programa completado en el depurador de Visual Studio
Paso 5: Instalar paquetes y administrar entornos de Python
Paso 6: Trabajar con Git
Requisitos previos
Visual Studio 2017 con la carga de trabajo de Python instalada. Para obtener instrucciones, consulte Trabajar
con Python en Visual Studio, paso 0.
También puede usar una versión anterior de Visual Studio con las Herramientas de Python para Visual Studio
instaladas. Consulte Instalación de la compatibilidad con Python en Visual Studio.
Paso 1: Crear un proyecto de Python

Visual Studio usa los proyectos para administrar todos los archivos que se combinan para generar una
aplicación. Los archivos de aplicación incluyen código fuente, recursos y configuraciones. Un proyecto formaliza
y mantiene las relaciones entre todos los archivos del proyecto. El proyecto también administra los recursos
externos que se comparten entre varios proyectos. Un proyecto permite que la aplicación se expanda y crezca
sin esfuerzo. El uso de proyectos es mucho más fácil que administrar manualmente las relaciones en carpetas
ad hoc, scripts, archivos de texto y la memoria.
Este tutorial empieza con un proyecto simple que contiene un único archivo de código vacío.
1. En Visual Studio, seleccione Archivo > Nuevo > Proyecto (Ctrl +Mayús +N ). Se abrirá el cuadro de
diálogo Nuevo proyecto . Aquí puede examinar plantillas de diferentes lenguajes. Seleccione una para el
proyecto y especifique dónde colocará los archivos Visual Studio.
2. Para ver las plantillas de Python, seleccione Instaladas > Python en la parte izquierda o busque
"Python". Si no recuerda la ubicación de una plantilla en el árbol de lenguajes, lo mejor es que use la
búsqueda.
La compatibilidad de Python con Visual Studio incluye varias plantillas de proyecto, incluidas aplicaciones
web que usan los marcos Bottle, Flask y Django. Para los fines de este tutorial, en cambio, comenzaremos
con un proyecto vacío.
3. Elija la plantilla Aplicación de Python , especifique un nombre para el proyecto y seleccione Aceptar .
4. Después de unos minutos, Visual Studio muestra la estructura del proyecto en la ventana del Explorador
de soluciones (1). El archivo de código predeterminado se abre en el editor (2). También aparece la
ventana de propiedades (3), en la que se muestra información adicional sobre los elementos
seleccionados en el Explorador de soluciones , incluida su ubicación exacta en el disco.
5. Tómese su tiempo para familiarizarse con el Explorador de soluciones , que es donde examinará los
archivos y las carpetas del proyecto.
(1) El proyecto está resaltado en negrita. Tiene el nombre que le ha asignado en el cuadro de diálogo
Nuevo proyecto . En el disco, este proyecto se representa mediante un archivo .pyproj en la carpeta del
proyecto.
(2) En el nivel superior se encuentra una solución, que de forma predeterminada tiene el mismo nombre
que el proyecto. Una solución, representada por un archivo .sln en el disco, es un contenedor para uno o
más proyectos relacionados. Por ejemplo, si escribe una extensión de C++ para la aplicación de Python,
ese proyecto de C++ puede estar en la misma solución. La solución también podría contener un proyecto
para un servicio web, junto con proyectos para programas de prueba dedicados.
(3) Bajo el proyecto verá los archivos de código fuente, en este caso, un solo archivo .py. Al seleccionar un
archivo, se muestran sus propiedades en la ventana Propiedades . Si hace doble clic en un archivo, se
abrirá de la manera más adecuada.
(4) Bajo el proyecto también se encuentra el nodo Entornos de Python . Si lo expande, verá los
intérpretes de Python disponibles. Expanda un nodo de intérprete para ver las bibliotecas que se instalan
en ese entorno (5).
Haga clic con el botón derecho en cualquier nodo o elemento del Explorador de soluciones para tener
acceso a un menú con los comandos aplicables. Por ejemplo, el comando Cambiar nombre permite
cambiar el nombre de un nodo o elemento, incluido el proyecto y la solución.
1. En Visual Studio, seleccione Archivo > Nuevo > Proyecto o presione Ctrl +Mayús +N . Aparece la
pantalla Crear un proyecto , donde puede buscar y examinar plantillas en distintos lenguajes.
2. Para ver las plantillas de Python, busque python. Si no recuerda la ubicación de una plantilla en el árbol
de lenguajes, la búsqueda es la mejor solución.
La compatibilidad de Python con Visual Studio incluye varias plantillas de proyecto, incluidas aplicaciones
web en los marcos Bottle, Flask y Django. Para este tutorial, comience con un proyecto vacío.
3. Seleccione la plantilla PythonConsoleApp y seleccione Siguiente .
4. En la pantalla Configurar el nuevo proyecto , especifique un nombre y una ubicación de archivo para
el proyecto y, después, seleccione Crear .
El nuevo proyecto se abre en Visual Studio.
En la ventana Explorador de soluciones de Visual Studio se muestra la estructura del proyecto (1) .
El archivo de código predeterminado se abre en el editor (2) .
En la ventana Propiedades se muestra más información sobre el elemento seleccionado en el
Explorador de soluciones , incluida su ubicación exacta en el disco (3) .
5. Familiarícese con el Explorador de soluciones , que es donde puede examinar los archivos y las
carpetas del proyecto.
En el nivel superior se encuentra la solución, que, de forma predeterminada, tiene el mismo

nombre que el proyecto (1) .
Una solución, que aparece como un archivo .sln en el disco, es un contenedor de uno o más
proyectos relacionados. Por ejemplo, si escribe una extensión de C++ para la aplicación de Python,
ese proyecto de C++ puede estar en la misma solución. La solución también podría contener un
proyecto para un servicio web, además de los proyectos para programas de prueba dedicados.
El proyecto, con el nombre que le dio en el cuadro de diálogo Crear un proyecto , aparece en
negrita (2) . En el disco, este proyecto es un archivo .pyproj en la carpeta del proyecto.
Bajo el proyecto están los archivos de código fuente, en este caso, un solo archivo .py (3) . Al
seleccionar un archivo, se muestran sus propiedades en la ventana Propiedades . Si hace doble
clic en un archivo, se abrirá de la manera más adecuada.
Bajo el proyecto también se encuentra el nodo Entornos de Python (4) . Expanda el nodo para
mostrar los intérpretes de Python disponibles.
Expanda un nodo de intérprete para ver las bibliotecas instaladas en ese entorno (5) .
Haga clic con el botón derecho en cualquier nodo o elemento del Explorador de soluciones para
mostrar un menú contextual con los comandos aplicables. Por ejemplo, Cambiar nombre permite
cambiar el nombre de un nodo o elemento, incluidos el proyecto y la solución.
Paso siguiente
Escritura y ejecución de código
Profundizar un poco más

Proyectos de Python en Visual Studio.
Obtenga información sobre el lenguaje Python en python.org
Python para principiantes (python.org)
Paso 2: Escribir y ejecutar código
Paso anterior : Crear un nuevo proyecto de Python

Aunque el Explorador de soluciones es donde se administran los archivos del proyecto, la ventana editor
suele ser donde se trabaja con los contenidos de los archivos, como el código fuente. El editor es sensible al
contexto del tipo de archivo que está editando, incluido el lenguaje de programación (basado en la extensión del
archivo) y ofrece características apropiadas para ese lenguaje, como el color de la sintaxis y la finalización
automática de IntelliSense.
1. Después de crear un nuevo proyecto como "Aplicación de Python", se abre un archivo vacío
predeterminado PythonApplication1.py en el editor de Visual Studio.
2. En el editor, comience a escribir print("Hello, Visual Studio") y observe cómo Visual Studio IntelliSense
muestra opciones de finalización automática mientras escribe. La opción destacada en la lista desplegable
se corresponde con la versión predeterminada que se usaba al presionar la tecla Tab . Las finalizaciones
son muy útiles cuando se trata de identificadores o instrucciones más largas.
3. IntelliSense muestra información diferente en función de la instrucción utilizada, la función invocada, etc.
Con la función print , al escribir ( tras print para indicar una llamada a la función, se muestra
información completa de uso para esa función. La ventana emergente de IntelliSense muestra también el
argumento actual en negrita (value tal y como se muestra aquí):
4. Complete la instrucción para que coincida con lo siguiente:
print("Hello, Visual Studio")
5. Tenga en cuenta el color de la sintaxis que diferencia la instrucción print del argumento
"Hello Visual Studio" . Además, elimine temporalmente el último " de la cadena y observe cómo
Visual Studio muestra un subrayado rojo en el código que contiene errores de sintaxis. Luego, vuelva a
colocar " para corregir el código.
TIP
Puesto que el entorno de desarrollo de cada uno es muy personal, Visual Studio ofrece un control completo de su
apariencia y comportamiento. Seleccione el comando de menú Herramientas > Opciones y explore los valores
de las pestañas Entorno y Editor de texto . De forma predeterminada, solo se ve un número limitado de
opciones. Para ver todas las opciones de todos los lenguajes de programación, seleccione Mostrar todas las
configuraciones en la parte inferior del cuadro de diálogo.
6. Ejecute el código que ha escrito hasta este punto pulsando Ctrl +F5 o seleccionando el elemento de
menú Depurar > Iniciar sin depurar . Visual Studio le advierte si todavía hay errores en el código.
7. Al ejecutar el programa, aparece una ventana de consola que muestra los resultados, como si ejecutara
un intérprete de Python con PythonApplication1.py desde la línea de comandos. Presione una tecla para
cerrar la ventana y volver al editor de Visual Studio.
8. Además de finalizaciones para instrucciones y funciones, IntelliSense ofrece finalizaciones para las
instrucciones import y from de Python. Estas finalizaciones le ayudan a detectar fácilmente qué
módulos están disponibles en su entorno y los miembros de esos módulos. En el editor, elimine la línea
print y comience a escribir import . Cuando se escribe el espacio, aparece una lista de módulos:
9. Escriba o seleccione sys para completar la línea.

10. En la línea siguiente, escriba from para volver a ver una lista de módulos:
11. Seleccione o escriba math , luego agregue un espacio y import , para mostrar los miembros del módulo:
12. Para terminar, importe los miembros sin , cos y radians , con las finalizaciones automáticas
disponibles para cada uno de ellos. Cuando haya terminado, el código debería aparecer como sigue:
import sys
from math import cos, radians
TIP
Las finalizaciones se activan con las subcadenas a medida que escribe, mostrando coincidencias con partes de
palabras, letras al principio de las palabras e incluso caracteres omitidos. Vea Edición de código: finalizaciones para
obtener información.
13. Agregue un poco más de código para imprimir los valores de coseno de 360 grados:
for i in range(360):
print(cos(radians(i)))
14. Vuelva a ejecutar el programa con Ctrl +F5 o Depurar > Iniciar sin depurar . Cuando haya terminado,
cierre la ventana de salida.
Paso siguiente
Usar la ventana interactiva de REPL

Editar código
Código de formato
Refactorizar código
Usar PyLint
Paso 3: Usar la ventana interactiva de REPL
Paso anterior : Escribir y ejecutar código

La ventana interactiva de Visual Studio para Python proporciona una experiencia de lectura-evaluación-
impresión-repetición (REPL) que reduce considerablemente el ciclo habitual de edición-compilación-depuración.
La ventana interactiva proporciona todas las funciones de la experiencia de REPL de la línea de comandos de
Python. También resulta muy fácil intercambiar el código con archivos de código fuente en el editor de Visual
Studio, que en otros casos es complicado con la línea de comandos.
NOTE
Si tiene problemas con REPL, asegúrese de tener instalados los paquetes ipython y ipykernel . Si necesita instalar
paquetes, consulte la pestaña de los paquetes de los entornos de Python.
1. Abra la ventana interactiva haciendo clic con el botón derecho en el entorno de Python del proyecto en
el Explorador de soluciones (por ejemplo, Python 3.6 (32 bits) como se muestra en un gráfico
anterior) y seleccione Abrir ventana interactiva . Como alternativa, puede seleccionar Ver > Otras
ventanas > Ventanas interactivas de Python en el menú principal de Visual Studio.
2. Se abre la ventana interactiva debajo del editor, con el símbolo estándar del sistema de REPL de Python
>>> . La lista desplegable Plataforma permite seleccionar un intérprete específico con el que trabajar. En
muchas ocasiones también querrá aumentar el tamaño de la ventana interactiva , lo que puede hacer si
arrastra el separador entre las dos ventanas:
TIP
Puede cambiar el tamaño de todas las ventanas en Visual Studio si arrastra los separadores de los bordes. También
puede arrastrar las ventanas independientemente del marco de Visual Studio y reorganizarlas como prefiera
dentro del marco. Para más información, vea Personalizar los diseños de ventana.
3. Escriba algunas instrucciones (como print("Hello, Visual Studio") ) y expresiones (como 123/456 ) para
ver los resultados inmediatos:
4. Al empezar a escribir una instrucción multilínea, como una definición de función, en la ventana
interactiva se muestra el símbolo ... de Python para las líneas siguientes que, a diferencia de la línea de
comandos de REPL, proporciona una sangría automática. Para agregar una línea nueva ... , presione
Shift+Enter :
5. La ventana interactiva proporciona un historial completo de todo lo que ha escrito y ofrece mejoras con
respecto a la línea de comandos de REPL con elementos de historial multilínea. Por ejemplo, puede
recuperar fácilmente la definición completa de la función f como una única unidad y cambiar el nombre
con facilidad a make_double , en lugar de tener que volver a crear la función línea por línea.
6. En Visual Studio se pueden enviar varias líneas de código desde una ventana del editor a la ventana
interactiva . Esta característica permite mantener el código en un archivo de origen y enviar con facilidad
elementos seleccionados a la ventana interactiva . Después, puede trabajar con estos fragmentos de
código en el entorno de REPL rápido en lugar de tener que ejecutar el programa completo. Para ver esta
característica, reemplace el bucle for del archivo PythonApplication1.py por lo siguiente:
# Create a string with spaces proportional to a cosine of x in degrees

def make_dot_string(x):
return ' ' * int(20 * cos(radians(x)) + 20) + 'o'
7. Seleccione las instrucciones de función import , from y make_dot_string en el archivo .py. Haga clic con
el botón derecho del texto seleccionado y elija Enviar a interactivo (o presione Ctrl +ENTRAR ). El
fragmento de código se pega inmediatamente en la ventana interactiva y se ejecuta. Dado que el código
ha definido una función, puede probarla rápidamente si la invoca varias veces:
TIP
Al presionar Ctrl+Entrar en el editor sin una selección se ejecuta la línea de código actual en la ventana
interactiva y se coloca automáticamente el símbolo de intercalación en la línea siguiente. Con esta característica,
puede presionar varias veces Ctrl+Entrar para recorrer el código, algo que no era posible hacer solo con la línea
de comandos de Python. También permite recorrer el código sin ejecutar el depurador y sin necesidad de iniciar el
programa desde el principio.
8. También puede copiar y pegar varias líneas de código en la ventana interactiva desde cualquier origen,
como el fragmento de código siguiente, lo que es difícil de hacer con el REPL de la línea de comandos de
Python. Cuando se pega, la ventana interactiva ejecuta el código como si se hubiera escrito:
for i in range(360):
s = make_dot_string(i)
print(s)
9. Como puede ver, este código funciona correctamente, pero su salida no es muy interesante. Un valor de
paso diferente en el bucle for mostraría más cantidad de la onda del coseno. Afortunadamente, como
todo el bucle for aparece en el historial de REPL como una única unidad, se puede volver atrás con
facilidad para realizar los cambios que quiera y probar la función de nuevo. Presione la tecla Flecha arriba
para recuperar primero el bucle for . Después, presione las teclas Flecha izquierda o Flecha derecha para
empezar a navegar en el código (hasta que lo haga, las teclas Flecha arriba y Flecha abajo continúan
recorriendo el historial). Vaya a la especificación range y cámbiela por range(0, 360, 12) . Después,
presione Ctrl +Entrar (en cualquier lugar del código) para volver a ejecutar la instrucción completa:
10. Repita el proceso para experimentar con valores de paso diferentes hasta que encuentre el que más le
guste. También puede hacer que se repita la onda si amplía el intervalo, por ejemplo, range(0, 1800, 12) .
11. Cuando esté satisfecho con el código que escribió en la ventana Interactiva , selecciónelo. A
continuación, haga clic con el botón derecho en el código y elija Copiar código (Ctrl +Mayús +C ). Por
último, pegue el código seleccionado en el editor. Observe que esta característica especial de Visual
Studio omite automáticamente cualquier salida y los símbolos >>> y ... . Por ejemplo, en la imagen
siguiente se muestra el uso del comando Copiar código en una selección que incluye los símbolos y la
salida:
Al pegar en el editor, solamente se obtiene el código:
for i in range(0, 1800, 12):

print(s)
Si quiere copiar el contenido exacto de la ventana interactiva , incluidos los símbolos y la salida, use el
comando Copiar estándar.
12. Lo que acaba de hacer es usar el entorno de REPL rápido de la ventana interactiva para elaborar los
detalles de un pequeño fragmento de código y después lo ha agregado cómodamente al archivo de
código fuente del proyecto. Si ahora vuelve a ejecutar el código con Ctrl +F5 (o Depurar > Iniciar sin
depurar ), verá los resultados exactos que quería.
Paso siguiente
Ejecución de código en el depurador

Uso de la ventana interactiva
Uso de IPython en la ventana interactiva (REPL)
Paso 4: Ejecución de código en el depurador
Paso anterior : Uso de la ventana interactiva de REPL

Además de administrar proyectos, ofrecer una experiencia de edición enriquecida y la ventana interactiva ,
Visual Studio proporciona una depuración completa para el código Python. En el depurador, puede ejecutar el
código paso a paso, incluida cada una de las iteraciones de un bucle. También puede pausar el programa cuando
ciertas condiciones sean verdaderas. En cualquier momento en el que el programa esté pausado en el
depurador, puede examinar el estado del programa completo y cambiar el valor de las variables. Estas acciones
son esenciales para el seguimiento de los errores de programa y también proporcionan una ayuda muy útil
para seguir con cuidado el flujo del programa exacto.
1. Reemplace el código del archivo PythonApplication1.py por lo siguiente. Esta variación del código
expande make_dot_string para que pueda examinar sus pasos discretos en el depurador. También coloca
el bucle for en una función main y lo ejecuta explícitamente mediante una llamada a esa función:
from math import cos, radians
# Create a string with spaces proportional to a cosine of x in degrees

def make_dot_string(x):
rad = radians(x) # cos works with radians
numspaces = int(20 * cos(rad) + 20) # scale to 0-40 spaces
st = ' ' * numspaces + 'o' # place 'o' after the spaces
return st
def main():
for i in range(0, 1800, 12):
print(s)
main()
2. Compruebe que el código funciona correctamente presionando F5 o seleccionando el comando de menú

Depurar > Iniciar depuración . Este comando ejecuta el código en el depurador, pero dado que aún no
ha hecho nada para pausar el programa mientras se está ejecutando, solo imprime un patrón ondulado
para algunas iteraciones. Presione cualquier tecla para cerrar la ventana de salida.
TIP
Para cerrar la ventana de salida automáticamente cuando se complete el programa, seleccione el comando de
menú Herramientas > Opciones , expanda el nodo Python , seleccione Depuración y, después, desactive la
opción Esperar la entrada cuando el proceso se cierre normalmente :
Para obtener información adicional sobre la depuración, incluidas tareas como establecer argumentos de script e
intérprete, vea Depuración del código de Python.
3. Establezca un punto de interrupción en la instrucción for haciendo clic una vez en el margen gris junto
a esa línea o colocando el operador exponencial en dicha línea y usando el comando Depurar >
Alternar puntos de interrupción (F9 ). Aparecerá un punto rojo en el margen gris para indicar el
punto de interrupción (como indica la flecha a continuación):
4. Vuelva a iniciar el depurador (F5 ) y verá que, al ejecutar el código, se detiene en la línea en que se ha
establecido el punto de interrupción. Aquí puede inspeccionar la pila de llamadas y examinar variables.
Las variables que están en dentro del ámbito aparecen en la ventana Automático cuando están
definidas; también puede cambiar a la vista Variables locales , situada en la parte inferior de esa
ventana, para mostrar todas las variables que Visual Studio encuentre en el ámbito actual (influidas
funciones), incluso antes de que se definan:
5. Observe la barra de herramientas de depuración (que se muestra a continuación) a lo largo de la parte
superior de la ventana de Visual Studio. Esta barra de herramientas proporciona acceso rápido a los
comandos de depuración más comunes (que también se pueden encontrar en el menú Depurar ):
Los botones son los siguientes de izquierda a derecha:

Continuar (F5 ) ejecuta el programa hasta el siguiente punto de interrupción o hasta la finalización
del programa.
Interrumpir todo (Ctrl +Alt +Inter ) pone en pausa un programa de ejecución prolongada.
Detener depuración (Mayús +F5 ) detiene el programa dondequiera que esté y sale del depurador.
Reiniciar (Ctrl +Mayús +F5 ) detiene el programa dondequiera que esté y lo reinicia desde el
principio en el depurador.
Mostrar la instrucción siguiente (Alt +Núm * ) cambia a la siguiente línea de código que se debe
ejecutar. Esto resulta especialmente útil si al navegar por el código durante una sesión de depuración
desea volver rápidamente al punto donde se pausó el depurador.
Paso a paso por instrucciones (F11 ) ejecuta la siguiente línea de código, entrando en las funciones
llamadas.
Paso a paso por procedimientos (F10 ) ejecuta la siguiente línea de código sin entrar en las
funciones llamadas.
Paso a paso para salir (Mayús +F11 ) ejecuta el resto de la función actual y se pausa en el código
de llamada.
6. Depure paso a paso por procedimientos la instrucción for mediante Paso a paso por
procedimientos . La ejecución paso a paso significa que el depurador ejecuta la línea de código actual,
incluidas las llamadas de función y luego se pone en pausa otra vez inmediatamente. Observe cómo la
variable i ahora está definida en las ventanas Variables locales y Automático .
7. Depure paso a paso por procedimientos la siguiente línea de código, que llama a make_dot_string y se
pone en pausa. Depurar paso a paso significa aquí que el depurador ejecuta toda la función
make_dot_string y se pone en pausa cuando se devuelve. El depurador no se detiene dentro de esa
función a menos que exista un punto de interrupción independiente.
8. Continúe ejecutando paso a paso por procedimientos el código varias veces y observe cómo cambian los
valores de las ventanas Variables locales o Automático .
9. En la ventana Variables locales o Automático , haga doble clic en la columna Valor para las variables
i o s a fin de editar el valor. Presione ENTRAR o haga clic en cualquier área fuera de ese valor para
aplicar los cambios.
10. Continúe ejecutando paso a paso el código usando Paso a paso por instrucciones . Depurar paso a
paso por instrucciones significa que el depurador entra dentro de cualquier llamada de función para la
que tenga información de depuración, como make_dot_string . Una vez dentro de make_dot_string puede
examinar sus variables locales y recorrer su código en concreto.
11. Continúe con la ejecución paso a paso por instrucciones y tenga en cuenta que, cuando llegue al final
de la función make_dot_string , el paso siguiente vuelve al bucle for con el nuevo valor devuelto en la
variable s . Mientras ejecuta de nuevo la instrucción print , observe que paso a paso por
instrucciones en print no entra en esa función. Esto se debe a que print no está escrita en Python,
sino que es código nativo dentro del tiempo de ejecución de Python.
12. Continúe usando Paso a paso por instrucciones hasta que esté de nuevo en la mitad de
make_dot_string . Luego, use Paso a paso para salir y observe que vuelve al bucle for . Con Paso a
paso para salir , el depurador ejecuta el resto de la función y, luego, se pausa automáticamente en el
código de llamada. Esto resulta muy útil cuando ha recorrido una parte de una función larga que desea
depurar, pero no necesita recorrer el resto y no desea establecer un punto de interrupción explícito en el
código de llamada.
13. Para continuar ejecutando el programa hasta que se alcance el siguiente punto de interrupción, use
Continuar (F5 ). Puesto que hay un punto de interrupción en el bucle for , la interrupción se producirá
en la siguiente iteración.
14. Recorrer cientos de iteraciones de un bucle puede resultar tedioso, por lo que Visual Studio le permite
agregar una condición a un punto de interrupción. De esta forma, el depurador pausa el programa en el
punto de interrupción solo cuando se cumple la condición. Por ejemplo, puede usar una condición con el
punto de interrupción en la instrucción for de modo que solo se ponga en pausa cuando el valor de i
sea superior a 1600. Para establecer una condición, haga clic con el botón derecho en el punto rojo del
punto de interrupción y seleccione Condiciones (Alt +F9 > C ). En el elemento emergente
Configuración del punto de interrupción que aparece, escriba i > 1600 como expresión y
seleccione Cerrar . Presione F5 para continuar y observe que el programa ejecuta muchas iteraciones
antes de la interrupción siguiente.
15. Para ejecutar el programa hasta su finalización, deshabilite el punto de interrupción haciendo clic con el
botón derecho en el punto del margen y seleccionando Deshabilitar punto de interrupción
(Ctrl +F9 ). Luego, seleccione Continuar (o presione F5 ) para ejecutar el programa. Cuando se finalice el
programa, Visual Studio detiene la sesión de depuración y vuelve a su modo de edición. Tenga en cuenta
que también puede eliminar el punto de interrupción si selecciona su punto o hace clic con el botón
derecho en el punto y selecciona Eliminar punto de interrupción , pero eso también elimina cualquier
condición que haya establecido.
TIP
En algunas situaciones, como un error al iniciar el intérprete de Python, la ventana de salida puede aparecer solo
brevemente y luego cerrarse de forma automática sin darle la oportunidad de ver los mensajes de error. Si esto ocurre,
haga clic con el botón derecho en el proyecto en el Explorador de soluciones , seleccione Propiedades , la pestaña
Depurar y, después, agregue -i al campo Argumentos del intérprete . Este argumento hace que el intérprete entre
en modo interactivo una vez que se haya finalizado un programa, con lo que la ventana se mantendrá abierta hasta que
pulse Ctrl+Z > Entrar para salir.
Paso siguiente
Instalar paquetes en un entorno de Python

Depuración
Debugging in Visual Studio (Depurar en Visual Studio) ofrece documentación completa sobre las
características de depuración de Visual Studio.
Paso 5: Instalación de paquetes en el entorno de
Python
Paso anterior : Ejecución de código en el depurador

La comunidad de desarrolladores de Python ha generado miles de paquetes útiles que puede incorporar a sus
proyectos. Visual Studio proporciona una interfaz de usuario para administrar paquetes en los entornos de
Python.
Ver entornos
1. Seleccione el comando de menú Vista > Otras ventanas > Entornos de Python . La ventana
Entornos de Python se abre como un elemento del mismo nivel para el Explorador de soluciones y
muestra los distintos entornos disponibles. La lista muestra los entornos que ha instalado mediante el
instalador de Visual Studio y los que ha instalado por separado. Esto incluye entornos globales, virtuales
y de Conda. El entorno en negrita es el entorno predeterminado que se usa para los nuevos proyectos.
Para obtener información adicional sobre cómo trabajar con entornos, vea Creación y administración de
entornos de Python en Visual Studio.
NOTE
Otra manera de abrir la ventana Entornos de Python es seleccionar la ventana Explorador de soluciones y usar el
método abreviado de teclado Ctrl + K, Ctrl + ' . Si el acceso directo no funciona y no encuentra la ventana
Entornos de Python en el menú, es posible que no haya instalado la carga de trabajo de Python. Vea Instalación
de la compatibilidad con Python en Visual Studio para obtener instrucciones sobre cómo instalar Python.
2. La pestaña Introducción del entorno proporciona acceso rápido a una ventana interactiva para ese
entorno junto con la carpeta de instalación y los intérpretes del entorno. Por ejemplo, al seleccionar Abrir
ventana interactiva se muestra una ventana interactiva para ese entorno específico en Visual Studio.
3. Ahora, cree un proyecto con Archivo > Nuevo > Proyecto y seleccione la plantilla Aplicación Python .
En el archivo de código que aparece, pegue el código siguiente, que crea una onda de coseno como en
los pasos del tutorial anteriores, pero esta vez trazada en un gráfico. Como alternativa, puede usar el
proyecto que creó anteriormente y reemplazar el código.
from math import radians

import numpy as np # installed with matplotlib
import matplotlib.pyplot as plt
def main():
x = np.arange(0, radians(1800), radians(12))
plt.plot(x, np.cos(x), 'b')
plt.show()
main()
4. Con un proyecto de Python abierto, también puede abrir la ventana Entornos de Python desde
Explorador de soluciones. Basta con hacer clic con el botón derecho en Entornos de Python y
seleccionar Ver todos los entornos de Python .
5. Al examinar la ventana del editor, observará que, si mantiene el puntero sobre las instrucciones Import
numpy e matplotlib , no están resueltas. Esto se debe a que los paquetes no se han instalado en el
entorno global predeterminado.
Instalación de paquetes con la ventana Entornos de Python
1. En la ventana Entornos de Python, seleccione el entorno predeterminado para los nuevos proyectos de
Python y elija la pestaña Paquetes . Verá una lista de los paquetes que están instalados actualmente en el
entorno.
2. Para instalar matplotlib , escriba su nombre en el campo de búsqueda y, después, seleccione la opción
Ejecutar comando: pip install matplotlib . Esto instalará matplotlib , así como los paquetes de los
que depende (en este caso, numpy ).
3. Si se le pide, dé su consentimiento para la elevación.
4. Una vez instalado el paquete, aparece en la ventana Entornos de Python . La X situada a la derecha del
paquete lo desinstala.
NOTE
Una barra de progreso pequeña podría aparecer debajo del entorno para indicar que Visual Studio está
compilando la base de datos de IntelliSense para el paquete recién instalado. La pestaña IntelliSense también
muestra información más detallada. Tenga en cuenta que hasta que se complete la base de datos, las
características de IntelliSense, como la finalización automática y la comprobación de sintaxis, no estarán activas en
el editor de ese paquete.
Visual Studio 2017, versión 15.6 y versiones posteriores, utiliza otro método más rápido para trabajar con
IntelliSense y muestra un mensaje a tal efecto en la pestaña IntelliSense .
Ejecutar el programa
1. Ahora que matplotlib está instalado, ejecute el programa con (F5 ) o sin el depurador (Ctrl +F5 ) para ver
el resultado:
Paso siguiente
Trabajar con Git

Entornos de Python
Información sobre Django en Visual Studio
Información sobre Flask en Visual Studio
Paso 6: Trabajar con Git
Paso anterior : Instalar paquetes en un entorno de Python
Adición de control de código fuente Git

Ahora que ha creado una aplicación, es posible que quiera agregarla a un repositorio de Git. Tenemos lo que
necesita. Visual Studio facilita el proceso con las herramientas de Git que puede usar directamente desde el IDE.
TIP
Git es el sistema de control de versiones moderno más usado, por lo que, tanto si es un desarrollador profesional como si
está aprendiendo a codificar, Git puede ser muy útil. Si ha empezado a usar Git recientemente, el sitio web https://git-
scm.com/ es un buen punto de partida. Allí encontrará hojas de referencia rápida, un libro en línea conocido y vídeos de
conceptos básicos de Git.
Para asociar el código a Git, empiece por crear un nuevo repositorio de Git donde se encuentra el código. A
continuación se muestra cómo hacerlo:
1. En la barra de estado de la esquina inferior derecha de Visual Studio, seleccione Agregar al control de
código fuente y, a continuación, Git .
2. Cuadro de diálogo Crear un repositorio GIT inicie sesión en GitHub.

El nombre del repositorio se rellena automáticamente en función de la ubicación de la carpeta. De forma
predeterminada, el nuevo repositorio es privado, lo que significa que usted es el único que puede acceder
a él.
TIP
Tanto si el repositorio es público como privado, es mejor tener una copia de seguridad remota del código
almacenada de forma segura en GitHub. Incluso si no trabaja con un equipo, un repositorio remoto pone el
código a su disposición desde cualquier equipo.
3. Seleccione Crear e inser tar .

Después de crear el repositorio, verá los detalles de estado en la barra de estado.
El primer icono con las flechas muestra cuántas confirmaciones salientes o entrantes hay en la rama
actual. Puede usar este icono para extraer las confirmaciones entrantes o insertar las confirmaciones
salientes. Puede elegir ver estas confirmaciones en primer lugar. Para ello, seleccione el icono y, a
continuación, Ver salientes y entrantes .
El segundo icono con el lápiz muestra el número de cambios no confirmados en el código. Puede
seleccionar este icono para ver esos cambios en la ventana Cambios de Git .
Para obtener más información sobre cómo usar Git con la aplicación, consulte la documentación del control de
versiones de Visual Studio.
Visual Studio proporciona integración directa con repositorios de Git locales y repositorios remotos en servicios
como GitHub y Azure Repos. La integración incluye clonar un repositorio, confirmar los cambios y administrar
ramas.
En este artículo se proporciona una introducción básica sobre la creación de un repositorio de Git local para un
proyecto existente e información para familiarizarse con algunas características relacionadas con Git de Visual
Studio.
1. Con un proyecto abierto en Visual Studio, como el proyecto del paso anterior, haga clic con el botón
derecho en la solución y seleccione Agregar solución al control de código fuente . Visual Studio crea
un repositorio de Git local que contiene el código del proyecto.
2. Cuando Visual Studio detecta que el proyecto se administra en un repositorio de Git, aparecen controles
relacionados con Git en la esquina inferior derecha de la ventana de Visual Studio. Los controles
muestran confirmaciones pendientes, cambios, el nombre del repositorio y la rama. Mantenga el puntero
sobre los controles para ver más información.
3. Al crear un nuevo repositorio o seleccionar cualquiera de los controles de Git, Visual Studio abre la
ventana Team Explorer . (Puede abrir la ventana en cualquier momento con el comando de menú Vista
> Team Explorer ). La ventana tiene tres paneles principales, entre los que puede cambiar mediante la
lista desplegable del encabezado de Team Explorer . El panel Sincronización panel, que proporciona
operaciones de publicación, también aparece cuando se selecciona el control de inserción (el icono de
flecha arriba):
4. Seleccione Cambios (o el control de Git con el icono de lápiz) para revisar cambios sin confirmar y
confirmarlos cuando quiera.
Haga doble clic en un archivo en la lista Cambios para abrir una vista de diferencias para dicho archivo:
5. Seleccione Ramas (o el control de Git con un nombre de rama) para examinar ramas y realizar
operaciones de combinar y fusionar mediante cambio de base:
6. Al seleccionar el control de Git con el nombre del repositorio (CosineWave en una imagen anterior),
Team Explorer muestra una interfaz Conectar con la que puede cambiar rápidamente a otro
repositorio por completo.
7. Cuando se usa un repositorio local, los cambios confirmados van directamente al repositorio. Si está
conectado a un repositorio remoto, seleccione el encabezado desplegable en Team Explorer , elija
Sincronización para cambiar a la sección Sincronización y trabaje con los comandos pull y fetch
incluidos allí.

Para ver un breve tutorial de creación de un proyecto desde un repositorio de Git remoto, vea Inició rápido:
Clonado de un repositorio de código Python en Visual Studio.
Para ver un tutorial mucho más completo, incluido el control de conflictos de combinación, la revisión de código
con solicitudes de incorporación de cambios, la reorganización y la selección exclusiva de cambios entre ramas,
consulte Get Started with Git and Azure Repos (Introducción a Git y Azure Repos).
Revisión del tutorial

Enhorabuena por completar este tutorial sobre Python en Visual Studio. En este tutorial ha aprendido a:
Crear proyectos y ver el contenido de un proyecto.
Usar el editor de código y ejecutar un proyecto.
Usar la ventana interactiva para desarrollar nuevo código y copiar fácilmente ese código en el editor.
Ejecutar el programa completado en el depurador de Visual Studio.
Instalar paquetes y administrar entornos de Python.
Trabajar con código en un repositorio de Git.
Desde aquí, explore los conceptos y las guías de procedimientos, incluidos los siguientes artículos:
Publicación en Azure App Service
Pruebas unitarias
Tutorial: Introducción al marco web de Django en
Visual Studio
Django es un marco de Python de alto nivel diseñado para el desarrollo web rápido, seguro y escalable. En este
tutorial se explora la plataforma de Django en el contexto de las plantillas de proyecto que proporciona Visual
Studio para simplificar la creación de aplicaciones web basadas en Django.
En este tutorial aprenderá a:
Crear un proyecto básico de Django en un repositorio de Git con la plantilla "Proyecto web de Django en
blanco" (paso 1)
Crear una aplicación de Django con una página y representar esa página con una plantilla (paso 2)
Atender archivos estáticos, agregar páginas y usar la herencia de plantilla (paso 3)
Utilizar la plantilla Proyecto web de Django para crear una aplicación con varias páginas y diseño con
capacidad de respuesta (paso 4)
Autenticar usuarios (paso 5)
Usar la plantilla Proyecto web de Django de sondeos para crear una aplicación que use modelos,
migraciones de base de datos y personalizaciones para la interfaz administrativa (paso 6)
Crear un proyecto básico de Django en un repositorio de Git con la plantilla "Proyecto web de Django en
blanco" (paso 1)
Crear una aplicación de Django con una página y representar esa página con una plantilla (paso 2)
Utilizar la plantilla Proyecto web de Django para crear una aplicación con varias páginas y diseño con
capacidad de respuesta (paso 4)
Autenticar usuarios (paso 5)
Prerequisites
Visual Studio 2017 o posterior en Windows con las siguientes opciones:
La carga de trabajo Desarrollo de Python (pestaña Carga de trabajo del instalador). Para obtener
instrucciones, vea Instalación de la compatibilidad con Python en Visual Studio en Windows.
Git para Windows y Extensión de GitHub para Visual Studio en la pestaña Componentes
individuales de Herramientas de código .
Las plantillas de proyecto de Django también se incluyen con todas las versiones anteriores de las Herramientas
de Python para Visual Studio, aunque los detalles pueden diferir de aquello que se describe en este tutorial
(especialmente respecto de las versiones anteriores de la plataforma Django).
El desarrollo de Python no es compatible actualmente en Visual Studio para Mac. En Mac y Linux, use la
extensión de Python en Visual Studio Code.
"Proyectos de Visual Studio" y "proyectos de Django"
En la terminología de Django, un "proyecto de Django" se compone de varios archivos de configuración de nivel
de sitio junto con una o varias "aplicaciones" que el usuario implementa en un host web para crear una
aplicación web completa. Un proyecto de Django puede contener varias aplicaciones, y la misma aplicación
puede estar en varios proyectos de Django.
Un proyecto de Visual Studio, por su parte, puede contener el proyecto de Django junto con varias aplicaciones.
Para facilitar la lectura, siempre que en este tutorial se mencione simplemente a"proyecto", nos estaremos
refiriendo al proyecto de Visual Studio. Cuando se haga referencia a la parte del "proyecto de Django" de la
aplicación web, usaremos específicamente "proyecto de Django".
En el transcurso de este tutorial creará una única solución de Visual Studio que contiene tres proyectos de
Django independientes, cada uno de los cuales contiene una única aplicación de Django. Al mantener los
proyectos en la misma solución, puede cambiar fácilmente entre distintos archivos para compararlos.
Paso 1.1: Crear una solución y un proyecto de Visual Studio

Cuando se trabaja con Django desde la línea de comandos, normalmente se inicia un proyecto ejecutando el
comando django-admin startproject <project_name> . En Visual Studio, con la plantilla "Proyecto web de Django
en blanco" se obtiene la misma estructura dentro de un proyecto y una solución de Visual Studio.
1. En Visual Studio, seleccione Archivo > Nuevo > Proyecto , busque "Django" y seleccione la plantilla
Proyecto web de Django en blanco . (La plantilla también se encuentra en Python > Web en la lista
de la izquierda).
2. En los campos de la parte inferior del cuadro de diálogo, escriba la información siguiente (como se
muestra en el gráfico anterior) y, a continuación, seleccione Aceptar :
Nombre : establezca el nombre del proyecto de Visual Studio en BasicProject . Este nombre también
se usa para el proyecto Django.
Ubicación : especifique una ubicación en la que se va a crear la solución y el proyecto de Visual
Studio.
Solución : deje este control establecido en la opción predeterminada Crear nueva solución .
Nombre de la solución : establézcalo en LearningDjango , que es adecuado para la solución como
contenedor de varios proyectos de este tutorial.
Crear directorio para la solución : deje el valor predeterminado.
Crear nuevo repositorio Git : active esta opción (que está desactivada de forma predeterminada)
para que Visual Studio cree un repositorio Git local al generar la solución. Si no ve esta opción, ejecute
el instalador de Visual Studio y agregue Git para Windows y Extensión de GitHub para Visual
Studio en la pestaña Componentes individuales en Herramientas de código .
3. Tras un momento, Visual Studio muestra un cuadro de diálogo que indica Este proyecto necesita
paquetes externos (se muestra abajo). Este cuadro de diálogo aparece porque la plantilla incluye un
archivo requirements.txt que hace referencia al paquete Django 1.x más reciente. (Active Mostrar
paquetes necesarios para ver las dependencias exactas).
4. Seleccione la opción Los instalaré de forma manual . Cree el entorno virtual en breve para asegurarse
de que se excluye del control de código fuente. (El entorno siempre puede crearse a partir de
requirements.txt).
Paso 1.2: Examinar los controles de Git y publicar en un repositorio

remoto
Como seleccionó Crear nuevo repositorio Git en el cuadro de diálogo Nuevo proyecto , el proyecto ya
estará confirmado para el control de código fuente local en cuanto se complete el proceso de creación. En este
paso, familiarícese con los controles de Git de Visual Studio y la ventana de Team Explorer en la que se trabaja
con el control de código fuente.
1. Examine los controles de Git en la esquina inferior de la ventana principal de Visual Studio. De izquierda a
derecha, estos controles muestran confirmaciones sin insertar, cambios sin confirmar, el nombre del
repositorio y la rama actual:
NOTE
Si no selecciona Crear nuevo repositorio Git en el cuadro de diálogo Nuevo proyecto , los controles de Git
solo muestran un comando Agregar al control de código fuente que crea un repositorio local.
2. Seleccione el botón de cambios y Visual Studio abre su ventana de Team Explorer en la página
Cambios . Dado que el proyecto recién creado ya se ha confirmado automáticamente en el control de
código fuente, no verá cambios pendientes.
3. En la barra de estado de Visual Studio, haga clic en el botón de confirmaciones sin insertar (la flecha
arriba con 2 ) para abrir la página Sincronización en Team Explorer . Como tiene solo un repositorio
local, la página ofrece opciones sencillas para publicar el repositorio en repositorios remotos diferentes.
Puede elegir cualquier servicio que desee para sus propios proyectos. En este tutorial se muestra el uso
de GitHub, donde se mantiene el código de ejemplo completo del tutorial en el repositorio
Microsoft/python-sample-vs-learning-django.
4. Al seleccionar cualquiera de los controles de Publicar , Team Explorer le pedirá más información. Por
ejemplo, al publicar el ejemplo para este tutorial, el propio repositorio tenía que haberse creado primero.
En este caso, la opción Inser tar en repositorio remoto se utilizó con la dirección URL del repositorio.
Si no tiene ningún repositorio, las opciones Publish to GitHub (Publicar en GitHub) e Inser tar en
Azure DevOps le permiten crear uno directamente desde Visual Studio.
5. Mientras esté trabajando en este tutorial, adopte la costumbre de usar los controles de Visual Studio
periódicamente para confirmar e insertar los cambios. Este tutorial se lo recuerda en los momentos
adecuados.
TIP
Para desplazarse rápidamente por Team Explorer , seleccione el encabezado (donde pone Changes o Push en las
imágenes anteriores) para ver un menú emergente de las páginas disponibles.
Pregunta: ¿Cuáles son algunas de las ventajas del uso de control de código fuente desde el principio de un
proyecto?
Respuesta: En primer lugar, usar el control de código fuente desde el principio, especialmente si también utiliza
un repositorio remoto, genera una copia de seguridad periódica externa del proyecto. A diferencia de mantener
un proyecto solo en un sistema de archivos local, el control de código fuente también proporciona un historial
de cambios completo y la capacidad de revertir con facilidad un único archivo o todo el proyecto a un estado
anterior. Ese historial de cambios ayuda a determinar la causa de regresiones (errores de prueba). Además, el
control de código fuente es esencial si varias personas trabajan en un proyecto, ya que administra las
sobrescrituras y ofrece solución para los conflictos. Por último, el control de código fuente, que es básicamente
una forma de automatización, facilita la automatización de las compilaciones, las pruebas y la administración de
versiones. Es realmente el primer paso para utilizar DevOps para un proyecto, y dado que las barreras de
entrada son tan bajas, realmente no hay ninguna razón que impida usar el control de código fuente desde el
principio.
Para obtener más información sobre el control de código fuente como automatización, consulte The Source of
Truth: The Role of Repositories in DevOps (El origen de la verdad, el rol de los repositorios en DevOps), un
artículo de MSDN Magazine escrito para aplicaciones móviles que se aplica también a las aplicaciones web.
Pregunta: ¿Puedo evitar que Visual Studio confirme automáticamente un nuevo proyecto?
Respuesta : Sí. Para deshabilitar la confirmación automática, vaya a la página Configuración de Team
Explorer , seleccione Git > Configuración global , desactive la opción Confirmar cambios tras la fusión
mediante combinación de forma predeterminada y, a continuación, seleccione Actualizar .
Paso 1.3: Crear el entorno virtual y excluirlo del control de código

fuente
Ahora que ha configurado el control de código fuente para el proyecto, puede crear el entorno virtual que
contiene los paquetes necesarios de Django para el proyecto. A continuación, puede usar Team Explorer para
excluir la carpeta del entorno del control de código fuente.
1. En el Explorador de soluciones , haga clic con el botón derecho en el nodo Entornos de Python y
seleccione Agregar entorno vir tual .
2. Aparece un cuadro de diálogo Agregar entorno vir tual con un mensaje que indica Hemos
encontrado un archivo requirements.txt . Este mensaje indica que Visual Studio usa ese archivo para
configurar el entorno virtual.
3. Seleccione Crear para aceptar los valores predeterminados. (Puede cambiar el nombre del entorno
virtual si lo desea, lo cual simplemente cambia el nombre de su subcarpeta, pero env es una convención
estándar).
4. Dé su consentimiento para los privilegios de administrador si se le solicita y, a continuación, tenga
paciencia durante unos minutos mientras Visual Studio descarga e instala los paquetes, lo que para
Django significa expandir varios miles archivos en casi tantas subcarpetas. Puede ver el progreso en la
ventana Salida de Visual Studio. Mientras espera, consulte la sección Preguntas a continuación.
5. En los controles de Git de Visual Studio (en la barra de estado), seleccione el indicador de cambios (que
muestra 99* ) que abre la página Cambios en Team Explorer .
La creación del entorno virtual implica miles de cambios, pero no es necesario que incluya ninguno de
ellos en el control de código fuente, dado que usted (o cualquier usuario que clone el proyecto) siempre
puede volver a crear el entorno a partir de requirements.txt.
Para excluir el entorno virtual, haga clic con el botón derecho en la carpeta env y seleccione Omitir
estos elementos locales .
6. Después de excluir el entorno virtual, los únicos cambios que faltan son en el archivo de proyecto y en
.gitignore. El archivo .gitignore contiene una entrada agregada para la carpeta del entorno virtual. Puede
hacer doble clic en el archivo para ver las diferencias.
7. Escriba un mensaje de confirmación y seleccione el botón Confirmar todo , a continuación, inserte las
confirmaciones en el repositorio remoto si lo desea.
Pregunta: ¿Por qué es conveniente crear un entorno virtual?
Respuesta: Un entorno virtual es una excelente manera de aislar las dependencias exactas de la aplicación. Este
tipo de aislamiento evita conflictos dentro de un entorno de Python global y contribuye a las pruebas y la
colaboración. Con el tiempo, a medida que desarrolle una aplicación, es inevitable que incorpore muchos
paquetes útiles de Python. Si mantiene los paquetes en un entorno virtual específico del proyecto, puede
actualizar fácilmente el archivo requirements.txt del proyecto que describe ese entorno, el cual se incluye en el
control de código fuente. Cuando el proyecto se copia en otros equipos, como los servidores de compilación, los
servidores de implementación y otros equipos de desarrollo, es fácil volver a crear el entorno con solo
requirements.txt (por este motivo no es necesario que el entorno esté en el control de código fuente). Para
obtener más información, vea Use virtual environments (Usar entornos virtuales).
Pregunta: ¿Cómo se quita un entorno virtual que ya se ha confirmado en el control de código fuente?
Respuesta: En primer lugar, edite el archivo .gitignore para excluir la carpeta: busque la sección del final con el
comentario # Python Tools for Visual Studio (PTVS) y agregue una línea nueva para la carpeta del entorno
virtual, como /BasicProject/env . (Dado que Visual Studio no muestra el archivo en el Explorador de
soluciones , ábralo directamente mediante el comando de menú Archivo > Abrir > Archivo . También puede
abrir el archivo desde Team Explorer : en la página Configuración , seleccione Configuración de
repositorios , vaya a la sección Archivos de omisión y de atributos y luego seleccione el vínculo Editar
junto a .gitignore ).
En segundo lugar, abra una ventana de comandos, vaya a la carpeta como BasicProject que contiene la carpeta
del entorno virtual, como env, y ejecute git rm -r env . A continuación, confirme esos cambios desde la línea de
comandos ( git commit -m 'Remove venv' ), o bien desde la página Cambios de Team Explorer .
Paso 1.4: Examinar el código reutilizable

Una vez que finalice la creación del proyecto, examine el código del proyecto de Django reutilizable (que es de
nuevo el mismo que se generó por el comando de la CLI django-admin startproject <project_name> ).
1. En la raíz del proyecto se encuentra manage.py, la utilidad administrativa de línea de comandos de
Django que Visual Studio establece automáticamente como archivo de inicio del proyecto. Ejecute la
utilidad en la línea de comandos usando python manage.py <command> [options] . Para las tareas comunes
de Django, Visual Studio proporciona los comandos de menú pertinentes. Haga clic con el botón derecho
en el proyecto en el Explorador de soluciones y seleccione Python para ver la lista. Encontrará
algunos de estos comandos en el transcurso de este tutorial.
2. En el proyecto se encuentra una carpeta que tiene el mismo nombre que el proyecto. Contiene los
archivos de proyecto Django básicos:
__init.py: un archivo vacío que indica a Python que esta carpeta es un paquete de Python.
wsgi.py: un punto de entrada para los servidores web compatibles con WSGI que van a servir al
proyecto. Normalmente, deberás dejar los archivos tal cual, ya que sirven de enlace para los
servidores web de producción.
settings.py: contiene la configuración del proyecto de Django, que se modifica durante el
desarrollo de una aplicación web.
urls.py: contiene una tabla de contenido para el proyecto de Django, que también se modifica
durante el desarrollo.
3. Como se ha indicado anteriormente, la plantilla de Visual Studio también agrega un archivo
requirements.txt al proyecto que especifica la dependencia del paquete de Django. La presencia de este
archivo es lo que le invita a crear un entorno virtual cuando empiece a crear el proyecto.
Pregunta: ¿Puede Visual Studio generar un archivo requirements.txt a partir de un entorno virtual después de
instalar otros paquetes?
Respuesta : Sí. Expanda el nodo Entornos de Python , haga clic con el botón derecho en su entorno virtual y
seleccione el comando Generar requirements.txt . Es conveniente usar este comando periódicamente a
medida que modifica el entorno, y confirmar los cambios de requirements.txt en el control de código fuente
junto con cualquier otro cambio de código que dependa de ese entorno. Si configura la integración continua en
un servidor de compilación, debe generar el archivo y confirmar los cambios cada vez que se modifique el
entorno.
Paso 1.5: Ejecutar el proyecto de Django vacío

1. En Visual Studio, seleccione Depurar > Iniciar depuración (F5 ) o use el botón Ser vidor web de la
barra de herramientas (el explorador puede variar):
2. La ejecución del servidor implica la ejecución del comando manage.py runserver <port> , que inicia el
servidor de desarrollo integrado de Django. Si Visual Studio indica No se pudo iniciar el depurador
con un mensaje relacionado con la falta de un archivo de inicio, haga clic con el botón derecho en
manage.py en el Explorador de soluciones y seleccione Establecer como archivo de inicio .
3. Al iniciar el servidor, verá una ventana de consola abierta que también muestra el registro del servidor.
Visual Studio abre automáticamente un explorador en http://localhost:<port> . Sin embargo, dado que
el proyecto de Django no tiene ninguna aplicación, Django muestra solo una página predeterminada para
confirmar que lo que tiene hasta ahora funciona correctamente:
4. Cuando haya terminado, detenga el servidor cerrando la ventana de la consola o con el comando
Depurar > Detener depuración en Visual Studio.
Pregunta: ¿Django es un servidor web además de una plataforma?
Respuesta: Sí y no. Django tiene un servidor web integrado que se usa para fines de desarrollo. Este servidor
web es lo que se usa al ejecutar la aplicación web localmente, como al depurar en Visual Studio. Sin embargo,
cuando realiza una implementación en un host web, Django utiliza el servidor web del host en su lugar. El
módulo wsgi.py del proyecto de Django se ocupa de enlazar con los servidores de producción.
Pregunta: ¿Cuál es la diferencia entre el uso de los comandos de menú de depuración y los comandos de
servidor en el submenú de Python del proyecto?
Respuesta: Además de con los comandos de menú de Depurar y los botones de la barra de herramientas,
también puede iniciar el servidor mediante los comandos Python > Run ser ver (Ejecutar servidor) o Python
> Run debug ser ver (Iniciar el servidor de depuración) en el menú contextual del proyecto. Ambos comandos
abren una ventana de consola en la que se ve la dirección URL local (localhost:port) del servidor en ejecución.
Sin embargo, debe abrir manualmente un explorador con esa dirección URL, y la ejecución del servidor de
depuración no inicia automáticamente el depurador de Visual Studio. Puede adjuntar un depurador al proceso
en ejecución más adelante, si lo desea, mediante el comando Depurar > Asociar al proceso .
Pasos siguientes
En este momento, el proyecto de Django básico no contiene ninguna aplicación. Crearemos una aplicación en el
paso siguiente. Dado que normalmente funcionan con las aplicaciones de Django más que con el proyecto de
Django, no necesita saber mucho más acerca de los archivos de código reutilizable en este momento.
Creación de una aplicación de Django con vistas y plantillas de página

Código del proyecto Django: Escribiendo su primera aplicación en Django, parte 1 (docs.djangoproject.com)
Utilidad administrativa: django-admin and manage.py (django-admin y manage.py)
(docs.djangoproject.com)
Código fuente del tutorial en GitHub: Microsoft/python-sample-vs-learning-django
Paso 2: Creación de una aplicación de Django con
vistas y plantillas de página
Paso anterior : Creación de una solución y un proyecto de Visual Studio

Lo que tiene hasta el momento en el proyecto de Visual Studio son solo los componentes de nivel de sitio de un
proyecto de Django, que puede ejecutar una o varias aplicaciones de Django. El siguiente paso consiste en crear
su primera aplicación con una sola página.
En este paso aprenderá lo siguiente:
Crear una aplicación de Django con una sola página (paso 2.1)
Ejecutar la aplicación desde el proyecto de Django (paso 2.2)
Representar una vista mediante HTML (paso 2.3)
Representar una vista utilizando una plantilla de página de Django (paso 2.4)
Paso 2-1: Creación de una aplicación con una estructura

predeterminada
Una aplicación de Django es un paquete de Python independiente que contiene un conjunto de archivos
relacionados para un propósito específico. Un proyecto de Django puede contener cualquier número de
aplicaciones, lo que refleja el hecho de que un host de web puede atender cualquier número de puntos de
entrada independientes desde un único nombre de dominio. Por ejemplo, es posible que un proyecto de Django
para un dominio como contoso.com contenga una aplicación para www.contoso.com , una segunda aplicación
para support.contoso.com y una tercera para docs.contoso.com. En este caso, el proyecto de Django controla el
enrutamiento y la configuración de direcciones URL de nivel de sitio (en sus archivos urls.py y settings.py),
mientras que cada aplicación tiene su propio estilo y comportamiento distintivo definidos por su enrutamiento
interno, vistas, modelos, archivos estáticos e interfaz administrativa.
Normalmente, una aplicación de Django comienza con un conjunto estándar de archivos. Visual Studio
proporciona plantillas de elementos para inicializar una aplicación de Django dentro de un proyecto de Django,
junto con un comando de menú integrado que tiene la misma finalidad:
Plantillas: En el Explorador de soluciones , haga clic con el botón derecho en el proyecto y seleccione
Agregar > Nuevo elemento . En el cuadro de diálogo Agregar nuevo elemento , seleccione la
plantilla Aplicación Django 1.9 , especifique el nombre de la aplicación en el campo Nombre y haga
clic en Aceptar .
Comando integrado: En el Explorador de soluciones , haga clic con el botón derecho en el proyecto y
seleccione Agregar > Aplicación de Django . Este comando le pide un nombre y crea una aplicación de
Django 1.9.
Con cualquiera de estos métodos, cree una aplicación con el nombre "HelloDjangoApp". El resultado es una
carpeta en el proyecto con ese nombre que contiene elementos como se describe en la tabla siguiente.
EL EM EN TO DESC RIP C IÓ N
__init__.py El archivo que identifica la aplicación como un paquete.

migrations Una carpeta en la que Django almacena los scripts que

actualizan la base de datos para adaptarlos a los cambios de
los modelos. Las herramientas de migración de Django
aplican entonces los cambios necesarios a cualquier versión
anterior de la base de datos para que coincida con los
modelos actuales. Con las migraciones, mantiene el foco en
los modelos y permite que Django controle el esquema de
base de datos subyacente. Las migraciones se tratan en el
paso 6; por ahora, la carpeta contiene simplemente un
archivo __init__.py (que indica que la carpeta define su propio
paquete de Python).
templates Carpeta para las plantillas de página de Django que

contienen un único archivo index.html dentro de una carpeta
que coincide con el nombre de la aplicación. (En Visual Studio
2017 15.7 y versiones anteriores, el archivo se encuentra
directamente en Plantillas y en los pasos del 2 al 4 se insta al
usuario a crear la subcarpeta). Las plantillas son bloques de
HTML en las que las vistas pueden agregar información para
representar una página de forma dinámica. Las "variables" de
la plantilla de la página, como {{ content }} en
index.html, son marcadores de posición para valores
dinámicos, como se explica más adelante en este artículo
(paso 2). Las aplicaciones de Django normalmente crean un
espacio de nombres colocándolas en una subcarpeta que
coincida con el nombre de la aplicación.
admin.py El archivo de Python en el que amplía la interfaz

administrativa de la aplicación (vea el paso 6), que se usa
para inicializar y editar datos en una base de datos.
Inicialmente, este archivo contiene solo la instrucción,
from django.contrib import admin . De forma
predeterminada, Django incluye una interfaz de
administración estándar a través de entradas en el archivo
settings.py del proyecto de Django, que puede activar
quitando las marcas de comentario de las entradas
existentes en urls.py.
apps.py Un archivo de Python que define una clase de configuración

para la aplicación (vea a continuación, después de esta tabla).
models.py Los modelos son objetos de datos, identificados por

funciones, a través de los cuales las vistas interactúan con la
base de datos subyacente de la aplicación (vea el paso 6).
Django proporciona el nivel de conexión de base de datos
para que las aplicaciones no tengan que preocuparse por
estos detalles. El archivo models.py es una ubicación
predeterminada para crear los modelos, e inicialmente
contiene solo la instrucción,
from django.db import models .
tests.py Un archivo de Python que contiene la estructura básica de

las pruebas unitarias.
views.py Las vistas son lo que se suele considerar páginas web, que
toman una solicitud HTTP y devuelven una respuesta HTTP.
Las vistas suelen representarse como código HTML que los
exploradores web saben cómo mostrar, pero una vista no
tiene necesariamente que ser visible (por ejemplo, un
formulario intermedio). Una vista se define mediante una
función de Python cuya responsabilidad es representar el
código HTML que se enviará al explorador. El archivo
views.py es una ubicación predeterminada para crear vistas,
e inicialmente contiene solo la instrucción,
from django.shortcuts import render .
__init__.py El archivo que identifica la aplicación como un paquete.
migrations Una carpeta en la que Django almacena los scripts que

actualizan la base de datos para adaptarlos a los cambios de
los modelos. Las herramientas de migración de Django
aplican entonces los cambios necesarios a cualquier versión
anterior de la base de datos para que coincida con los
modelos actuales. Con las migraciones, mantiene el foco en
los modelos y permite que Django controle el esquema de
base de datos subyacente. Las migraciones se describen en
la documentación de Django; por ahora, la carpeta contiene
simplemente un archivo __init__.py (que indica que la carpeta
define su propio paquete de Python).
templates Carpeta para las plantillas de página de Django que

contienen un único archivo index.html dentro de una carpeta
que coincide con el nombre de la aplicación. (En Visual Studio
2017 15.7 y versiones anteriores, el archivo se encuentra
directamente en Plantillas y en los pasos del 2 al 4 se insta al
usuario a crear la subcarpeta). Las plantillas son bloques de
HTML en las que las vistas pueden agregar información para
representar una página de forma dinámica. Las "variables" de
la plantilla de la página, como {{ content }} en
index.html, son marcadores de posición para valores
dinámicos, como se explica más adelante en este artículo
(paso 2). Las aplicaciones de Django normalmente crean un
espacio de nombres colocándolas en una subcarpeta que
coincida con el nombre de la aplicación.
admin.py El archivo de Python en el que amplía la interfaz

administrativa de la aplicación, que se usa para inicializar y
editar datos en una base de datos. Inicialmente, este archivo
from django.contrib import admin . De forma
predeterminada, Django incluye una interfaz de
administración estándar a través de entradas en el archivo
settings.py del proyecto de Django, que puede activar
quitando las marcas de comentario de las entradas
existentes en urls.py.
apps.py Un archivo de Python que define una clase de configuración

para la aplicación (vea a continuación, después de esta tabla).
models.py Los modelos son objetos de datos, identificados por

funciones, mediante los cuales las vistas interactúan con la
base de datos subyacente de la aplicación. Django
proporciona el nivel de conexión de base de datos para que
las aplicaciones no tengan que preocuparse por estos
detalles. El archivo models.py es una ubicación
predeterminada para crear los modelos, e inicialmente
from django.db import models .
tests.py Un archivo de Python que contiene la estructura básica de

las pruebas unitarias.
views.py Las vistas son lo que se suele considerar páginas web, que
toman una solicitud HTTP y devuelven una respuesta HTTP.
Las vistas suelen representarse como código HTML que los
exploradores web saben cómo mostrar, pero una vista no
tiene necesariamente que ser visible (por ejemplo, un
formulario intermedio). Una vista se define mediante una
función de Python cuya responsabilidad es representar el
código HTML que se enviará al explorador. El archivo
views.py es una ubicación predeterminada para crear vistas,
e inicialmente contiene solo la instrucción,
from django.shortcuts import render .
El contenido de apps.py aparece del modo siguiente cuando se usa el nombre "HelloDjangoApp":
from django.apps import AppConfig
class HelloDjangoAppConfig(AppConfig):
name = 'HelloDjango'
Pregunta: Estoy utilizando un certificado X.509 con mi servicio y obtengo un

System.Security.Cryptography.CryptographicException. ¿La creación de una aplicación de Django en Visual
Studio es diferente de la creación de una aplicación en la línea de comandos?
Respuesta: La ejecución del comando Agregar > Aplicación de Django o el uso de Agregar > Nuevo
elemento con una plantilla de aplicación de Django genera los mismos archivos que el comando de Django
manage.py startapp <app_name> . La ventaja de crear la aplicación en Visual Studio es que la carpeta de la
aplicación y todos sus archivos se integran automáticamente en el proyecto. Puede usar el mismo comando de
Visual Studio para crear cualquier número de aplicaciones en el proyecto.
Paso 2-2: Ejecución de la aplicación desde el proyecto de Django

En este punto, si ejecuta el proyecto de nuevo en Visual Studio (con el botón de la barra de herramientas o
Depurar > Iniciar depuración ), seguirá viendo la página predeterminada. No aparece ningún contenido de la
aplicación porque debe definir una página específica de la aplicación y agregar la aplicación al proyecto de
Django:
1. En la carpeta HelloDjangoApp, modifique views.py para que coincida con el código siguiente, que define
una vista denominada "index":
from django.shortcuts import render
from django.http import HttpResponse
def index(request):
return HttpResponse("Hello, Django!")
2. En la carpeta BasicProject (creada en el paso 1), modifique urls.py para que al menos coincida con el
código siguiente (puede conservar los comentarios instructivos si quiere):
from django.conf.urls import include, url

import HelloDjangoApp.views
# Django processes URL patterns in the order they appear in the array
urlpatterns = [
url(r'^$', HelloDjangoApp.views.index, name='index'),
url(r'^home$', HelloDjangoApp.views.index, name='home'),
]
Cada modelo de dirección URL describe las vistas a las que Django enruta las direcciones URL relativas al
sitio específicas (es decir, la parte que sigue a https://www.domain.com/ ). La primera entrada de
urlPatterns que comienza con la expresión regular ^$ es el enrutamiento para la raíz del sitio, "/". La
segunda entrada, ^home$ específicamente enruta "/home". Puede tener cualquier número de
enrutamientos a la misma vista.
3. Ejecute el proyecto de nuevo para ver el mensaje Hello, Django! definido por la vista. Cuando haya
terminado, detenga el servidor.
Confirmación en el control de código fuente
Dado que ha realizado cambios en el código y ha probado que funcionan correctamente, ahora es un buen
momento para revisar y confirmar los cambios en el control de código fuente. Los pasos posteriores de este
tutorial le recuerdan los momentos adecuados para volver a confirmar el control de código fuente, y le remiten
a esta sección.
1. Seleccione el botón de cambios de la parte inferior de Visual Studio (en un círculo abajo), que le lleva a
Team Explorer .
2. En Team Explorer , escriba un mensaje de confirmación como "Crear la aplicación inicial de Django" y
seleccione Confirmar todo . Una vez que se haya completado la confirmación, verá un mensaje
Confirmar <hash> de creación local. Sincronizar para compar tir los cambios con el ser vidor.
Si desea insertar los cambios en el repositorio remoto, seleccione Sincronizar y luego Inser tar en
Confirmaciones de salida . También puede acumular varias confirmaciones locales antes de insertar en
la instancia remota.
System.Security.Cryptography.CryptographicException. ¿Para qué sirve el prefijo "r" que aparece delante de
las cadenas de enrutamiento?
Respuesta: El prefijo "r" en una cadena de Python significa "raw" (sin formato), lo que indica a Python que no
trate como escape ninguno de los caracteres de la cadena. Dado que las expresiones regulares usan muchos
caracteres especiales, el prefijo "r" hace que esas cadenas sean mucho más fáciles de leer que si contuvieran una
serie de caracteres de escape "\".
System.Security.Cryptography.CryptographicException. ¿Qué significan los caracteres ^ y $ en las entradas
de enrutamiento de dirección URL?
Respuesta: En las expresiones regulares que definen patrones de dirección URL, ^ significa "inicio de línea" y $
significa "final de línea," donde de nuevo las direcciones URL se refieren a la raíz del sitio (la parte que sigue a
https://www.domain.com/ ). La expresión regular ^$ significa "en blanco" y, por tanto, coincide con la dirección
URL completa https://www.domain.com/ (no se agrega nada a la raíz del sitio). El patrón ^home$ coincide
exactamente con https://www.domain.com/home/ . (Django no usa la barra / final en detección de patrones).
Si no utiliza el carácter $ final en una expresión regular, como en ^home , el patrón de la dirección URL coincide
con cualquier dirección URL que comience por "home" , como "home", "homework", "homestead" y
"home192837".
Para experimentar con diferentes expresiones regulares, pruebe herramientas en línea como regex101.com en
pythex.org.
Paso 2-3: Representación de una vista mediante HTML

La función index que tiene de momento en views.py solo genera una respuesta HTTP en texto sin formato para
la página. La mayoría las páginas web reales, por supuesto, responden con páginas HTML enriquecidas que a
menudo incorporan datos en directo. De hecho, la razón principal para definir una vista usando una función es
que pueda generar ese contenido dinámicamente.
Dado que el argumento HttpResponse es simplemente una cadena, es posible crear cualquier HTML que desee
dentro de una cadena. Como ejemplo sencillo, reemplace la función index por el código siguiente
(manteniendo las instrucciones from existentes), lo cual genera una respuesta HTML con contenido dinámico
que se actualiza cada vez que actualice la página:
from datetime import datetime
def index(request):
now = datetime.now()
html_content = "<html><head><title>Hello, Django</title></head><body>"

html_content += "<strong>Hello Django!</strong> on " + now.strftime("%A, %d %B, %Y at %X")
html_content += "</body></html>"
return HttpResponse(html_content)
Ejecute el proyecto nuevo, para ver un mensaje como "Hello Django! el lunes, 16 de abril de 2018 a las
16:28:10". Actualice la página para actualizar la hora y confirme que el contenido se genera con cada solicitud.
Cuando haya terminado, detenga el servidor.
TIP
Un acceso directo para detener y reiniciar el proyecto es usar el comando de menú Depurar > Reiniciar
(Ctrl+Mayús +F5 ) o el botón Reiniciar de la barra de herramientas de depuración:
Paso 2-4: Representación de una vista mediante una plantilla de

página
La generación de HTML en el código funciona perfectamente en páginas muy pequeñas, pero a medida que las
páginas sean más sofisticadas, querrá mantener las partes HTML estáticas de la página ( junto con las
referencias a archivos CSS y JavaScript) como "plantillas de página" en las que podrá insertar contenido
dinámico generado por el código. En la sección anterior, solo la fecha y hora de la llamada now.strftime son
dinámicos, lo que significa que todo el contenido se puede colocar en una plantilla de página.
Una plantilla de página de Django es un bloque de código HTML que puede contener cualquier número de
tokens de reemplazo denominados "variables" que se delimitan por {{ y }} , como en {{ content }} . El
módulo de creación de plantillas de Django reemplaza entonces las variables por el contenido dinámico que
proporciona en el código.
En los pasos siguientes se muestra el uso de las plantillas de página:
1. En la carpeta BasicProject, que contiene el proyecto de Django, abra el archivo settings.py y agregue el
nombre de la aplicación, "HelloDjangoApp", a la lista INSTALLED_APPS . Con la adición de la aplicación a la
lista se indica al proyecto de Django que hay una carpeta con ese nombre que contiene una aplicación:
INSTALLED_APPS = [
'HelloDjangoApp',
# Other entries...
]
2. Además, en settings.py, asegúrese de que el objeto TEMPLATES contiene la siguiente línea (incluida de
forma predeterminada), que indica a Django que busque plantillas en la carpeta templates de una
aplicación instalada:
'APP_DIRS': True,
3. En la carpeta HelloDjangoApp, abra el archivo de plantilla de página

templates/HelloDjangoApp/index.html (o templates/index.html en VS 2017 15.7 y versiones
anteriores)para observar que contiene una variable, {{ content }} :
<html>
<head><title></title></head>
<body>
{{ content }}
</body>
</html>
4. En la carpeta HelloDjangoApp, abra views.py y reemplace la función index por el siguiente código que
usa la función del asistente django.shortcuts.render . El asistente render proporciona una interfaz
simplificada para trabajar con plantillas de página. Asegúrese de mantener todas las instrucciones from
existentes.
from django.shortcuts import render # Added for this step
def index(request):
return render(
request,
"HelloDjangoApp/index.html", # Relative path from the 'templates' folder to the template
file
# "index.html", # Use this code for VS 2017 15.7 and earlier
{
'content': "<strong>Hello Django!</strong> on " + now.strftime("%A, %d %B, %Y at %X")
}
)
El primer argumento para render , como puede ver, es el objeto de solicitud, seguido de la ruta de acceso
relativa al archivo de plantilla dentro de la carpeta templates de la aplicación. Se asigna a un archivo de
plantilla el nombre de la vista que admite, si procede. El tercer argumento para render es un diccionario
de variables al que hace referencia la plantilla. Puede incluir objetos en el diccionario, en cuyo caso una
variable de la plantilla puede hacer referencia a {{ object.property }} .
5. Ejecute el proyecto y observe la salida. Verá un mensaje similar al del paso 2.2, que indica que la plantilla
funciona.
Sin embargo, tenga en cuenta que el código HTML que usó en la propiedad content se representa solo
como texto sin formato porque la función render convierte automáticamente en escape ese HTML. El
escape automático evita vulnerabilidades accidentales en los ataques por inyección de código: los
desarrolladores suelen recopilar información de una página y emplearla como valor en otra mediante un
marcador de posición de plantilla. El escape también sirve como recordatorio de que es mejor conservar
el HTML en la plantilla de página y fuera del código. Por suerte, resulta sencillo crear variables adicionales
cuando es necesario. Por ejemplo, cambie index.html por templates para que coincida con el siguiente
marcado, que agrega un título de página y mantiene todo el formato de la plantilla de página:
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<strong>{{ message }}</strong>{{ content }}
</body>
</html>
A continuación, escriba la función de vista index como sigue, para proporcionar valores para todas las
variables en la plantilla de página:
def index(request):
return render(
request,
"HelloDjangoApp/index.html", # Relative path from the 'templates' folder to the template
file
# "index.html", # Use this code for VS 2017 15.7 and earlier
{
'title' : "Hello Django",
'message' : "Hello Django!",
'content' : " on " + now.strftime("%A, %d %B, %Y at %X")
}
)
6. Detenga el servidor y reinicie el proyecto, y observe que la página ahora se representa correctamente:
7. Visual Studio 2017 15.7 y versiones anteriores: Como paso final, mueva las plantillas a una subcarpeta
con el mismo nombre que la aplicación, que crea un espacio de nombres y evita posibles conflictos con
otras aplicaciones que es posible que se agreguen al proyecto. (Las plantillas en VS 2017 15.8+ hacen
esto automáticamente). Es decir, cree una subcarpeta en templates denominada HelloDjangoApp, mueva
index.html a esa subcarpeta y modifique la función de vista index para que haga referencia a la nueva
ruta de acceso de la plantilla, HelloDjangoApp/index.html. A continuación, ejecute el proyecto, compruebe
que la página se representa correctamente y detenga el servidor.
8. Confirme los cambios en el control de código fuente y actualice su repositorio remoto, si lo desea, tal y
como se describe en el paso 2.2.
System.Security.Cryptography.CryptographicException. ¿Las plantillas de página deben estar en un archivo
independiente?
Respuesta: Aunque las plantillas normalmente se guardan en archivos HTML independientes, también se puede
usar una plantilla insertada. No obstante, se recomienda usar un archivo independiente para mantener una
separación clara entre código y marcado.
System.Security.Cryptography.CryptographicException. ¿Deben usar las plantillas la extensión de archivo
.html?
Respuesta: La extensión .html para archivos de plantilla de página es completamente opcional, ya que siempre
puede identificar la ruta de acceso exacta relativa al archivo en el segundo argumento para la función render .
Pero Visual Studio (y otros editores) normalmente ofrecen características como la finalización de código y el
coloreado de sintaxis con archivos .html, lo que compensa con creces el hecho de que las plantillas de página no
sean estrictamente HTML.
De hecho, cuando esté trabajando con un proyecto de Django, Visual Studio detecta automáticamente cuándo el
archivo HTML que está editando es realmente una plantilla de Django y proporciona algunas características de
completado automático. Por ejemplo, al comenzar a escribir un comentario de plantilla de página de Django,
{# , Visual Studio proporciona automáticamente los caracteres #} de cierre. Los comandos Selección con
comentarios y Selección sin comentarios (en el menú Editar > Opciones avanzadas y en la barra de
herramientas) también utilizan comentarios de plantilla en lugar de comentarios HTML.
System.Security.Cryptography.CryptographicException. Cuando ejecuto el proyecto, aparece un error que
indica que no se encuentra la plantilla. ¿Qué ocurre?
Respuesta: Si ve errores que indican que no se encuentra la plantilla, asegúrese de que se ha agregado la
aplicación al archivo settings.py del proyecto de Django en la lista INSTALLED_APPS . Sin esa entrada, Django no
sabe que ha de buscar en la carpeta templates de la aplicación.
System.Security.Cryptography.CryptographicException. ¿Por qué es importante el espaciado entre nombres
de la plantilla?
Respuesta: Cuando Django busca una plantilla a la que se hace referencia en la función render , usa el primer
archivo que encuentre que coincida con la ruta de acceso relativa. Si tiene varias aplicaciones de Django en el
mismo proyecto que utilizan las mismas estructuras de carpeta para las plantillas, es probable que una
aplicación use involuntariamente una plantilla desde otra aplicación. Para evitar tales errores, cree siempre una
subcarpeta bajo una carpeta templates de la aplicación que coincida con el nombre de la aplicación para evitar
cualquier duplicación.
Pasos siguientes
Atender archivos estáticos, agregar páginas y usar la herencia de plantilla

Escribiendo su primera aplicación en Django, parte 1: vistas (docs.djangoproject.com)
Para conocer más funciones de las plantillas de Django, como la inclusión y la herencia, consulte The Django
template language (El lenguaje de plantilla de Django) (docs.djangoproject.com)
Regular expression training on inLearning (Entrenamiento de expresión regular en inLearning) (LinkedIn)
Paso 3: Atender archivos estáticos, agregar páginas
y usar la herencia de plantilla con la aplicación
Django
Paso anterior : Creación de una aplicación de Django con vistas y plantillas de página
En los pasos anteriores de este tutorial, ha aprendido a crear una aplicación de Django mínima con una sola
página HTML independiente. Pero las aplicaciones web modernas están formadas normalmente por muchas
páginas y usan recursos compartidos, como archivos CSS y JavaScript, para proporcionar un comportamiento y
un estilo uniformes.
Usar plantillas de elementos de Visual Studio para agregar rápidamente nuevos archivos de distintos tipos
con práctico código reutilizable (paso 3.1)
Configurar el proyecto de Django para atender archivos estáticos (paso 3.2)
Agregar páginas adicionales a la aplicación (paso 3.3)
Usar la herencia de plantilla para crear un encabezado y una barra de navegación que se use en varias
páginas (paso 3.4)
Paso 3-1: Familiarizarse con las plantillas de elemento

A medida que desarrolle una aplicación de Django, lo normal es que vaya agregando muchos más archivos
Python, HTML, CSS y JavaScript. Para cada tipo de archivo (así como otros archivos como web.config que pueda
necesitar para la implementación), Visual Studio ofrece prácticas plantillas de elemento para empezar.
Para ver las plantillas disponibles, vaya al Explorador de soluciones , haga clic con el botón derecho en la
carpeta en la que desee crear el elemento y seleccione Agregar > Nuevo elemento :
Para usar una plantilla, seleccione la plantilla deseada, especifique un nombre para el archivo y seleccione
Aceptar . La adición de un elemento de este modo agrega automáticamente el archivo al proyecto de Visual
Studio y marca los cambios para el control de código fuente.
Pregunta: ¿Cómo sabe Visual Studio qué plantillas de elemento debe ofrecer?
Respuesta: El archivo de proyecto de Visual Studio (.pyproj) contiene un identificador de tipo de proyecto que lo
marca como un proyecto de Python. Visual Studio utiliza este identificador de tipo para mostrar solo aquellas
plantillas de elementos que sean adecuadas para el tipo de proyecto. De esta manera, Visual Studio puede
proporcionar un amplio conjunto de plantillas de elemento para muchos tipos de proyecto sin pedirle que los
ordene cada vez.
Paso 3.2: Atender archivos estáticos desde la aplicación

En una aplicación web compilada con Python (con cualquier plataforma), los archivos de Python siempre se
ejecutan en el servidor del host web y nunca se transmiten al equipo de un usuario. Otros archivos, sin
embargo, como CSS y JavaScript, se usan exclusivamente por el explorador, por lo que el servidor host
simplemente los ofrece tal cual cada vez que se soliciten. Estos archivos se denominan archivos "estáticos", y
Django puede distribuirlos automáticamente sin tener que escribir ningún código.
Un proyecto de Django se configura de forma predeterminada para proporcionar archivos estáticos de la
carpeta static de la aplicación, gracias a estas líneas en el archivo settings.py del proyecto de Django:
# Static files (CSS, JavaScript, Images)

# https://docs.djangoproject.com/en/1.9/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT = posixpath.join(*(BASE_DIR.split(os.path.sep) + ['static']))
Puede organizar los archivos con cualquier estructura de carpetas de static que quiera y luego usar rutas de
acceso relativas dentro de esa carpeta para hacer referencia a los archivos. Para mostrar este proceso, en los
pasos siguientes se agrega un archivo CSS a la aplicación y luego se usa esa hoja de estilos en la plantilla
index.html:
1. En el Explorador de soluciones , haga clic con el botón derecho en la carpeta HelloDjangoApp del
proyecto de Visual Studio, seleccione Agregar > Nueva carpeta y ponga a la carpeta el nombre
static .
2. Haga clic con el botón derecho en la carpeta static y seleccione Agregar > Nuevo elemento . En el
cuadro de diálogo que aparece, seleccione la plantilla Hoja de estilo , ponga al archivo el nombre
site.css y haga clic en Aceptar . El archivo site.css aparece en el proyecto y se abre en el editor. La
estructura de carpetas debería ser similar a la de la imagen siguiente:
3. Reemplace el contenido de site.css por el código siguiente y guarde el archivo:
.message {
font-weight: 600;
color: blue;
}
4. Reemplace el contenido del archivo templates/HelloDjangoApp/index.html de la aplicación por el código

siguiente, que reemplaza el elemento <strong> usado en el paso 2 por un <span> que hace referencia a
la clase de estilo message . El uso de una clase de estilo de este modo ofrece mucha más flexibilidad al
aplicar estilo al elemento. (Si no ha movido index.html a una subcarpeta de templates al usar VS 2017
15.7 y versiones anteriores, vea Template namespacing [Espaciado entre nombres de plantilla] en el paso
2-4).
<html>
<head>
{% load staticfiles %} 
<link rel="stylesheet" type="text/css" href="{% static 'site.css' %}" />
</head>
<body>
<span class="message">{{ message }}</span>{{ content }}
</body>
</html>
5. Ejecute el proyecto y observe los resultados. Detenga el servidor cuando haya finalizado y confirme los
cambios en el control de código fuente si lo desea (como se explica en paso 2).
System.Security.Cryptography.CryptographicException. ¿Para qué sirve la etiqueta {% load staticfiles %}?
Respuesta: La línea {% load staticfiles %} se requiere antes de hacer referencia a los archivos estáticos en
elementos como <head> y <body> . En el ejemplo que se muestra en esta sección, "staticfiles" hace referencia a
un conjunto de etiquetas de plantilla de Django personalizado, que es lo que le permite usar la sintaxis
{% static %} para hacer referencia a los archivos estáticos. Sin {% load staticfiles %} , verá una excepción
cuando se ejecute la aplicación.
System.Security.Cryptography.CryptographicException. ¿Hay alguna convención para organizar los archivos
estáticos?
Respuesta: Puede agregar otros archivos HTML, CSS y JavaScript a la carpeta static como quiera. Una forma
habitual de organizar los archivos estáticos es crear subcarpetas denominadas fonts, scripts y content (para las
hojas de estilos y cualquier otro archivo). En cada caso, no olvide incluir esas carpetas en la ruta de acceso
relativa al archivo en las referencias de {% static %} .
System.Security.Cryptography.CryptographicException. ¿Puedo completar la misma tarea sin usar la etiqueta
{% load staticfiles %}?
Respuesta: Sí, puede hacerlo.
<html>
<head>
<link rel="stylesheet" type="text/css" href="../../static/site.css" />
</head>
<body>
</body>
</html>
Paso 3-3: Adición de una página a la aplicación

La adición de otra página a la aplicación implica lo siguiente:
Agregar una función de Python que define la vista.
Agregar una plantilla para el marcado de la página.
Agregar el enrutamiento necesario al archivo urls.py del proyecto de Django.
Los pasos siguientes agregan una página de información al proyecto de "HelloDjangoApp" y los vínculos a esta
página desde la página principal:
1. En el Explorador de soluciones , haga clic con el botón derecho en la carpeta
templates/HelloDjangoApp , seleccione Agregar > Nuevo elemento , seleccione la plantilla de
elemento Página HTML , ponga al archivo el nombre about.html y haga clic en Aceptar .
TIP
Si el comando Nuevo elemento no aparece en el menú Agregar , asegúrese de que ha detenido el servidor para
que Visual Studio salga del modo de depuración.
2. Reemplace el contenido de about.html por el siguiente marcado (reemplace el vínculo explícito a la

página principal por una barra de navegación sencilla en el paso 3-4):
<html>
<head>
{% load staticfiles %}
</head>
<body>
<div><a href="home">Home</a></div>
{{ content }}
</body>
</html>
3. Abra el archivo views.py de la aplicación y agregue una función denominada about que use la plantilla:
def about(request):
return render(
request,
"HelloDjangoApp/about.html",
{
'title' : "About HelloDjangoApp",
'content' : "Example app page for Django."
}
)
4. Abra el archivo urls.py del proyecto de Django y agregue la línea siguiente a la matriz urlPatterns :
url(r'âbout$', HelloDjangoApp.views.about, name='about'),
5. Abra el archivo templates/HelloDjangoApp/index.html y agregue la línea siguiente debajo del elemento

<body> para vincular a la página Acerca de (de nuevo, reemplace este vínculo por una barra de
navegación en el paso 3-4):
<div><a href="about">About</a></div>
6. Guarde todos los archivos con el comando de menú Archivo > Guardar todo o simplemente presione
Ctrl +Mayús +S . (Técnicamente, este paso no es necesario porque la ejecución del proyecto en Visual
Studio guarda los archivos automáticamente. No obstante, es un comando que viene bien conocer).
7. Ejecute el proyecto para observar los resultados y compruebe la navegación entre las páginas. Cierre el
servidor cuando haya finalizado.
System.Security.Cryptography.CryptographicException. He intentado usar "index" para el vínculo a la página
principal, pero no ha funcionado. ¿Por qué?
Respuesta: Aunque la función de vista de views.py se denomina index , los patrones de enrutamiento de
dirección URL del archivo urls.py del proyecto de Django no contienen una expresión regular que coincida con
la cadena "index". Para que coincida con esa cadena, debe agregar otra entrada para el patrón îndex$ .
Como se muestra en la siguiente sección, es mucho mejor usar la etiqueta {% url '<pattern_name>' %} en la
plantilla de página para hacer referencia al nombre de un modelo, en cuyo caso Django crea la dirección URL
adecuada para su caso. Por ejemplo, reemplace <div><a href="home">Home</a></div> en about.html por
<div><a href="{% url 'index' %}">Home</a></div> . El uso de "index" aquí funciona porque el primer patrón de
dirección URL de urls.py se denomina, de hecho "index" (en virtud del argumento name='index' ). También
puede utilizar "home" para hacer referencia al segundo patrón.
Paso 3-4: Uso de la herencia de plantilla para crear un encabezado y
una barra de navegación
En lugar de tener vínculos de navegación explícitos en cada página, las aplicaciones web modernas suelen
utilizan un encabezado de personalización de marca y una barra de navegación que proporciona los vínculos de
página, los menús emergentes, etc. más importantes. Sin embargo, es poco práctico repetir el mismo código en
cada plantilla de página para asegurarse de que el encabezado y la barra de navegación son los mismos en
todas las páginas. Es preferible definir los elementos comunes de todas las páginas en un solo lugar.
El sistema de plantillas de Django ofrece dos formas de reutilizar elementos específicos a través de varias
plantillas: la inclusión y la herencia.
La inclusión son otras plantillas de página que se insertan en una ubicación específica de la plantillas de
referencia mediante la sintaxis {% include <template_path> %} . También puede utilizar una variable si
desea cambiar la ruta de acceso dinámicamente en el código. La inclusión se utiliza normalmente en el
cuerpo de una página para incorporar la plantilla compartida en una ubicación específica de la página.
La herencia utiliza {% extends <template_path> %} al principio de una plantilla de página para especificar
una plantilla base compartida sobre la que construye a continuación la plantilla de referencia. La herencia
se suele utilizar para definir un diseño, una barra de navegación y otras estructuras que se comparten
entre las páginas de una aplicación, de manera que las plantillas de referencia solo tengan que agregar o
modificar áreas específicas de la plantilla base denominadas bloques.
En ambos casos, <template_path> se refiere a la carpeta templates de la aplicación ( ../ o ./ también son
válidos).
Una plantilla base delimita los bloques usando las etiquetas {% block <block_name> %} y {% endblock %} . Si una
plantilla de referencia utiliza etiquetas con el mismo nombre de bloque, su contenido de bloque reemplaza al de
la plantilla base.
Los pasos siguientes muestran la herencia:
1. En la carpeta templates/HelloDjangoApp de la aplicación, cree un nuevo archivo HTML (con el menú
contextual Agregar > Nuevo elemento o Agregar > Página HTML ) denominado layout.html y
reemplace su contenido por el siguiente marcado. Puede ver que esta plantilla contiene un bloque
denominado "content" que es todo lo que tienen que reemplazar las páginas de referencia:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
</head>
<body>
<div class="navbar">
<a href="/" class="navbar-brand">Hello Django</a>
<a href="{% url 'home' %}" class="navbar-item">Home</a>
<a href="{% url 'about' %}" class="navbar-item">About</a>
</div>
<div class="body-content">
{% block content %}{% endblock %}
<hr/>
<footer>
<p>© 2018</p>
</footer>
</div>
</body>
</html>
2. Agregue los estilos siguientes al archivo static/site.css de la aplicación (en este tutorial no se está
intentando mostrar un diseño con capacidad de respuesta; estos estilos simplemente sirven para generar
un resultado interesante):
.navbar {
background-color: lightslategray;
font-size: 1em;
font-family: 'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-
serif;
color: white;
padding: 8px 5px 8px 5px;
}
.navbar a {
text-decoration: none;
color: inherit;
}
.navbar-brand {
font-size: 1.2em;
font-weight: 600;
}
.navbar-item {
font-variant: small-caps;
margin-left: 30px;
}
.body-content {
padding: 5px;
font-family:'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
}
3. Modifique templates/HelloDjangoApp/index.html para hacer referencia a la plantilla base y reemplace el

bloque de contenido. Puede ver que, mediante la herencia, esta plantilla se simplifica:
{% extends "HelloDjangoApp/layout.html" %}
{% block content %}
{% endblock %}
4. Modifique templates/HelloDjangoApp/about.html para que también haga referencia a la plantilla base y

reemplace el bloque de contenido:
{% extends "HelloDjangoApp/layout.html" %}
{% block content %}
{{ content }}
{% endblock %}
5. Ejecute el servidor para observar los resultados. Cierre el servidor cuando haya finalizado.
6. Dado que ha realizado cambios sustanciales en la aplicación, es de nuevo un buen momento para
confirmar los cambios en el control de código fuente.
Pasos siguientes
Usar la plantilla completa de Proyecto web de Django

Publicación de la aplicación web en Azure App Service
Escribiendo su primera aplicación en Django, parte 3 (vistas) (docs.djangoproject.com)
Para conocer más funciones de las plantillas de Django, como el flujo de control, consulte The Django
template language (El lenguaje de plantilla de Django) (docs.djangoproject.com).
Para obtener información detallada sobre el uso de la etiqueta {% url %} , consulte url dentro de Built-in
template tags and filters for Django templates reference (Etiquetas y filtros de plantilla integrados para
referencia de plantillas de Django) (docs.djangoproject.com)
Paso 4. Usar la plantilla completa de Proyecto web
de Django
Paso anterior : Atender archivos estáticos, agregar páginas y usar la herencia de plantilla
Ahora que ha explorado los conceptos básicos de Django mediante la creación de una aplicación a partir de la
plantilla "Proyecto web de Django en blanco" en Visual Studio, podrá comprender fácilmente la aplicación más
completa que se genera mediante la plantilla "Proyecto web de Django".
En este paso, hará lo siguiente:
Crear una aplicación web de Django más completa mediante la plantilla "Proyecto web de Django" y
examinar la estructura del proyecto (paso 4.1)
Comprender las vistas y las plantillas de página creadas por la plantilla de proyecto, que consta de tres
páginas que heredan de una plantilla de página base y emplea las bibliotecas estáticas de JavaScript, como
jQuery y Bootstrap (paso 4.2)
Comprender el enrutamiento de direcciones URL que proporciona la plantilla (paso 4.3)
La plantilla también proporciona autenticación básica, que se explica en el paso 5.
Paso 4.1: Crear un proyecto a partir de la plantilla

1. En Visual Studio, vaya al Explorador de soluciones , haga clic con el botón derecho en la solución
LearningDjango creada anteriormente en este tutorial y seleccione Agregar > Nuevo proyecto . (En
caso de que desee utilizar una nueva solución, tendrá que seleccionar Archivo > Nuevo > Proyecto ).
2. En el cuadro de diálogo del nuevo proyecto, busque y seleccione la plantilla Proyecto web de Django ,
asigne al proyecto el nombre "DjangoWeb" y haga clic en Aceptar .
3. Dado que la plantilla de nuevo incluye un archivo requirements.txt, Visual Studio le pregunta dónde
instalar esas dependencias. Elija la opción Install into a vir tual environment (Instalar en un entorno
virtual) y, en el cuadro de diálogo Agregar entorno vir tual , seleccione Crear para aceptar los valores
predeterminados.
4. Una vez que Visual Studio termine de configurar el entorno virtual, siga las instrucciones del archivo
readme.html que aparece para crear un superusuario de Django (es decir, un administrador).
Simplemente haga clic con el botón derecho en el proyecto de Visual Studio y seleccione el comando
Python > Django Create Superuser (Crear superusuario de Django); a continuación, siga las
indicaciones. Asegúrese de registrar su nombre de usuario y contraseña cuando los use al ejecutar las
características de autenticación de la aplicación.
5. Establezca el proyecto DjangoWeb como predeterminado para la solución de Visual Studio; para ello,
haga clic con el botón derecho en ese proyecto en el Explorador de soluciones y seleccione
Establecer como proyecto de inicio . El proyecto de inicio, que se muestra en negrita, es lo que
ejecuta cuando se inicia el depurador.
6. Seleccione Depurar > Iniciar depuración (F5 ) o use el botón Ser vidor web de la barra de
herramientas para ejecutar el servidor:
7. La aplicación creada por la plantilla tiene tres páginas: una de inicio, otra de información y otra de
contacto, por las que puede navegar con la barra de navegación. Tómese un par de minutos para
examinar las diferentes partes de la aplicación. Para autenticarse en la aplicación a través del comando
Iniciar sesión , use las credenciales de superusuario creadas anteriormente.
8. La aplicación creada por la plantilla "Proyecto web de Django" usa Bootstrap para el diseño con capacidad
de respuesta que acoge los factores de los formatos móviles. Para ver esta capacidad de respuesta,
cambie el tamaño del explorador a una vista estrecha para que el contenido se represente verticalmente
y la barra de navegación se convierta en un icono de menú:
9. Puede dejar la aplicación en ejecución para las secciones siguientes.

Si quiere detener la aplicación y confirmar los cambios en el control de código fuente, primero abra la
página Cambios en Team Explorer , haga clic con el botón derecho en la carpeta del entorno virtual
(probablemente env ) y seleccione Omitir estos elementos locales .
Examen de lo que crea la plantilla
En el nivel más amplio, la plantilla "Proyecto web de Django" crea la siguiente estructura:
Archivos en la raíz del proyecto:
manage.py, la utilidad administrativa de Django.
db.sqlite3, una base de datos de SQLite predeterminada.
requirements.txt, que contiene una dependencia en Django 1.x.
readme.html, un archivo que se muestra en Visual Studio después de crear el proyecto. Como se
indicó en la sección anterior, siga estas instrucciones para crear una cuenta de superusuario
(administrador) para la aplicación.
La carpeta app contiene todos los archivos de la aplicación, lo que incluye vistas, modelos, pruebas,
formularios, plantillas y archivos estáticos (vea el paso 4-2). Puede cambiar el nombre de esta carpeta para
utilizar otro que le ayude a distinguirla mejor.
La carpeta DjangoWeb (proyecto de Django) contiene los archivos de proyecto típicos de Django: __init__.py,
settings.py, urls.py y wsgi.py. Con la plantilla de proyecto, settings.py ya está configurado para la aplicación y
el archivo de base de datos, mientras que urls.py ya está configurado con las rutas a todas las páginas de la
aplicación, incluido el formulario de inicio de sesión.
Pregunta: ¿Es posible compartir un entorno virtual entre los proyectos de Visual Studio?
Respuesta: Sí, pero hágalo siendo consciente de que es probable que proyectos diferentes usen paquetes
diferentes con el tiempo y, por lo tanto, un entorno virtual compartido debe contener todos los paquetes de
todos los proyectos que lo usan.
No obstante, para usar un entorno virtual existente, haga lo siguiente:
1. Cuando se le solicite instalar las dependencias en Visual Studio, seleccione la opción Los instalaré de
forma manual .
seleccione Agregar entorno vir tual existente .
3. Vaya la carpeta que contiene el entorno virtual, selecciónela y luego elija Aceptar .
Paso 4.2: Comprender las vistas y las plantillas de página creadas por
la plantilla de proyecto
Tal y como se observa cuando se ejecuta el proyecto, la aplicación contiene tres vistas: inicio, información y
contacto. El código de estas vistas se encuentra en la carpeta app/views. Cada función de la vista simplemente
llama a django.shortcuts.render con la ruta de acceso a una plantilla y un sencillo objeto de diccionario. Por
ejemplo, la función about es quien controla la página de información:
def about(request):
"""Renders the about page."""
assert isinstance(request, HttpRequest)
return render(
request,
'app/about.html',
{
'title':'About',
'message':'Your application description page.',
'year':datetime.now().year,
}
)
Las plantillas se encuentran en la carpeta templates/app de la aplicación (y normalmente se quiere cambiar el

nombre app por el de la aplicación real). La plantilla base, layout.html, es la más extensa. Hace referencia a todos
los archivos estáticos necesarios (JavaScript y CSS), define un bloque denominado "content" que otras páginas
sobrescriben, y proporciona otro bloque denominado "scripts". Los siguientes extractos con anotaciones de
layout.html muestran estas áreas específicas:
<!DOCTYPE html>
<html>
<head>


<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{{ title }} - My Django Application</title>
<link rel="stylesheet" type="text/css" href="{% static 'app/content/bootstrap.min.css' %}" />
<link rel="stylesheet" type="text/css" href="{% static 'app/content/site.css' %}" />
<script src="{% static 'app/scripts/modernizr-2.6.2.js' %}"></script>
</head>
<body>

<div class="container body-content">


{% block content %}{% endblock %}
<hr/>
<footer>
<p>© {{ year }} - My Django Application</p>
</footer>
</div>

<script src="{% static 'app/scripts/jquery-1.10.2.js' %}"></script>
<script src="{% static 'app/scripts/bootstrap.js' %}"></script>
<script src="{% static 'app/scripts/respond.js' %}"></script>
{% block scripts %}{% endblock %}
</body>
</html>
Las plantillas de página individuales, about.html, contact.html e index.html, amplían la plantilla base layout.html.
about.html es la más sencilla y muestra las etiquetas {% extends %} y {% block content %} :
{% extends "app/layout.html" %}
{% block content %}
<h2>{{ title }}.</h2>

<h3>{{ message }}</h3>
<p>Use this area to provide additional information.</p>
{% endblock %}
index.html y contact.html usan la misma estructura y proporcionan contenido más largo en el bloque "content".
En la carpeta templates/app también hay una cuarta página login.html, junto con loginpartial.html, que se
traslada a layout.html mediante {% include %} . Estos archivos de plantilla se describen en el paso 5 sobre la
autenticación.
Pregunta: ¿Es posible aplicar sangría a {% block %} y {% endblock %} en la plantilla de página de Django?
Respuesta: Sí, las plantillas de página de Django funcionan correctamente si aplica sangría a las etiquetas de
bloque, quizás para alinearlas en sus elementos principales más adecuados. No se les aplica sangría en las
plantillas de página generadas por la plantilla de proyecto de Visual Studio para que pueda ver claramente
donde se colocan.
Paso 4.3: Comprender el enrutamiento de direcciones URL creado por
la plantilla
El archivo urls.py del proyecto Django, tal como lo crea la plantilla "Proyecto web de Django", contiene el código
siguiente:

from django.conf.urls import url
import django.contrib.auth.views
import app.forms
import app.views
urlpatterns = [
url(r'^$', app.views.home, name='home'),
url(r'^contact$', app.views.contact, name='contact'),
url(r'âbout$', app.views.about, name='about'),
url(r'^login/$',
django.contrib.auth.views.login,
{
'template_name': 'app/login.html',
'authentication_form': app.forms.BootstrapAuthenticationForm,
'extra_context':
{
'title': 'Log in',
'year': datetime.now().year,
}
},
name='login'),
url(r'^logout$',
django.contrib.auth.views.logout,
{
'next_page': '/',
},
name='logout'),
]
Los primeros tres patrones de dirección URL se asignan directamente a las vistas home , contact y about en el
archivo views.py de la aplicación. Los patrones ^login/$ y ^logout$ , por otra parte, usan las vistas de Django
integradas en lugar de vistas definidas por la aplicación. Las llamadas al método url también incluyen datos
adicionales para personalizar la vista. En el paso 5 se exploran estas llamadas.
Pregunta: En el proyecto que he creado, ¿por qué el patrón de dirección URL "about" usa "âbout" en lugar
de "âbout$" como se ha visto aquí?
Respuesta: La falta de la "$" al final de la expresión regular se debe simplemente a un descuido en muchas de las
versiones de la plantilla del proyecto. El patrón de dirección URL funciona perfectamente en una página
denominada "about", pero sin el carácter "$" el patrón de dirección URL coincide también direcciones URL como
"about=django", "about09876", "aboutoflaughter", etc. El carácter "$" al final se muestra aquí para crear un
patrón de dirección URL que coincida solo con "about".
Pasos siguientes
Autenticación de usuarios en Django

Escribiendo su primera aplicación en Django, parte 4 (formas y vistas genéricas) (docs.djangoproject.com)
Paso 5: Autenticación de usuarios en Django
Paso anterior : Uso de la plantilla completa de Proyecto web de Django

Dado que la autenticación es una necesidad común para las aplicaciones web, la plantilla "Proyecto web de
Django" incluye un flujo de autenticación básica. (La plantilla "Proyecto web de Django de sondeos", que se
describe en el paso 6 de este tutorial, también incluye el mismo flujo). Al usar cualquiera de las plantillas de
proyecto de Django, Visual Studio incluye todos los módulos necesarios para la autenticación en el archivo
settings.py del proyecto de Django.
Dado que la autenticación es una necesidad común para las aplicaciones web, la plantilla "Proyecto web de
Django" incluye un flujo de autenticación básica. Al usar cualquiera de las plantillas de proyecto de Django,
Visual Studio incluye todos los módulos necesarios para la autenticación en el archivo settings.py del proyecto
de Django.
En este paso, aprenderá lo siguiente:
Cómo usar el flujo de autenticación proporcionado en las plantillas de Visual Studio (paso 5.1)
Paso 5-1: Uso del flujo de autenticación

En los pasos siguientes se utiliza el flujo de autenticación y se describen las partes del proyecto que intervienen:
1. Si no ha seguido todavía las instrucciones del archivo readme.html de la raíz del proyecto para crear una
cuenta de superusuario (administrador), hágalo ahora.
2. Ejecute la aplicación desde Visual Studio mediante Depurar > Iniciar depuración (F5 ). Cuando la
aplicación aparezca en el explorador, observe que aparece Iniciar sesión en la esquina superior derecha
de la barra de navegación.
3. Abra templates/app/layout.html y observe que el elemento <div class="navbar ...> contiene la etiqueta
{% include app/loginpartial.html %} . La etiqueta {% include %} indica al sistema de plantillas de Django
que incorpore el contenido del archivo incluido en este momento en la plantilla que lo contiene.
4. Abra templates/app/loginpartial.html y observe cómo usa la etiqueta condicional
{% if user.is_authenticated %} junto con una etiqueta {% else %} para representar diferentes
elementos de la interfaz de usuario en función de si se ha autenticado al usuario:
{% if user.is_authenticated %}
<form id="logoutForm" action="/logout" method="post" class="navbar-right">
{% csrf_token %}
<ul class="nav navbar-nav navbar-right">
<li><span class="navbar-brand">Hello {{ user.username }}!</span></li>
<li><a href="javascript:document.getElementById('logoutForm').submit()">Log off</a></li>
</ul>
</form>
{% else %}
<ul class="nav navbar-nav navbar-right">

<li><a href="{% url 'login' %}">Log in</a></li>
</ul>
{% endif %}
5. Habida cuenta que no hay ningún usuario autenticado al iniciar la aplicación por primera vez, este código
de plantilla representa solo el vínculo "Iniciar sesión" en la ruta de acceso relativa "login". Como se
especifica en urls.py (tal como se muestra en la sección anterior), esa ruta está asignada a la vista
django.contrib.auth.views.login . Esa vista recibe los siguientes datos:
{
'template_name': 'app/login.html',
'authentication_form': app.forms.BootstrapAuthenticationForm,
'extra_context':
{
'title': 'Log in',
}
}
Aquí, template_name identifica la plantilla de la página de inicio de sesión, en este caso

templates/app/login.html. La propiedad extra_context se agrega a los datos de contexto
predeterminados proporcionados a la plantilla. Por último, authentication_form especifica una clase de
formulario que se usa con el inicio de sesión; en la plantilla aparece como objeto form . El valor
predeterminado es AuthenticationForm (de django.contrib.auth.views ); la plantilla de proyecto de Visual
Studio usa en su lugar el formulario definido en el archivo forms.py de la aplicación:
from django import forms

from django.contrib.auth.forms import AuthenticationForm
from django.utils.translation import ugettext_lazy as _
class BootstrapAuthenticationForm(AuthenticationForm):
"""Authentication form which uses boostrap CSS."""
username = forms.CharField(max_length=254,
widget=forms.TextInput({
'class': 'form-control',
'placeholder': 'User name'}))
password = forms.CharField(label=_("Password"),
widget=forms.PasswordInput({
'class': 'form-control',
'placeholder':'Password'}))
Como puede ver, esta clase de formulario se deriva de AuthenticationForm e invalida específicamente los
campos de nombre de usuario y contraseña para agregar texto de marcador de posición. La plantilla de
Visual Studio incluye este código explícito suponiendo que probablemente quiera personalizar el
formulario, por ejemplo, agregando una característica de validación de la seguridad de la contraseña.
6. Cuando se desplaza a la página de inicio de sesión, la aplicación representa la plantilla login.html. Las
variables {{ form.username }} y {{ form.password }} representan los formularios CharField de
BootstrapAuthenticationForm . También hay una sección integrada para mostrar errores de validación, y
un elemento listo para su uso para los inicios de sesión con medios sociales, por si opta por agregar esos
servicios.
{% block content %}
<h2>{{ title }}</h2>

<div class="row">
<div class="col-md-8">
<section id="loginForm">
<form action="." method="post" class="form-horizontal">
{% csrf_token %}
<h4>Use a local account to log in.</h4>
<hr />
<div class="form-group">
<label for="id_username" class="col-md-2 control-label">User name</label>
{{ form.username }}
</div>
</div>
<label for="id_password" class="col-md-2 control-label">Password</label>
{{ form.password }}
</div>
</div>
<div class="col-md-offset-2 col-md-10">
<input type="hidden" name="next" value="/" />
<input type="submit" value="Log in" class="btn btn-default" />
</div>
</div>
{% if form.errors %}
<p class="validation-summary-errors">Please enter a correct user name and password.
</p>
{% endif %}
</form>
</section>
</div>
<section id="socialLoginForm"></section>
</div>
</div>
{% endblock %}
7. Cuando se envía el formulario, Django intenta autenticar las credenciales (por ejemplo, las credenciales
del superusuario). Si se produce un error en la autenticación, permanecerá en la página actual, pero
form.errors se establecerá en true. Si la autenticación se realiza correctamente, Django navegará a la
dirección URL relativa del campo "next", <input type="hidden" name="next" value="/" /> , que en este caso
es la página principal ( / ).
8. Ahora, cuando se vuelve a representar la página principal, la propiedad user.is_authenticated es true si
se representa la plantilla loginpartial.html. Como resultado, se ve un mensaje Hello (nombre de
usuario) y Cerrar sesión . Puede usar user.is_authenticated en otras partes de la aplicación para
comprobar la autenticación.
9. Para comprobar si el usuario autenticado está autorizado a acceder a recursos específicos, deberá
recuperar permisos específicos de usuario de la base de datos. Para obtener más información, vea Using
the Django authentication system (Uso del sistema de autenticación de Django) (Documentación de
Django).
10. El superusuario o el administrador, en concreto, está autorizado a acceder a las interfaces de
administrador de Django integradas con las direcciones URL relativas "/admin/" y "/admin/doc/". Para
habilitar estas interfaces, haga lo siguiente:
a. Instale el paquete de Python docutils en el entorno. Una excelente manera de hacerlo es agregar
"docutils" al archivo requirements.txt y, luego, en el Explorador de soluciones , expandir el nodo
Entornos de Python , hacer clic con el botón derecho en el entorno que está usando y seleccionar
Instalar desde requirements.txt .
b. Abra el archivo urls.py del proyecto de Django y quite los comentarios predeterminados de las
siguientes entradas:
from django.conf.urls import include

from django.contrib import admin
admin.autodiscover()
# ...
urlpatterns = [
# ...
url(r'âdmin/doc/', include('django.contrib.admindocs.urls')),
url(r'âdmin/', include(admin.site.urls)),
]
c. En el archivo settings.py del proyecto de Django, vaya a la colección INSTALLED_APPS y agregue

'django.contrib.admindocs' .
d. Cuando reinicie la aplicación, puede ir a "/admin/" y "/admin/doc/" y realizar tareas como crear
cuentas de usuario adicionales.
11. La parte final del flujo de autenticación es el cierre de sesión. Como puede ver en loginpartial.html, el
vínculo Cerrar sesión simplemente realiza una operación POST a la dirección URL relativa "/login", que
se controla mediante la vista integrada django.contrib.auth.views.logout . Esta vista no muestra ninguna
interfaz de usuario y solo se desplaza a la página principal (como se muestra en urls.py para el patrón
"^logout$"). Si desea mostrar una página de cierre de sesión, cambie primero el patrón de dirección URL
como se indica a continuación para agregar una propiedad "template_name" y quite la propiedad
"next_page":
url(r'^logout$',
django.contrib.auth.views.logout,
{
'template_name': 'app/loggedoff.html',
# 'next_page': '/',
},
name='logout')
Luego cree templates/app/loggedoff.html con el siguiente contenido (mínimo):
{% block content %}
<h3>You have been logged off</h3>
{% endblock %}
El resultado se muestra de la manera siguiente:
12. Cuando haya terminado, detenga el servidor y una vez más confirme los cambios en el control de código
fuente.
System.Security.Cryptography.CryptographicException. ¿Cuál es la finalidad de la etiqueta {% csrf_token %}
que aparece en los elementos <form>?
Respuesta: La etiqueta {% csrf_token %} incluye la protección de falsificación de solicitud entre sitios (csrf)
integrada de Django (documentación de Django). Normalmente se agrega esta etiqueta a cualquier elemento
que incluya los métodos de solicitud POST, PUT o DELETE, como un formulario. Luego, la función de
representación de la plantilla ( render ) inserta la protección necesaria.
Pasos siguientes
Usar la plantilla de proyecto web de Django de sondeos
NOTE
Si ha estado confirmando la solución de Visual Studio en el control de código fuente en el transcurso de este tutorial,
ahora es un buen momento de hacer otra confirmación. La solución debe coincidir con el código fuente del tutorial en
GitHub: Microsoft/python-sample-vs-learning-django.
Ya ha explorado por completo las plantillas "Proyecto web de Django en blanco" y "Proyecto web de Django" en
Visual Studio. Ha aprendido todos los elementos básicos de Django, como el uso de vistas y plantillas, y ha
explorado el enrutamiento, la autenticación y el uso de modelos de base de datos. Ahora podrá crear una
aplicación web propia con las vistas y los modelos que necesite.
La ejecución de una aplicación web en el equipo de desarrollo es solamente un paso en el proceso de poner la
aplicación a disposición de sus clientes. Los pasos siguientes pueden incluir las siguientes tareas:
Implementar la aplicación web en un servidor de producción, como Azure App Service. Consulte
Publicación en Azure App Service.
Personalice la página 404 mediante la creación de una plantilla denominada templates/404.html. Cuando
está presente, Django utiliza esta plantilla en lugar de la predeterminada. Para obtener más información,
consulte Error views (Vistas de error) en la documentación de Django.
Escriba pruebas unitarias en tests.py; las plantillas de proyecto de Visual Studio proporcionan puntos de
inicio para eso; además, puede encontrar más información en Writing your first Django app, part 5 -
testing (Escribir la primera aplicación de Django, parte 5: pruebas) y Testing in Django (Pruebas en
Django) en la documentación de Django.
Cambiar la aplicación de SQLite a un almacén de datos a nivel de producción como PostgreSQL, MySQL y
SQL Server (todos se pueden hospedar en Azure). Como se describe en When to use SQLite (Cuándo
usar SQLite) (sqlite.org), SQLite funciona perfectamente en sitios de tráfico bajo a medio, con menos de
100.000 visitas al día, pero no se recomienda en volúmenes más elevados. También está limitado a un
único equipo, por lo tanto no se puede usar en escenarios de varios servidores, como el equilibrio de
carga y la replicación geográfica. Para obtener información sobre la compatibilidad con Django otras
bases de datos, vea Configuración de la base de datos. También puede usar el SDK de Azure para Python
para trabajar con los servicios de almacenamiento de Azure, como tablas y blobs.
Configurar una canalización de implementación continua/integración continua en un servicio como
Azure DevOps. Además de funcionar con el control de código fuente (en Azure Repos, GitHub u otro
servicio), puede configurar un proyecto de Azure DevOps para que ejecute automáticamente pruebas
unitarias como requisito previo para la publicación y también configurar la canalización para
implementar en un servidor de ensayo para pruebas adicionales antes de implementar en producción.
Azure DevOps, además, se integra con soluciones de supervisión como App Insights y cierra todo el ciclo
con herramientas de planeación de Ágil. Para obtener más información, consulte Creación de una
canalización de CI/CD para Python con Azure DevOps Projects y también la Azure DevOps
Documentation (Documentación de Azure DevOps) general.

User authentication in Django (Autenticación de usuarios en Django) (docs.djangoproject.com)
Paso 6. Usar la plantilla de proyecto web de Django
de sondeos
Paso anterior : Autenticación de los usuarios en Django

Ahora que conoce la plantilla "Proyecto web de Django" de Visual Studio, podemos analizar la tercera plantilla
de Django, "Proyecto web de Django de sondeos", que se basa en el mismo código base y demuestra el trabajo
con una base de datos.
Crear un proyecto a partir de la plantilla e inicializar la base de datos (paso 6.1)
Comprender los modelos de datos (paso 6.2)
Aplicar migraciones (paso 6.3)
Comprender las vistas y las plantillas de página creadas por la plantilla de proyecto (paso 6.4)
Crear una interfaz de administración personalizada (paso 6.5)
El proyecto creado con esta plantilla es similar al que se obtiene tras seguir el tutorial Escribiendo su primera
aplicación en Django de la documentación de Django. La aplicación web consta de un sitio público que permite
a los usuarios ver sondeos y votar en ellos, además de una interfaz de administración personalizada que sirve
para administrar los sondeos. En ella se utiliza el mismo sistema de autenticación que en la plantilla "Proyecto
web de Django" y se hace un mayor uso de la base de datos mediante la implementación de modelos de
Django, tal y como se muestra en las secciones siguientes.
Paso 6.1: Crear el proyecto e inicializar la base de datos

1. En Visual Studio, vaya al Explorador de soluciones , haga clic con el botón derecho en la solución
LearningDjango creada anteriormente en este tutorial y seleccione Agregar > Nuevo proyecto . (En
caso de que desee utilizar una nueva solución, tendrá que seleccionar Archivo > Nuevo > Proyecto ).
2. En el cuadro de diálogo del nuevo proyecto, busque y seleccione la plantilla Proyecto web de Django
de sondeos , asigne al proyecto el nombre "DjangoPolls" y haga clic en Aceptar .
3. Al igual que otras plantillas de proyecto de Visual Studio, la plantilla "Proyecto web de Django de
sondeos" incluye un archivo requirements.txt, y Visual Studio pregunta dónde instalar esas dependencias.
Elija la opción Install into a vir tual environment (Instalar en un entorno virtual) y, en el cuadro de
diálogo Agregar entorno vir tual , seleccione Crear para aceptar los valores predeterminados.
4. Una vez que Python termine de configurar el entorno virtual, siga las instrucciones del archivo
readme.html que aparece para inicializar la base de datos y crear un superusuario de Django (es decir, un
administrador). Primero hay que hacer clic con el botón derecho en el proyecto DjangoPolls en el
Explorador de soluciones , seleccionar el comando Python > Migración de Django , luego hacer clic
de nuevo con el botón derecho en el proyecto, seleccionar el comando Python > Crear superusuario
de Django y seguir las indicaciones. (Si intenta crear un superusuario primero, verá un error porque no
se inicializó la base de datos).
5. Establezca el proyecto DjangoPolls como predeterminado para la solución de Visual Studio; para ello,
haga clic con el botón derecho en ese proyecto en el Explorador de soluciones y seleccione
Establecer como proyecto de inicio . El proyecto de inicio, que se muestra en negrita, es lo que
ejecuta cuando se inicia el depurador.
herramientas para ejecutar el servidor:
7. La aplicación creada por la plantilla tiene tres páginas: una de inicio, otra de información y otra de
contacto, por las que puede navegar con la barra de la parte superior. Tómese un minuto o dos para
examinar las diferentes partes de la aplicación (las páginas de información y contacto son muy similares
al "Proyecto web de Django" y no se vuelven a tratar).
8. Seleccione también el vínculo Administración en la barra de navegación, que muestra una pantalla de
inicio de sesión para demostrar que la interfaz administrativa está autorizada únicamente para los
administradores autenticados. Use las credenciales de superusuario y se le dirigirá a la página "/admin",
que está habilitada de forma predeterminada cuando se usa esta plantilla de proyecto.
9. Puede dejar la aplicación en ejecución para las secciones siguientes.

Si quiere detener la aplicación y confirmar los cambios en el control de código fuente, primero abra la
página Cambios en Team Explorer , haga clic con el botón derecho en la carpeta del entorno virtual
(probablemente env ) y seleccione Omitir estos elementos locales .
Examen del contenido del proyecto
Como se indicó previamente, gran parte de lo que aparece en un proyecto creado a partir de la plantilla de
"Proyecto web de Django de sondeos" debe resultarle familiar si ha explorado las otras plantillas de proyecto en
Visual Studio. En el resto de pasos de este artículo se resumen los cambios y novedades más importantes; en
especial, los modelos de datos y las vistas adicionales.
Pregunta: ¿Para qué sirve el comando Migración de Django?
Respuesta: El comando Migración de Django ejecuta específicamente el comando manage.py migrate , que
ejecuta los scripts de la carpeta app/migrations que no se hayan ejecutado con anterioridad. En este caso, el
comando ejecuta el script 0001_initial.py de esa carpeta para configurar el esquema necesario en la base de
datos.
El propio script de migración se crea mediante el comando manage.py makemigrations , que examina el archivo
models.py de la aplicación, lo compara con el estado actual de la base de datos y luego genera los scripts
necesarios para migrar el esquema de la base de datos para que coincida con los modelos actuales. Esta
característica de Django es muy eficaz, ya que permite actualizar y modificar los modelos a lo largo del tiempo.
Mediante la generación y ejecución de migraciones, puede mantener los modelos y la base de datos
sincronizados con bastante sencillez.
En el paso 6.3 de este artículo trabajará con una migración.
Paso 6.2: Comprender los modelos de datos

Los modelos de la aplicación, denominados Poll y Choice, se definen en app/models.py. Cada uno de ellos es
una clase de Python que se deriva de django.db.models.Model y usa los métodos de la clase models , como
CharField y IntegerField , para definir campos en el modelo, que se asignan a columnas de la base de datos.
from django.db import models

from django.db.models import Sum
class Poll(models.Model):
"""A poll object for use in the application views and repository."""
text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
def total_votes(self):
"""Calculates the total number of votes for this poll."""
return self.choice_set.aggregate(Sum('votes'))['votes__sum']
def __unicode__(self):
"""Returns a string representation of a poll."""
return self.text
class Choice(models.Model):
"""A poll choice object for use in the application views and repository."""
poll = models.ForeignKey(Poll)
text = models.CharField(max_length=200)
votes = models.IntegerField(default=0)
def votes_percentage(self):
"""Calculates the percentage of votes for this choice."""
total = self.poll.total_votes()
return self.votes / float(total) * 100 if total > 0 else 0
def __unicode__(self):
"""Returns a string representation of a choice."""
return self.text
Como puede ver, un modelo Poll mantiene una descripción en su campo text y una fecha de publicación en
pub_date . Estos campos son los únicos que existen para el elemento Poll de la base de datos. El campo
total_votes se calcula en tiempo de ejecución.
Un elemento Choice se relaciona con un elemento Poll a través del campo poll , contiene una descripción en
text y mantiene un recuento para esa opción en votes . El campo votes_percentage se calcula en tiempo de
ejecución y no se encuentra en la base de datos.
La lista completa de tipos de campo es CharField (texto limitado), TextField (texto ilimitado), EmailField ,
URLField , DateTimeField , IntegerField , DecimalField , BooleanField , ForeignKey y ManyToMany . Cada campo
tiene algunos atributos, como max_length . El atributo blank=True significa que el campo es opcional;
null=true significa que un valor es opcional. También hay un atributo choices que limita los valores a valores
en una matriz de tuplas de valor de datos/valor de visualización. (Consulte Model field reference [Modelado de
referencia de campo] en la documentación de Django).
Puede confirmar exactamente qué hay almacenado en la base de datos si examina el archivo db.sqlite3 del
proyecto con una herramienta como el explorador SQLite. En la base de datos, verá que un campo de clave
externa como poll en el modelo Choice se almacena como poll_id ; Django controla la asignación
automáticamente.
En general, trabajar con la base de datos en Django significa trabajar exclusivamente a través de los modelos
para que Django pueda administrar la base de datos subyacente en su nombre.
Inicialización de la base de datos a partir de samples.json
Inicialmente, la base de datos no contiene ningún sondeo. Puede usar la interfaz administrativa en la dirección
URL "/admin" para agregar sondeos manualmente, y también puede visitar la página "/seed" en el sitio de
ejecución para agregar a la base de datos los sondeos definidos en el archivo samples.json de la aplicación.
El archivo urls.py del proyecto de Django tiene un patrón de dirección URL agregado,
url(r'^seed$', app.views.seed, name='seed'), . La vista seed de app/views.py carga el archivo samples.json y
crea los objetos de modelo necesarios. A continuación, Django crea automáticamente los registros coincidentes
en la base de datos subyacente.
Observe el uso del decorador @login_required para indicar el nivel de autorización para la vista.
@login_required
def seed(request):
"""Seeds the database with sample polls."""
samples_path = path.join(path.dirname(__file__), 'samples.json')
with open(samples_path, 'r') as samples_file:
samples_polls = json.load(samples_file)
for sample_poll in samples_polls:

poll = Poll()
poll.text = sample_poll['text']
poll.pub_date = timezone.now()
poll.save()
for sample_choice in sample_poll['choices']:

choice = Choice()
choice.poll = poll
choice.text = sample_choice
choice.votes = 0
choice.save()
return HttpResponseRedirect(reverse('app:home'))
Para ver el efecto, ejecute la aplicación primero para ver que no existe todavía ningún sondeo. Luego, visite la
dirección URL "/seed" y, cuando la aplicación vuelva a la página de inicio, debería constatar que los sondeos ya
están disponibles. Una vez más, no dude en examinar el archivo db.sqlite3 sin formato con una herramienta
como el explorador de SQLite.
Pregunta: ¿Es posible inicializar la base de datos con la utilidad administrativa de Django?
Respuesta: Sí, puede usar el comando django-admin loaddata para realizar la misma tarea que la página de
inicialización de la aplicación. Cuando se trabaja en una aplicación web completa, puede usar una combinación
de los dos métodos: inicializar una base de datos desde la línea de comandos y, a continuación, convertir la
página de inicialización aquí en una API a la que puede enviar cualquier otro JSON arbitrario en lugar de confiar
en un archivo codificado de forma rígida.
Paso 6.3: Usar migraciones

Cuando ejecutó el comando manage.py makemigrations (mediante el menú contextual de Visual Studio) después
de crear el proyecto, Django creó el archivo app/migrations/0001_initial.py. Este archivo contiene un script que
crea las tablas de base de datos iniciales.
Habida cuenta que inevitablemente tendrá que hacer cambios en los modelos con el paso del tiempo, Django
facilita la puesta al día del esquema de la base de datos subyacente con estos modelos. El flujo de trabajo
general es el siguiente:
1. Haga cambios en los modelos del archivo models.py.
2. En Visual Studio, haga clic con el botón derecho en el proyecto en el Explorador de soluciones y
seleccione el comando Python > Django Make Migrations (Hacer migraciones de Django). Como se ha
explicado anteriormente, este comando genera scripts en app/migrations para migrar la base de datos de su
estado actual al nuevo estado.
3. Para aplicar los scripts a la base de datos real, haga clic de nuevo en el proyecto con el botón derecho y
seleccione Python > Django Migrate (Migrar Django).
Django realiza un seguimiento de las migraciones que se han aplicado a cualquier base de datos, de manera que
cuando se ejecuta el comando de migración, Django aplica tantas migraciones como sean necesarias. Si crea
una base de datos nueva y vacía, por ejemplo, la ejecución del comando de migración la pone al día con los
modelos actuales aplicando cada script de migración. Del mismo modo, si realiza varios cambios en el modelo y
genera las migraciones en un equipo de desarrollo, puede aplicar las migraciones acumulativas a la base de
datos de producción con el comando de migración en el servidor de producción. Django de nuevo aplica solo
aquellos scripts de migración que se han generado desde la última migración de la base de datos de
producción.
Para ver el efecto del cambio de un modelo, pruebe lo siguiente:
1. Agregue un campo de autor opcional al modelo Poll en app/models.py al agregar la siguiente línea
después del campo pub_date para agregar un campo author opcional:
author = models.CharField(max_length=100, blank=True)
2. Guarde el archivo, haga clic con el botón derecho en el proyecto DjangoPolls en el Explorador de
soluciones y seleccione el comando Python > Django Make Migrations (Hacer migraciones de
Django).
3. Seleccione Proyecto > Mostrar todos los archivos para ver el script recién generado en la carpeta
migrations , cuyo nombre empieza por 002_auto_ . Haga clic con el botón derecho en ese archivo y
seleccione Incluir en el proyecto . A continuación, puede seleccionar Proyecto > Mostrar todos los
archivos de nuevo para restaurar la vista original. (Vea la segunda pregunta a continuación para obtener
más información acerca de este paso).
4. Si lo desea, abra el archivo para examinar la manera en que Django refleja en script el cambio del estado
del modelo anterior al nuevo estado.
5. Haga clic de nuevo en el proyecto de Visual Studio con el botón derecho y seleccione Python > Django
Migrate (Migrar Django) para aplicar los cambios a la base de datos.
6. Si lo desea, abra la base de datos en un visor adecuado para confirmar el cambio.
En general, la característica de migración de Django implica que no tendrá que administrar nunca el esquema de
base de datos manualmente. Simplemente realice cambios en los modelos, genere los scripts de migración y
aplíquelos con el comando de migración.
Pregunta: ¿Qué sucede si olvido ejecutar el comando de migración después de realizar cambios en los
modelos?
Respuesta: Si los modelos no coinciden con lo que aparece en la base de datos, Django genera un error en
tiempo de ejecución con las excepciones apropiadas. Por ejemplo, si se olvida de migrar el modelo cambiado
que se muestra en la sección anterior, aparece el error no such column: app_poll.author :
.
Pregunta: ¿Por qué el Explorador de soluciones no muestra los scripts recién generados después de ejecutar
Django Make Migrations (Hacer migraciones de Django )?
Respuesta: Aunque los scripts recién generados existen en la carpeta app/migrations y se aplican cuando se
ejecuta el comando Migración de Django , no aparecen automáticamente en el Explorador de soluciones
porque no se han agregado al proyecto de Visual Studio. Para que sean visibles, seleccione primero el comando
de menú Proyecto > Mostrar todos los archivos o el botón de la barra de herramientas que se describe en
la siguiente imagen. Este comando hace que el Explorador de soluciones muestre todos los archivos en la
carpeta del proyecto, con un icono de contorno punteado para los elementos que no se han agregado al propio
proyecto. Haga clic con el botón derecho en los archivos que desea agregar y seleccione Incluir en el
proyecto , lo cual los incluye también en el control de código fuente en la siguiente confirmación.
Pregunta: ¿Puedo ver qué migraciones se aplicarían antes de ejecutar el comando de migración?
Respuesta: Sí, use el comando django-admin showmigrations.
Paso 6.4: Comprender las vistas y las plantillas de página creadas por
la plantilla de proyecto
La mayoría de las vistas generadas por la plantilla "Proyecto web de Django de sondeos", como las vistas de las
páginas de información y contacto, son muy similares a las vistas creadas por la plantilla "Proyecto web de
Django" con la que trabajó anteriormente en este tutorial. La diferencia en la aplicación Polls es que su página
principal utiliza los modelos, como hacen otras páginas añadidas para votar y ver los resultados de los sondeos.
Para comenzar, la primera línea de la matriz urlpatterns del proyecto de Django en el archivo urls.py es más
que un simple enrutamiento a una vista de la aplicación. Lo que hace es incorporar los cambios en el propio
archivo urls.py de la aplicación:
from django.conf.urls import url, include

import app.views
urlpatterns = [
url(r'^', include('app.urls', namespace="app")),
# ..
]
Así pues, el archivo app/urls.py contiene código de enrutamiento más interesante (con comentarios
explicativos):
urlpatterns = [
# Home page routing
url(r'^$',
app.views.PollListView.as_view(
queryset=Poll.objects.order_by('-pub_date')[:5],
context_object_name='latest_poll_list',
template_name='app/index.html',),
name='home'),
# Routing for a poll page, which use URLs in the form <poll_id>/,
# where the id number is captured as a group named "pk".
url(r'^(?P<pk>\d+)/$',
app.views.PollDetailView.as_view(
template_name='app/details.html'),
name='detail'),
# Routing for <poll_id>/results pages, again using a capture group

# named pk.
url(r'^(?P<pk>\d+)/results/$',
app.views.PollResultsView.as_view(
template_name='app/results.html'),
name='results'),
# Routing for <poll_id>/vote pages, with the capture group named

# poll_id this time, which becomes an argument passed to the view.
url(r'^(?P<poll_id>\d+)/vote/$', app.views.vote, name='vote'),
]
Si no está familiarizado con las expresiones regulares más complejas que se usan aquí, puede pegar la
expresión en regex101.com para obtener una explicación en un lenguaje claro. (Necesitará convertir en escape
las barras diagonales / mediante la adición de una barra diagonal inversa \ delante; el escape no es
necesario en Python por el prefijo r de la cadena, que significa "raw" [sin formato]).
En Django, la sintaxis ?P<name>pattern crea un grupo denominado name , que se pasa como argumentos a
vistas en el orden en que aparecen. En el código mostrado anteriormente, PollsDetailView y PollsResultsView
reciben un argumento con nombre pk y app.views.vote recibe un argumento denominado poll_id .
También puede ver que la mayoría de las vistas no son simplemente referencias directas a una función de vista
en app/views.py. En su lugar, la mayoría hacen referencia a una clase de ese mismo archivo que se deriva de
django.views.generic.ListView o django.views.generic.DetailView . Las clases base proporcionan los métodos
as_view , que tienen un argumento template_name para identificar la plantilla. La clase base ListView , como se
usa para la página principal, también espera una propiedad queryset que contiene los datos y una propiedad
context_object_name con el nombre de la variable por la que desea hacer referencia a los datos en la plantilla;
en este caso, latest_poll_list .
Ahora puede examinar el elemento PollListView de la página principal, que se define como sigue en
app/views.py:
class PollListView(ListView):
"""Renders the home page, with a list of all polls."""
model = Poll
def get_context_data(self, **kwargs):

context = super(PollListView, self).get_context_data(**kwargs)
context['title'] = 'Polls'
context['year'] = datetime.now().year
return context
Todo lo que se hace aquí sirve para identificar el modelo con el que funciona la vista (Poll) y reemplazar el
método get_context_data para agregar los valores title y year al contexto.
El núcleo de la plantilla (templates/app/index.html) es como sigue:
{% if latest_poll_list %}
<table class="table table-hover">
<tbody>
{% for poll in latest_poll_list %}
<tr>
<td>
<a href="{% url 'app:detail' poll.id %}">{{poll.text}}</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% else %}

{% endif %}
En pocas palabras, la plantilla recibe la lista de objetos de Polls en latest_poll_list y, a continuación, recorre en
iteración la lista para crear una fila de tabla que contiene un vínculo a cada sondeo por medio del valor text
del sondeo. En la etiqueta {% url %} , "app:detail" hace referencia al patrón de dirección URL de app/urls.py
denominado "detail", con poll.id como argumento. El efecto es que Django crea una dirección URL con el
patrón adecuado y lo utiliza para el vínculo. Esta pequeña prueba de futuro significa que puede cambiar ese
patrón de dirección URL en cualquier momento, y los vínculos generados se actualizan automáticamente para
coincidir.
Las clases PollDetailView y PollResultsView de app/views.py (que no se muestran aquí) son casi idénticas a
PollListView , a excepción de que se derivan de DetailView . Sus plantillas correspondientes,
app/templates/details.html y app/templates/results.html, colocan los campos adecuados de los modelos en
diferentes controles HTML. Algo único en details.html es que las opciones de un sondeo están incluidas en un
formulario HTML que, cuando se envía, realiza una operación POST a la dirección URL /vote. Como se ha visto
antes, este patrón de dirección URL se enruta a app.views.vote , que se implementa como sigue (observe el
argumento poll_id , que es de nuevo un grupo con nombre en la expresión regular utilizada en el
enrutamiento para esta vista):
def vote(request, poll_id):

"""Handles voting. Validates input and updates the repository."""
poll = get_object_or_404(Poll, pk=poll_id)
try:
selected_choice = poll.choice_set.get(pk=request.POST['choice'])
except (KeyError, Choice.DoesNotExist):
return render(request, 'app/details.html', {
'title': 'Poll',
'poll': poll,
'error_message': "Please make a selection.",
})
else:
selected_choice.votes += 1
selected_choice.save()
return HttpResponseRedirect(reverse('app:results', args=(poll.id,)))
En este caso, la vista no tiene su propia plantilla correspondiente, como las otras páginas. En su lugar, valida el
sondeo seleccionado, que muestra un error 404 si el sondeo no existe (solo en caso de que alguien escriba una
dirección URL como "vote/1a2b3c"). Luego se asegura de que la opción votada sea válida para el sondeo. Si no
es así, el bloque except simplemente representa la página de detalles de nuevo con un mensaje de error. Si la
opción es válida, la vista registra el voto y lo redirecciona a la página de resultados.
Paso 6.5: Crear una interfaz de administración personalizada
Los últimos datos de la plantilla de "Proyecto web de Django de sondeos" son las extensiones personalizadas
para la interfaz administrativa de Django personalizada, tal como se mostró anteriormente en el paso 6.1 de
este artículo. La interfaz predeterminada ofrece administración de usuario y grupo, pero nada más. La plantilla
de proyecto de sondeos agrega características que le permiten también administrar los sondeos.
En primer lugar, los patrones de dirección URL del archivo urls.py del proyecto Django tienen
url(r'âdmin/', include(admin.site.urls)), incluido de manera predeterminada; el patrón "admin/doc" está
incluido también pero sin comentarios.
La aplicación contiene el archivo admin.py, que Django ejecuta automáticamente cuando se visita la interfaz
administrativa gracias a la inclusión de django.contrib.admin en la matriz INSTALLED_APPS de settings.py. El
código en ese archivo, tal y como se especifica en la plantilla del proyecto, es el siguiente:
from django.contrib import admin

from app.models import Choice, Poll
class ChoiceInline(admin.TabularInline):
"""Choice objects can be edited inline in the Poll editor."""
model = Choice
extra = 3
class PollAdmin(admin.ModelAdmin):
"""Definition of the Poll editor."""
fieldsets = [
(None, {'fields': ['text']}),
('Date information', {'fields': ['pub_date']}),
]
inlines = [ChoiceInline]
list_display = ('text', 'pub_date')
list_filter = ['pub_date']
search_fields = ['text']
date_hierarchy = 'pub_date'
admin.site.register(Poll, PollAdmin)
Como puede ver, la clase PollAdmin se deriva de django.contrib.admin.ModelAdmin y personaliza un número de

sus campos con nombres del modelo Poll , que administra. Estos campos se describen en las opciones de
ModelAdmin en la documentación de Django.
La llamada a admin.site.register conecta entonces esa clase al modelo ( Poll ) y lo incluye en la interfaz de
administración. El resultado global se muestra a continuación:
Pasos siguientes
NOTE
Si ha estado confirmando la solución de Visual Studio en el control de código fuente en el transcurso de este tutorial,
ahora es un buen momento de hacer otra confirmación. La solución debe coincidir con el código fuente del tutorial en
GitHub: Microsoft/python-sample-vs-learning-django.
Ya ha explorado por completo las plantillas "Proyecto web de Django en blanco", "Proyecto web de Django" y
"Proyecto web de Django de sondeos" en Visual Studio. Ha aprendido todos los elementos básicos de Django,
como el uso de vistas y plantillas, y ha explorado el enrutamiento, la autenticación y el uso de modelos de base
de datos. Ahora podrá crear una aplicación web propia con las vistas y los modelos que necesite.
La ejecución de una aplicación web en el equipo de desarrollo es solamente un paso en el proceso de poner la
aplicación a disposición de sus clientes. Los pasos siguientes pueden incluir las siguientes tareas:
Implementar la aplicación web en un servidor de producción, como Azure App Service. Consulte
Publicación en Azure App Service.
Personalice la página 404 mediante la creación de una plantilla denominada templates/404.html. Cuando
está presente, Django utiliza esta plantilla en lugar de la predeterminada. Para obtener más información,
consulte Error views (Vistas de error) en la documentación de Django.
Escriba pruebas unitarias en tests.py; las plantillas de proyecto de Visual Studio proporcionan puntos de
inicio para eso; además, puede encontrar más información en Writing your first Django app, part 5 -
testing (Escribir la primera aplicación de Django, parte 5: pruebas) y Testing in Django (Pruebas en
Django) en la documentación de Django.
Cambiar la aplicación de SQLite a un almacén de datos a nivel de producción como PostgreSQL, MySQL y
SQL Server (todos se pueden hospedar en Azure). Como se describe en When to use SQLite (Cuándo
usar SQLite) (sqlite.org), SQLite funciona perfectamente en sitios de tráfico bajo a medio, con menos de
100.000 visitas al día, pero no se recomienda en volúmenes más elevados. También está limitado a un
único equipo, por lo tanto no se puede usar en escenarios de varios servidores, como el equilibrio de
carga y la replicación geográfica. Para obtener información sobre la compatibilidad con Django otras
bases de datos, vea Configuración de la base de datos. También puede usar el SDK de Azure para Python
para trabajar con los servicios de almacenamiento de Azure, como tablas y blobs.
Configurar una canalización de implementación continua/integración continua en un servicio como
Azure DevOps. Además de funcionar con el control de código fuente (en Azure Repos, GitHub u otro
servicio), puede configurar un proyecto de Azure DevOps para que ejecute automáticamente pruebas
unitarias como requisito previo para la publicación y también configurar la canalización para
implementar en un servidor de ensayo para pruebas adicionales antes de implementar en producción.
Azure DevOps, además, se integra con soluciones de supervisión como App Insights y cierra todo el ciclo
con herramientas de planeación de Ágil. Para obtener más información, consulte Creación de una
canalización de CI/CD para Python con Azure DevOps Projects y también la Azure DevOps
Documentation (Documentación de Azure DevOps) general.
Tutorial: Introducción al marco web de Flask en
Visual Studio
Flask es un marco de Python ligero para aplicaciones web que proporciona los elementos básicos para el
enrutamiento de direcciones URL y la representación de páginas.
Flask es un "micromarco" porque no proporciona de forma directa características como la validación de
formularios, la abstracción de bases de datos, la autenticación, etc. Dichas características se proporcionan en
paquetes especiales de Python llamados extensiones de Flask. Las extensiones se integran perfectamente con
Flask para que aparezcan como si formaran parte del mismo Flask. Por ejemplo, Flask por sí solo no
proporciona un motor de plantillas de página. La creación de plantillas se proporciona mediante extensiones
como Jinja y Jade, como se muestra en este tutorial.
En este tutorial, aprenderá a:
Crear un proyecto básico de Flask en un repositorio de Git con la plantilla "Proyecto web de Flask en blanco"
(paso 1)
Crear una aplicación de Flask con una página y representar esa página con una plantilla (paso 2)
Usar la plantilla Proyecto web de Flask para crear una aplicación con varias páginas y diseño con capacidad
de respuesta (paso 4)
Use la plantilla Proyecto web de Flask de sondeos para crear una aplicación de sondeos que use una serie de
opciones de almacenamiento (Azure Storage, MongoDB o memoria).
En el transcurso de estos pasos creará una única solución de Visual Studio que contendrá tres proyectos
independientes. Creará el proyecto mediante distintas plantillas de proyecto de Flask que se incluyen con Visual
Studio. Al mantener los proyectos en la misma solución, puede cambiar fácilmente entre distintos archivos para
compararlos.
En este tutorial, aprenderá a:
Crear un proyecto básico de Flask en un repositorio de Git con la plantilla "Proyecto web de Flask en blanco"
(paso 1)
Crear una aplicación de Flask con una página y representar esa página con una plantilla (paso 2)
Usar la plantilla Proyecto web de Flask para crear una aplicación con varias páginas y diseño con capacidad
de respuesta (paso 4)
Al seguir estos pasos, creará una única solución de Visual Studio que contendrá dos proyectos independientes.
Creará el proyecto mediante distintas plantillas de proyecto de Flask que se incluyen con Visual Studio. Al
mantener los proyectos en la misma solución, puede cambiar fácilmente entre distintos archivos para
compararlos.
NOTE
Este tutorial difiere del inicio rápido de Flask en el sentido de que obtendrá más información sobre Flask y sobre cómo
usar las distintas plantillas de proyecto de Flask que proporcionan un punto de partida más amplio para sus propios
proyectos. Por ejemplo, las plantillas de proyecto instalan automáticamente el paquete de Flask al crear un proyecto, en
lugar de tener que instalarlo manualmente, como se muestra en el inicio rápido.
Prerequisites
Visual Studio 2017 o posterior en Windows con las siguientes opciones:
La carga de trabajo Desarrollo de Python (pestaña Carga de trabajo del instalador). Para obtener
instrucciones, vea Instalación de la compatibilidad con Python en Visual Studio en Windows.
Git para Windows y Extensión de GitHub para Visual Studio en la pestaña Componentes
individuales de Herramientas de código .
Las plantillas de proyecto de Flask se incluyen con todas las versiones anteriores de las Herramientas de Python
para Visual Studio, aunque los detalles pueden diferir de lo que se describe en este tutorial.
El desarrollo de Python no es compatible actualmente en Visual Studio para Mac. En Mac y Linux, use la
extensión de Python en Visual Studio Code.
Paso 1.1: Crear una solución y un proyecto de Visual Studio

1. En Visual Studio, seleccione Archivo > Nuevo > Proyecto , busque "Flask" y seleccione la plantilla
Proyecto web de Flask en blanco . (La plantilla también se encuentra en Python > Web en la lista de
la izquierda).
2. En los campos de la parte inferior del cuadro de diálogo, escriba la información siguiente (como se
muestra en el gráfico anterior) y, a continuación, seleccione Aceptar :
Nombre : establezca el nombre del proyecto de Visual Studio en BasicProject . Este nombre también
se usa para el proyecto de Flask.
Ubicación : especifique una ubicación en la que se va a crear la solución y el proyecto de Visual
Studio.
Nombre de la solución : establezca en LearningFlask , que es adecuado para la solución como
contenedor de varios proyectos de este tutorial.
Crear directorio para la solución : deje el valor predeterminado.
Crear nuevo repositorio Git : active esta opción (que está desactivada de forma predeterminada)
para que Visual Studio cree un repositorio Git local al generar la solución. Si no ve esta opción, ejecute
el instalador de Visual Studio y agregue Git para Windows y Extensión de GitHub para Visual
Studio en la pestaña Componentes individuales en Herramientas de código .
3. Tras un momento, Visual Studio muestra un cuadro de diálogo que indica Este proyecto necesita
paquetes externos (se muestra abajo). Este cuadro de diálogo aparece porque la plantilla incluye un
archivo requirements.txt que hace referencia al paquete Flask 1.x más reciente. (Active Mostrar
paquetes necesarios para ver las dependencias exactas).
4. Seleccione la opción Los instalaré de forma manual . Cree el entorno virtual en breve para asegurarse
de que se excluye del control de código fuente. (El entorno siempre puede crearse a partir de
requirements.txt).
Paso 1.2: Examinar los controles de Git y publicar en un repositorio

remoto
Como seleccionó Crear nuevo repositorio Git en el cuadro de diálogo Nuevo proyecto , el proyecto ya
estará confirmado para el control de código fuente local en cuanto se complete el proceso de creación. En este
paso, familiarícese con los controles de Git de Visual Studio y la ventana de Team Explorer en la que se trabaja
con el control de código fuente.
1. Examine los controles de Git en la esquina inferior de la ventana principal de Visual Studio. De izquierda a
derecha, estos controles muestran confirmaciones sin insertar, cambios sin confirmar, el nombre del
repositorio y la rama actual:
NOTE
Si no selecciona Crear nuevo repositorio Git en el cuadro de diálogo Nuevo proyecto , los controles de Git
solo muestran un comando Agregar al control de código fuente que crea un repositorio local.
2. Seleccione el botón de cambios y Visual Studio abre su ventana de Team Explorer en la página
Cambios . Dado que el proyecto recién creado ya se ha confirmado automáticamente en el control de
código fuente, no verá cambios pendientes.
3. En la barra de estado de Visual Studio, haga clic en el botón de confirmaciones sin insertar (la flecha
arriba con 2 ) para abrir la página Sincronización en Team Explorer . Como tiene solo un repositorio
local, la página ofrece opciones sencillas para publicar el repositorio en repositorios remotos diferentes.
Puede elegir cualquier servicio que desee para sus propios proyectos. En este tutorial se muestra el uso
de GitHub, donde se mantiene el código de ejemplo completo del tutorial en el repositorio
Microsoft/python-sample-vs-learning-flask.
4. Al seleccionar cualquiera de los controles de Publicar , Team Explorer le pedirá más información. Por
ejemplo, al publicar el ejemplo para este tutorial, el propio repositorio tenía que haberse creado primero.
En este caso, la opción Inser tar en repositorio remoto se utilizó con la dirección URL del repositorio.
Si no tiene ningún repositorio, las opciones Publish to GitHub (Publicar en GitHub) e Inser tar en
Azure DevOps le permiten crear uno directamente desde Visual Studio.
5. Mientras esté trabajando en este tutorial, adopte la costumbre de usar los controles de Visual Studio
periódicamente para confirmar e insertar los cambios. Este tutorial se lo recuerda en los momentos
adecuados.
TIP
Para desplazarse rápidamente por Team Explorer , seleccione el encabezado (donde pone Changes o Push en las
imágenes anteriores) para ver un menú emergente de las páginas disponibles.
Pregunta: ¿Cuáles son algunas de las ventajas del uso de control de código fuente desde el principio de un
proyecto?
Respuesta: En primer lugar, usar el control de código fuente desde el principio, especialmente si también utiliza
un repositorio remoto, genera una copia de seguridad periódica externa del proyecto. A diferencia de mantener
un proyecto solo en un sistema de archivos local, el control de código fuente también proporciona un historial
de cambios completo y la capacidad de revertir con facilidad un único archivo o todo el proyecto a un estado
anterior. Ese historial de cambios ayuda a determinar la causa de regresiones (errores de prueba). Además, el
control de código fuente es esencial si varias personas trabajan en un proyecto, ya que administra las
sobrescrituras y ofrece solución para los conflictos. Por último, el control de código fuente, que es básicamente
una forma de automatización, facilita la automatización de las compilaciones, las pruebas y la administración de
versiones. Es realmente el primer paso para utilizar DevOps para un proyecto, y dado que las barreras de
entrada son tan bajas, realmente no hay ninguna razón que impida usar el control de código fuente desde el
principio.
Para obtener más información sobre el control de código fuente como automatización, consulte The Source of
Truth: The Role of Repositories in DevOps (El origen de la verdad, el rol de los repositorios en DevOps), un
artículo de MSDN Magazine escrito para aplicaciones móviles que se aplica también a las aplicaciones web.
Pregunta: ¿Puedo evitar que Visual Studio confirme automáticamente un nuevo proyecto?
Respuesta : Sí. Para deshabilitar la confirmación automática, vaya a la página Configuración de Team
Explorer , seleccione Git > Configuración global , desactive la opción Confirmar cambios tras la fusión
mediante combinación de forma predeterminada y, a continuación, seleccione Actualizar .
Paso 1.3: Crear el entorno virtual y excluirlo del control de código

fuente
Ahora que ha configurado el control de código fuente para el proyecto, puede crear el entorno virtual para los
paquetes Flask necesarios que requiere el proyecto. A continuación, puede usar Team Explorer para excluir la
carpeta del entorno del control de código fuente.
seleccione Agregar entorno vir tual .
2. Aparece un cuadro de diálogo Agregar entorno vir tual con un mensaje que indica Hemos
encontrado un archivo requirements.txt . Este mensaje indica que Visual Studio usa ese archivo para
configurar el entorno virtual.
3. Seleccione Crear para aceptar los valores predeterminados. (Puede cambiar el nombre del entorno
virtual si lo desea, lo cual simplemente cambia el nombre de su subcarpeta, pero env es una convención
estándar).
4. Dé su consentimiento para los privilegios de administrador si se le solicita y tenga paciencia durante
unos minutos mientras Visual Studio descarga e instala los paquetes, lo que para Flask y sus
dependencias implica expandir cerca de miles de archivos en más de 100 subcarpetas. Puede ver el
progreso en la ventana Salida de Visual Studio. Mientras espera, consulte la sección Preguntas a
continuación. También puede ver una descripción de las dependencias de Flask en la página de
instalación de Flask (flask.pcocoo.org).
5. En los controles de Git de Visual Studio (en la barra de estado), seleccione el indicador de cambios (que
muestra 99* ) que abre la página Cambios en Team Explorer .
La creación del entorno virtual implica cientos de cambios, pero no es necesario que incluya ninguno de
ellos en el control de código fuente, dado que usted (o cualquier usuario que clone el proyecto) siempre
puede volver a crear el entorno a partir de requirements.txt.
Para excluir el entorno virtual, haga clic con el botón derecho en la carpeta env y seleccione Omitir
estos elementos locales .
6. Después de excluir el entorno virtual, los únicos cambios que faltan son en el archivo de proyecto y en
.gitignore. El archivo .gitignore contiene una entrada agregada para la carpeta del entorno virtual. Puede
hacer doble clic en el archivo para ver las diferencias.
7. Escriba un mensaje de confirmación y seleccione el botón Confirmar todo , a continuación, inserte las
confirmaciones en el repositorio remoto si lo desea.
Pregunta: ¿Por qué es conveniente crear un entorno virtual?
Respuesta: Un entorno virtual es una excelente manera de aislar las dependencias exactas de la aplicación. Este
tipo de aislamiento evita conflictos dentro de un entorno de Python global y contribuye a las pruebas y la
colaboración. Con el tiempo, a medida que desarrolle una aplicación, es inevitable que incorpore muchos
paquetes útiles de Python. Si mantiene los paquetes en un entorno virtual específico del proyecto, puede
actualizar fácilmente el archivo requirements.txt del proyecto que describe ese entorno, el cual se incluye en el
control de código fuente. Cuando el proyecto se copia en otros equipos, como los servidores de compilación, los
servidores de implementación y otros equipos de desarrollo, es fácil volver a crear el entorno con solo
requirements.txt (por este motivo no es necesario que el entorno esté en el control de código fuente). Para
obtener más información, vea Use virtual environments (Usar entornos virtuales).
Pregunta: ¿Cómo se quita un entorno virtual que ya se ha confirmado en el control de código fuente?
Respuesta: En primer lugar, edite el archivo .gitignore para excluir la carpeta: busque la sección del final con el
comentario # Python Tools for Visual Studio (PTVS) y agregue una línea nueva para la carpeta del entorno
virtual, como /BasicProject/env . (Dado que Visual Studio no muestra el archivo en el Explorador de
soluciones , ábralo directamente mediante el comando de menú Archivo > Abrir > Archivo . También puede
abrir el archivo desde Team Explorer : en la página Configuración , seleccione Configuración de
repositorios , vaya a la sección Archivos de omisión y de atributos y luego seleccione el vínculo Editar
junto a .gitignore ).
En segundo lugar, abra una ventana de comandos, vaya a la carpeta como BasicProject que contiene la carpeta
del entorno virtual, como env, y ejecute git rm -r env . A continuación, confirme esos cambios desde la línea de
comandos ( git commit -m 'Remove venv' ), o bien desde la página Cambios de Team Explorer .
Paso 1.4: Examinar el código reutilizable
1. Cuando termina la creación del proyecto, se ven la solución y el proyecto en el Explorador de
soluciones , donde el proyecto contiene solo dos archivos, app.py y requirements.txt:
2. Como se ha indicado antes, el archivo requirements.txt especifica la dependencia del paquete de Flask. La
presencia de este archivo es lo que le invita a crear un entorno virtual cuando empiece a crear el
proyecto.
3. El archivo app.py único consta de tres partes. La primera es una instrucción import para Flask, en la que
se crea una instancia de la clase Flask , que se asigna a la variable app , y luego se asigna una variable
wsgi_app (que es útil cuando se implementa en un host web, pero no se usa en este momento):

# Make the WSGI interface available at the top level so wfastcgi can get it.
wsgi_app = app.wsgi_app
4. La segunda parte, al final del archivo, es un fragmento de código opcional que inicia el servidor de
desarrollo de Flask con unos valores de host y de puerto específicos que se han tomado de las variables
de entorno (el valor predeterminado es localhost:5555):
if __name__ == '__main__':
import os
try:
except ValueError:
PORT = 5555
app.run(HOST, PORT)
5. La tercera es un fragmento de código que asigna una función a una ruta de dirección URL, lo que
significa que la función proporciona el recurso identificado por la dirección URL. Las rutas se definen con
el decorador @app.route de Flask, cuyo argumento es la dirección URL relativa de la raíz del sitio. Como
puede ver en el código, aquí la función solo devuelve una cadena de texto, que basta para representar un
explorador. En los pasos siguientes se representan páginas más enriquecidas con HTML.
@app.route('/')
def hello():
Pregunta: ¿Cuál es el propósito del argumento name para la clase de Flask?

Respuesta: El argumento es el nombre del módulo o del paquete de la aplicación e indica a Flask dónde se
deben buscar plantillas, archivos estáticos y otros recursos que pertenecen a la aplicación. Para las aplicaciones
incluidas en un solo módulo, __name__ siempre es el valor adecuado. También es importante para las
extensiones que necesitan información de depuración. Para obtener más información y argumentos adicionales,
vea la documentación sobre las clases de Flask (flask.pocoo.org).
Pregunta: ¿Una función puede tener más de un decorador de ruta?
Respuesta: Sí, puede usar todos los decoradores que quiera si la misma función sirve para varias rutas. Por
ejemplo, para usar la función hello para "/" y "/hello", use el código siguiente:
@app.route('/')
def hello():
Pregunta: ¿Cómo trabaja Flask con las rutas de dirección URL de variables y con los parámetros de consulta?
Respuesta: En una ruta, las variables se marcan con <variable_name> y Flask pasa la variable a la función usando
un argumento con nombre en la ruta de acceso de la dirección URL. Por ejemplo, una ruta con el formato
/hello/<name> genera un argumento de cadena a la función denominado name . Los parámetros de consulta
también están disponibles mediante la propiedad request.args , en concreto mediante el método
request.args.get . Para obtener más información, vea la información sobre el objeto Request de la
documentación de Flask.
# URL: /hello/<name>?message=Have%20a%20nice%20day
@app.route('/hello/<name>')
def hello(name):
msg = request.args.get('message','')
return "Hello " + name + "! "+ msg + "."
Para cambiar el tipo, anteponga la variable con int , float , path (que acepta barras diagonales para delinear
los nombres de las carpetas) y uuid . Para obtener información detallada, vea las reglas de las variables en la
documentación de Flask.
Pregunta: ¿Puede Visual Studio generar un archivo requirements.txt a partir de un entorno virtual después de
instalar otros paquetes?
Respuesta : Sí. Expanda el nodo Entornos de Python , haga clic con el botón derecho en su entorno virtual y
seleccione el comando Generar requirements.txt . Es conveniente usar este comando periódicamente a
medida que modifica el entorno, y confirmar los cambios de requirements.txt en el control de código fuente
junto con cualquier otro cambio de código que dependa de ese entorno. Si configura la integración continua en
un servidor de compilación, debe generar el archivo y confirmar los cambios cada vez que se modifique el
entorno.
Paso 1-5: ejecutar el proyecto

1. En Visual Studio, seleccione Depurar > Iniciar depuración (F5 ) o use el botón Ser vidor web de la
barra de herramientas (el explorador puede variar):
2. Cualquiera de los comandos asigna un número de puerto aleatorio a la variable de entorno PORT y,
luego, ejecuta python app.py . El código inicia la aplicación usando ese puerto en el servidor de desarrollo
de Flask. Si Visual Studio indica No se pudo iniciar el depurador con un mensaje relacionado con la
falta de un archivo de inicio, haga clic con el botón derecho en app.py en el Explorador de soluciones
y seleccione Establecer como archivo de inicio .
3. Al iniciar el servidor, verá una ventana de consola abierta en la que se muestra el registro del servidor.
Luego, Visual Studio abre automáticamente un explorador en http://localhost:<port> , donde debería
ver el mensaje que se representa mediante la función hello :
4. Cuando haya terminado, detenga el servidor cerrando la ventana de la consola o con el comando
Depurar > Detener depuración en Visual Studio.
Pregunta: ¿Cuál es la diferencia entre el uso de los comandos de menú de depuración y los comandos de
servidor en el submenú de Python del proyecto?
Respuesta: Además de con los comandos de menú de Depurar y los botones de la barra de herramientas,
también puede iniciar el servidor mediante los comandos Python > Run ser ver (Ejecutar servidor) o Python
> Run debug ser ver (Iniciar el servidor de depuración) en el menú contextual del proyecto. Ambos comandos
abren una ventana de consola en la que se ve la dirección URL local (localhost:port) del servidor en ejecución.
Sin embargo, debe abrir manualmente un explorador con esa dirección URL, y la ejecución del servidor de
depuración no inicia automáticamente el depurador de Visual Studio. Puede adjuntar un depurador al proceso
en ejecución más adelante, si lo desea, mediante el comando Depurar > Asociar al proceso .
Pasos siguientes
En este momento, el proyecto básico de Flask contiene el código de inicio y el código de página en el mismo
archivo. Es mejor separar estos dos elementos y separar también el código HTML y los datos mediante
plantillas.
Creación de una aplicación de Flask con vistas y plantillas de página

Inicio rápido de Flask (flask.pocoo.org)
Código fuente del tutorial en GitHub: Microsoft/python-sample-vs-learning-flask
Paso 2: Creación de una aplicación de Flask con
vistas y plantillas de página
Paso anterior : Creación de una solución y un proyecto de Visual Studio

Lo que ha conseguido en el paso 1 de este tutorial es una aplicación de Flask con una página y todo el código en
un único archivo. Para facilitar un desarrollo futuro, es mejor refactorizar el código y crear una estructura para
las plantillas de página. En concreto, debe separar el código de las vistas de la aplicación de otros aspectos,
como el código de inicio.
Refactorizar el código de la aplicación para separar las vistas del código de inicio (paso 2-1)
Representar una vista mediante una plantilla de página (paso 2-2)
Paso 2-1: Refactorización del proyecto para admitir desarrollo

adicional
En el código creado por la plantilla "Proyecto web de Flask en blanco" tiene un archivo único app.py que
contiene el código de inicio junto con una sola vista. Para facilitar un desarrollo futuro de una aplicación que
tiene varias vistas y plantillas, es mejor separar estos elementos.
1. En la carpeta del proyecto, cree una carpeta de aplicación llamada HelloFlask (haga clic con el botón
derecho en el proyecto en el Explorador de soluciones y seleccione Agregar > Nueva carpeta ).
2. En la carpeta HelloFlask, cree un archivo denominado __init__.py con el siguiente contenido que crea la
instancia Flask y carga las vistas de la aplicación (que se crean en el siguiente paso):

import HelloFlask.views
3. En la carpeta HelloFlask, cree un archivo denominado views.py con el siguiente contenido. El nombre
views.py es importante porque se ha usado import HelloFlask.views en __init__.py. Verá un error en
tiempo de ejecución si los nombres no coinciden.

from HelloFlask import app
@app.route('/')
@app.route('/home')
def home():
return "Hello Flask!"
Además de cambiar el nombre de la función y la ruta a home , este código contiene el código de
representación de la página de app.py e importa el objeto app que se declara en __init__.py.
4. Cree una subcarpeta en HelloFlask denominada templates, que de momento estará vacía.
5. En la carpeta raíz del proyecto, cambie el nombre de app.py por runserver.py y haga coincidir el
contenido con el siguiente código:
import os
from HelloFlask import app # Imports the code from HelloFlask/__init__.py
if __name__ == '__main__':
try:
except ValueError:
PORT = 5555
app.run(HOST, PORT)
6. La estructura del proyecto debe parecerse a la siguiente imagen:
herramientas (el explorador puede variar) para que se inicie la aplicación y se abra un explorador. Pruebe
las rutas de dirección URL / y /home.
8. También puede establecer puntos de interrupción en distintas partes del código y reiniciar la aplicación
para seguir la secuencia de inicio. Por ejemplo, establezca un punto de interrupción en las primeras líneas
de runserver.py y HelloFlask_ init _.py y en la línea return "Hello Flask!" de views.py. Luego, reinicie la
aplicación (Depurar > Reiniciar , Ctrl +Mayús +F5 , o el botón de la barra de herramientas que se
muestra a continuación) y recorra el código (F10 ) o ejecútelo desde cada punto de interrupción mediante
F5 .
9. Cuando haya terminado, detenga la aplicación.

Confirmación en el control de código fuente
Dado que ha realizado cambios en el código y ha probado que funcionan correctamente, ahora es un buen
momento para revisar y confirmar los cambios en el control de código fuente. Los pasos posteriores de este
tutorial le recuerdan los momentos adecuados para volver a confirmar el control de código fuente, y le remiten
a esta sección.
1. Seleccione el botón de cambios de la parte inferior de Visual Studio (en un círculo abajo), que le lleva a
Team Explorer .
2. En Team Explorer , escriba un mensaje de confirmación como "Refactorizar código" y seleccione

Confirmar todo . Una vez que se haya completado la confirmación, verá un mensaje Confirmar
<hash> de creación local. Sincronizar para compar tir los cambios con el ser vidor. Si desea
insertar los cambios en el repositorio remoto, seleccione Sincronizar y luego Inser tar en
Confirmaciones de salida . También puede acumular varias confirmaciones locales antes de insertar en
la instancia remota.

System.Security.Cryptography.CryptographicException. ¿Con qué frecuencia se debe confirmar en el control
de código fuente?
Respuesta: La confirmación de los cambios en el control de código fuente crea un registro en el registro de
cambios y un punto al que puede revertir el repositorio si es necesario. También se puede examinar cada
confirmación para ver los cambios concretos. Dado que las confirmaciones en Git son asequibles, es mejor
hacer confirmaciones frecuentes que acumular muchos cambios en una confirmación. Evidentemente, no es
necesario confirmar todos los cambios en archivos concretos. Por lo general se efectúa una confirmación al
agregar una característica, al cambiar una estructura como ha hecho en este paso o al llevar a cabo ciertas
refactorizaciones de código. Compruebe también con otros usuarios del equipo la granularidad de las
confirmaciones que mejor funcionen para cada uno.
La frecuencia con la que confirme y la frecuencia con la que se envían las confirmaciones a un repositorio
remoto son dos cuestiones diferentes. Se pueden acumular varias confirmaciones en el repositorio local antes
de enviarlas al repositorio remoto. Una vez más, la frecuencia con la que confirme dependerá de cómo quiera
administrar su equipo el repositorio.
Paso 2-2: Uso de una plantilla para representar una página

La función home que tiene de momento en views.py solo genera una respuesta HTTP en texto sin formato para
la página. Pero la mayoría las páginas web reales responden con páginas HTML enriquecidas que a menudo
incorporan datos en directo. De hecho, la razón principal para definir una vista mediante una función es la
generación de contenido de forma dinámica.
Como el valor devuelto para la vista es una cadena, puede crear cualquier código HTML que quiera dentro de
una cadena mediante contenido dinámico, pero dado que es mejor separar el marcado de los datos, es mucho
mejor colocarlo en una plantilla y mantener los datos en el código.
1. Para empezar, edite views.py para que contenga el siguiente código que usa HTML insertado para la
página con algún contenido dinámico:
from flask import render_template
from HelloFlask import app
@app.route('/')
@app.route('/home')
def home():
formatted_now = now.strftime("%A, %d %B, %Y at %X")
html_content = "<html><head><title>Hello Flask</title></head><body>"

html_content += "<strong>Hello Flask!</strong> on " + formatted_now
html_content += "</body></html>"
return html_content
2. Ejecute la aplicación y actualice la página varias veces para comprobar que se actualice la fecha y la hora.
Cuando haya terminado, detenga la aplicación.
3. Para convertir la representación de la página para usar una plantilla, cree un archivo denominado
index.html en la carpeta templates con el siguiente contenido, donde {{ content }} es un marcador de
posición o un token de reemplazo (también denominado variable de plantilla) para el que se proporciona
un valor en el código:
<html>
<head><title>Hello Flask</title></head>
<body>
{{ content }}
</body>
</html>
4. Modifique la función home para usar render_template para cargar la plantilla y proporcione un valor
para "content", lo cual se hace usando un argumento con nombre que coincida con el nombre del
marcador de posición. Flask busca automáticamente plantillas en la carpeta templates, así que la ruta de
acceso a la plantilla es relativa a esa carpeta:
def home():
return render_template(
"index.html",
content = "<strong>Hello, Flask!</strong> on " + formatted_now)
5. Ejecute la aplicación para ver los resultados y observe que el HTML insertado del valor content no se
representa como HTML porque el motor de plantillas (Jinja) efectúa un escape automático del contenido
HTML. El escape automático evita vulnerabilidades accidentales en los ataques por inyección de código:
los desarrolladores suelen recopilar información de una página y emplearla como valor en otra mediante
un marcador de posición de plantilla. El escape también sirve como recordatorio de que es mejor
conservar el HTML fuera del código.
En consecuencia, compruebe que templates\index.html contenga distintos marcadores de posición para
cada sección de los datos dentro del marcado:
<html>
<head>
</head>
<body>
<strong>{{ message }}</strong>{{ content }}
</body>
</html>
Luego, actualice la función home para proporcionar valores para todos los marcadores de posición:
def home():
"index.html",
title = "Hello Flask",
message = "Hello, Flask!",
content = " on " + formatted_now)
6. Vuelva a ejecutar la aplicación para ver la salida correctamente representada.
7. Confirme los cambios en el control de código fuente y actualice su repositorio remoto, si quiere, tal y
como se describe en el paso 2-1.
System.Security.Cryptography.CryptographicException. ¿Las plantillas de página deben estar en un archivo
independiente?
Respuesta: Aunque las plantillas normalmente se guardan en archivos HTML independientes, también se puede
usar una plantilla insertada. No obstante, se recomienda usar un archivo independiente para mantener una
separación clara entre código y marcado.
System.Security.Cryptography.CryptographicException. ¿Deben usar las plantillas la extensión de archivo
.html?
Respuesta: La extensión .html para los archivos de plantilla de página es completamente opcional, ya que
siempre puede identificar la ruta de acceso exacta relativa al archivo en el primer argumento de la función
render_template . Pero Visual Studio (y otros editores) normalmente ofrecen características como la finalización
de código y el coloreado de sintaxis con archivos .html, lo que compensa con creces el hecho de que las
plantillas de página no sean estrictamente HTML.
De hecho, cuando está trabajando con un proyecto de Flask, Visual Studio detecta automáticamente si el archivo
HTML que está editando es realmente una plantilla de Flask y proporciona algunas características de
autocompletar. Por ejemplo, al comenzar a escribir un comentario de plantilla de página de Flask, {# , Visual
Studio proporciona automáticamente los caracteres #} de cierre. Los comandos Selección con comentarios
y Selección sin comentarios (en el menú Editar > Opciones avanzadas y en la barra de herramientas)
también utilizan comentarios de plantilla en lugar de comentarios HTML.
System.Security.Cryptography.CryptographicException. ¿Las plantillas se pueden organizar en más
subcarpetas?
Respuesta: Sí, se pueden usar subcarpetas y luego hacer referencia a la ruta de acceso relativa en templates en
las llamadas a render_template . Es una excelente manera de crear espacios de nombres de forma efectiva para
las plantillas.
Pasos siguientes
Atender archivos estáticos, agregar páginas y usar la herencia de plantilla

Inicio rápido de Flask: Representación de plantillas (flask.pocoo.org)
Paso 3: Atender archivos estáticos, agregar páginas
y usar la herencia de plantilla con la aplicación Flask
Paso anterior : Crear una aplicación de Flask con vistas y plantillas de página
En los pasos anteriores de este tutorial, ha aprendido a crear una aplicación de Flask mínima con una sola
página HTML independiente. Pero las aplicaciones web modernas están formadas normalmente por muchas
páginas y usan recursos compartidos, como archivos CSS y JavaScript, para proporcionar un comportamiento y
un estilo uniformes.
Usar plantillas de elementos de Visual Studio para agregar rápidamente nuevos archivos de distintos tipos
con práctico código reutilizable (paso 3.1)
Atender archivos estáticos desde el código (paso 3-2, opcional)
Agregar páginas adicionales a la aplicación (paso 3.3)
Usar la herencia de plantilla para crear un encabezado y una barra de navegación que se use en varias
páginas (paso 3.4)
Paso 3.1: Familiarizarse con las plantillas de elemento

A medida que desarrolle una aplicación de Flask, lo normal es que vaya agregando muchos más archivos
Python, HTML, CSS y JavaScript. Para cada tipo de archivo (así como otros archivos como web.config que pueda
necesitar para la implementación), Visual Studio ofrece prácticas plantillas de elemento para empezar.
Para ver las plantillas disponibles, vaya al Explorador de soluciones , haga clic con el botón derecho en la
carpeta en la que desee crear el elemento y seleccione Agregar > Nuevo elemento :
Para usar una plantilla, seleccione la plantilla deseada, especifique un nombre para el archivo y seleccione
Aceptar . La adición de un elemento de este modo agrega automáticamente el archivo al proyecto de Visual
Studio y marca los cambios para el control de código fuente.
Pregunta: ¿Cómo sabe Visual Studio qué plantillas de elemento debe ofrecer?
Respuesta: El archivo de proyecto de Visual Studio (.pyproj) contiene un identificador de tipo de proyecto que lo
marca como un proyecto de Python. Visual Studio utiliza este identificador de tipo para mostrar solo aquellas
plantillas de elementos que sean adecuadas para el tipo de proyecto. De esta manera, Visual Studio puede
proporcionar un amplio conjunto de plantillas de elemento para muchos tipos de proyecto sin pedirle que los
ordene cada vez.
Paso 3.2: Atender archivos estáticos desde la aplicación

En una aplicación web compilada con Python (con cualquier plataforma), los archivos de Python siempre se
ejecutan en el servidor del host web y nunca se transmiten al equipo de un usuario. Otros archivos, sin
embargo, como CSS y JavaScript, se usan exclusivamente por el explorador, por lo que el servidor host
simplemente los ofrece tal cual cada vez que se soliciten. Estos archivos se denominan archivos "estáticos", y
Flask puede distribuirlos automáticamente sin tener que escribir ningún código. En los archivos HTML, por
ejemplo, puede hacer referencia a archivos estáticos con una ruta de acceso relativa en el proyecto. En la
primera sección de este paso se agrega un archivo CSS a la plantilla de página existente.
Cuando necesite proporcionar un archivo estático desde el código, por ejemplo, mediante una implementación
de punto de conexión de API, Flask ofrece un cómodo método con el que hacer referencia a archivos mediante
rutas de acceso relativas dentro de una carpeta denominada static (en la raíz del proyecto). En la segunda
sección de este paso se muestra ese método usando un archivo de datos estático simple.
En cualquier caso, puede organizar los archivos en static como quiera.
Usar un archivo estático en una plantilla
1. En el Explorador de soluciones , haga clic con el botón derecho en la carpeta HelloFlask en el
proyecto de Visual Studio, seleccione Agregar > Nueva carpeta y asigne a la carpeta el nombre
static .
2. Haga clic con el botón derecho en la carpeta static y seleccione Agregar > Nuevo elemento . En el
cuadro de diálogo que aparece, seleccione la plantilla Hoja de estilo , ponga al archivo el nombre
site.css y haga clic en Aceptar . El archivo site.css aparece en el proyecto y se abre en el editor. La
estructura de carpetas debería ser similar a la de la imagen siguiente:
3. Reemplace el contenido de site.css por el código siguiente y guarde el archivo:
.message {
font-weight: 600;
color: blue;
}
4. Reemplace el contenido del archivo templates/index.html de la aplicación por el código siguiente, que
reemplaza el elemento <strong> usado en el paso 2 por un <span> que hace referencia a la clase de
estilo message . El uso de una clase de estilo de este modo ofrece mucha más flexibilidad al aplicar estilo
al elemento.
<html>
<head>
<link rel="stylesheet" type="text/css" href="/static/site.css" />
</head>
<body>
</body>
</html>
5. Ejecute el proyecto y observe los resultados. Detenga la aplicación cuando haya finalizado y confirme los
cambios en el control de código fuente si quiere (como se explica en paso 2).
Atender un archivo estático desde el código
Flask proporciona una función denominada serve_static_file a la que puede llamar desde el código para
hacer referencia a cualquier archivo de la carpeta static del proyecto. El siguiente proceso crea un punto de
conexión de API simple que devuelve un archivo de datos estáticos.
1. Si aún no lo ha hecho, cree una carpeta static: en el Explorador de soluciones , haga clic con el botón
derecho en la carpeta HelloFlask del proyecto de Visual Studio, seleccione Agregar > Nueva carpeta y
asigne a la carpeta el nombre static .
2. En la carpeta static, cree un archivo de datos JSON estático denominado data.json con el siguiente
contenido (que son datos de ejemplo carentes de significado):
{
"01": {
"note" : "Data is very simple because we're demonstrating only the mechanism."
}
}
3. En views.py, agregue una función con la ruta /api/data que devuelva el archivo de datos estático
mediante el método send_static_file :
@app.route('/api/data')
def get_data():
return app.send_static_file('data.json')
4. Ejecute la aplicación y vaya al punto de conexión /api/data para comprobar que se ha devuelto el archivo
estático. Cuando haya terminado, detenga la aplicación.
Pregunta: ¿Hay alguna convención para organizar los archivos estáticos?
Respuesta: Puede agregar otros archivos HTML, CSS y JavaScript a la carpeta static como quiera. Una forma
habitual de organizar los archivos estáticos es crear subcarpetas denominadas fonts, scripts y content (para las
hojas de estilos y cualquier otro archivo).
Pregunta: ¿Cómo gestiono las variables de dirección URL y los parámetros de consulta en una API?
Respuesta: Vea la respuesta en el paso 1-4 de la Pregunta: ¿Cómo trabaja Flask con las rutas de dirección URL de
variables y con los parámetros de consulta?
Paso 3.3: Agregar una página a la aplicación

La adición de otra página a la aplicación implica lo siguiente:
Agregar una función de Python que define la vista.
Agregar una plantilla para el marcado de la página.
Agregar el enrutamiento necesario al archivo urls.py del proyecto de Flask.
Los pasos siguientes agregan una página de información al proyecto de "HelloFlask" y los vínculos a esta página
desde la página principal:
1. En el Explorador de soluciones , haga clic con el botón derecho en la carpeta templates , seleccione
Agregar > Nuevo elemento , seleccione la plantilla de elemento Página HTML , ponga al archivo el
nombre about.html y haga clic en Aceptar .
TIP
Si el comando Nuevo elemento no aparece en el menú Agregar , asegúrese de que ha detenido la aplicación
para que Visual Studio salga del modo de depuración.
2. Reemplace el contenido de about.html por el siguiente marcado (reemplace el vínculo explícito a la

página principal por una barra de navegación sencilla en el paso 3-4):
<html>
<head>
</head>
<body>
<div><a href="home">Home</a></div>
{{ content }}
</body>
</html>
3. Abra el archivo views.py de la aplicación y agregue una función denominada about que use la plantilla:
@app.route('/about')
def about():
"about.html",
title = "About HelloFlask",
content = "Example app page for Flask.")
4. Abra el archivo templates/index.html y agregue la siguiente línea dentro del elemento <body> que se va
a vincular a la página Acerca de (de nuevo, reemplace este vínculo por una barra de navegación en el
paso 3-4):
<div><a href="about">About</a></div>
5. Guarde todos los archivos con el comando de menú Archivo > Guardar todo o simplemente presione
Ctrl +Mayús +S . (Técnicamente, este paso no es necesario porque la ejecución del proyecto en Visual
Studio guarda los archivos automáticamente. No obstante, es un comando que viene bien conocer).
6. Ejecute el proyecto para observar los resultados y compruebe la navegación entre las páginas. Detenga la
aplicación cuando haya finalizado.
Pregunta: ¿Importa en Flask el nombre de una función de página?
Respuesta: No, porque es el decorador @app.route el que determina las direcciones URL para las que Flask
llama a la función para generar una respuesta. Los desarrolladores suelen hacer coincidir el nombre de la
función con la ruta, aunque no es algo obligatorio.
Paso 3.4: Usar la herencia de plantilla para crear un encabezado y una

barra de navegación
En lugar de tener vínculos de navegación explícitos en cada página, las aplicaciones web modernas suelen
utilizan un encabezado de personalización de marca y una barra de navegación que proporciona los vínculos de
página, los menús emergentes, etc. más importantes. Sin embargo, es poco práctico repetir el mismo código en
cada plantilla de página para asegurarse de que el encabezado y la barra de navegación son los mismos en
todas las páginas. Es preferible definir los elementos comunes de todas las páginas en un solo lugar.
El sistema de plantillas de Flask (Jinja de forma predeterminada) ofrece dos formas de reutilizar elementos
específicos a través de varias plantillas: la inclusión y la herencia.
La inclusión son otras plantillas de página que se insertan en una ubicación específica de la plantillas de
referencia mediante la sintaxis {% include <template_path> %} . También puede utilizar una variable si
desea cambiar la ruta de acceso dinámicamente en el código. La inclusión se utiliza normalmente en el
cuerpo de una página para incorporar la plantilla compartida en una ubicación específica de la página.
La herencia utiliza {% extends <template_path> %} al principio de una plantilla de página para especificar
una plantilla base compartida sobre la que construye a continuación la plantilla de referencia. La herencia
se suele utilizar para definir un diseño, una barra de navegación y otras estructuras que se comparten
entre las páginas de una aplicación, de manera que las plantillas de referencia solo tengan que agregar o
modificar áreas específicas de la plantilla base denominadas bloques.
En ambos casos, <template_path> se refiere a la carpeta templates de la aplicación ( ../ o ./ también son
válidos).
Una plantilla base delimita los bloques mediante las etiquetas {% block <block_name> %} y {% endblock %} . Si
una plantilla de referencia utiliza etiquetas con el mismo nombre de bloque, su contenido de bloque reemplaza
al de la plantilla base.
Los pasos siguientes muestran la herencia:
1. En la carpeta templates de la aplicación, cree un nuevo archivo HTML (con el menú contextual Agregar >
Nuevo elemento o Agregar > Página HTML ) denominado layout.html y reemplace su contenido por
el siguiente marcado. Puede ver que esta plantilla contiene un bloque denominado "content" que es todo
lo que tienen que reemplazar las páginas de referencia:
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<div class="navbar">
<a href="/" class="navbar-brand">Hello Flask</a>
<a href="{{ url_for('home') }}" class="navbar-item">Home</a>
<a href="{{ url_for('about') }}" class="navbar-item">About</a>
</div>
<div class="body-content">
{% block content %}
{% endblock %}
<hr/>
<footer>
<p>© 2018</p>
</footer>
</div>
</body>
</html>
2. Agregue los estilos siguientes al archivo static/site.css de la aplicación (en este tutorial no se está
intentando mostrar un diseño con capacidad de respuesta; estos estilos simplemente sirven para generar
un resultado interesante):
.navbar {
background-color: lightslategray;
font-size: 1em;
font-family: 'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-
serif;
color: white;
padding: 8px 5px 8px 5px;
}
.navbar a {
text-decoration: none;
color: inherit;
}
.navbar-brand {
font-size: 1.2em;
font-weight: 600;
}
.navbar-item {
font-variant: small-caps;
margin-left: 30px;
}
.body-content {
padding: 5px;
font-family:'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
}
3. Modifique templates/index.html para hacer referencia a la plantilla base y reemplace el bloque de

contenido. Puede ver que, mediante la herencia, esta plantilla se simplifica:
{% extends "layout.html" %}
{% block content %}
{% endblock %}
4. Modifique templates/about.html para hacer también referencia a la plantilla base y reemplace el bloque
de contenido:
{% extends "layout.html" %}
{% block content %}
{{ content }}
{% endblock %}
5. Ejecute el servidor para observar los resultados. Cierre el servidor cuando haya finalizado.
6. Dado que ha efectuado cambios sustanciales en la aplicación, vuelve a ser un buen momento para
confirmar los cambios en el control de código fuente.
Pasos siguientes
Puede profundizar más con estos recursos:
Para ver más funcionalidades de las plantillas de Jinja, como el flujo de control, vea la documentación del
diseñador de plantillas de Jinja ( jinja.pocoo.org)
Para obtener información detallada sobre cómo usar url_for , vea url_for en la documentación de objetos
de aplicación de Flask (flask.pocoo.org)
Proyectos de Python en Visual Studio
Las aplicaciones de Python suelen definirse usando solo carpetas y archivos, pero esta estructura se puede
complicar a medida que aplicaciones se van haciendo cada vez más grandes y pueden llegar a afectar a los
archivos generados automáticamente, a JavaScript para aplicaciones web, etc. Un proyecto de Visual Studio le
ayuda a administrar esta complejidad. El proyecto (un archivo .pyproj) identifica todos los archivos de origen y
de contenido asociados al proyecto, contiene información de compilación para cada archivo, mantiene la
información para integrarse con sistemas de control de código fuente y le ayuda a organizar la aplicación en
componentes lógicos.
Además, los proyectos siempre se administran dentro de una solución de Visual Studio, que puede contener
cualquier número de proyectos que pueden hacerse referencia entre sí. Por ejemplo, un proyecto de Python
puede hacer referencia a un proyecto de C++ que implementa un módulo de extensión. Con esta relación,
Visual Studio genera automáticamente el proyecto de C++ (si es necesario) al iniciar la depuración del proyecto
de Python. (Para obtener información general, consulte Soluciones y proyectos en Visual Studio).
Visual Studio proporciona numerosas plantillas de proyecto de Python para configurar rápidamente una serie
de estructuras de aplicación, incluida una plantilla para crear un proyecto a partir de un árbol de carpetas
existente y una plantilla para crear un proyecto vacío y limpio. Consulte la sección Plantillas de proyecto para ver
un índice.
TIP
Visual Studio 2019 permite abrir una carpeta que contiene código de Python y ejecutar ese código sin crear archivos de
solución y proyecto de Visual Studio. Para obtener más información, vea Inicio rápido: Apertura y ejecución de código de
Python en una carpeta. Sin embargo, usar un archivo del proyecto trae ventajas, como se explica en esta sección.
TIP
Sin un proyecto, todas las versiones de Visual Studio funcionan bien con el código de Python. Por ejemplo, puede abrir un
archivo de Python por sí mismo y disfrutar de las funciones de autocompletar, IntelliSense y depuración. Para ello, haga
clic con el botón derecho en el editor y seleccione Iniciar con depurar . Como dicho código siempre usa el entorno
global predeterminado, puede ver finalizaciones incorrectas o errores si el código está pensado para un entorno diferente.
Además, Visual Studio analiza todos los archivos y paquetes de la carpeta desde la que se abrió el archivo único, lo que
podría consumir mucho tiempo de CPU.
Se puede crear fácilmente un proyecto de Visual Studio a partir de código existente, como se describe en Creación de un
proyecto a partir de archivos existentes.
Deep Dive: Use source control with Python projects (Profundización: uso del control de código fuente
con proyectos de Python).
Incorporación de archivos, asignación de un archivo de inicio y

establecimiento de entornos
Al desarrollar la aplicación, normalmente necesita agregar nuevos archivos de distintos tipos al proyecto. La
adición de dichos archivos se realiza fácilmente haciendo clic con el botón derecho en el proyecto y
seleccionando Agregar > Elemento existente , lo que le permitirá buscar un archivo que quiere agregar, o
mediante Agregar > Nuevo elemento , que abre un cuadro de diálogo con numerosas plantillas de elementos.
Como se describe en la referencia sobre plantillas de elemento, las opciones incluyen archivos de Python vacíos,
una clase de Python, una prueba unitaria y varios archivos relacionados con aplicaciones web. Puede explorar
estas opciones con un proyecto de prueba para saber lo que está disponible en la versión de Visual Studio.
Cada proyecto de Python tiene un archivo de inicio asignado, que se muestra en negrita en el Explorador de
soluciones . El archivo de inicio es el archivo que se ejecuta al iniciar la depuración (F5 o Depurar > Iniciar
depuración ) o que ejecuta el proyecto en la ventana interactiva (Mayús +Alt +F5 o Depurar > Ejecutar
proyecto en Python interactivo ). Para cambiarlo, haga clic con el botón derecho en el archivo nuevo y
seleccione Establecer como elemento de inicio (o Establecer como archivo de inicio en versiones
anteriores de Visual Studio).
TIP
Si quita el archivo de inicio seleccionado de un proyecto y no selecciona uno nuevo, Visual Studio no sabrá con que
archivo de Python empezar al intentar ejecutar el proyecto. En este caso, Visual Studio 2017, versión 15.6 y posteriores,
muestra un error; con las versiones anteriores, se abre una ventana de salida con el intérprete de Python en ejecución o
verá la ventana de salida aparecer pero desaparecer a continuación casi de inmediato. Si se produce alguno de estos
comportamientos, compruebe que tiene un archivo de inicio asignado.
Si desea mantener abierta la ventana de salida por cualquier motivo, haga clic con el botón derecho en el proyecto,
seleccione Propiedades , seleccione la pestaña Depurar y, después, agregue -i al campo Argumentos del
intérprete . Este argumento hace que el intérprete entre en modo interactivo una vez que se haya finalizado un
programa, con lo que la ventana se mantendrá abierta hasta que pulse Ctrl+Z > Entrar para salir.
Un proyecto nuevo siempre está asociado al entorno de Python global predeterminado. Para asociar el proyecto
a otro entorno (incluidos los entornos virtuales), haga clic con el botón derecho en el nodo Python
Environments (Entornos de Python) del proyecto, seleccione Add/Remove Python Environments (Agregar
o quitar entornos de Python) y seleccione los que desee.
Un proyecto nuevo siempre está asociado al entorno de Python global predeterminado. Para asociar el proyecto
con un entorno distinto (incluidos los entornos virtuales), haga clic con el botón derecho en el nodo Entornos
de Python del proyecto, seleccione Agregar entorno… y seleccione el que quiera. También puede usar el
control desplegable de entornos de la barra de herramientas para seleccionar un entorno o agregar uno al
proyecto.
Para cambiar el entorno activo, haga clic con el botón derecho en el entorno que quiera en el Explorador de
soluciones y seleccione Activar entorno como se muestra a continuación. Para más información, vea
Selección de un entorno para un proyecto.
Plantillas de proyecto
Visual Studio ofrece varias maneras de configurar un proyecto de Python, desde cero o a partir de código
existente. Para usar una plantilla, seleccione el comando de menú Archivo > Nuevo > Proyecto o haga clic
con el botón derecho en la solución en el Explorador de soluciones y seleccione Agregar > Nuevo
proyecto . Ambas acciones abrirán el cuadro de diálogo Nuevo proyecto que se muestra a continuación. Para
ver plantillas específicas de Python, busque "Python" o seleccione el nodo Instalado > Python :
En la tabla siguiente se muestra un resumen de las plantillas disponibles en Visual Studio 2017 (no todas las
plantillas están disponibles en todas las versiones anteriores):
P L A N T IL L A DESC RIP C IÓ N
Desde código de Python existente Crea un proyecto de Visual Studio a partir de código Python
existente en una estructura de carpetas.
Aplicación de Python Estructura básica de proyecto para una nueva aplicación de

Python con un solo archivo de origen vacío. De forma
predeterminada, el proyecto se ejecuta en el intérprete de la
consola del entorno global predeterminado, que se puede
cambiar asignando un entorno diferente.
Proyectos web Proyectos para aplicaciones web basados en distintos

marcos, incluidos Bottle, Django y Flask.
Aplicación de IronPython Similar a la plantilla Python Application (Aplicación de

Python), pero usa IronPython de forma predeterminada
habilitando la interoperabilidad .NET y la depuración en
modo mixto con lenguajes de. NET.
Aplicación de WPF de IronPython Estructura de proyecto que usa IronPython con archivos
XAML de Windows Presentation Foundation para la interfaz
de usuario de la aplicación. Visual Studio proporciona un
diseñador de IU XAML, el código subyacente se puede
escribir en Python y la aplicación se ejecuta sin mostrar una
consola.
Página de IronPython y Silverlight Proyecto de IronPython que se ejecuta en un explorador

mediante Silverlight. El código Python de la aplicación se
incluye en la página web como un script. Una etiqueta de
script reutilizable extrae código de JavaScript que inicializa
IronPython ejecutándose dentro de Silverlight, desde donde
el código Python puede interactuar con DOM.
Aplicación de Windows Forms de IronPython Estructura de proyecto que usa IronPython con la interfaz de
usuario creada mediante código con Windows Forms. La
aplicación se ejecuta sin mostrar una consola.
Aplicación en segundo plano (IoT) Admite la implementación de proyectos de Python para que
se ejecuten como servicios en segundo plano en
dispositivos. Visite el Centro de desarrollo de Windows IoT
para más información.
Módulo de extensión de Python Esta plantilla aparece en Visual C++ si ha instalado las
herramientas de desarrollo nativo Python con la carga
de trabajo de Python en Visual Studio 2017 o versiones
posteriores (vea Instalación). Proporciona la estructura básica
de un archivo DLL de extensión de C++, similar a lo que se
describe en Creación de una extensión de C++ para Python.
En la tabla siguiente se resumen las plantillas disponibles en Visual Studio 2019 (no todas las plantillas están
disponibles en todas las versiones anteriores):
Desde código de Python existente Crea un proyecto de Visual Studio a partir de código Python
existente en una estructura de carpetas.
Aplicación de Python Estructura básica de proyecto para una nueva aplicación de

Python con un solo archivo de origen vacío. De forma
predeterminada, el proyecto se ejecuta en el intérprete de la
consola del entorno global predeterminado, que se puede
cambiar asignando un entorno diferente.
Proyectos web Proyectos para aplicaciones web basados en distintos

marcos, incluidos Bottle, Django y Flask.
Aplicación de IronPython Similar a la plantilla Python Application (Aplicación de

Python), pero usa IronPython de forma predeterminada
habilitando la interoperabilidad .NET y la depuración en
modo mixto con lenguajes de. NET.
Aplicación de WPF de IronPython Estructura de proyecto que usa IronPython con archivos
XAML de Windows Presentation Foundation para la interfaz
de usuario de la aplicación. Visual Studio proporciona un
diseñador de IU XAML, el código subyacente se puede
escribir en Python y la aplicación se ejecuta sin mostrar una
consola.
Página de IronPython y Silverlight Proyecto de IronPython que se ejecuta en un explorador

mediante Silverlight. El código Python de la aplicación se
incluye en la página web como un script. Una etiqueta de
script reutilizable extrae código de JavaScript que inicializa
IronPython ejecutándose dentro de Silverlight, desde donde
el código Python puede interactuar con DOM.
Aplicación de Windows Forms de IronPython Estructura de proyecto que usa IronPython con la interfaz de
usuario creada mediante código con Windows Forms. La
aplicación se ejecuta sin mostrar una consola.
Aplicación en segundo plano (IoT) Admite la implementación de proyectos de Python para que
se ejecuten como servicios en segundo plano en
dispositivos. Visite el Centro de desarrollo de Windows IoT
Módulo de extensión de Python Esta plantilla aparece en Visual C++ si ha instalado las
herramientas de desarrollo nativo Python con la carga
de trabajo de Python en Visual Studio 2017 o versiones
posteriores (vea Instalación). Proporciona la estructura básica
de un archivo DLL de extensión de C++, similar a lo que se
describe en Creación de una extensión de C++ para Python.
NOTE
Dado que Python es un lenguaje interpretado, los proyectos de Python en Visual Studio no producen un archivo
ejecutable independiente al igual que otros proyectos de lenguaje compilado (C#, por ejemplo). Para obtener más
información, consulte Preguntas y respuestas.
Creación de un proyecto a partir de archivos existentes
IMPORTANT
El proceso que se describe aquí no mueve ni copia los archivos de código fuente originales. Si quiere trabajar con una
copia, duplique primero la carpeta.
1. Inicie Visual Studio y seleccione Archivo > Nuevo > Proyecto .

2. En el cuadro de diálogo Nuevo proyecto , busque "Python", seleccione la plantilla Desde código de
Python existente , asigne al proyecto un nombre y una ubicación y, después, haga clic en Aceptar .
3. En el asistente que aparece, establezca la ruta de acceso al código existente, así como un filtro para tipos
de archivo, especifique una ruta de acceso de búsqueda que requiera el proyecto y, después, seleccione
Siguiente . Si no sabe cuáles son las rutas de acceso de búsqueda, deje ese campo en blanco.
4. En el siguiente cuadro de diálogo, seleccione el archivo de inicio para el proyecto y, después, Siguiente .
Si quiere, seleccione un entorno; en caso contrario, acepte los valores predeterminados. Tenga en cuenta
que el cuadro de diálogo solo muestra los archivos del directorio raíz; si el archivo que quiere está en una
subcarpeta, deje el archivo de inicio en blanco y establézcalo posteriormente en el Explorador de
soluciones (descrito a continuación).
5. Seleccione la ubicación en la que se va a guardar el archivo del proyecto (un archivo .pyproj en disco). Si
procede, también puede incluir la detección automática de entornos virtuales y personalizar el proyecto
para marcos web diferentes. Si no conoce estas opciones, déjelas con los valores predeterminados.
6. Haga clic en Finalizar . Visual Studio creará el proyecto y lo abrirá en el Explorador de soluciones . Si
quiere mover el archivo .pyproj a otra parte, selecciónelo en el Explorador de soluciones y elija
Archivo > Guardar como . Esta acción actualiza las referencias de archivo en el proyecto pero no mueve
ningún archivo de código.
7. Para establecer otro archivo de inicio, localice el archivo en el Explorador de soluciones , haga clic con
el botón derecho y seleccione Establecer como archivo de inicio .
Archivos vinculados
Los archivos vinculados son archivos que se incorporan a un proyecto pero normalmente residen fuera de las
carpetas de proyecto de la aplicación. Aparecen en el Explorador de soluciones como archivos normales con
un icono de acceso directo superpuesto:
Los archivos vinculados se especifican en el archivo .pyproj mediante el elemento <Compile Include="..."> . Los
archivos vinculados son implícitos si usan una ruta de acceso relativa fuera de la estructura de directorios o
explícitos si usan rutas de acceso dentro del Explorador de soluciones :
<Compile Include="..\test2.py">
<Link>MyProject\test2.py</Link>
</Compile>
Los archivos vinculados se omiten en cualquiera de las condiciones siguientes:

El archivo vinculado contiene metadatos de vínculo y la ruta de acceso especificada en el atributo Include
reside dentro del directorio del proyecto.
El archivo vinculado duplica un archivo que existe dentro de la jerarquía del proyecto.
El archivo vinculado contiene metadatos de vínculo y la ruta de acceso del vínculo es una ruta de acceso
relativa fuera de la jerarquía del proyecto.
La ruta de acceso del vínculo es raíz.
Trabajar con archivos vinculados
Para agregar un elemento existente como un vínculo, haga clic con el botón derecho en la carpeta donde desea
agregar el archivo, seleccione Agregar > Elemento existente . En el cuadro de diálogo que aparece, seleccione
un archivo y pulse Agregar como vínculo en la lista desplegable del botón Agregar . Siempre que no haya
ningún archivo en conflicto, este comando crea un vínculo en la carpeta seleccionada. Sin embargo, el vínculo
no se agrega si ya existe un archivo con el mismo nombre o ya existe un vínculo a ese archivo en el proyecto.
Si intenta establecer el vínculo a un archivo que ya existe en las carpetas de proyecto, se agrega como un
archivo normal y no como un vínculo. Para convertir un archivo en un vínculo, seleccione Archivo > Guardar
como para guardar el archivo en una ubicación fuera de la jerarquía del proyecto; Visual Studio lo convierte
automáticamente en un vínculo. De forma similar, se puede invertir la conversión de un vínculo mediante
Archivo > Guardar como para guardar el archivo en algún lugar dentro de la jerarquía del proyecto.
Si mueve un archivo vinculado en el Explorador de soluciones , dicho vínculo se mueve, pero el archivo real
no se ve afectado. De manera similar, al eliminar un vínculo este se quita sin afectar al archivo.
El nombre de los archivos vinculados no se puede cambiar.
Referencias
Los proyectos de Visual Studio admiten la incorporación de referencias a proyectos y extensiones, que aparecen
bajo el nodo References del Explorador de soluciones :
Las referencias de extensión normalmente indican dependencias entre proyectos y se utilizan para proporcionar
IntelliSense en tiempo de diseño o vinculación en tiempo de compilación. Los proyectos de Python usan
referencias de manera similar pero, debido a la naturaleza dinámica de Python, se utilizan principalmente en
tiempo de diseño para mejorar la funcionalidad IntelliSense. También se pueden utilizar para implementación en
Microsoft Azure para instalar dependencias adicionales.
Módulos de extensión
Una referencia a un archivo .pyd habilita IntelliSense para el módulo generado. Visual Studio carga el archivo
.pyd en el intérprete de Python y realiza introspecciones en sus tipos y funciones. También intenta analizar las
cadenas de documento para que las funciones proporcionen ayuda para las firmas.
Si en cualquier momento el módulo de extensión se actualiza en el disco, Visual Studio vuelve a analizarlo en
segundo plano. Esta acción no afecta al comportamiento en tiempo de ejecución, pero algunas finalizaciones no
están disponibles hasta que se complete el análisis.
Puede que también necesite agregar una ruta de acceso de búsqueda a la carpeta que contiene el módulo.
Proyectos de .NET
Cuando trabaje con IronPython, puede agregar referencias a ensamblados de .NET para habilitar IntelliSense.
Para los proyectos de .NET de la solución, haga clic con el botón derecho en el nodo References en el proyecto
de Python, seleccione Agregar referencia , seleccione la pestaña Proyectos y vaya al proyecto que desee. Para
archivos DLL que haya descargado por separado, seleccione la pestaña Examinar y vaya al archivo DLL que
desee.
Dado que las referencias de IronPython no están disponibles hasta que se realiza una llamada a
clr.AddReference('<AssemblyName>') , también necesita agregar una llamada clr.AddReference apropiada al
ensamblado, normalmente al principio del código. Por ejemplo, el código creado por la plantilla de proyecto
IronPython Windows Forms Application (Aplicación de Windows Forms en IronPython) de Visual Studio
incluye dos llamadas en la parte superior del archivo:
import clr
clr.AddReference('System.Drawing')
clr.AddReference('System.Windows.Forms')
from System.Drawing import *

from System.Windows.Forms import *
# Other code omitted
Proyectos de WebPI
Puede agregar referencias a entradas de producto de WebPI para la implementación en Microsoft Azure Cloud
Services donde puede instalar componentes adicionales a través de la fuente de WebPI. De manera
predeterminada, la fuente que se muestra es específica de Python e incluye Django, CPython y otros
componentes principales. También puede seleccionar su propia fuente tal como se muestra a continuación. Al
publicar en Microsoft Azure, una tarea de configuración instala todos los productos a los que se hace referencia.
IMPORTANT
Los proyectos de WebPI no están disponibles en Visual Studio 2017 o Visual Studio 2019.
Plantillas de proyecto de aplicación web para
Python
Python en Visual Studio admite el desarrollo de proyectos web en los marcos Bottle, Flask y Django mediante
plantillas de proyecto y un iniciador de depuración que puede configurarse para controlar varios marcos. Estas
plantillas incluyen un archivo requirements.txt para declarar las dependencias necesarias. Al crear un proyecto a
partir de alguna de estas plantillas, Visual Studio le pide que instale esos paquetes (vea Instalar requisitos de
proyecto más adelante en este artículo).
También puede usar la plantilla Proyecto web genérica para otras plataformas como Pyramid. En este caso, no
se instala ningún marco con la plantilla. En su lugar, instale los paquetes necesarios en el entorno que va a usar
para el proyecto (vea Ventana Entornos de Python - Pestaña Paquetes).
Para obtener información sobre la implementación de una aplicación web de Python en Azure, vea Publicar en
Azure App Service.
Usar una plantilla de proyecto

Para crear un proyecto a partir de una plantilla, seleccione Archivo > Nuevo > Proyecto . Para ver plantillas
para proyectos web, seleccione Python > Web en el lado izquierdo del cuadro de diálogo. Después, seleccione
una plantilla de su elección, asigne los nombres al proyecto y a la solución, defina las opciones para un
directorio de la solución y el repositorio de Git y seleccione Aceptar .
La plantilla genérica Proyecto web , que se ha mencionado anteriormente, solo ofrece un proyecto vacío de
Visual Studio sin código ni supuestos, aparte de que se trata de un proyecto de Python.
La plantilla genérica Proyecto web , que se ha mencionado anteriormente, solo ofrece un proyecto vacío de
Visual Studio sin código ni supuestos, aparte de que se trata de un proyecto de Python.
Todas las demás plantillas se basan en los marcos web de Bottle, Flask o Django y se dividen en tres grupos
generales, como se describe en las secciones siguientes. Las aplicaciones creadas con cualquiera de estas
plantillas contienen código suficiente para ejecutar y depurar la aplicación en local. Cada una de ellas ofrece el
objeto de aplicación WSGI necesario (python.org) para el uso con servidores web de producción.
Grupo en blanco
Todas las plantillas Proyecto web de <framework> en blanco crean un proyecto con más o menos el
código reutilizable mínimo y las dependencias necesarias declaradas en un archivo requirements.txt.
P L A N T IL L A DESC RIP T IO N
Proyecto web de Bottle en blanco Genera una aplicación mínima en app.py con una página
principal de / y una página /hello/<name> que devuelve
<name> mediante una plantilla de página insertada muy
breve.
Proyecto web de Django en blanco Genera un proyecto de Django con la estructura del sitio
principal de Django pero sin ninguna aplicación de Django.
Para obtener más información, vea Plantilla de proyecto web
de Django y Tutorial: Introducción al marco web de Django
en Visual Studio.
Proyecto web de Flask en blanco Genera un aplicación mínima con una única página "Hola
mundo" para / . Esta aplicación es similar al resultado
obtenido tras seguir los pasos detallados descritos en Inicio
rápido: usar Visual Studio para crear su primera aplicación
web Python. Vea también Tutorial: Introducción al marco
web de Flask en Visual Studio.
Grupo web
Todas las plantillas Proyecto web de <Framework> crean una aplicación web de inicio con un diseño
idéntico, con independencia del marco elegido. La aplicación tiene una página de inicio, otra de Acerca de y otra
de contacto, además de una barra de navegación y un diseño dinámico que usa el arranque. Cada aplicación
está correctamente configurada para archivos estáticos (CSS, JavaScript y fuentes) y usa un mecanismo de
plantilla de página adecuado para el marco.
Proyecto web de Bottle Genera una aplicación cuyos archivos estáticos se

encuentran en la carpeta static y se controlan mediante
código en app.py. El enrutamiento de las páginas
individuales se encuentra en routes.py y la carpeta views
contiene las plantillas de página.
Proyecto web de Django Genera un proyecto de Django y una aplicación de Django

con tres páginas, compatibilidad con la autenticación y una
base de datos de SQLite (pero no hay modelos de datos).
Para obtener más información, vea Plantilla de proyecto web
de Django y Paso 4. Usar la plantilla completa de Proyecto
web de Django.
Proyecto web de Flask Genera una aplicación cuyos archivos estáticos se

encuentran en la carpeta static. El código de views.py
controla el enrutamiento y las plantillas de página que usan
el motor de Jinja están incluidas en la carpeta templates. El
archivo runserver.py proporciona el código de inicio. Vea
Grupo de sondeos
Las plantillas Proyecto web de <framework> de sondeos crean una aplicación web de inicio con la que los
usuarios pueden votar sobre distintas preguntas de sondeo. Cada aplicación se basa en la estructura de las
plantillas de proyecto web para usar una base de datos para administrar los sondeos y las respuestas de los
usuarios. Las aplicaciones incluyen modelos de datos apropiados y una página de aplicación especial (/seed)
que carga los sondeos desde un archivo samples.json.
Proyecto web de Bottle de sondeos Genera una aplicación que se puede ejecutar en una base de
datos en memoria, MongoDB o Azure Table Storage, que se
configura mediante la variable de entorno
REPOSITORY_NAME . Los modelos de datos y el código de
almacén de datos se encuentran en la carpeta models y el
archivo settings.py contiene código para determinar qué
almacén de datos se usa.
Proyecto web de Django de sondeos Genera un proyecto de Django y una aplicación de Django
con tres páginas y una base de datos de SQLite. Incluye las
personalizaciones de la interfaz administrativa de Django
para permitir que un administrador autenticado cree y
administre los sondeos. Para obtener más información, vea
Plantilla de proyecto web de Django y Paso 6. Usar la
plantilla de proyecto web de Django de sondeos.
Proyecto web de Flask/Jade de sondeos Genera la misma aplicación que con la plantilla Proyecto
web de Flask de sondeos , pero con la extensión Jade
para el motor de plantillas de Jinja.
Instalar requisitos de proyecto

Al crear un proyecto a partir de una plantilla específica del marco, aparece un cuadro de diálogo que le ayudará
a instalar los paquetes necesarios mediante pip. También se recomienda usar un entorno virtual para proyectos
web de forma que se incluyan las dependencias correctas cuando publique el sitio web:
Si se usa control de código fuente, normalmente se omite la carpeta del entorno virtual, ya que dicho entorno
solo puede volver a crearse con requirements.txt. La mejor forma de excluir la carpeta es seleccionar primero I
will install them myself (Haré la instalación por mi cuenta) en el aviso mostrado anteriormente y luego
deshabilitar la confirmación automática antes de crear el entorno virtual. Para obtener detalles, vea los pasos 1-
2 y 1-3 del tutorial de Django y los pasos 1-2 y 1-3 del tutorial de Flask.
Cuando implemente Microsoft Azure App Service, seleccione una versión de Python como una extensión del
sitio e instale los paquetes manualmente. Además, dado que Azure App Service no instala automáticamente los
paquetes de un archivo requirements.txt cuando se implementa desde Visual Studio, siga los detalles de
configuración de aka.ms/PythonOnAppService.
Depuración
Cuando se inicia un proyecto web para la depuración, Visual Studio inicia el servidor web local en un puerto
aleatorio y abre el explorador predeterminado en esa dirección y puerto. Para especificar opciones adicionales,
haga clic con el botón derecho en el proyecto, seleccione Propiedades y haga clic en la pestaña Iniciador web :
En el grupo Depurar :
Rutas de acceso de búsqueda , Argumentos de script , Argumentos del intérprete y Ruta del
intérprete : estas opciones son las mismas que para la depuración normal.
Iniciar URL : especifica la dirección URL que se abre en el explorador. El valor predeterminado es localhost .
Número de puer to : Puerto que se utilizará si no se especifica ninguno en la dirección URL (Visual Studio
selecciona uno automáticamente de forma predeterminada). Esta opción le permite invalidar el valor
predeterminado de la variable de entorno SERVER_PORT , usado por las plantillas para configurar el puerto en
el que escucha el servidor de depuración local.
Las propiedades de los grupos Ejecutar comando del ser vidor y Comando del ser vidor de depuración
(este último está por debajo de lo que es visible en la imagen) determinan cómo se inicia el servidor web. Dado
que muchos marcos requieren el uso de un script fuera del proyecto actual, se puede configurar aquí el script y
el nombre del módulo de inicio se puede pasar como parámetro.
Comando : puede ser un script de Python (archivo *.py), un nombre de módulo (como en
python.exe -m module_name ) o una sola línea de código (como en python.exe -c "code" ). El valor de la lista
desplegable indica cuál de estos tipos está previsto.
Argumentos : estos argumentos se pasan en la línea de comandos después del comando.
Entorno : lista separada por nuevas líneas de pares <NAME>=<VALUE> que especifican variables de
entorno. Estas variables se establecen después de todas las propiedades que pueden modificar el entorno,
como el número de puerto y las rutas de acceso de búsqueda y, por lo tanto, pueden sobrescribir estos
valores.
Cualquier propiedad de proyecto o variable de entorno se puede especificar con la sintaxis de MSBuild, por
ejemplo: $(StartupFile) --port $(SERVER_PORT) . $(StartupFile) es la ruta de acceso relativa al archivo de inicio
y {StartupModule} es el nombre del archivo de inicio que se puede importar. $(SERVER_HOST) y $(SERVER_PORT)
son variables de entorno normales que se establecen mediante las propiedades URL de inicio y Número de
puer to , automáticamente o mediante la propiedad Entorno .
NOTE
Los valores de Ejecutar comando del ser vidor se usan con el comando Depurar > Iniciar ser vidor o Ctrl+F5 ; los
valores del grupo Comando del ser vidor de depuración se usan con el comando Depurar > Iniciar el ser vidor
de depuración o F5 .
Configuración de Bottle de ejemplo

La plantilla Proyecto web de Bottle incluye código reutilizable que realiza la configuración necesaria. Sin
embargo, una aplicación de Bottle importada no puede incluir este código, en cuyo caso la siguiente
configuración inicia la aplicación mediante el módulo bottle instalado:
Grupo Run Ser ver Command (Comando de servidor de ejecución):
Comando : bottle (módulo)
Argumentos : --bind=%SERVER_HOST%:%SERVER_PORT% {StartupModule}:app
Grupo Debug Ser ver Command (Comando de servidor de depuración):
Comando : bottle (módulo)
Argumentos --debug --bind=%SERVER_HOST%:%SERVER_PORT% {StartupModule}:app
La opción --reload no se recomienda cuando se usa Visual Studio para la depuración.

Configuración de Pyramid de ejemplo
Las aplicaciones de Pyramid actualmente se crean mejor mediante la herramienta de la línea de comandos
pcreate . Una vez creada una aplicación, se puede importar mediante la plantilla Desde código de Python
existente . Después de realizar esto, seleccione la personalización Proyecto web genérico para configurar las
opciones. Esta configuración asume que Pyramid se ha instalado en un entorno virtual en ..\env .
Grupo Depurar :
Puer to de ser vidor : 6543 (o lo que se haya configurado en los archivos .ini)
Grupo Run Ser ver Command (Comando de servidor de ejecución):
Comando: ..\env\scripts\pserve-script.py (script)
Argumentos: Production.ini
Grupo Debug Ser ver Command (Comando de servidor de depuración):
Comando: ..\env\scripts\pserve-script.py (script)
Argumentos: Development.ini
TIP
Es probable que tenga que configurar la propiedad Directorio de trabajo del proyecto porque las aplicaciones de
Pyramid suelen encontrarse en una carpeta por debajo de la raíz del proyecto.
Otras configuraciones
Si tiene una configuración para otro marco que quiere compartir, o si quiere solicitar la configuración para otro
marco, abra un problema en GitHub.
Vea también
Referencia de plantillas de elemento de Python
Plantilla de proyecto web de Django
Django es un marco de Python de alto nivel diseñado para el desarrollo web rápido, seguro y escalable. La
compatibilidad de Python en Visual Studio proporciona varias plantillas de proyecto para configurar la
estructura de una aplicación web basada en Django. Para usar una plantilla en Visual Studio, seleccione Archivo
> Nuevo > Proyecto , busque "Django" y seleccione alguna de las plantillas Proyecto web de Django en
blanco , Proyecto web de Django y Proyecto web de Django de sondeos . Vea el tutorial de aprendizaje
de Django para obtener una guía detallada de todas las plantillas.
Django es un marco de Python de alto nivel diseñado para el desarrollo web rápido, seguro y escalable. La
compatibilidad de Python en Visual Studio proporciona varias plantillas de proyecto para configurar la
estructura de una aplicación web basada en Django. Para usar una plantilla en Visual Studio, seleccione Archivo
> Nuevo > Proyecto , busque "Django" y seleccione alguna de las plantillas del proyecto web de Django en
blanco y del proyecto web de Django . Vea el tutorial de aprendizaje de Django para obtener una guía
detallada de todas las plantillas.
Visual Studio proporciona IntelliSense al completo para proyectos de Django:
Variables de contexto que se pasan en la plantilla:
Etiquetado y filtrado para elementos integrados y definidos por el usuario:
Color de sintaxis para JavaScript y CSS insertado:

Visual Studio también proporciona compatibilidad con la depuración completa para los proyectos de Django:
Es habitual que los proyectos de Django se administren mediante su archivo manage.py, que es una hipótesis
que sigue Visual Studio. Si deja de usar ese archivo como el punto de entrada, básicamente divide el archivo del
proyecto. En ese caso necesita volver a crear el proyecto de archivos existentes sin marcarlo como un proyecto
de Django.
Consola de administración de Django

El acceso a la consola de administración de Django se realiza a través de varios comandos del menú Proyecto o
haciendo clic con el botón derecho en el proyecto en el Explorador de soluciones .
Abrir Shell de Django : abre un Shell en el contexto de la aplicación que le permite manipular los
modelos:
Django Sync DB (Base de datos de sincronización de Django): ejecuta manage.py syncdb en una ventana
interactiva :
Collect Static (Recopilar estáticos): ejecuta manage.py collectstatic --noinput para copiar todos los
archivos estáticos en la ruta de acceso que STATIC_ROOT especifica en settings.py.
Validar : ejecuta manage.py validate , que informa de los errores de validación en los modelos instalados
que especifica INSTALLED_APPS en settings.py:
Vea también
Tutorial de aprendizaje de Django
Creación y administración de entornos de Python
en Visual Studio
Un entorno de Python es un contexto en el que se ejecuta el código de Python e incluye los entornos globales,
virtuales y de Conda. Un entorno consta de un intérprete, una biblioteca (normalmente la biblioteca estándar de
Python) y un conjunto de paquetes instalados. Todos estos componentes determinan qué construcciones de
lenguaje y sintaxis son válidas, a qué función de sistema operativo puede acceder y qué paquetes puede usar.
En Visual Studio en Windows, se usa la ventana Entornos de Python , como se explica en este artículo, para
administrar entornos y seleccionar uno como valor predeterminado para los proyectos nuevos. En los siguientes
artículos se indican otros aspectos de los entornos:
En cualquier proyecto puede seleccionar un entorno concreto en lugar de usar el predeterminado.
Para obtener detalles sobre la creación y el empleo de entornos virtuales para proyectos de Python, vea
Uso de entornos virtuales.
Si quiere instalar paquetes en un entorno, vea la referencia de la pestaña Paquetes.
Para instalar otro intérprete de Python, vea Instalación de intérpretes de Python. En general, si descarga y
ejecuta el instalador de una distribución principal de Python, Visual Studio detecta esa nueva instalación y
el entorno aparece en la ventana Entornos de Python y se puede seleccionar para los proyectos.
Si no está familiarizado con Python en Visual Studio, los siguientes artículos también proporcionan un contexto
general:
Uso de Python en Visual Studio
Instalación de la compatibilidad con Python en Visual Studio
NOTE
No puede administrar entornos de código de Python abiertos como carpeta con el comando Archivo > Abrir >
Carpeta . En su lugar, cree un proyecto de Python a partir del código existente para disfrutar de las características del
entorno de Visual Studio.
NOTE
Los entornos de código de Python abiertos como una carpeta se pueden administrar con el comando Archivo > Abrir >
Carpeta . La barra de herramientas de Python permite alternar entre todos los entornos detectados y, también, agregar
un entorno nuevo. La información del entorno se almacena en el archivo PythonSettings.json, en la carpeta .vs del área de
trabajo.
La ventana Entornos de Python

Los entornos que Visual Studio conoce aparecen en la ventana Entornos de Python . Para abrir la ventana, use
uno de los métodos siguientes:
Seleccione el comando de menú Vista > Otras ventanas > Entornos de Python .
Haga clic con el botón derecho en el nodo Entornos de Python de un proyecto en el Explorador de
soluciones y seleccione View All Python Environments (Ver todos los entornos de Python):
En cualquier caso, la ventana Entornos de Python aparece junto al Explorador de soluciones :

Visual Studio busca entornos globales instalados mediante el Registro (tras PEP 514), junto con entornos
virtuales y entornos de Conda (vea Tipos de entornos). Si no ve un entorno previsto en la lista, vea Identificación
manual de un entorno existente.
Al seleccionar un entorno de la lista, Visual Studio muestra distintas propiedades y comandos de ese entorno en
la pestaña Información general . Por ejemplo, en la imagen anterior puede ver que la ubicación del intérprete
es C:\Python36-32. Los cuatro comandos en la parte inferior de la pestaña Información general abren un
símbolo del sistema con el intérprete en ejecución. Para obtener más información, vea Referencia de pestañas de
la ventana Entorno de Python: Información general.
Use la lista desplegable situada debajo de la lista de entornos para cambiar de pestañas, como Paquetes o
IntelliSense . Estas pestañas también se describen en la Referencia de pestañas de la ventana Entornos de
Python.
La selección de un entorno no cambia su relación con los proyectos. El entorno predeterminado, que aparece en
negrita en la lista, es el que usa Visual Studio para los proyectos nuevos. Para usar otro entorno con los
proyectos nuevos, use el comando Conver tir este entorno en el predeterminado para nuevos
proyectos . En el contexto de un proyecto siempre puede seleccionar un entorno concreto. Para más
información, vea Selección de un entorno para un proyecto.
A la derecha de cada entorno de la lista figura un control que abre una ventana interactiva para ese entorno.
(En Visual Studio 2017, versión 15.5 y anteriores, aparece otro control que actualiza la base de datos de
IntelliSense para ese entorno. Vea Referencia de pestañas de la ventana Entornos de Python para obtener
información detallada sobre la base de datos).
TIP
Si expande la ventana Entornos de Python con un ancho suficiente, obtendrá una vista más completa de los entornos
con la que podrá trabajar de una manera más cómoda.
TIP
Si expande la ventana Entornos de Python con un ancho suficiente, obtendrá una vista más completa de los entornos
con la que podrá trabajar de una manera más cómoda.
NOTE
Aunque Visual Studio respeta la opción de paquetes de sitio de sistema, no ofrece una forma de cambiarla desde dentro
de Visual Studio.
¿Qué ocurre si no aparece ningún entorno?
Si no aparece ningún entorno, significa que Visual Studio no pudo detectar ninguna instalación de Python en las
ubicaciones estándar. Por ejemplo, es posible que haya instalado Visual Studio 2017 o una versión posterior,
pero también que haya borrado todas las opciones de intérprete en las opciones del instalador de la carga de
trabajo de Python. De manera similar, es posible que haya instalado Visual Studio 2015 o una versión anterior,
pero que no haya instalado un intérprete de manera manual (vea Instalación de intérpretes de Python).
Si sabe que tiene un intérprete de Python en el equipo pero Visual Studio (cualquier versión) no lo detectó, use
el comando + Personalizado para especificar manualmente la ubicación. Consulte la sección siguiente,
Identificación manual de un entorno existente.
TIP
Visual Studio detecta las actualizaciones de un intérprete existente, como actualizar Python 2.7.11 a 2.7.14 mediante los
instaladores de python.org. Durante el proceso de instalación, el entorno anterior desaparece de la lista de entornos de
Python antes de que aparezca la actualización en su lugar.
Sin embargo, si mueve manualmente un intérprete y su entorno con el sistema de archivos, Visual Studio no sabrá cuál es
la ubicación nueva. Para obtener más información, vea la sección sobre cómo mover un intérprete.
Tipos de entornos
Visual Studio puede trabajar con entornos globales, virtuales y de Conda.
Entornos globales
Cada instalación de Python (por ejemplo, Python 2.7, Python 3.6, Python 3.7, Anaconda 4.4.0, etc., vea Instalación
de intérpretes de Python) mantiene su propio entorno global. Cada entorno está formado por el intérprete de
Python correspondiente, su biblioteca estándar, un conjunto de paquetes preinstalados y cualquier paquete
adicional que instale mientras ese entorno está activado. Al instalar un paquete en un entorno global, este pasa
a estar disponible para todos los proyectos que usan ese entorno. Si el entorno se encuentra en un área
protegida del sistema de archivos (dentro de c:\archivos de programa, por ejemplo), la instalación de paquetes
requiere privilegios de administrador.
Los entornos globales están disponibles para todos los proyectos del equipo. En Visual Studio, debe seleccionar
un entorno global como predeterminado, que será el que se utilice para todos los proyectos (a menos que elija
específicamente otro diferente para un proyecto). Para más información, vea Selección de un entorno para un
proyecto.
Entornos virtuales
Aunque trabajar en un entorno global es una forma sencilla de empezar, con el tiempo, ese entorno se llena de
muchos paquetes diferentes que se han instalado para distintos proyectos. Tal desorden dificulta probar
exhaustivamente una aplicación en un conjunto específico de paquetes con versiones conocidas, que es
exactamente el tipo de entorno que se configuraría en un servidor web o de compilación. También pueden
producirse conflictos si dos proyectos necesitan paquetes no compatibles o versiones diferentes del mismo
paquete.
Por este motivo, los desarrolladores suelen crear un entorno virtual para un proyecto. Un entorno virtual es una
subcarpeta de un proyecto que contiene una copia de un intérprete determinado. Al activar el entorno virtual,
los paquetes que instale se instalan solo en la subcarpeta de ese entorno. Si luego ejecuta un programa de
Python en ese entorno, sabe que se está ejecutando solo en esos paquetes específicos.
Visual Studio permite crear directamente un entorno virtual para un proyecto. Por ejemplo, si abre un proyecto
que contiene un archivo requirements.txt o crea un proyecto a partir de una plantilla que incluye ese archivo,
Visual Studio le pide que cree automáticamente un entorno virtual e instale esas dependencias.
En un proyecto abierto puede crear un nuevo entorno virtual en cualquier momento. En el Explorador de
soluciones , expanda el nodo del proyecto, haga clic con el botón derecho en Entornos de Python y
seleccione "Agregar entorno virtual". Para obtener más información, vea Creación de un entorno virtual.
Visual Studio además proporciona un comando para generar un archivo requirements.txt desde un entorno
virtual, con lo que resulta sencillo volver a crear el entorno en otros equipos. Para obtener más información, vea
Use virtual environments (Usar entornos virtuales).
Entornos de coda
Un entorno de Conda es el creado mediante la herramienta conda o con la administración de Conda integrada
en Visual Studio 2017, versión 15.7 y versiones posterior. (Requiere Anaconda o Miniconda, que están
disponibles a través del instalador de Visual Studio; vea Instalación).
1. Seleccione + Crear entorno de Conda en la ventana Entornos de Python , que abre una pestaña
Crear nuevo entorno de Conda :
2. Escriba un nombre para el entorno en el campo Nombre , luego seleccione un intérprete de Python base
en el campo Python y, después, seleccione Crear .
3. La ventana Salida muestra el progreso del nuevo entorno, con algunas instrucciones de CLI cuando se
completa la creación:
4. En Visual Studio, puede activar un entorno de Conda para un proyecto de la misma forma que con
cualquier otro entorno, tal como se describe en Cómo asignar el entorno de Python que se usa en un
proyecto.
5. Para instalar paquetes en el entorno, use la pestaña Paquetes.
1. Seleccione Agregar entorno... en la ventana Entornos de Python (o desde la barra de herramientas
de Python), con lo que se abre el cuadro de diálogo Agregar entorno . En ese cuadro de diálogo,
seleccione la pestaña Entorno de Conda :
2. Configure los campos siguientes:
CAMPO DESC RIP C IÓ N
Proyecto Proyecto en el que se creará el entorno (si tiene varios

proyectos en la misma solución de Visual Studio).
NOMBRE Nombre del entorno de Conda.
Agregar paquetes desde Elija Archivo de entorno si tiene un archivo

environment.yml que describe las dependencias o elija
One or more Anaconda package names (Uno o
más nombres de paquetes de Anaconda) y muestre al
menos un paquete de Python o una versión de Python
en el campo a continuación. La lista de paquetes indica a
Conda que cree un entorno de Python. Para instalar la
versión más reciente de Python, use python ; para
instalar una versión específica, use
python=,major>.<minor> como en python=3.7 .
También puede usar el botón del paquete para
seleccionar las versiones de Python y los paquetes
comunes en una serie de menús.
Establecer como entorno actual Activa el entorno nuevo en el proyecto seleccionado una
vez que se crea el entorno.
Establecer como entorno predeterminado para los Establecer y activa automáticamente el entorno de
nuevos proyectos Conda en los nuevos proyectos creados en Visual Studio.
Esta opción es igual que usar el comando Conver tir
este entorno en el predeterminado para nuevos
proyectos en la ventana Entornos de Python .
Ver en la ventana de entornos de Python Especifica si mostrar la ventana Entornos de Python

después de crear el entorno.
IMPORTANT
Cuando cree un entorno de Conda, asegúrese de especificar al menos una versión de Python o un paquete de
Python con environments.yml o con la lista de paquetes, lo que garantiza que el entorno contiene un runtime
de Python. En caso contrario, Visual Studio omite el entorno: el entorno no aparece en ninguna parte de la
ventana Entornos de Python , no se establece como el entorno actual de ningún proyecto ni tampoco está
disponible como entorno global.
Si crea un entorno de Conda sin una versión de Python, use el comando conda info para ver las ubicaciones de
las carpetas del entorno de Conda y luego quite manualmente la subcarpeta del entorno de esa ubicación.
3. Seleccione Crear y observe el progreso en la ventana Salida . La salida incluye unas cuantas
instrucciones de la CLI una vez que se completa la creación:
4. En Visual Studio, puede activar un entorno de Conda para un proyecto de la misma forma que con
cualquier otro entorno, tal como se describe en Cómo asignar el entorno de Python que se usa en un
proyecto.
5. Para instalar paquetes adicionales en el entorno, use la pestaña Paquetes.
NOTE
Para obtener mejores resultados con entornos de Conda, use Conda 4.4.8 o posterior (las versiones de Conda son
diferentes de las versiones de Anaconda). Puede instalar las versiones adecuadas de Miniconda (Visual Studio 2019) y
Anaconda (Visual Studio 2017) mediante el instalador de Visual Studio.
Para ver la versión de conda, donde se almacenan los entornos de Conda, y otra información, ejecute
conda info en un símbolo del sistema de Anaconda (es decir, un símbolo del sistema donde Anaconda está en
la ruta de acceso):
conda info
Las carpetas de entorno de Conda tienen el siguiente aspecto:
envs directories : C:\Users\user\.conda\envs

c:\anaconda3\envs
C:\Users\user\AppData\Local\conda\conda\envs
Debido a que los entornos de Conda no se almacenan con un proyecto, actúan de forma similar a los entornos
globales. Por ejemplo, al instalar un paquete nuevo en un entorno de conda, ese paquete pasa a estar disponible
para todos los proyectos que usan ese entorno.
Para Visual Studio 2017, versión 15.6 y anteriores, puede usar entornos de Conda apuntando a ellos de forma
manual tal como se describe en Manually identify an existing environment (Identificar de forma manual un
entorno existente).
Visual Studio 2017, versión 15.7 y posteriores, detecta automáticamente los entornos de Conda y los muestra
en la ventana Entornos de Python , tal y como se describe en la sección siguiente.
Identificación manual de un entorno existente

Use los pasos siguientes para identificar un entorno instalado en una ubicación no estándar, como los entornos
de Conda en Visual Studio 2017, versión 15.6 y anteriores:
1. Seleccione + Personalizado en la ventana Entornos de Python , lo que abre la pestaña Configurar :
2. Escriba un nombre para el entorno en el campo Descripción .

3. Escriba o busque (con ... ) la ruta de acceso del intérprete en el campo Ruta de acceso de prefijo .
4. Si Visual Studio detecta un intérprete de Python en esa ubicación (como la ruta de acceso que aparece a
continuación para un entorno de conda), habilita el comando Detección automática . Cuando
selecciona Detección automática , se completan los campos restantes. También puede completar estos
campos de manera manual.
5. Una vez que los campos contienen los valores que desea, seleccione Aplicar para guardar la
configuración. Ahora puede usar el entorno como cualquier otro dentro de Visual Studio.
6. Si necesita quitar un entorno identificado manualmente, seleccione el comando Quitar en la pestaña
Configurar . Los entornos detectados automáticamente no proporcionan esta opción. Para más
información, consulte la sección sobre la pestaña de configuración.
1. Seleccione Agregar entorno... en la ventana Entornos de Python (o desde la barra de herramientas
de Python), con lo que se abre el cuadro de diálogo Agregar entorno . En ese cuadro de diálogo,
seleccione la pestaña Entorno existente :
2. Seleccione el menú desplegable Entorno y seleccione Personalizado :

3. En los campos que se proporcionan en el cuadro de diálogo, escriba o busque (con ... ) la ruta de acceso
del intérprete en Ruta de acceso del prefijo , que se rellena en la mayoría de los otros campos.
Después de revisar esos valores y modificarlos según sea necesario, seleccione Agregar .
4. Los detalles del entorno se pueden revisar y modificar en cualquier momento en la ventana Entornos de
Python . En esa ventana, seleccione el entorno y luego, la pestaña Configurar . Después de hacer
cambios, seleccione el comando Aplicar . También puede quitar el entorno con el comando Quitar (que
no está disponible en entornos detectados automáticamente). Para más información, consulte la sección
sobre la pestaña de configuración.
Corrección o eliminación de entornos no válidos

Si Visual Studio encuentra entradas del Registro de un entorno, pero la ruta de acceso para el intérprete no es
válida, la ventana Entornos de Python mostrará el nombre con una fuente tachada:
Para corregir un entorno que quiera mantener, en primer lugar intente usar el proceso Reparar del instalador.
Los instaladores de la versión estándar de Python 3.x, por ejemplo, incluyen esa opción.
Para corregir un entorno sin opción de reparación o quitar un entorno no válido, siga estos pasos para modificar
el Registro directamente. Visual Studio actualiza automáticamente la ventana Entornos de Python al realizar
cambios en el Registro.
1. Ejecute regedit.exe.
2. Vaya a HKEY_LOCAL_MACHINE\SOFTWARE\Python o a
HKEY_CURRENT_USER\SOFTWARE\Python . Para IronPython, busque IronPython .
3. Expanda el nodo que coincida con la distribución, como Python Core para CPython o
ContinuumAnalytics para Anaconda. Para IronPython, expanda el nodo de número de versión.
4. Inspeccione los valores del nodo InstallPath :
Si el entorno todavía figura en el equipo, cambie el valor de ExecutablePath a la ubicación adecuada.

Corrija también los valores (Predeterminado) y WindowedExecutablePath según sea necesario.
Si el entorno ya no figura en el equipo y quiere eliminarlo de la ventana Entornos de Python ,
elimine el nodo primario de InstallPath , como, por ejemplo, 3.6 en la imagen anterior.
La configuración no válida en HKEY_CURRENT_USER\SOFTWARE\Python reemplaza la
configuración en HKEY_LOCAL_MACHINE\SOFTWARE\Python
Vea también
Cómo seleccionar un entorno de Python para un
proyecto
Todo el código de un proyecto de Python se ejecuta dentro del contexto de un entorno concreto, como uno de
Python global, de Anaconda, virtual o de Conda. Visual Studio también usa ese entorno para la depuración, las
finalizaciones de importaciones y miembros, la comprobación de sintaxis y cualquier otra tarea que necesite
servicios de lenguaje específicos de la versión de Python y un conjunto de paquetes instalados.
Todos los proyectos Python nuevos en Visual Studio están configurados inicialmente para usar el entorno global
predeterminado, que aparece en el nodo Entornos de Python en el Explorador de soluciones :
Para cambiar el entorno para un proyecto, haga clic en el nodo Entornos de Python y seleccione Agregar o
quitar entornos de Python . En la lista mostrada, que incluye entornos globales, virtuales y de conda,
seleccione todos los que desee que aparezca en el nodo Entornos de Python :
Una vez que seleccione Aceptar , todos los entornos seleccionados aparecen en el nodo Entornos de Python .
El entorno activado actualmente aparece en negrita:
Para activar rápidamente un entorno distinto, haga clic con el botón derecho en el nombre de ese entorno y
seleccione Activar entorno . La opción se guarda con el proyecto y ese entorno se abrirá cada vez que abra el
proyecto. Si desactiva todas las opciones en el cuadro de diálogo Agregar o quitar entornos de Python ,
Visual Studio activa el entorno predeterminado global.
El menú contextual del nodo Entornos de Python también proporciona comandos adicionales:
C O M A N DO DESC RIP C IÓ N
Agregar entorno vir tual Inicia el proceso de creación de un nuevo entorno virtual en
el proyecto. Consulte Creación de un entorno virtual.
Agregar entorno vir tual existente Le pide que seleccione una carpeta que contenga un
entorno virtual y lo agrega a la lista bajo Entornos de
Python , pero no lo activa. Consulte Activación de un
entorno virtual existente.
Crear entorno de Conda Cambia a la ventana Entornos de Python en la que se

escribe un nombre para el entorno y se especifica su
intérprete básico. Vea Entornos de Conda.
Para cambiar el entorno de un proyecto, haga clic con el botón derecho en el nodo Entornos de Python y
seleccione Agregar entorno . También puede seleccionar Agregar entorno en la lista desplegable de entornos
de la barra de herramientas de Python.
Una vez en el cuadro de diálogo Agregar entorno , seleccione la pestaña Entorno existente y elija un entorno
nuevo en la lista desplegable Entorno :
Si ya agregó un entorno distinto del valor predeterminado global a un proyecto, es posible que tenga que
activar un entorno recién agregado. Haga clic con el botón derecho en ese entorno en el nodo Entornos de
Python y seleccione Activar entorno . Para quitar un entorno del proyecto, seleccione Quitar .
Uso de entornos virtuales

Un entorno virtual es una combinación única de un intérprete de Python específico y un conjunto de bibliotecas
específico distinto de otros entornos globales y de conda. Un entorno virtual es específico a un proyecto y se
mantiene en una carpeta de proyecto. Esta carpeta contiene las bibliotecas instaladas del entorno junto con un
archivo pyvenv.cfg que especifica la ruta de acceso al intérprete básico de ese entorno en otra parte del sistema
de archivos. (Es decir, un entorno virtual no contiene una copia del intérprete, solo un vínculo a él).
Una ventaja de usar un entorno virtual es que a medida que el proyecto se desarrolla a lo largo del tiempo, el
entorno virtual siempre refleja las dependencias exactas del proyecto. (Por otra parte, un entorno global
compartido, contiene cualquier número de bibliotecas independientemente de si se usan en el proyecto o no). A
continuación, puede crear fácilmente un archivo requirements.txt desde el entorno virtual, que después se usa
para volver a instalar esas dependencias en otro equipo de desarrollo o producción. Para más información,
consulte Administración de los paquetes necesarios con requirements.txt.
Cuando abre un proyecto en Visual Studio que contiene un archivo requirements.txt, Visual Studio
automáticamente le ofrece la opción de volver a crear el entorno virtual. En los equipos donde no está instalado
Visual Studio, puede usar pip install -r requirements.txt para restaurar los paquetes.
Dado que un entorno virtual contiene una ruta de acceso codificada de forma rígida al intérprete básico y que
puede volver a crear el entorno mediante requirements.txt, normalmente se omite toda la carpeta del entorno
virtual del control de código fuente.
En las siguientes secciones se explica cómo activar un entorno virtual existente en un proyecto y cómo crear un
nuevo entorno virtual.
En Visual Studio, se puede activar un entorno virtual para un proyecto como cualquier otro a través del nodo
Entornos de Python en el Explorador de soluciones .
Una vez que un entorno virtual se agrega al proyecto, aparece en la ventana Entornos de Python . Puede
activarlo después al igual que cualquier otro entorno así como administrar sus paquetes.
Creación de un entorno virtual
Puede crear un entorno virtual directamente en Visual Studio como se indica a continuación:
1. Haga clic con el botón derecho en Entornos de Python en el Explorador de soluciones y seleccione
Agregar entorno vir tual , con lo que se mostrará el cuadro de diálogo siguiente:
2. En el campo Ubicación del entorno vir tual , especifique una ruta de acceso para el entorno virtual. Si
especifica solo un nombre, el entorno virtual se crea dentro del proyecto actual en una subcarpeta con
ese nombre.
3. Seleccione un entorno como el intérprete base y seleccione Crear . Visual Studio muestra una barra de
progreso mientras se configura el entorno y descarga los paquetes necesarios. Una vez finalizado, el
entorno virtual aparece en la ventana Entornos de Python para el proyecto contenedor.
4. El entorno virtual no se activa de manera predeterminada. Para activar el entorno virtual del proyecto,
haga clic con el botón derecho en él y seleccione Activar entorno .
NOTE
Si la ruta de acceso de la ubicación identifica un entorno virtual existente, Visual Studio detecta de manera automática el
intérprete básico (con el archivo orig-prefix.txt en el directorio lib del entorno) y cambia el botón Crear a Agregar .
Si existe un archivo requirements.txt cuando se agrega un entorno virtual, el cuadro de diálogo Agregar entorno
vir tual muestra una opción para instalar los paquetes de manera automática, lo que facilita volver a crear un entorno en
otro equipo:
En cualquier caso, el resultado es el mismo que si se usara el comando Agregar entorno vir tual existente .
Activación de un entorno virtual existente

Si ya creó un entorno virtual en otro lugar, puede activarlo para un proyecto como se indica a continuación:
Agregar entorno vir tual existente .
2. En el cuadro de diálogo Examinar que aparece, vaya a la carpeta que contiene el entorno virtual,
selecciónela y, luego, seleccione Aceptar . Si Visual Studio detecta un archivo requirements.txt en ese
entorno, preguntará si instalar esos paquetes.
3. Después de unos momentos, el entorno virtual aparece en el nodo Entornos de Python en el
Explorador de soluciones . El entorno virtual no se activa de manera predeterminada, por lo que debe
hacer clic con el botón derecho en él y seleccionar Activar entorno .
Creación de un entorno virtual
Puede crear un entorno virtual directamente en Visual Studio como se indica a continuación:
Agregar entorno , o bien seleccione Agregar entorno en la lista desplegable de entornos de la barra
de herramientas de Python. En el cuadro de diálogo Agregar entorno que aparece, seleccione la
pestaña Entorno vir tual :
2. Especifique un nombre para el entorno virtual, seleccione un intérprete básico y compruebe su ubicación.
En Install packages from file (Instalar paquetes desde archivo), proporcione la ruta de acceso a un
archivo requirements.txt si lo desea.
3. Revise las otras opciones del cuadro de diálogo:
Establecer como entorno actual Activa el entorno nuevo en el proyecto seleccionado una
vez que se crea el entorno.
Establecer como entorno predeterminado para los Establecer y activa automáticamente el entorno virtual
nuevos proyectos en los nuevos proyectos creados en Visual Studio.
Cuando se usa esta opción, el entorno virtual debe estar
en una ubicación fuera de un proyecto específico.
Ver en la ventana de entornos de Python Especifica si abrir la ventana Entornos de Python

después de crear el entorno.
Poner el entorno a disposición globalmente Especifica si el entorno virtual también sirve como
entorno global. Cuando se usa esta opción, el entorno
virtual debe estar en una ubicación fuera de un proyecto
específico.
4. Seleccione Crear para finalizar el entorno virtual. Visual Studio muestra una barra de progreso mientras
se configura el entorno y descarga los paquetes necesarios. Una vez finalizado, el entorno virtual se
activa y aparece en el nodo Entornos de Python del Explorador de soluciones y la ventana
Entornos de Python del proyecto contenedor.
Activación de un entorno virtual existente
Si ya creó un entorno virtual en otro lugar, puede activarlo para un proyecto como se indica a continuación:
Agregar entorno .
2. En el cuadro de diálogo Examinar que aparece, vaya a la carpeta que contiene el entorno virtual,
selecciónela y, luego, seleccione Aceptar . Si Visual Studio detecta un archivo requirements.txt en ese
entorno, preguntará si instalar esos paquetes.
3. Después de unos momentos, el entorno virtual aparece en el nodo Entornos de Python en el
Explorador de soluciones . El entorno virtual no se activa de manera predeterminada, por lo que debe
hacer clic con el botón derecho en él y seleccionar Activar entorno .
Eliminación de un entorno virtual
1. En el Explorador de soluciones , haga clic con el botón derecho en el entorno virtual y seleccione
Quitar .
2. Visual Studio pregunta si desea quitar o eliminar el entorno virtual. Si selecciona Quitar , deja de estar
disponible para el proyecto pero sigue en el sistema de archivos. Si selecciona Eliminar , se quita el
entorno del proyecto y se elimina del sistema de archivos. El intérprete básico no se ve afectado.
Visualización de los paquetes instalados

En el Explorador de soluciones, expanda cualquier nodo específico del entorno para ver rápidamente los
paquetes que están instalados en ese entorno (lo que significa que puede importar esos paquetes y usarlos en
el código cuando el entorno está activo):
Para instalar paquetes nuevos, haga clic con el botón derecho en el entorno y seleccione Instalar paquete de
Python para cambiar a la pestaña Paquetes correspondiente en la ventana Entornos de Python . Escriba un
término de búsqueda (por lo general, el nombre del paquete) y Visual Studio mostrará los paquetes que
coincidan.
Para instalar paquetes nuevos, haga clic con el botón derecho en el entorno y seleccione Administrar
paquetes de Python (o use el botón de paquete de la barra de herramientas de Python) para cambiar a la
pestaña Paquetes correspondiente en la ventana Entornos de Python . En la pestaña Paquetes , escriba un
término de búsqueda (por lo general, el nombre del paquete) y Visual Studio mostrará los paquetes que
coincidan.
Dentro de Visual Studio, los paquetes (y las dependencias) de la mayoría de los entornos se descargan desde
Python Package Index (PyPI) (Índice de paquetes de Python), donde también puede buscar los paquetes
disponibles. La barra de estado y la ventana de salida de Visual Studio muestran información sobre la
instalación. Para desinstalar un paquete, haga clic con el botón derecho en él y seleccione Quitar .
Por lo general, el administrador de paquetes de Conda usa https://repo.continuum.io/pkgs/ como el canal
predeterminado, pero hay otros canales disponibles. Para más información, consulte Administrar canales
(docs.conda.io).
Tenga en cuenta que las entradas mostradas puede que no sean siempre precisas, y la instalación y
desinstalación pueden no ser confiables o estar disponibles. Visual Studio usa el administrador de paquetes de
pip si está disponible y lo descarga e instala cuando sea necesario. Visual Studio también puede usar el
administrador de paquetes de easy_install. También se muestran los paquetes instalados con pip o
easy_install desde la línea de comandos.
Tenga en cuenta también que Visual Studio no admite actualmente el uso de conda para instalar paquetes en
un entorno de conda. En su lugar, use conda desde la línea de comandos.
TIP
Una situación común donde pip no puede instalar un paquete es cuando este incluye código fuente para componentes
nativos en archivos *.pyd. Sin la versión necesaria de Visual Studio instalada, pip no puede compilar estos componentes. El
mensaje de error que aparece en esta situación es error : Unable to find vcvarsall.bat (Error: no se encuentra
vcvarsall.bat). easy_install suele poder descargar los binarios previamente compilados, y el usuario puede descargar
un compilador adecuado para versiones anteriores de Python de https://python.en.uptodown.com/windows/versions.
Para más información, consulte How to deal with the pain of "unable to find vcvarsallbat" (Cómo afrontar la dificultad de
"no poder encontrar vcvarsallbat") en el blog del equipo de herramientas de Python.
Vea también
Creación y administración de entornos de Python en Visual Studio
Administración de los paquetes necesarios con
requirements.txt
Si comparte un proyecto con otros usuarios, usa un sistema de compilación o pretende copiar el proyecto en
cualquier otra ubicación donde necesita restaurar un entorno, necesita especificar los paquetes externos que
dicho proyecto requiere. El enfoque recomendado es usar un archivo requirements.txt (readthedocs.org) que
contiene una lista de comandos para pip que instala las versiones necesarias de los paquetes dependientes. El
comando más común es pip freeze > requirements.txt , que registra la lista de paquetes actual del entorno en
requirements.txt.
Técnicamente, se puede utilizar cualquier nombre de archivo para realizar un seguimiento de los requisitos
(mediante el uso de -r <full path to file> al instalar un paquete), pero Visual Studio proporciona
compatibilidad específica para requirements.txt:
Si ha cargado un proyecto que contiene requirements.txt y desea instalar todos los paquetes enumerados
en ese archivo, expanda el nodo Python Environments en el Explorador de soluciones y, luego, haga
clic con el botón derecho en un nodo de entorno y seleccione Instalar desde requirements.txt :
Si quiere instalar las dependencias en un entorno virtual, cree y active primero ese entorno y luego use el
comando Instalar desde requirements.txt . Para más información sobre cómo crear un entorno
virtual, consulte Uso de entornos virtuales.
Si ya tiene todos los paquetes necesarios instalados en un entorno, puede hacer clic con el botón derecho
en ese entorno en el Explorador de soluciones y seleccionar Generar requirements.txt para crear el
archivo necesario. Si el archivo ya existe, aparece un mensaje sobre cómo actualizarlo:
Replace entire file (Reemplazar todo el archivo) quita todos los elementos, comentarios y opciones
que existen.
Actualizar entradas existentes detecta los requisitos del paquete y actualiza los especificadores de
versión para que coincidan con la versión actualmente instalada.
Update and add entries (Actualizar y agregar entradas) actualiza todos los requisitos que se
encuentran y agrega todos los demás paquetes al final del archivo.
Dado que los archivos requirements.txt están pensados para inmovilizar los requisitos de un entorno, todos los
paquetes instalados se escriben con versiones precisas. Usar versiones precisas garantiza que puede reproducir
fácilmente el entorno en otro equipo. Los paquetes se incluyen aunque se instalaran con un intervalo de
versiones, como una dependencia de otro paquete, o con un instalador distinto de pip.
Si un paquete no se puede instalar mediante pip y aparece en un archivo requirements.txt, toda la instalación
produce un error. En este caso, edite manualmente el archivo para excluir este paquete o para usar opciones de
pip para hacer referencia a una versión instalable del paquete. Por ejemplo, puede ser preferible usar pip wheel
para compilar una dependencia y agregar la opción --find-links <path> a su requirements.txt:
C:\Project>pip wheel azure

Downloading/unpacking azure
Running setup.py (path:C:\Project\env\build\azure\setup.py) egg_info for package azure
Building wheels for collected packages: azure

Running setup.py bdist_wheel for azure
Destination directory: c:\project\wheelhouse
Successfully built azure
Cleaning up...
C:\Project>type requirements.txt
--find-links wheelhouse
--no-index
azure==0.8.0
C:\Project>pip install -r requirements.txt -v

Downloading/unpacking azure==0.8.0 (from -r requirements.txt (line 3))
Local files found: C:/Project/wheelhouse/azure-0.8.0-py3-none-any.whl
Installing collected packages: azure
Successfully installed azure
Cleaning up...
Removing temporary dir C:\Project\env\build...
Vea también
Cómo usa Visual Studio las rutas de acceso de
búsqueda de Python
Con un uso típico de Python, la variable de entorno PYTHONPATH (o IRONPYTHONPATH , etc.) proporciona la ruta de
acceso de búsqueda predeterminada para los archivos de módulo. Es decir, cuando usa una instrucción
from <name> import... or import <name> , Python busca un nombre coincidente en las siguientes ubicaciones en
orden:
1. Módulos integrados de Python.
2. La carpeta que contiene el código de Python que está ejecutando.
3. La "ruta de acceso de búsqueda de módulo" tal y como la definió la variable de entorno aplicable. (Consulte
The Module Search Path (Ruta de acceso de búsqueda de módulos) y Environment variables (Variables de
entorno) en la documentación principal de Python).
Sin embargo, Visual Studio omite la variable de entorno de ruta de acceso de búsqueda, incluso si se ha
establecido para todo el sistema. De hecho, se omite precisamente porque se establece para todo el sistema y,
por tanto, surgen determinadas preguntas que no se pueden responder automáticamente: ¿Están los módulos a
los que se hace referencia diseñados para Python 2.7 o Python 3.6+? ¿Van a invalidar a los módulos de
biblioteca estándar? ¿Es consciente el desarrollador de este comportamiento o se trata de un intento de
secuestro de sesión malintencionado?
Visual Studio proporciona así un medio para especificar rutas de acceso de búsqueda directamente tanto en
entornos como en proyectos. El código que ejecuta o depura en Visual Studio recibe rutas de acceso de
búsqueda en el valor de PYTHONPATH (y otras variables equivalente). Mediante la incorporación de rutas de
acceso de búsqueda, Visual Studio inspecciona las bibliotecas en estas ubicaciones y crea bases de datos de
IntelliSense para ellas cuando sea necesario (Visual Studio 2017, versión 15.5 y anteriores; crear la base de datos
puede tardar algún tiempo dependiendo del número de bibliotecas).
Para agregar una ruta de búsqueda, vaya al Explorador de soluciones , expanda el nodo del proyecto, haga
clic con el botón derecho en Rutas de búsqueda y seleccione Agregar carpeta a ruta de búsqueda :
Este comando muestra un explorador en el que se puede seleccionar la carpeta que se va a incluir.
Si la variable de entorno PYTHONPATH ya incluye las carpetas que quiere, use Agregar PYTHONPATH a rutas
de búsqueda como un cómodo acceso directo.
Una vez que se han agregado las carpetas a las rutas de búsqueda, Visual Studio usa esas rutas para cualquier
entorno asociado al proyecto. (Puede ver errores si el entorno se basa en Python 3 e intenta agregar una ruta de
acceso de búsqueda a los módulos de Python 2.7).
Los archivos con una extensión .zip o .egg también se pueden agregar como rutas de búsqueda al seleccionar el
comando Add Zip Archive to Search Path (Agregar archivo Zip a ruta de búsqueda). Al igual que con las
carpetas, el contenido de estos archivos se examina y se pone a disposición de IntelliSense.
Vea también
Referencia de pestañas de la ventana Entorno de
Python
Para abrir la ventana Entornos de Python :

Seleccione el comando de menú Vista > Otras ventanas > Entornos de Python .
Haga clic con el botón derecho en el nodo Entornos de Python de un proyecto en el Explorador de
soluciones y seleccione View All Python Environments (Ver todos los entornos de Python).
Si expande la ventana Entornos de Python con un ancho suficiente, estas opciones se muestran como
pestañas, lo cual puede resultarle más cómodo. Para mayor claridad, en este artículo las pestañas se muestran
en la vista expandida.
Pestaña Información general
Proporciona información básica y comandos para el entorno:
Hacer que este entorno sea el predeterminado para Establece el entorno activo, que puede hacer que Visual
los proyectos nuevos Studio (2017, versión 15.5 y anteriores) deje de responder
por unos instantes mientras se carga la base de datos de
IntelliSense. Los entornos con muchos paquetes pueden
dejar de responder durante más tiempo.
Visitar el sitio web del distribuidor Abre un explorador en la URL proporcionada por la
distribución de Python. Python 3.x, por ejemplo, se dirige a
python.org.
Abrir ventana interactiva Abre la ventana interactiva (REPL) para este entorno en
Visual Studio, aplicando cualquiera de los scripts de inicio
(ver a continuación).
Explorar scripts interactivos Vea Scripts de inicio.

Usar el modo interactivo de IPython Cuando se establece, se abre la ventana interactiva con
IPython de manera predeterminada. Esto habilita los gráficos
en línea, así como la sintaxis de IPython extendida como
name? para ver la ayuda y !command para los comandos
del shell. Esta opción se recomienda al usar una distribución
de Anaconda, ya que necesita paquetes adicionales. Para
obtener más información, vea Uso de IPython en la ventana
interactiva.
Abrir en PowerShell Inicie el intérprete en una ventana de comandos de

PowerShell.
(Vínculos de carpeta y programa) Le proporcionan acceso rápido a la carpeta de instalación del

entorno, al intérprete python.exe y al intérprete
pythonw.exe. La primera se abre en Explorador de Windows,
los dos últimos abren una ventana de consola.
Scripts de inicio
A medida que usa las ventanas interactivas en su flujo de trabajo diario, probablemente desarrolle funciones del
asistente que usa con frecuencia. Por ejemplo, puede crear una función que abra un DataFrame en Excel y,
después, guardar ese código como un script de inicio de manera que siempre esté disponible en la ventana
interactiva .
Los scripts de inicio contienen código que la ventana interactiva carga y ejecuta automáticamente, como
importaciones, definiciones de función y literalmente cualquier otra cosa. Hay dos maneras de hacer referencia
a dichos scripts:
1. Cuando instala un entorno, Visual Studio crea una carpeta Documents\Visual Studio
<version>\Python Scripts\<environment> donde <versión> se corresponde a la versión de
Visual Studio (como 2017 o 2019) y <entorno> coincide con el nombre del entorno. Puede navegar
fácilmente a la carpeta específica del entorno con el comando Explorar scripts interactivos . Cuando
inicie la ventana interactiva para ese entorno, se cargan y ejecutan los archivos de .py que se encuentran
aquí en orden alfabético.
2. El control Scripts de la pestaña Herramientas > Opciones > Python > Ventanas interactivas
(consulte Opciones de las ventanas interactivas) pretende especificar una carpeta adicional para los
scripts de inicio que se cargan y ejecutan en todos los entornos. No obstante, esta característica no
funciona actualmente.
Pestaña Configurar
Si está disponible, la pestaña Configurar contiene detalles como se describe en la tabla siguiente. Si esta
pestaña no está presente, significa que Visual Studio administra todos los detalles automáticamente.
Descripción Nombre que se va a dar al entorno.
Prefix path (Ruta de acceso de prefijo) Ubicación de la carpeta base del intérprete. Si rellena este
valor y hace clic en Detección automática , Visual Studio
intentará rellenar los demás campos automáticamente.
Interpreter path (Ruta de acceso del intérprete) Ruta de acceso al ejecutable del intérprete, normalmente la
ruta de acceso de prefijo seguida de python.exe .
Windowed interpreter (Intérprete en ventanas) Ruta de acceso al ejecutable que no es de consola,

normalmente la ruta de acceso de prefijo seguida de
pythonw.exe .
Librar y path (Ruta de acceso a la biblioteca) Especifica la raíz de la biblioteca estándar, pero este valor se
(si está disponible) puede omitir si Visual Studio es capaz de solicitar una ruta de
acceso más precisa desde el intérprete.
Versión de lenguaje Se selecciona en el menú desplegable.
Arquitectura Normalmente se detecta y rellena automáticamente; de lo

contrario especifica 32 o 64 bits .
Path environment variable (Variable de entorno de ruta Variable de entorno que el intérprete usa para encontrar
de acceso) rutas de acceso de búsqueda. Visual Studio cambia el valor
de la variable al iniciar Python para que contenga las rutas
de búsqueda del proyecto. Normalmente, esta propiedad se
debe establecer en PYTHONPATH , pero algunos intérpretes
utilizan un valor diferente.
Pestaña Paquetes
También se etiqueta como "pip" en versiones anteriores
Administra los paquetes instalados en el entorno con pip (la pestaña Paquetes (PyPI) ) o conda (la pestaña
Paquetes (Conda) para entornos en la versión 15.7 y posteriores de Visual Studio 2017). En esta pestaña
también se pueden buscar e instalar paquetes nuevos, incluidas sus dependencias.
Los paquetes que ya están instalados aparecen con controles para actualizar (una flecha hacia arriba) y
desinstalar (la X en un círculo) el paquete:
Especifique los filtros de un término de búsqueda en la lista de paquetes instalados, así como paquetes que
pueden instalarse desde PyPI.
Como puede ver en la imagen anterior, los resultados de la búsqueda muestran un número de paquetes que
coinciden con el término de búsqueda; pero la primera entrada de la lista es un comando para ejecutar pip
install <name> directamente. Si se encuentra en la pestaña Paquetes (Conda) , en su lugar verá conda
install <name> :
En ambos casos, puede personalizar la instalación si agrega argumentos en el cuadro de búsqueda después del
nombre del paquete. Cuando se incluyen argumentos, en los resultados de la búsqueda se muestra pip install
o conda install seguido del contenido del cuadro de búsqueda:
Al instalar un paquete se crean subcarpetas dentro de la carpeta Lib del entorno en el sistema de archivos. Por
ejemplo, si tiene instalado Python 3.6 en c:\Python36, los paquetes se instalan en c:\Python36\Lib; si tiene
instalado Anaconda3 en c:\Program Files\Anaconda3, los paquetes se instalan en c:\Program
Files\Anaconda3\Lib. En el caso de los entornos de Conda, los paquetes se instalan en la carpeta de ese entorno.
Concesión de privilegios de administrador para la instalación de paquetes
Al instalar paquetes en un entorno que está situado en un área protegida del sistema de archivos, como
c:\Program Files\Anaconda3\Lib, Visual Studio debe ejecutar pip install con permisos elevados para
permitirle que cree subcarpetas del paquete. Cuando se necesita la elevación de privilegios, Visual Studio
muestra el mensaje Puede que se necesiten privilegios de administrador para instalar, actualizar o
desinstalar paquetes para este entorno :
Elevar ahora concede privilegios administrativos a pip para una única operación, sujeto también a cualquier
sistema operativo que solicite permisos. Al seleccionar Continuar sin privilegios de administrador se
intenta instalar el paquete, pero pip produce un error al intentar crear carpetas con un resultado como error :
no se pudo crear "C:\Archivos de programa\Anaconda3\Lib\site-packages\png.py": permiso
denegado.
Al seleccionar Elevar siempre al instalar o desinstalar paquetes se impide que el cuadro de diálogo
aparezca para el entorno en cuestión. Para que el cuadro de diálogo aparezca de nuevo, vaya a Herramientas >
Opciones > Python > General y seleccione el botón Restablecer todos los cuadros de diálogo ocultos
de manera permanente .
En esa misma pestaña de opciones , también puede seleccionar Ejecutar siempre pip como administrador
para suprimir el cuadro de diálogo en todos los entornos. Vea Opciones: pestaña General.
Restricciones de seguridad con versiones anteriores de Python
Cuando se usa Python 2.6, 3.1 y 3.2, Visual Studio muestra la advertencia Debido a restricciones de
seguridad, la instalación desde Internet podría no funcionar en esta versión de Python :
El motivo de la advertencia es que con estas versiones anteriores de Python, pip install no admite la
Seguridad de la capa de transporte (TLS) 1.2, que es necesaria para descargar paquetes desde el proveedor,
pypi.org. Las compilaciones de Python personalizadas pueden admitir TLS 1.2, en cuyo caso pip install podría
funcionar.
Es posible descargar el get-pip.py apropiado para un paquete desde bootstrap.pypa.io, descargar manualmente
un paquete desde pypi.org y, a continuación, instalar el paquete desde esa copia local.
Pero lo recomendable es actualizar a una versión reciente de Python, en cuyo caso no aparece la advertencia.
Pestaña IntelliSense
Muestra el estado actual de la base de datos de finalización de IntelliSense:
En Visual Studio 2017, versión 15.5 y versiones anteriores, las finalizaciones de IntelliSense dependen de una
base de datos que se han compilado para esa biblioteca. La creación de la base de datos se realiza en
segundo plano cuando se instala una biblioteca, pero puede tardar un tiempo y es posible que no esté
completa cuando comience a escribir código.
Visual Studio 2017, versión 15.6 y posteriores, usa un método más rápido para proporcionar las
finalizaciones que no dependen de la base de datos de forma predeterminada. Por esta razón la pestaña se
etiqueta como IntelliSense [base de datos deshabilitada] . Puede habilitar la base de datos si desactiva
la opción Herramientas > Opciones > Python > Experimental > Usar el nuevo estilo IntelliSense
para los entornos .
Cuando Visual Studio detecta un nuevo entorno (o el usuario agrega uno), comienza a compilar
automáticamente la base de datos analizando los archivos de origen de la biblioteca. Este proceso puede tardar
desde un minuto a una hora o más dependiendo de lo que esté instalado. (Anaconda, por ejemplo, incluye
muchas bibliotecas y tarda algún tiempo en compilar la base de datos.) Una vez finalizado, obtiene detalles de
IntelliSense y no necesita actualizar la base de datos (con el botón Refresh DB (Actualizar base de datos)) hasta
que instale más bibliotecas.
Las bibliotecas para las que no se han compilado los datos se marcan con ! ; si la base de datos de un entorno
no está completa, también aparece ! junto a ella en la lista principal de entornos.
Vea también
Configuración de aplicaciones web de Python para
IIS
Cuando se usa Internet Information Services (IIS) como servidor web en un equipo Windows (incluidas
máquinas virtuales Windows en Azure, las aplicaciones de Python deben incluir una configuración específica en
sus archivos web.config para que IIS pueda procesar correctamente el código Python. El equipo mismo también
debe tener instalado Python junto con cualquier paquete que la aplicación web necesite.
NOTE
Anteriormente, este artículo contenía guías para la configuración de Python en Azure App Service en Windows. Las
extensiones de Python y los hosts de Windows que se usaban en ese escenario quedaron en desuso a favor de Azure App
Service en Linux. Para más información, consulte Publicación de una aplicación de Python en Azure App Service (Linux). Sin
embargo, todavía puede encontrar el artículo anterior en Configuración de un entorno de Python en Azure App Service.
Instalación de Python en Windows

Para ejecutar una aplicación web, primero debe instalar la versión necesaria de Python directamente en la
máquina host Windows, tal como se describe en Instalación de intérpretes de Python.
Anote la ubicación del intérprete python.exe para pasos posteriores. Para mayor comodidad, puede agregar esa
ubicación a la variable de entorno PATH.
Instalar paquetes
Cuando se usa un host dedicado, puede usar el entorno global de Python para ejecutar la aplicación en lugar de
un entorno virtual. En consecuencia, para instalar todos los requisitos de la aplicación en el entorno global,
simplemente ejecute pip install -r requirements.txt en un símbolo del sistema.
Configuración de web.config para que apunte al intérprete de Python

El archivo web.config de la aplicación indica al servidor web de IIS (7+) que se ejecuta en Windows el modo en
que debe administrar las solicitudes de Python a través de FastCGI o HttpPlatform (recomendado). Visual Studio
2015 y versiones anteriores realizan automáticamente estas modificaciones. Al usar Visual Studio 2017, debe
modificar manualmente el archivo web.config.
Configuración del controlador de HttpPlatform
El módulo HttpPlatform pasa conexiones de socket directamente a un proceso de Python independiente. Ese
paso a través le permite ejecutar cualquier servidor web que quiera, pero necesita un script de inicio que ejecute
un servidor web local. Especifique el script en el elemento <httpPlatform> de web.config, donde el atributo
processPath apunta al intérprete de Python de la extensión de sitio y el atributo arguments , a su script y a
cualquier argumento que quiera proporcionar:
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.webServer>
<handlers>
<add name="PythonHandler" path="*" verb="*" modules="httpPlatformHandler" resourceType="Unspecified"/>
</handlers>
<httpPlatform processPath="c:\python36-32\python.exe"
arguments="c:\home\site\wwwroot\runserver.py --port %HTTP_PLATFORM_PORT%"
stdoutLogEnabled="true"
stdoutLogFile="c:\home\LogFiles\python.log"
startupTimeLimit="60"
processesPerApplication="16">
<environmentVariables>
<environmentVariable name="SERVER_PORT" value="%HTTP_PLATFORM_PORT%" />
</environmentVariables>
</httpPlatform>
</system.webServer>
</configuration>
La variable de entorno HTTP_PLATFORM_PORT que se muestra aquí contiene el puerto en el que debe escuchar su
servidor local para las conexiones del localhost. Este ejemplo también muestra cómo crear otra variable de
entorno (si se quiere), que en este caso es SERVER_PORT .
Configuración del controlador FastCGI
FastCGI es una interfaz que funciona en el nivel de solicitud. IIS recibe conexiones entrantes y reenvía cada
solicitud a una aplicación WSGI que se ejecuta en uno o más procesos de Python persistentes.
Para usarlo, primero instale y configure el paquete wfastcgi como se describe en pypi.org/project/wfastcgi/.
A continuación, modifique el archivo web.config para incluir las rutas de acceso completas a python.exe y
wfastcgi.py en la clave PythonHandler . En los pasos que aparecen a continuación, se supone que Python está
instalado en c:\python36-32 y que el código de aplicación se encuentra en c:\home\site\wwwroot, por lo que
debe ajustar las rutas de acceso según corresponda:
1. Modifique la entrada PythonHandler en web.config para que la ruta de acceso coincida con la ubicación
de instalación de Python (consulte Referencia de configuración de IIS (iis.net) para ver los detalles
exactos).
<system.webServer>
<handlers>
<add name="PythonHandler" path="*" verb="*" modules="FastCgiModule"
scriptProcessor="c:\python36-32\python.exe|c:\python36-32\wfastcgi.py"
resourceType="Unspecified" requireAccess="Script"/>
</handlers>
</system.webServer>
2. En la sección <appSettings> del archivo web.config, agregue claves para WSGI_HANDLER , WSGI_LOG
(opcional) y PYTHONPATH :
<appSettings>
<add key="PYTHONPATH" value="c:\home\site\wwwroot"/>

<add key="WSGI_HANDLER" value="app.wsgi_app()"/>
<add key="WSGI_LOG" value="c:\home\LogFiles\wfastcgi.log"/>
</appSettings>
Estos valores de <appSettings> están disponibles para la aplicación como variables de entorno:
El valor de PYTHONPATH puede ampliarse libremente, pero debe incluir la raíz de la aplicación.
WSGI_HANDLER debe apuntar a una aplicación WSGI que se pueda importar desde la aplicación.
WSGI_LOG es opcional, pero es recomendable para depurar la aplicación.
3. Establezca la entrada WSGI_HANDLER en web.config de forma adecuada para el marco que esté usando:
Bottle : asegúrese de usar paréntesis después de app.wsgi_app como se muestra a continuación.
Esto resulta necesario porque ese objeto es una función (vea app.py) en lugar de una variable:


<add key="WSGI_HANDLER" value="app.wsgi_app()"/>
Flask : cambie el valor WSGI_HANDLER por <project_name>.app , donde <project_name> coincide con
el nombre del proyecto. Puede encontrar el identificador exacto examinando la instrucción
from <project_name> import app en runserver.py. Por ejemplo, si el proyecto se denominara
"FlaskAzurePublishExample", la entrada aparecería así:

<add key="WSGI_HANDLER" value="FlaskAzurePublishExample.app"/>
Django : se requieren dos cambios en web.config para los proyectos de Django. En primer lugar,
cambie el valor WSGI_HANDLER a django.core.wsgi.get_wsgi_application() (el objeto está en el
archivo wsgi.py):


<add key="WSGI_HANDLER" value="django.core.wsgi.get_wsgi_application()"/>
En segundo lugar, agregue la siguiente entrada debajo de la de WSGI_HANDLER , reemplazando

DjangoAzurePublishExample por el nombre del proyecto:
<add key="DJANGO_SETTINGS_MODULE" value="django_iis_example.settings" />
4. Solo para las aplicaciones de Django : en el archivo settings.py del proyecto de Django, agregue el
dominio de dirección URL del sitio o la dirección IP a ALLOWED_HOSTS , como se muestra más adelante,
reemplazando, por supuesto, "1.2.3.4" con su dirección URL o su dirección IP:
# Change the URL or IP address to your specific site

ALLOWED_HOSTS = ['1.2.3.4']
Si no agrega la dirección URL a la matriz, se genera un error DisallowedHost at / Invalid HTTP_HOST

header : "<site URL>". Es posible que tenga que agregar "<site URL>" a ALLOWED_HOSTS.
Tenga en cuenta que, cuando la matriz está vacía, Django permite automáticamente "localhost" y
"127.0.0.1", pero agregar la dirección URL de producción quita esas funcionalidades. Por este motivo,
puede que desee mantener copias de desarrollo y producción independientes de settings.py, o bien usar
variables de entorno para controlar los valores de tiempo de ejecución.
Implementación en IIS o una máquina virtual Windows

Con el archivo web.config correcto en el proyecto, puede publicar en el equipo que ejecuta IIS si usa el comando
Publish en el menú contextual del proyecto en el Explorador de soluciones y selecciona la opción IIS, FTP,
etc. . En este caso, Visual Studio simplemente copia los archivos del proyecto en el servidor. Usted es
responsable de toda la configuración del lado servidor.
Dado que invierte mucho tiempo de desarrollo en el editor de código, la compatibilidad de Python en Visual
Studio proporciona funciones para ayudarle a ser más productivo. Las características incluyen resalte de sintaxis
de IntelliSense, finalización automática, ayuda para la firma, invalidaciones de método, búsqueda y navegación.
El editor también está integrado en la ventana interactiva de Visual Studio, lo que hace que sea sencillo
intercambiar código entre los dos. Vea Paso 3: Usar la ventana interactiva de REPL y Uso de la ventana
interactiva - Comando Enviar código a Interactive para obtener información detallada.
Para obtener documentación general sobre la edición de código en Visual Studio, vea Características del editor
de código. Vea también Esquematización, que le ayudará a mantenerse centrado en determinadas secciones del
código.
También puede usar el Examinador de objetos de Visual Studio (Ver > Otras ventanas > Examinador de
objetos o Ctrl +W > J ) para inspeccionar las clases de Python definidas en cada módulo y las funciones
definidas en esas clases.
IntelliSense
IntelliSense ofrece finalizaciones, ayuda para la firma, información rápida y coloración de código. Visual Studio
2017 versión 15.7 y posteriores también admite sugerencias de tipo.
Para mejorar el rendimiento, IntelliSense en Visual Studio 2017, versión 15.5 y versiones anteriores, depende de
la base de datos de finalizaciones que se genera para cada entorno de Python en el proyecto. Si agrega, quita o
actualiza paquetes las bases de datos puede que necesiten actualizarse. El estado de la base de datos se muestra
en la ventana Entornos de Python (un elemento relacionado del Explorador de soluciones ) en la pestaña
IntelliSense (vea Referencia de pestañas de la ventana Entorno de Python).
Visual Studio 2017, versión 15.6 y posteriores, se utiliza un medio diferente para proporcionar finalizaciones de
IntelliSense que no dependen de la base de datos.
Finalizaciones
Las finalizaciones aparecen como instrucciones, identificadores y otras palabras que pueden especificarse
adecuadamente en la ubicación actual en el editor. Lo que se muestra en la lista se basa en contexto y se filtra
para omitir las opciones incorrectas o molestas. Las finalizaciones a menudo se desencadenan escribiendo
instrucciones diferentes (como import ) y operadores (incluido el punto), pero puede hacer que aparezcan en
cualquier momento si presiona Ctrl +J > Espacio .
Cuando se abre una lista de finalizaciones, puede buscar la finalización que desee con las teclas de dirección, el
mouse o bien escribiendo algo más. A medida que escriba más letras, la lista se seguirá filtrando para mostrar
las finalizaciones probables. También puede usar accesos directos como:
Escribir letras que no están al principio del nombre, como "parse" para buscar "argparse"
Escribir solo las letras que se encuentran al principio de palabras, como "abc" para buscar 'AbstractBaseClass'
o "air" para buscar "as_integer_ratio"
Omitir letras, como "b64" para buscar "base64"
He aquí algunos ejemplos:
Las finalizaciones de miembros aparecen automáticamente al escribir un punto después de una variable o un
valor, junto con los métodos y atributos de los tipos posibles. Si una variable puede ser de más de un tipo, la
lista incluye todas las posibilidades de todos los tipos, con información adicional para indicar qué tipos admite
cada finalización. Cuando una finalización es compatible con todos los tipos posibles, se muestra sin la
anotación.
De manera predeterminada, no se muestran los miembros "dunder" (miembros que comienzan y terminan con
un doble carácter de subrayado). En general, no se debe acceder a dichos miembros directamente. En cambio, si
necesita uno, al escribir el doble carácter de subrayado inicial se agregan estas finalizaciones a la lista:
Las instrucciones import y from ... import muestran una lista de módulos que pueden importarse. Con
from ... import , la lista incluye miembros que pueden importarse desde el módulo especificado.
Las instrucciones raise y except muestran listas de clases que probablemente sean tipos de error. La lista
puede no incluir todas las excepciones definidas por el usuario, pero le ayudan a encontrar rápidamente las
excepciones integradas adecuadas:
Al escribir @ se inicia un decorador y se muestran todos los posibles decoradores. Muchos de estos elementos
no se pueden usar como decoradores; consulte la documentación de la biblioteca para determinar cuál se va a
usar.
TIP
Puede configurar el comportamiento de estas finalizaciones en Herramientas > Opciones > Editor de texto >
Python > Opciones avanzadas . De estas opciones, Filter list based on search string (Filtrar lista en función de la
cadena de búsqueda) aplica el filtrado de sugerencias de finalización mientras se escribe (activo de manera
predeterminada) y Member completion displays intersection of members (La finalización de miembros muestra la
intersección de miembros) muestra solo las finalizaciones que son compatibles con todos los posibles tipos (desactivado
de manera predeterminada). Vea Opciones: resultados de finalización.
Sugerencias de escritura
Visual Studio 2017, versión 15.7 y posteriores
"Sugerencias de escritura" en Python 3.5 + (PEP 484 (python.org) es una sintaxis de anotación de funciones y
clases que indica los tipos de argumentos, valores devueltos y atributos de clase. IntelliSense muestra
sugerencias de tipo cuando mantiene el mouse sobre las llamadas a funciones, argumentos y variables que
tengan dichas anotaciones.
En el ejemplo siguiente, la clase Vector se declara como List[float] , y la función scale contiene sugerencias
de tipo para sus argumentos y el valor devuelto. Al mantener el mouse sobre una llamada a esa función se
muestran las sugerencias de tipo:
En el ejemplo siguiente puede ver cómo los atributos anotados de la clase Employee aparecen en la ventana
emergente de finalización de IntelliSense para un atributo:
También es útil validar las sugerencias de tipo en todo el proyecto, porque los errores normalmente no
aparecerán hasta el tiempo de ejecución. Para ello, Visual Studio integra la herramienta estándar del sector
MyPy mediante el comando de menú contextual Python > Ejecutar MyPy en el Explorador de soluciones :
Al ejecutar el comando se le solicita que instale el paquete MyPy, si es necesario. Después, Visual Studio ejecuta
MyPy para validar las sugerencias de tipo de cada archivo de Python en el proyecto. Los errores se muestran en
la ventana Lista de errores de Visual Studio. Al seleccionar un elemento en la ventana se desplaza a la línea
adecuada del código.
Como ejemplo sencillo, la siguiente definición de función contiene una sugerencia de tipo para indicar que el
argumento input es de tipo str , mientras que la llamada a esa función intenta pasar un entero:
def commas_to_colons(input: str):
items = input.split(',')
items = [x.strip() for x in items]
return ':'.join(items)
commas_to_colons(1)
Al usar el comando Ejecutar MyPy en este código se genera el siguiente error:
TIP
Para las versiones de Python anteriores a la 3.5, Visual Studio también muestra las sugerencias de tipo que proporcione a
través de archivos de código auxiliar de Typeshed (.pyi). Puede usar archivos de código auxiliar siempre que no quiera
incluir sugerencias de tipo directamente en el código o cuando quiera crear sugerencias de tipo para una biblioteca que
no los usa directamente. Para obtener más información, vea Create Stubs for Python Modules (Creación de códigos
auxiliares para los módulos de Python) en la wiki de proyecto de MyPy.
Actualmente Visual Studio no admite sugerencias de tipo en los comentarios.
TIP
Para las versiones de Python anteriores a la 3.5, Visual Studio también muestra las sugerencias de tipo que proporcione a
través de archivos de código auxiliar de Typeshed (.pyi). Puede usar archivos de código auxiliar siempre que no quiera
incluir sugerencias de tipo directamente en el código o cuando quiera crear sugerencias de tipo para una biblioteca que
no los usa directamente. Para obtener más información, vea Create Stubs for Python Modules (Creación de códigos
auxiliares para los módulos de Python) en la wiki de proyecto de MyPy.
Visual Studio incluye un conjunto de agrupaciones de archivos Typeshed para Python 2 y 3, por lo que no se necesitan
otras descargas. Sin embargo, si quiere usar un conjunto de archivos distinto, puede especificar la ruta en las opciones
Herramientas > Opciones > Python > Ser vidor de lenguaje . Consulte Opciones: servidor de lenguaje.
Actualmente Visual Studio no admite sugerencias de tipo en los comentarios.
Ayuda para la firma

Al escribir código que llama a una función, la ayuda para la firma aparece cuando se escribe el ( de apertura y
muestra la información de documentación y parámetros disponible. También puede hacer que aparezca con
Ctrl +Mayús +Espacio dentro de una llamada de función. La información que se muestra depende de las
cadenas de documentación del código fuente de la función, pero incluye los valores predeterminados.
TIP
Para deshabilitar la ayuda para la firma, vaya a Herramientas > Opciones > Editor de texto > Python > General y
desactive Finalización de instrucciones > Información de parámetros .
Información rápida
Al pasar el puntero del mouse sobre un identificador aparece una sugerencia de información rápida. Según el
identificador, la información rápida puede mostrar los valores o tipos posibles, cualquier documentación
disponible, los tipos de devolución y las ubicaciones de definición:
Coloración de código
La coloración de código utiliza información desde análisis de código a variables de colores, instrucciones y otras
partes del código. Por ejemplo, las variables que hacen referencia a clases o módulos pueden mostrarse en un
color diferente que las funciones u otros valores, y los nombres de los parámetros aparecen en un color
diferente que las variables locales o globales. (De manera predeterminada, las funciones no se muestran en
negrita):
Para personalizar los colores, vaya a Herramientas > Opciones > Entorno > Fuentes y colores y modifique
las entradas de Python en la lista Mostrar elementos :
TIP
Para deshabilitar la coloración de código, vaya a Herramientas > Opciones > Editor de texto > Python > Opciones
avanzadas y desactive Otras opciones > Color names based on type (Nombres de colores basados en tipo). Vea
Opciones: Otras opciones.
Fragmentos de código
Los fragmentos de código son pedazos de código que se pueden insertar en los archivos mediante un método
abreviado de teclado y la tecla Tab o bien con los comandos Editar > IntelliSense > Inser tar fragmento de
código y Delimitar con , seleccionando Python y luego el fragmento deseado.
Por ejemplo, class es un acceso directo para un fragmento de código que inserta una definición de clase. El
fragmento de código aparece en la lista de finalización automática cuando se escribe class :
Al presionar Tab , se genera el resto de la clase. Puede escribir sobre el nombre y la lista de bases, moviéndose
entre los campos resaltados con Tab , y luego presionar Entrar para empezar a escribir el cuerpo.
Comandos de menú
Cuando use el comando de menú Editar > IntelliSense > Inser tar fragmento de código , seleccione
Python primero y luego un fragmento de código:
Del mismo modo, el comando Editar > IntelliSense > Delimitar con , coloca la selección actual en el editor de
texto dentro de un elemento estructural elegido. Por ejemplo, suponga que tiene un poco de código similar al
siguiente:
sum = 0
for x in range(1, 100):
sum = sum + x
Al seleccionar este código y elegir el comando Delimitar con aparece una lista de fragmentos de código
disponibles. Al elegir def en la lista se coloca el código seleccionado dentro de una definición de función, y
puede utilizar la tecla Tab para desplazarse entre los argumentos y el nombre de la función resaltados:
Examen de los fragmentos de código disponibles

Puede ver los fragmentos de código disponibles en el Administrador de fragmentos de código , que se abre
con el comando de menú Herramientas > Administrador de fragmentos de código , y seleccionando
Python como lenguaje:
Para crear sus propios fragmentos de código, vea Tutorial: Crear un fragmento de código.
Si escribe un fragmento de código excelente que le gustaría compartir, no dude en publicarlo de manera
resumida y hacérnoslo saber. Es posible que podamos incluirlo en una futura versión de Visual Studio.
Navegar por el código

La compatibilidad con Python en Visual Studio proporciona varios medios para desplazarse rápidamente dentro
del código, incluidas las bibliotecas para las que hay código fuente disponible: la barra de navegación, Ir a
definición , Navegar a y Buscar todas las referencias . También se puede usar el Examinador de objetos
de Visual Studio.
Barra de navegación
La barra de navegación se muestra en la parte superior de cada ventana del editor e incluye una lista de dos
niveles de definiciones. La lista desplegable de la izquierda contiene la clase de nivel superior y las definiciones
de funciones en el archivo actual; la lista desplegable de la derecha muestra una lista de definiciones dentro del
ámbito que se muestra en la izquierda. A medida que recorra el editor, las listas se actualizan para mostrar el
contexto actual y, además, puede seleccionar una entrada de estas listas para ir directamente a ella.
TIP
Para ocultar la barra de navegación, vaya a Herramientas > Opciones > Editor de texto > Python > General y
desactive Configuración > Barra de navegación .
Ir a definición
Ir a definición rápidamente salta del uso de un identificador (por ejemplo, un nombre de función, clase o
variable) al código fuente donde se define. Se invoca haciendo clic con el botón derecho en un identificador y
seleccionando Ir a definición , o colocando el símbolo de intercalación en el identificador y presionando F12 .
Funciona en todo su código y las bibliotecas externas siempre que el código fuente esté disponible. Si el código
fuente de la biblioteca no está disponible, Ir a definición salta a la correspondiente instrucción import para
una referencia de módulo, o mostrará un error.
Navegar a
El comando Editar > Navegar a (Ctrl + , ) muestra un cuadro de búsqueda en el editor donde puede escribir
cualquier cadena y consultar las posibles coincidencias en el código que define una función, una clase o una
variable que contiene la cadena. Esta característica proporciona una función similar a Ir a definición , pero sin
tener que buscar un uso de un identificador.
Haga doble clic en cualquier nombre, o seleccione con las teclas de dirección y Entrar , para navegar a la
definición de ese identificador.
Buscar todas las referencias

Buscar todas las referencias es una forma útil de detectar aquellas instancias en las que un identificador
determinado se define y utiliza, incluidas las importaciones y las asignaciones. Se invoca haciendo clic con el
botón derecho en un identificador y seleccionando Buscar todas las referencias , o colocando el símbolo de
intercalación en el identificador y presionando Mayús +F12 . Al hacer doble clic en un elemento de la lista se
navega hasta su ubicación.
Consulte también
Formato
Refactorización
Utilizar un linter
Aplicar formato a código de Python
Visual Studio permite volver a aplicar formato rápidamente al código para que coincida con las opciones de
formato configuradas previamente.
Para aplicar formato a una selección: seleccione Editar > Opciones avanzadas > Dar formato a la
selección o presione Ctrl +E > F .
Para aplicar formato a todo el archivo: seleccione Editar > Opciones avanzadas > Dar formato al
documento o presione Ctrl +E > D .
Las opciones se configuran en Herramientas > Opciones > Editor de texto > Python > Formato y sus
pestañas anidadas. Es necesario seleccionar Mostrar todas las configuraciones para que aparezcan estas
opciones:
Las opciones de formato se establecen de forma predeterminada para que coincidan con un supraconjunto de la
guía de estilo PEP 8. La pestaña General determina cuándo se aplica el formato; la configuración de las otras
tres pestañas se describe en este artículo.
La compatibilidad con Python en Visual Studio también agrega el práctico comando Rellenar párrafo del
comentario al menú Editar > Opciones avanzadas , como se describe en una sección posterior.
Espaciado
El espaciado controla dónde se insertan o quitan los espacios en torno a diversas construcciones de lenguajes.
Cada opción tiene tres valores posibles:
Activada: garantiza que se aplica el espaciado.
Desactivada: elimina el espaciado.
Indeterminada: deja el formato original en su sitio.
En las tablas siguientes se proporcionan ejemplos de las distintas opciones:
O P C IÓ N DEF IN IC IO N ES DE C L A SE A C T IVA DA DESA C T IVA DO
Inser tar espacio entre el nombre class X (object): pass class X(object): pass
de la declaración de clase y la
lista de bases
Inser tar espacio en paréntesis de class X( object ): pass class X(object): pass
lista de bases
Inser tar espacio en paréntesis de class X( ): pass class X(): pass

lista de bases vacía
O P C IÓ N DEF IN IC IO N ES DE F UN C IÓ N A C T IVA DA DESA C T IVA DO
Inser tar espacio entre el nombre def X (): pass def X(): pass
de una declaración de función y
la lista de parámetros
Inser tar espacio en paréntesis de def X( a, b ): pass def X(a, b): pass
lista de parámetros
Inser tar espacio en paréntesis de def X( ): pass def X(): pass

lista de parámetros vacía
Inser tar espacios alrededor de includes X(a = 42): pass includes X(a=42): pass
"=" en valores de parámetro
predeterminados
Inser tar espacio antes y después includes X() -> 42: pass includes X()->42: pass
de los operadores de anotación
de valor devuelto
O P C IÓ N DE O P ERA DO RES A C T IVA DA DESA C T IVA DO
Inser tar espacios alrededor de a + b a+b

operadores binarios
Inser tar espacios alrededor de a = b a=b

asignaciones
O P C IÓ N DE ESPA C IA DO DE
EXP RESIÓ N A C T IVA DA DESA C T IVA DO
Inser tar espacio entre el nombre X () X()

de una llamada de función y la
lista de argumentos
Inser tar espacio entre paréntesis X( ) X()

vacíos de la lista de argumentos
O P C IÓ N DE ESPA C IA DO DE
EXP RESIÓ N A C T IVA DA DESA C T IVA DO
Inser tar espacio entre paréntesis X( a, b ) X(a, b)

de la lista de argumentos
Inser tar espacio en paréntesis de ( a ) (a)

expresión
Inser tar espacio en paréntesis de ( ) ()

tupla vacía
Inser tar espacio en paréntesis de ( a, b ) (a, b)

tupla
Inser tar espacio entre corchetes [ ] []

vacíos
Inser tar espacios entre corchetes [ a, b ] [a, b]

de listas
Inser tar espacio delante de x [i] x[i]

corchete de aper tura
Inser tar espacio entre corchetes x[ i ] x[i]
Instrucciones
Las opciones de instrucciones controlan la reescritura automática de diversas instrucciones en varios
formularios de Python.
O P C IÓ N A N T ES DE A P L IC A R F O RM ATO DESP UÉS DE A P L IC A R F O RM ATO
Colocar módulos impor tados en import sys, pickle import sys

nueva línea import pickle
Quitar punto y coma innecesario x = 42; x = 42
Colocar varias instrucciones en x = 42; y = 100 x = 42

las nuevas líneas y = 100
Ajuste
Ajuste le permite establecer el Ancho máximo del comentario (el valor predeterminado es 80). Si la opción
Ajustar comentarios que son demasiado anchos está activada, Visual Studio volverá a aplicar formato a
los comentarios para no superar ese ancho máximo.
# Wrapped to 40 columns
# There should be one-- and preferably
# only one --obvious way to do it.
# Not-wrapped:
# There should be one-- and preferably only one --obvious way to do it.
Comando Fill Comment Paragraph command (Rellenar párrafo de

comentarios)
Editar > Opciones avanzadas > Rellenar párrafo del comentario (Ctrl +E > P ) redistribuye el texto del
comentario y le aplica formato, combinando líneas cortas y separando largas.
Por ejemplo:
# foo
# bar
# baz
cambia a:
# foo bar baz
# This is a very long long long long long long long long long long long long long long long long long long
long comment
cambia a:
# This is a very long long long long long long long long long long long long
# long long long long long long long comment
Refactorización del código de Python
Visual Studio proporciona varios comandos para transformar y limpiar automáticamente el código fuente de
Python:
Cambiar nombre: cambia el nombre de la clase, el método o la variable seleccionados.
Extraer método: crea un nuevo método a partir del código seleccionado.
Agregar importación: proporciona una etiqueta inteligente para agregar una importación que falta.
Quitar importaciones no usadas: quita las importaciones no utilizadas.
Cambiar nombre
1. Haga clic con el botón derecho en el identificador cuyo nombre desea cambiar y seleccione Rename
(Cambiar nombre); o bien, coloque el símbolo de intercalación en ese identificador y seleccione el
comando de menú Edit > Refactor > Rename (Editar > Refactorizar > Cambiar nombre...) (F2 ).
2. En el diálogo Rename (Cambiar nombre) que aparece, escriba el nuevo nombre del identificador y
seleccione OK (Aceptar):
3. En el siguiente diálogo, seleccione los archivos y las instancias del código al que se va a aplicar el cambio
de nombre; seleccione cualquier instancia individual para obtener una vista previa del cambio concreto:
4. Seleccione Apply (Aplicar) para realizar los cambios en los archivos de código fuente. (Esta acción se no
puede deshacer).
Extraer método
1. Seleccione las líneas de código o la expresión para extraer en un método distinto.
2. Seleccione el comando de menú Edit > Refactor > Extract method (Editar > Refactorizar > Extraer
método...) o pulse Ctrl +R > M .
3. En el diálogo que aparece, escriba un nuevo nombre de método, indique dónde extraerlo y seleccione las
variables de cierre. Las variables no seleccionadas para cierre se convierten en los argumentos de
método:
4. Seleccione OK (Aceptar); el código se modifica en consecuencia:
Agregar importación
Al colocar el símbolo de intercalación en un identificador que carece de información de tipo, Visual Studio
proporciona una etiqueta inteligente (el icono de bombilla a la izquierda del código) cuyos comandos agregan la
instrucción import o from ... import necesaria:
Visual Studio ofrece finalizaciones de import para paquetes de nivel superior y módulos en el proyecto actual y
la biblioteca estándar. Visual Studio también ofrece finalizaciones de from ... import para submódulos y
subpaquetes, así como para miembros de módulo. Las finalizaciones incluyen funciones, clases o datos
exportados. Al seleccionar cualquier opción, se agrega la instrucción a la parte superior del archivo, detrás de
otras importaciones, o a una instrucción from ... import existente si ya se importó el mismo módulo.
Visual Studio intenta filtrar miembros que no están definidos realmente en un módulo, como módulos que se
importan en otros, pero no son elementos secundarios del módulo que realiza la importación. Por ejemplo,
muchos módulos usan import sys en lugar de from xyz import sys , por lo que no verá una finalización para
importar sys desde otros módulos, aunque a los módulos les falte un miembro __all__ que excluye sys .
De forma similar, Visual Studio filtra las funciones que se importan desde otros módulos o desde el espacio de
nombres integrado. Por ejemplo, si un módulo importa la función settrace desde el módulo sys , en teoría
podría importarla desde ese módulo. Pero es mejor usar import settrace from sys directamente, y así Visual
Studio ofrece esa instrucción específicamente.
Por último, si algo se fuese a excluir normalmente, pero tiene otros valores que se incluirán (por ejemplo,
porque al nombre se le ha asignado un valor en el módulo), Visual Studio sigue excluyendo la importación. Este
comportamiento asume que el valor no debe exportarse porque está definido en otro módulo y, por tanto, es
probable que la asignación adicional sea un valor ficticio que tampoco se exporta.
Quitar importaciones no usadas

Al escribir código, resulta fácil terminar con instrucciones import para módulos que no se usan en absoluto.
Dado que Visual Studio analiza el código, puede determinar automáticamente si una instrucción import es
necesaria; basta con que vea si el nombre importado se usa dentro del ámbito siguiente donde se produce la
instrucción.
Haga clic con el botón derecho en cualquier parte en un editor y seleccione Remove Impor ts (Quitar
importaciones), que le proporciona opciones para quitar de todos los ámbitos o solo del ámbito actual :
Después, Visual Studio realiza los cambios adecuados en el código:
Tenga en cuenta que Visual Studio no tiene en cuenta el flujo de control; el uso de un nombre delante de una
instrucción import se tratará como si de hecho se usara el nombre. Visual Studio también omite todas las
importaciones from __future__ , importaciones que se realizan dentro de una definición de clase y de las
instrucciones from ... import * .
Uso de PyLint para comprobar el código de Python
PyLint, una herramienta ampliamente usada que busca errores en el código de Python y promueve patrones
correctos de codificación en Python, se integra en proyectos de Visual Studio para Python.
Ejecución de PyLint
Simplemente haga clic con el botón derecho en un proyecto de Python en el Explorador de soluciones y
seleccione Python > Run PyLint (Ejecutar PyLint...):
Al usar este comando se le pide que instale PyLint en su entorno activo si todavía no está presente.
Aparecen errores y advertencias de PyLint en la ventana de lista de errores :
Al hacer doble clic en un error se le dirigirá directamente al código fuente que ha generado el problema.
TIP
Consulte la referencia de características de PyLint para obtener una lista detallada de todos los mensajes de salida de
PyLint.
Configuración de las opciones de línea de comandos de PyLint

En la sección de opciones de línea de comandos de la documentación de PyLint se describe cómo controlar el
comportamiento de PyLint mediante un archivo de configuración .pylintrc. Este archivo se puede colocar en la
raíz de un proyecto de Python en Visual Studio, o bien en alguna otra parte, según cuán extensamente se quiera
aplicar esa configuración (vea las opciones de línea de comandos para obtener más información).
Por ejemplo, para suprimir las advertencias "falta docstring" que se muestran en la imagen anterior con un
archivo .pylintrc en un proyecto, realice los pasos:
1. En la línea de comandos, vaya a la raíz del proyecto (que contiene su archivo .pyproj) y ejecute el
siguiente comando para generar un archivo de configuración comentado:
pylint --generate-rcfile > .pylintrc
2. En el Explorador de soluciones de Visual Studio, haga clic con el botón derecho en el proyecto, seleccione
Agregar > Elemento existente , vaya al nuevo archivo .pylintrc, selecciónelo y haga clic en Agregar .
3. Abra el archivo para editarlo; que contiene una variedad de opciones de configuración con las que puede
trabajar. Para deshabilitar una advertencia, busque la sección [MESSAGES CONTROL] y luego el valor
disable en esa sección. Existe una cadena larga de mensajes concretos, a la que se puede anexar
cualquier advertencia que quiera. En este ejemplo, anexe ,missing-docstring (incluida la coma de
delimitación).
4. Guarde el archivo .pylintrc y ejecute PyLint de nuevo para ver que ahora las advertencias se han
suprimido.
TIP
Para usar un archivo .pylintrc desde un recurso compartido de red, cree una variable de entorno denominada PYLINTRC
con el valor del nombre de archivo en el recurso compartido de red con una ruta de acceso UNC o una letra de unidad
asignada. Por ejemplo, PYLINTRC=\\myshare\python\.pylintrc .
Definir comandos personalizados para proyectos de
Python
Al trabajar con proyectos de Python, es posible que se encuentre cambiando a una ventana de comandos para
ejecutar módulos o scripts concretos, ejecutar comandos pip o ejecutar alguna otra herramienta arbitraria. Para
mejorar este flujo de trabajo, se pueden agregar comandos personalizados al submenú Python en el menú
contextual del proyecto de Python. Esos comandos se pueden ejecutar en una ventana de consola o en la
ventana de salida de Visual Studio. También se pueden usar expresiones regulares para indicar a Visual Studio
cómo analizar los errores y advertencias de la salida del comando.
Este menú contiene de forma predeterminada un solo comando, Ejecutar PyLint :
Los comandos personalizados aparecen en este mismo menú contextual. Los comandos personalizados se
agregan a un archivo de proyecto directamente cuando son de aplicación en ese proyecto individual en
cuestión. Los comandos personalizados también se pueden definir en un archivo .targets que se puede importar
fácilmente en varios archivos de proyecto.
Algunas plantillas de proyecto de Python en Visual Studio ya agregan sus propios comandos personalizados
mediante su archivo .targets. Por ejemplo, las plantillas Proyecto web de Bottle y Proyecto web de Flask agregan
dos comandos, Iniciar ser vidor e Iniciar el ser vidor de depuración . La plantilla Proyecto web de Django
agrega esos mismos comandos y unos cuantos más:
Cada comando personalizado puede hacer referencia a un archivo de Python, a un módulo de Python, a código
de Python en línea, a un archivo ejecutable al azar o a un comando de pip. También puede especificar cómo y
dónde se ejecuta el comando.
TIP
Cada vez que se realicen cambios en un archivo de proyecto en un editor de texto, será necesario volver a cargar el
proyecto en Visual Studio para que esos cambios surtan efecto. Por ejemplo, deberá volver a cargar un proyecto después
de agregar definiciones de comando personalizado para que esos comandos aparezcan en el menú contextual de dicho
proyecto.
Como puede que sepa, Visual Studio permite modificar el archivo de proyecto directamente. En primer lugar, haga clic con
el botón derecho en el archivo de proyecto y seleccione Descargar el proyecto ; luego, vuelva a hacer clic con el botón
derecho y seleccione Editar <project-name> para abrir el proyecto en el editor de Visual Studio. Hacemos y
guardamos las modificaciones necesarias, hacemos clic con el botón derecho en el proyecto una vez más y seleccionamos
Volver a cargar el proyecto , que le pedirá confirmación para cerrar el archivo de proyecto en el editor.
Bien es cierto que todos estos clics pueden resultar tediosos al desarrollar un comando personalizado. Para lograr un flujo
de trabajo más eficaz, cargue el proyecto en Visual Studio y además abra el archivo .pyproj en un editor aparte (por
ejemplo, otra instancia de Visual Studio, Visual Studio Code, el Bloc de notas, etc.). Al guardar los cambios en el editor y
cambiar a Visual Studio, este detecta los cambios y le pregunta si quiere volver a cargar el proyecto (El proyecto
<name> se ha modificado fuera del entorno ). Seleccione Volver a cargar . Los cambios se aplicarán
inmediatamente en un solo paso.
Tutorial: Adición de un comando a un archivo de proyecto

Para que se familiarice con los comandos personalizados, en esta sección se examina un ejemplo sencillo en el
que se ejecuta el archivo de inicio de un proyecto directamente con python.exe. (Un comando de ese tipo es, a
todos los efectos, lo mismo que usar Depurar > Iniciar sin depurar ).
1. Cree un proyecto denominado "Python-CustomCommands" con la plantilla Aplicación de Python . (Vea
Inicio rápido: (Creación de un proyecto de Python desde una plantilla para obtener instrucciones si aún
no está familiarizado con el proceso).
2. En Python_CustomCommands.py, agregue el código print("Hello custom commands") .
3. Haga clic con el botón derecho en el proyecto en el Explorador de soluciones , seleccione Python y
fíjese en que el único comando que aparece en el submenú es Ejecutar PyLint . Los comandos
personalizados aparecen en este mismo submenú.
4. Tal y como se sugiere en la introducción, abra Python-CustomCommands.pyproj en un editor de texto
aparte. Después, agregue las siguientes líneas al final del archivo, justo dentro del elemento </Project>
de cierre, y guarde el archivo.
<PropertyGroup>
<PythonCommands>
$(PythonCommands);
</PythonCommands>
</PropertyGroup>
5. Cambie a Visual Studio y seleccione Volver a cargar cuando le pregunte acerca del cambio de archivo.
Tras ello, consulte de nuevo el menú Python para ver que Ejecutar PyLint sigue siendo el único
elemento aparece, dado que las líneas que hemos agregado replican únicamente el grupo de
propiedades <PythonCommands> predeterminado que contiene el comando de PyLint.
6. Cambie al editor con el archivo de proyecto y agregue la siguiente definición de <Target> después de
<PropertyGroup> . Como se explica más adelante en este artículo, este elemento Target define un
comando personalizado para ejecutar el archivo de inicio (identificado por la propiedad "StartupFile") por
medio de python.exe en una ventana de la consola. El atributo ExecuteIn="consolepause" usa una consola
que espera a que el usuario presione una tecla antes de cerrarse.
<Target Name="Example_RunStartupFile" Label="Run startup file" Returns="@(Commands)">

<CreatePythonCommandItem
TargetType="script"
Target="$(StartupFile)"
Arguments=""
WorkingDirectory="$(MSBuildProjectDirectory)"
ExecuteIn="consolepause">
<Output TaskParameter="Command" ItemName="Commands" />
</CreatePythonCommandItem>
</Target>
7. Agregue el valor del atributo Name del destino al grupo de propiedades <PythonCommands> que
agregamos anteriormente para que el elemento sea similar al siguiente código. El nombre del destino
que agregamos a esta lista es lo que se incorpora al menú de Python .
<PythonCommands>
$(PythonCommands);
Example_RunStartupFile
</PythonCommands>
Si quiere que el comando aparezca antes que los que hay definidos en $(PythonCommands) , colóquelo
antes de ese token.
8. Guarde el archivo de proyecto, cambie a Visual Studio y vuelva a cargar el proyecto cuando se le pida.
Después, haga clic con el botón derecho en el proyecto Python-CustomCommands y seleccione
Python . Debería haber un elemento Run star tup file (Ejecutar archivo de inicio) en el menú. Si no lo ve,
confirme que ha agregado el nombre al elemento <PythonCommands> . Vea también Solución de problemas
más adelante en este artículo.
9. Seleccione el comando Run star tup file (Ejecutar archivo de inicio) para que se abra una ventana de
comandos con el texto Hello custom commands seguido de Press any key to continue . Presione
cualquier tecla para cerrar la ventana.
10. Vuelva al editor con el archivo de proyecto abierto y cambie el valor del atributo ExecuteIn a output .
Guarde el archivo, cambie a Visual Studio, vuelva a cargar el proyecto e invoque el comando de nuevo.
Esta vez, verá que la salida del programa se muestra en la ventana Resultados de Visual Studio:
11. Para agregar más comandos, defina un elemento <Target> adecuado para cada comando, agregue el
nombre del destino al grupo de propiedades <PythonCommands> y vuelva a cargar el proyecto en Visual
Studio.
TIP
Si invoca un comando que usa propiedades del proyecto, como ($StartupFile) , y se produce un error en ese comando
porque no hay un token definido, Visual Studio lo deshabilita hasta que el proyecto se vuelva a cargar. Realizar cambios en
el proyecto que definan la propiedad no hace que el estado de estos comandos se actualice, de modo que en esos casos
seguirá siendo necesario volver a cargar el proyecto.
Estructura de destino de comando

En el siguiente pseudocódigose muestra la forma general del elemento <Target> :
<Target Name="Name1" Label="Display Name" Returns="@(Commands)">
<CreatePythonCommandItem Target="filename, module name, or code"
TargetType="executable/script/module/code/pip"
Arguments="..."
ExecuteIn="console/consolepause/output/repl[:Display name]/none"
WorkingDirectory="..."
ErrorRegex="..."
WarningRegex="..."
RequiredPackages="...;..."
Environment="...">

</Target>
Para hacer referencia a propiedades del proyecto o a variables de entorno en los valores de atributo, use el
nombre dentro de un token $() , como $(StartupFile) y $(MSBuildProjectDirectory) . Para más información,
vea Propiedades de MSBuild.
Atributos de destino
AT RIB UTO O B L IGATO RIO DESC RIP C IÓ N
Nombre Sí Identificador del comando dentro del

proyecto de Visual Studio. Este nombre
debe estar incluido en el grupo de
propiedades <PythonCommands> para
que el comando aparezca en el
submenú Python.
Etiqueta Sí Nombre para mostrar de interfaz de

usuario que aparece en el submenú
Python.
Valores devueltos Sí Debe contener @(Commands) , que

identifica el destino como un comando.
Atributos CreatePythonCommandItem
Ninguno de los valores de atributo distingue entre mayúsculas y minúsculas.

TargetType Sí Especifica lo que el atributo Target

contiene y cómo se usa junto con el
atributo Arguments:
executable : se ejecuta el
archivo ejecutable mencionado
en Target, lo que anexa el valor
en Arguments, como si se
insertara directamente en la
línea de comandos. El valor
debe contener solo un nombre
de programa, sin argumentos.
script : se ejecuta python.exe
con el nombre de archivo
mencionado en Target, seguido
del valor reflejado en
Arguments.
module : se ejecuta
python -m seguido del
nombre de módulo
mencionado en Target y
seguido del valor en
Arguments.
code : se ejecuta el código
insertado incluido en Target. El
valor de Arguments se omite.
pip : se ejecuta pip con el
comando mencionado en
Target seguido de Arguments;
pero si ExecuteIn está
establecido en "output", pip da
por hecho el comando
install y usa Target como el
nombre de paquete.
Destino Sí Nombre de archivo, nombre de

módulo, código o comando pip que se
usa en función de TargetType.
Argumentos Optional Especifica una cadena de argumentos

(si los hay) que proporcionar al
destino. Tenga en cuenta que cuando
TargetType es script , los
argumentos se proporcionan al
programa Python, no a python.exe.
Este elemento se omite en el
TargetType code .
ExecuteIn Sí Especifica el entorno en el que se va a

ejecutar el comando:
console : (Valor
predeterminado) Se ejecuta
Target y los argumentos
correspondientes como si se
hubieran escrito directamente
en la línea de comandos.
Mientras Target se está
ejecutando, se abre una
ventana de comandos, que al
finalizar se cierra
automáticamente.
consolepause : igual que
console, pero se espera a que
se presione una tecla para
cerrar la ventana.
output : se ejecuta Target y se
muestran sus resultados en la
ventana Resultados de Visual
Studio. Si TargetType es "pip",
Visual Studio usa Target como
el nombre del paquete y anexa
los argumentos indicados en
Arguments.
repl: se ejecuta Target en la
ventana Python interactivo; el
nombre para mostrar opcional
se usa como título de la
ventana.
none : El comportamiento es el
mismo que con console.
WorkingDirectory Optional Carpeta en la que se va a ejecutar el

comando.
ErrorRegex Optional Se usa únicamente cuando ExecuteIn

WarningRegEx es output . Ambos valores especifican
una expresión regular con la que Visual
Studio analiza los resultados del
comando para mostrar los errores y las
advertencias en la ventana Lista de
errores . Si no se especifica, el
comando no afecta a la ventana Lista
de errores . Para más información
sobre qué espera Visual Studio, vea
Grupos de capturas con nombre.
RequiredPackages Optional Lista de requisitos de paquete del

comando en la que se usa el mismo
formato que en requirements.txt
(pip.readthedocs.io). El comando
Ejecutar PyLint , por ejemplo,
especifica pylint>=1.0.0 . Antes de
ejecutar el comando, Visual Studio
comprueba que todos los paquetes
que figuran en la lista están instalados.
Visual Studio usa pip para instalar los
paquetes que faltan.
Entorno Optional Cadena de variables de entorno que

hay que definir antes de ejecutar el
comando. Cada variable usa el formato
<NAME>=<VALUE> con varias
variables separadas por punto y coma.
Una variable con varios valores debe
incluirlos entre comillas simples o
dobles, por ejemplo,
"NAME=VALUE1;VALUE2".
Grupos de capturas con nombre de expresiones regulares

Al analizar los errores y advertencias de la salida de un comando, Visual Studio espera que las expresiones
regulares en los valores ErrorRegex y WarningRegex usen los siguientes grupos con nombre:
(?<message>...) : Texto del error
(?<code>...) : Código de error
(?<filename>...) : Nombre del archivo del que se notifica el error
(?<line>...) : Número de línea de la ubicación en el archivo del que se notifica el error.
(?<column>...) : Número de columna de la ubicación en el archivo del que se notifica el error.
Por ejemplo, PyLint muestra advertencias de la siguiente forma:
************* Module hello

C: 1, 0: Missing module docstring (missing-docstring)
Para permitir que Visual Studio extraiga la información correcta de esas advertencias y las muestre en la
ventana Lista de errores , el valor de WarningRegex en el comando Ejecutar Pylint es el siguiente:
^(?<filename>.+?)$(?<line>\d+),(?<column>\d+)$: warning (?<msg_id>.+?): (?<message>.+?)$]]
Tenga en cuenta que msg_id en el valor debe ser en realidad code ; vea el problema 3680.
Crear un archivo .targets con comandos personalizados

Cuando se definen comandos personalizados en un archivo de proyecto, solo están disponibles para ese archivo
de proyecto. Para usar comandos en varios archivos de proyecto, hay que definir el grupo de propiedades
<PythonCommands> y todos sus elementos <Target> en un archivo .targets. y, luego, importar ese archivo a los
archivos de proyecto individuales que se quiera.
El archivo .targets tiene el siguiente formato:
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<PythonCommands>
$(PythonCommands);

</PythonCommands>
</PropertyGroup>
<Target Name="..." Label="..." Returns="@(Commands)">


</Target>


</Project>
Para cargar un archivo .targets en un proyecto, coloque un elemento <Import Project="(path)"> en cualquier
lugar dentro del elemento <Project> . Por ejemplo, si tiene un archivo denominado CustomCommands.targets
en una subcarpeta targets del proyecto, use el siguiente código:
<Import Project="targets/CustomCommands.targets"/>
NOTE
Cada vez que se modifica el archivo .targets, es necesario volver a cargar la solución que contiene un proyecto, no solo el
propio proyecto.
Comandos de ejemplo
Ejecutar PyLint (Target: module )
Aparece el siguiente código en el archivo Microsoft.PythonTools.targets:
<PropertyGroup>
<PythonCommands>$(PythonCommands);PythonRunPyLintCommand</PythonCommands>
<PyLintWarningRegex>
<![CDATA[^(?<filename>.+?)$(?<line>\d+),(?<column>\d+)$: warning (?<msg_id>.+?): (?<message>.+?)$]]>
</PyLintWarningRegex>
</PropertyGroup>
<Target Name="PythonRunPyLintCommand"
Label="resource:Microsoft.PythonTools.Common;Microsoft.PythonTools.Common.Strings;RunPyLintLabel"
Returns="@(Commands)">
<CreatePythonCommandItem Target="pylint.lint"
TargetType="module"
Arguments=""--msg-template={abspath}({line},{column}): warning {msg_id}:
{msg} [{C}:{symbol}]" -r n @(Compile, ' ')"
WorkingDirectory="$(MSBuildProjectDirectory)"
ExecuteIn="output"
RequiredPackages="pylint>=1.0.0"
WarningRegex="$(PyLintWarningRegex)">
</Target>
Ejecutar pip install con un paquete específico (Target: pip)

El siguiente comando ejecuta pip install my-package en la ventana Resultados . Puede usar un comando de
este tipo al desarrollar un paquete y probar su instalación. Fíjese en que Target contiene el nombre del paquete y
no el comando install , que se da por hecho al usar ExecuteIn="output" .
<PropertyGroup>
<PythonCommands>$(PythonCommands);InstallMyPackage</PythonCommands>
</PropertyGroup>
<Target Name="InstallMyPackage" Label="pip install my-package" Returns="@(Commands)">

<CreatePythonCommandItem Target="my-package" TargetType="pip" Arguments=""
WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
</Target>
Mostrar paquetes de pip obsoletos (Target: pip)
<PropertyGroup>
<PythonCommands>$(PythonCommands);ShowOutdatedPackages</PythonCommands>
</PropertyGroup>
<Target Name="ShowOutdatedPackages" Label="Show outdated pip packages" Returns="@(Commands)">

<CreatePythonCommandItem Target="list" TargetType="pip" Arguments="-o --format columns"
WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="consolepause">
</Target>
Ejecutar un archivo ejecutable con consolepause

El siguiente comando simplemente ejecuta where para mostrar los archivos de Python, empezando por la
carpeta del proyecto:
<PropertyGroup>
<PythonCommands>$(PythonCommands);ShowAllPythonFilesInProject</PythonCommands>
</PropertyGroup>
<Target Name="ShowAllPythonFilesInProject" Label="Show Python files in project" Returns="@(Commands)">

<CreatePythonCommandItem Target="where" TargetType="executable" Arguments="/r . *.py"
WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
</Target>
Comandos Iniciar servidor e Iniciar el servidor de depuración

Para saber cómo se definen los comandos Iniciar ser vidor e Iniciar el ser vidor de depuración en los
proyectos web, eche un vistazo a Microsoft.PythonTools.Web.targets (GitHub).
Instalar el paquete para desarrollo
<PropertyGroup>
<PythonCommands>PipInstallDevCommand;$(PythonCommands);</PythonCommands>
</PropertyGroup>
<Target Name="PipInstallDevCommand" Label="Install package for development" Returns="@(Commands)">

<CreatePythonCommandItem Target="pip" TargetType="module" Arguments="install --editable $(ProjectDir)"
WorkingDirectory="$(WorkingDirectory)" ExecuteIn="Repl:Install package for development">
</Target>
De fxthomas/Example.pyproj.xml (GitHub), usado con permiso.

Generar el instalador de Windows
<PropertyGroup>
<PythonCommands>$(PythonCommands);BdistWinInstCommand;</PythonCommands>
</PropertyGroup>
<Target Name="BdistWinInstCommand" Label="Generate Windows Installer" Returns="@(Commands)">

<CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"
Arguments="bdist_wininst --user-access-control=force --title "$(InstallerTitle)" --dist-
dir="$(DistributionOutputDir)""
WorkingDirectory="$(WorkingDirectory)" RequiredPackages="setuptools"
ExecuteIn="Repl:Generate Windows Installer">
</Target>

Generar un paquete Wheel
<PropertyGroup>
<PythonCommands>$(PythonCommands);BdistWheelCommand;</PythonCommands>
</PropertyGroup>
<Target Name="BdistWheelCommand" Label="Generate Wheel Package" Returns="@(Commands)">
<CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"

Arguments="bdist_wheel --dist-dir="$(DistributionOutputDir)""
WorkingDirectory="$(WorkingDirectory)" RequiredPackages="wheel;setuptools"
ExecuteIn="Repl:Generate Wheel Package">
</Target>
Mensaje: "No se pudo cargar el archivo del proyecto"
Indica que hay errores de sintaxis en el archivo de proyecto. El mensaje refleja el error específico con un número
de línea y una posición de carácter.
La ventana de la consola se cierra inmediatamente después de que el comando se ejecute
Use ExecuteIn="consolepause" en lugar de ExecuteIn="console" .
El comando no aparece en el menú
Compruebe que el comando está incluido en el grupo de propiedades <PythonCommands> y que el nombre que
figura en la lista de comandos es el mismo que el nombre especificado en el elemento <Target> .
Por ejemplo, en el siguiente código, el nombre "Example" en el grupo de propiedades no coincide con el nombre
"ExampleCommand" en el destino. Visual Studio no encuentra un comando llamado "Example", así que no se
muestra ningún comando. Use "ExampleCommand" en la lista de comandos, o bien cambie el nombre del
destino a sencillamente "Example".
<PropertyGroup>
<PythonCommands>$(PythonCommands);Example</PythonCommands>
</PropertyGroup>
<Target Name="ExampleCommand" Label="Example Command" Returns="@(Commands)">

</Target>
Mensaje: "Error al ejecutar <command name>. No se pudo obtener el comando <target-name> del
proyecto."
Indica que el contenido de los elementos <Target> o <CreatePythonCommandItem> es incorrecto. Esto puede
deberse a lo siguiente:
El atributo Target necesario está vacío.
El atributo TargetType necesario está vacío o contiene un valor no reconocido.
El atributo ExecuteIn necesario está vacío o contiene un valor no reconocido.
Se ha especificado ErrorRegex o WarningRegex sin definir ExecuteIn="output" .
Existen atributos no reconocidos en el elemento. Por ejemplo, puede que haya usado Argumnets (mal escrito)
en lugar de Arguments .
Los valores de atributo pueden estar vacíos si se hace referencia a una propiedad que no está definida. Por
ejemplo, si usa el token $(StartupFile) , pero no ha definido ningún archivo de inicio en el proyecto, el token se
resuelve como una cadena vacía. En tales casos, conviene definir un valor predeterminado. Por ejemplo, los
comandos Iniciar ser vidor e Iniciar el ser vidor de depuración definidos en las plantillas de proyecto de
Bottle, Flask y Django se establecen de forma predeterminada en manage.py si no se ha especificado un archivo
de inicio del servidor en las propiedades del proyecto.
Visual Studio deja de responder cuando el comando se ejecuta
Probablemente esté intentando ejecutar un comando de consola con ExecuteIn="output" , en cuyo caso Visual
Studio se puede bloquear al intentar analizar la salida. Utilice ExecuteIn="console" en su lugar. (Vea el problema
3682).
El comando ejecutable "no se reconoce como un comando interno o externo, programa o archivo por lotes
ejecutable"
Al usar TargetType="executable" , el valor de Target debe ser únicamente el nombre del programa sin
argumentos, como python o python.exe exclusivamente. Mueva los argumentos que haya al atributo Arguments .
Uso de la ventana interactiva de Python
Visual Studio proporciona una ventana interactiva read-evaluate-print loop (REPL) para cada entorno de Python,
que ofrece mejoras con respecto al REPL obtenido con python.exe en la línea de comandos. La ventana
interactiva (que se abre con los comandos de menú Ver > Otras ventanas > <entorno >Interactivo ) le
permite escribir código de Python arbitrario y ver resultados inmediatos. Esta manera de codificación le ayuda a
obtener información y experimentar con las API y las bibliotecas, así como a desarrollar de manera interactiva
código de trabajo para incluirlo en sus proyectos.
Visual Studio tiene una serie de modos de REPL de Python entre los que se puede elegir:
REP L DESC RIP C IÓ N EDITA R DEP URA C IÓ N IM Á GEN ES
Estándar REPL Edición estándar Sí, mediante No

predeterminado, que (multilínea, etc.). $attach
habla directamente
con Python
Depuración REPL Edición estándar Solo depuración No

predeterminado, que
habla directamente
con el proceso de
Python depurado
IPython REPL habla con el Comandos de No Sí, insertado en REPL

back-end de IPython IPython, ventajas de
PyLab
IPython sin PyLab REPL habla con el IPython estándar No Sí, ventana
back-end de IPython independiente
En este artículo se describen los modos de REPL Estándar y Depurar . Para obtener más información sobre los
modos de IPython, vea Uso de IPython en la ventana interactiva.
Para obtener un tutorial detallado con ejemplos, incluidas las interacciones con el editor como Ctrl +Entrar , vea
Paso 3 del tutorial: Uso de la ventana interactiva de REPL.
Apertura de una ventana interactiva

Hay varias maneras de abrir la ventana interactiva de un entorno.
En primer lugar, cambie a la ventana Entornos de Python (Ver > Otras ventanas > Entornos de Python o
Ctrl +K > ,Ctrl + ` ) y seleccione el comando o botón Abrir ventana interactiva de un entorno concreto.
En segundo lugar, cerca del botón del menú Ver > Otras ventanas , se encuentra el comando Ventana
interactiva de Python , que puede usar en su entorno predeterminado, así como un comando para cambiar a
la ventana de entornos :
En tercer lugar, puede abrir una ventana interactiva en el archivo de inicio del proyecto o en un archivo
independiente; para ello, seleccione el comando de menú Depurar > Ejecutar <Project | File> en la
ventana interactiva de Python (Mayús +Alt +F5 ):
Por último, puede seleccionar código en el archivo y usar el comando Enviar a interactivo descrito a
continuación.
Opciones de la ventana interactiva

Puede controlar varios aspectos de la ventana interactiva mediante Herramientas > Opciones > Python >
Ventanas interactivas (consulte Opciones):
Uso de la ventana interactiva
Cuando la ventana interactiva está abierta, puede empezar a escribir código línea por línea donde aparece el
símbolo >>> . La ventana interactiva ejecuta cada línea según la escribe, lo que incluye importar módulos,
definir variables, entre otros:
La excepción se produce cuando se necesitan líneas de código adicionales para realizar una instrucción
completa, como cuando una instrucción for termina en dos puntos como se ha mostrado anteriormente. En
estos casos, el símbolo de la línea cambia a ... , lo que indica que necesita escribir líneas adicionales para el
bloque, tal como se muestra en las líneas cuarta y quinta del gráfico anterior. Si presiona Entrar en una línea en
blanco, la ventana interactiva cierra el bloque y lo ejecuta en el intérprete.
TIP
La ventana interactiva ofrece mejoras con respecto a la experiencia de REPL de línea de comandos de Python habitual,
ya que aplica sangrías automáticamente a las instrucciones que pertenecen a un ámbito adyacente. Su historial
(recuperado con la flecha arriba) también ofrece elementos multilínea, mientras que el REPL de la línea de comandos solo
ofrece líneas simples.
La ventana interactiva también admite varios metacomandos. Todos los metacomandos empiezan con $ , y
puede escribir $help para obtener una lista de los metacomandos y $help <command> para obtener los detalles
de uso de un comando específico.
M ETA C O M A N DO DESC RIP C IÓ N
$$ Inserta un comentario, lo que resulta útil para comentar el

código a lo largo de la sesión.
$attach Asocia el depurador de Visual Studio con el proceso de la

ventana de REPL para habilitar la depuración.
$cls , $clear Borra el contenido de la ventana del editor, pero deja

intactos el historial y el contexto de ejecución.
$help Muestra una lista de comandos o ayuda sobre un comando

específico.
$load Carga los comandos del archivo y los ejecuta hasta que
terminan.
$mod Cambia el ámbito actual al nombre del módulo especificado.
$reset Restablece el entorno de ejecución al estado inicial, pero

mantiene el historial.
$wait Espera al menos el número de milisegundos especificado.
M ETA C O M A N DO DESC RIP C IÓ N
$$ Inserta un comentario, lo que resulta útil para comentar el

código a lo largo de la sesión.
$cls , $clear Borra el contenido de la ventana del editor, pero deja

intactos el historial y el contexto de ejecución.
$help Muestra una lista de comandos o ayuda sobre un comando

específico.
$load Carga los comandos del archivo y los ejecuta hasta que
terminan.
$mod Cambia el ámbito actual al nombre del módulo especificado.
$reset Restablece el entorno de ejecución al estado inicial, pero

mantiene el historial.
$wait Espera al menos el número de milisegundos especificado.
Los comandos también se extienden mediante extensiones de Visual Studio con la implementación y
exportación de IInteractiveWindowCommand (ejemplo).
Ámbitos de cambio
De forma predeterminada, la ventana interactiva de un proyecto se limita al archivo de inicio del proyecto,
como si lo ejecutara desde el símbolo del sistema. Para un archivo independiente, se limita a dicho archivo. No
obstante, el menú desplegable de la parte superior de la ventana interactiva permite cambiar en cualquier
momento el ámbito durante la sesión de REPL:
Después de importar un módulo, como escribir import importlib , aparecen opciones en el menú desplegable
para cambiar a cualquier ámbito en dicho módulo. Un mensaje en la ventana interactiva también indica el
nuevo ámbito, para que pueda realizar un seguimiento de cómo ha adoptado un estado determinado durante la
sesión.
Al escribir dir() en un ámbito, se muestran identificadores válidos en dicho ámbito, como nombres de
funciones, clases y variables. Por ejemplo, con import importlib seguido de dir() , se muestra lo siguiente:
Comando Enviar a interactivo

Además de trabajar directamente en la ventana interactiva , puede seleccionar código en el editor, hacer clic con
el botón derecho y seleccionar Enviar a interactivo o presionar Ctrl +Entrar .
Este comando resulta útil para el desarrollo de código iterativo o evolutivo, incluido probar el código a medida
que se desarrolla. Por ejemplo, después de enviar una porción de código a la ventana interactiva y ver la salida,
puede presionar la flecha arriba para volver a ver el código, modificarlo y probarlo rápidamente si presiona las
teclas Ctrl +Entrar . (Si presiona Entrar al final de la entrada, la ejecuta, pero, si presiona Entrar en el medio de
la entrada, inserta una nueva línea). Cuando tenga el código que desea, puede volver a copiarlo con facilidad en
el archivo del proyecto.
TIP
De manera predeterminada, Visual Studio quita >>> y ... REPL pregunta al pegar código desde la ventana interactiva al
editor. Puede cambiar este comportamiento en la pestaña Herramientas > Opciones > Editor de texto > Python >
Opciones avanzadas con la opción Quitar mensajes de REPL al pegar . Vea Opciones: Otras opciones.
Trabajo con celdas de código

Las celdas de código se pueden usar en el análisis de datos y son compatibles con varios editores de texto.
Por ejemplo, al usar un archivo de código como un bloc de dictado, a menudo tiene un pequeño bloque de
código que quiere enviar a la vez. Para agrupar el código, márquelo como una celda de código. Para ello,
agregue un comentario que comience por #%% al principio de la celda, con lo cual se termina la anterior. Las
celdas de código pueden contraerse y expandirse, y al usar Ctrl +Entrar dentro de una celda de código se envía
la celda completa a la ventana interactiva y se pasa a la siguiente.
Visual Studio también detecta celdas de código que comienzan con comentarios como # In[1]: , que es el
formato que se obtiene al exportar un Jupyter Notebook como un archivo de Python. Esta detección facilita la
ejecución de un bloc de notas desde Azure Notebooks. Para ello, se descarga como un archivo de Python, se
abre en Visual Studio y se usa Ctrl +Entrar para ejecutar cada celda.
Comportamiento de IntelliSense
La ventana interactiva incluye IntelliSense basándose en los objetos activos, a diferencia del editor de código,
en el que IntelliSense se basa exclusivamente en el análisis de código fuente. Estas sugerencias son más
correctas en la ventana interactiva , sobre todo, con el código generado de forma dinámica. El inconveniente es
que las funciones con efectos secundarios (como los mensajes de registro) pueden afectar a su experiencia de
desarrollo.
Si este comportamiento es un problema, cambie la configuración en Herramientas > Opciones > Python >
Ventanas Interactivas en el grupo Modo de finalización , como se describe en Opciones: Opciones de las
ventanas interactivas.
Uso de IPython en la ventana interactiva
La ventana interactiva de Visual Studio en modo de IPython es un entorno de desarrollo interactivo avanzado y
fácil de usar que tiene características de computación paralela interactiva. En este artículo se explica cómo usar
IPython en la ventana interactiva de Visual Studio, en la que también están disponibles todas las características
habituales de la ventana interactiva.
Para este tutorial, deberá tener instalados IPython, numpy y matplotlib. Si usa Anaconda, estas bibliotecas ya
están instaladas. En el resto del tutorial se da por supuesto que usa Anaconda.
NOTE
IronPython no admite IPython, a pesar de que puede seleccionarlo en el formulario Interactive Options (Opciones de
interactivo). Para obtener más información, vea la Solicitud de características.
1. Abra Visual Studio, cambie a la ventana Entornos de Python , en Ver > Otras ventanas > Entornos
de Python , y después seleccione el entorno de Anaconda.
2. Vaya a la pestaña Paquetes (Conda) (que pueden aparecer como pip o Paquetes ) de ese entorno para
asegurarse de que ipython y matplotlib se muestren. De lo contrario, instálelos. Vea Ventana Entorno
de Python - pestaña Paquetes.
3. Seleccione la pestaña Información general y después Usar modo interactivo de IPython . (En Visual
Studio 2015, seleccione Configurar opciones interactivas para abrir el cuadro de diálogo Opciones ,
después establezca Modo interactivo en IPython y haga clic en Aceptar ).
4. Seleccione Abrir ventana interactiva para que aparezca la ventana interactiva en modo de IPython.
Puede que necesite restablecer la ventana si solo ha cambiado el modo interactivo; también puede que
necesite presionar Entrar si solo aparece un mensaje >>>, para recibir una solicitud como En [2] .
5. Escriba el siguiente código:

import numpy as np
x = np.linspace(0, 5, 10)
y = x ** 2
plt.plot(x, y, 'r', x, x ** 3, 'g', x, x ** 4, 'b')
6. Después de escribir la última línea, debe aparecer un gráfico insertado, cuyo tamaño puede modificar si
arrastra la esquina inferior derecha.
7. En lugar de escribir en el REPL, puede escribir código en el editor, seleccionarlo, hacer clic con el botón
derecho y seleccionar el comando Enviar a interactivo (o presionar Ctrl +Entrar ). Intente pegar el
código siguiente en un nuevo archivo en el editor; selecciónelo con Ctrl +A y envíelo a la ventana
interactiva . (Visual Studio envía el código como una unidad para evitar que se representen gráficos
intermedios o parciales. Y si no tiene un proyecto de Python abierto con otro entorno seleccionado,
Visual Studio abre una ventana interactiva para el entorno que esté seleccionado como predeterminado
en la ventana Entornos de Python ).
from mpl_toolkits.mplot3d import Axes3D

import numpy as np
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for c, z in zip(['r', 'g', 'b', 'y'], [30, 20, 10, 0]):
xs = np.arange(20)
ys = np.random.rand(20)
# You can provide either a single color or an array. To demonstrate this,
# the first bar of each set is colored cyan.
cs = [c] * len(xs)
cs[0] = 'c'
ax.bar(xs, ys, zs=z, zdir='y', color=cs, alpha=0.8)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()
8. Para ver los gráficos fuera de la ventana interactiva , ejecute el código en lugar de utilizar el comando
Depurar > Iniciar sin depurar .
IPython tiene muchas otras características útiles, como el escape al shell del sistema, la sustitución de variables,
la captura de salidas, etc. Vea la documentación de IPython para obtener más información.
Vea también
Azure Data Science Virtual Machine está preconfigurado para ejecutar cuadernos de Jupyter, junto con una
amplia variedad de otras herramientas de ciencia de datos.
Depurar el código de Python
Visual Studio proporciona una experiencia de depuración completa para Python, lo que incluye la asociación a
procesos en ejecución, la evaluación de expresiones en las ventanas Inspección e Inmediato , la inspección de
variables locales, los puntos de interrupción, las instrucciones Depurar paso a paso por
instrucciones/procedimientos/para salir, Establecer instrucción siguiente , etc.
Vea también los siguientes artículos de depuración específicos para distintos escenarios:
Depuración remota de Linux
Mixed-mode Python/C++ debugging (Depuración en modo mixto Python/C++)
Symbols for mixed-mode debugging (Símbolos de depuración en modo mixto)
TIP
Python en Visual Studio admite la depuración sin un proyecto. Con un archivo independiente de Python abierto, haga clic
con el botón derecho en el editor y seleccione Iniciar con depuración . Visual Studio inicia el script con el entorno
predeterminado global (vea Entornos de Python) y sin argumentos. Pero desde ese momento, dispone de compatibilidad
total para depuración.
Para controlar el entorno y los argumentos, cree un proyecto para el código de manera sencilla con la plantilla de
proyecto Desde código de Python existente.
Depuración básica
El flujo de trabajo de depuración básica conlleva configurar puntos de interrupción, recorrer paso a paso el
código, inspeccionar valores y administrar excepciones, tal y como se describe en las secciones siguientes.
Puede iniciar una sesión de depuración con el comando Depurar > Iniciar depuración , el botón Iniciar de la
barra de herramientas o la tecla F5 . Estas acciones inician el archivo de inicio del proyecto (se muestra en
negrita en el Explorador de soluciones ) con el entorno activo del proyecto y los argumentos de línea de
comandos o las rutas de búsqueda que se hayan especificado en Propiedades del proyecto (vea Project
debugging options [Opciones de depuración de proyectos]). Visual Studio 2017, versión 15.6 y posteriores, le
avisa si no tiene un archivo de inicio configurado; en las versiones anteriores, es posible que se abra una
ventana de salida con el intérprete de Python en ejecución o que la ventana de salida aparezca brevemente y
luego desaparezca. En cualquier caso, haga clic con el botón derecho en el archivo adecuado y seleccione
Establecer como archivo de inicio .
NOTE
El depurador siempre se inicia con el entorno de Python activo para el proyecto. Para cambiar el entorno, active otro
distinto como se explica en Cómo asignar el entorno de Python que se usa en un proyecto.
Puntos de interrupción
Los puntos de interrupción detienen la ejecución del código en un punto especificado, a fin de poder
inspeccionar el estado del programa. Para establecer los puntos de interrupción, haga clic en el margen
izquierdo del editor de código o haga clic con el botón derecho en una línea de código y seleccione Punto de
interrupción > Inser tar punto de interrupción . En cada línea con un punto de interrupción, aparece un
punto rojo.
Para eliminar un punto de interrupción, haga clic en el punto rojo o haga clic con el botón derecho en la línea de
código y seleccione Punto de interrupción > Eliminar punto de interrupción . También puede
deshabilitarlo sin quitarlo; para ello, use el comando Punto de interrupción > Deshabilitar punto de
interrupción .
NOTE
Algunos puntos de interrupción de Python pueden resultar sorprendentes para aquellos desarrolladores que hayan
trabajado con otros lenguajes de programación. En Python, todo el archivo es código ejecutable, por lo que Python
ejecuta el archivo cuando se carga para procesar cualquier definición de clase o función de nivel superior. Si se ha
establecido un punto de interrupción, puede observar que el depurador se interrumpe parcialmente a través de una
declaración de clase. Este comportamiento es correcto, aunque a veces sea sorprendente.
Puede personalizar las condiciones en que se desencadena un punto de interrupción, como que la interrupción
se lleve a cabo cuando una variable se establece en un valor concreto o en un intervalo de valor. Para definir las
condiciones, haga clic con el botón derecho en el punto rojo del punto de interrupción, seleccione Condición y
después cree expresiones con código Python. Para obtener todos los detalles sobre esta característica de Visual
Studio, vea Breakpoint conditions (Condiciones de los puntos de interrupción).
Al definir las condiciones, también puede completar el campo Acción y crear un mensaje para registrarlo en la
ventana de salida, con la opción de que la ejecución continúe automáticamente. Al registrar el mensaje se crea lo
que se denomina un punto de seguimiento sin agregar código de registro directamente en la aplicación:
Examinar el código
Una vez detenido en un punto de interrupción, hay varias maneras de recorrer el código paso a paso o de
ejecutar bloques de código antes de que se produzca una nueva interrupción. Estos comandos están disponibles
en varias ubicaciones, como la barra de herramientas de depuración de la parte superior, el menú Depurar , en
el menú contextual del editor de código y mediante métodos abreviados de teclado (aunque no todos los
comandos están en todas las ubicaciones):
C A RA C T ERÍST IC A P UL SA C IÓ N DE T EC L A DESC RIP C IÓ N
Continue F5 Ejecuta código hasta que se alcanza el

punto de interrupción siguiente.
Depurar paso a paso por F11 Ejecuta la instrucción siguiente y se

instrucciones detiene. Si la siguiente instrucción es
una llamada a una función, el
depurador se detiene en la primera
línea de la función que se va a invocar.
Paso a paso por procedimientos F10 Ejecuta la siguiente instrucción, como

realizar una llamada a una función
(mediante la ejecución de todo su
código) y aplicar cualquier valor
devuelto. Esta acción permite omitir
con facilidad aquellas funciones que no
necesita depurar.
Paso a paso para salir Mayús +F11 Ejecuta el código hasta el final de la
función actual y después pasa a la
instrucción de llamada. Este comando
resulta útil cuando no necesita depurar
el resto de la función actual.
Ejecutar hasta el cursor Ctrl+F10 Ejecuta código hasta la ubicación del

operador exponencial en el editor. Este
comando le permite saltar fácilmente
un segmento de código que no
necesita depurar.
Establecer instrucción siguiente Ctrl+Mayús +F10 Cambia el punto de ejecución actual

del código a la ubicación del operador
exponencial. Este comando le permite
omitir por completo la ejecución de un
segmento de código, por ejemplo,
cuando sabe que el código es erróneo
o que produce un efecto secundario
no deseado.
Mostrar la instrucción siguiente Alt +Num * Le remite a la instrucción siguiente que

se va a ejecutar. Este comando es útil si
ha estado mirando el código, pero no
recuerda dónde se ha detenido el
depurador.
Inspeccionar y modificar valores

Cuando el depurador se detiene, puede inspeccionar y modificar los valores de variables. También puede usar la
ventana Inspección para supervisar variables individuales y expresiones personalizadas. (Vea Inspeccionar
variables para obtener detalles).
Para ver un valor con Información sobre datos , solo tiene que mantener el puntero sobre cualquier variable
en el editor. Puede hacer clic en el valor para cambiarlo:
La ventana Automático (Depurar > Ventanas > Automático ) contiene variables y expresiones cercanas a la
instrucción actual. Puede hacer doble clic en la columna de valor o seleccionar y presionar F2 para modificar el
valor:
La ventana Variables locales (Depurar > Ventanas > Variables locales ) muestra todas las variables que se
encuentran en el ámbito actual, que se pueden volver a modificar:
Para obtener más información sobre el uso de Automático y Variables locales , vea Inspect variables in the
Autos and Locals windows (Inspeccionar las variables en las ventanas Variables locales y Automático).
Las ventanas Inspección (Depurar > Ventanas > Inspección > Inspección 1-4 ) permiten especificar
expresiones arbitrarias de Python y ver los resultados. Las expresiones se vuelven a evaluar para cada paso:
Para obtener más información sobre el uso de Inspección , vea Set a watch on variables using the Watch and
QuickWatch windows (Establecimiento de una inspección en variables mediante las ventanas Inspección e
Inspección rápida).
Al inspeccionar un valor de cadena ( str , unicode , bytes y bytearray se consideran cadenas para este
propósito), aparece un icono de lupa a la derecha del valor. Al hacer clic en este icono, se muestra el valor de
cadena sin comillas en un cuadro de diálogo emergente, con las opciones de ajuste y desplazamiento, que
resultan útiles para cadenas largas. Además, seleccionar la flecha desplegable en el icono le permite seleccionar
texto sin formato y visualizaciones HTML, XML y JSON:
Las visualizaciones HTML, XML y JSON aparecen en ventanas emergentes independientes con resaltado de
sintaxis y vistas de árbol.
Excepciones
Si se produce algún error en su programa durante la depuración, pero no dispone de un controlador de
excepciones para él, el depurador se interrumpe en el punto de la excepción:
En este punto puede inspeccionar el estado del programa, incluida la pila de llamadas. En cambio, si intenta
recorrer el código, la excepción sigue produciéndose hasta que se controle o hasta que el programa se cierre.
El comando de menú Depurar > Ventanas > Configuración de excepciones abre una ventana en la que
puede expandir Excepciones de Python :
La casilla de cada excepción controla si el depurador siempre se interrumpe cuando se produce la excepción.
Active esta casilla si quiere que las interrupciones sean más frecuentes para una excepción concreta.
De manera predeterminada, la mayoría de las excepciones activan una interrupción cuando no se pueda
encontrar un controlador de excepciones en el código fuente. Para cambiar este comportamiento, haga clic con
el botón derecho en cualquier excepción y modifique la opción Continuar cuando no se controle en el
código de usuario . Desactive esta casilla si quiere que las interrupciones sean menos frecuentes para una
excepción.
Para configurar una excepción que no aparece en esta lista, haga clic en el botón Agregar para agregarla. El
nombre debe coincidir con el nombre completo de la excepción.
Opciones de depuración de proyectos

De forma predeterminada, el depurador inicia el programa con el selector de Python estándar, sin argumentos
de línea de comandos ni otras rutas de acceso o condiciones especiales. Las opciones de inicio se cambian
mediante las propiedades de depuración del proyecto; para acceder a ellas, haga clic con el botón derecho en el
proyecto en el Explorador de soluciones , seleccione Propiedades y después la pestaña Depurar .
Opciones de Modo de inicio

Iniciador de Python estándar Utiliza código de depuración escrito en Portable Python que
es compatible con CPython, IronPython y variantes, como
Stackless Python. Proporciona la mejor experiencia de
depuración de código Python puro. Al realizar una asociación
a un proceso python.exe en ejecución, se usa este iniciador.
Este selector también proporciona depuración en modo
mixto para CPython, que permite cambiar sin problemas
entre los códigos C/C++ y Python.
Iniciador web Inicia el explorador predeterminado para la selección y

habilita la depuración de plantillas. Vea la sección de
depuración de plantillas web para obtener más información.
Iniciador web de Django Idéntico al selector web y se muestra solo para la

compatibilidad con versiones anteriores.
Iniciador de IronPython (.NET) Usa el depurador de .NET, que solo funciona con IronPython,
pero permite cambiar entre cualquier proyecto en lenguaje
.NET, incluidos C# y VB. Este selector se usa para establecer
una asociación con un proceso .NET en ejecución que
hospeda IronPython.
Opciones de ejecución (rutas de búsqueda, argumentos de inicio y variables de entorno )

Rutas de búsqueda Estos valores coinciden con lo que se muestra en el nodo

Rutas de búsqueda del proyecto en el Explorador de
soluciones . Puede modificar este valor aquí, pero es más
fácil usar el Explorador de soluciones , ya que permite
examinar las carpetas y convierte automáticamente las rutas
de acceso a un formato relativo.
Argumentos de script Estos argumentos se agregan al comando que se ha usado

para iniciar el script, y aparecen después del nombre de
archivo del script. El primer elemento aquí está disponible
para el script como sys.argv[1] , el segundo como
sys.argv[2] , y así sucesivamente.
Argumentos del intérprete Estos argumentos se agregan a la línea de comandos del

iniciador antes del nombre del script. Los argumentos
comunes aquí son -W ... para controlar advertencias,
-O para optimizar ligeramente el programa y -u para
utilizar E/S no almacenada en el búfer. Los usuarios de
IronPython probablemente usen este campo para pasar
opciones -X , como -X:Frames o -X:MTA .
Ruta del intérprete Reemplaza la ruta de acceso asociada con el entorno actual.
El valor puede resultar útil para iniciar el script con un
intérprete no estándar.
Variables de entorno En este cuadro de texto multilínea, agregue entradas con el

formato <NAME>=<VALUE>. Como esta opción se aplica al
final, por encima de cualquier variable de entorno global
existente y, después, PYTHONPATH se establece según la
configuración de Rutas de búsqueda , puede usarse para
reemplazar manualmente cualquiera de esas otras variables.
Ventanas inmediatas e interactivas

Existen dos ventanas interactivas que puede usar durante una sesión de depuración: la ventana Inmediato
estándar de Visual Studio y la ventana Interactiva de depuración de Python .
La ventana Inmediato (Depurar > Ventanas > Inmediato ) se usa para la evaluación rápida de expresiones
de Python y la inspección o la asignación de variables en el programa en ejecución. Vea el artículo general
Ventana Inmediato para obtener detalles.
La ventana Interactiva de depuración de Python (Depurar > Ventanas > Interactiva de depuración de
Python ) tiene más características, ya que habilita la experiencia completa de REPL interactivo durante la
depuración, incluidas la escritura y la ejecución de código. Se conecta automáticamente a cualquier proceso
iniciado en el depurador mediante el iniciador de Python estándar (incluidos los procesos asociados mediante
Depurar > Asociar al proceso ). No obstante, no está disponible si se usa la depuración en modo mixto de
C/C++.
La ventana Interactiva de depuración admite metacomandos especiales además de los comandos estándar
de REPL:
C O M A N DO A RGUM EN TO S DESC RIP C IÓ N
$continue , $cont , $c Inicia la ejecución del programa a

partir de la instrucción actual.
$down , $d Baja el marco actual un nivel en el

seguimiento de la pila.
$frame Muestra el identificador del marco

actual.
$frame frame ID Cambia el marco actual al identificador

del marco especificado.
$load Carga los comandos del archivo y los

ejecuta hasta que terminan.
$proc Muestra el identificador de proceso

actual.
C O M A N DO A RGUM EN TO S DESC RIP C IÓ N
$proc process ID Cambia el proceso actual al

identificador de proceso especificado.
$procs Muestra los procesos que se están

depurando actualmente.
$stepin , $step , $s Recorre paso a paso instrucciones

hasta llegar a la siguiente llamada de
función, si es posible.
$stepout , $return , $r Sale paso a paso de la función actual.
$stepover , $until , $unt Pasa por alto la siguiente llamada de

función.
$thread Muestra el identificador de subproceso

actual.
$thread thread ID Cambia el subproceso actual al

identificador de subproceso
especificado.
$threads Muestra los subprocesos que se están

depurando actualmente.
$up , $u Sube el marco actual un nivel en el

seguimiento de la pila.
$where , $w , $bt Muestra los marcos del subproceso

actual.
Tenga en cuenta que las ventanas estándar del depurador, como Procesos , Subprocesos y Pila de llamadas ,
no están sincronizadas con la ventana Interactiva de depuración . El cambio del marco, subproceso o proceso
activo en la ventana Interactiva de depuración no afecta a las otras ventanas del depurador. Del mismo
modo, el cambio del marco, subproceso o proceso activo en las otras ventanas del depurador no afecta a la
ventana Interactiva de depuración .
Usar el depurador heredado

Visual Studio 2017 15.8 y versiones posteriores usan un depurador basado en ptvsd 4.1+.
Visual Studio 2019 16.5 y las versiones posteriores usan un depurador basado en debugpy. Estas versiones del
depurador son compatibles con Python 2.7 y Python 3.5+. Si usa Python 2.6, 3.1 hasta 3.4 o IronPython, Visual
Studio muestra el error El depurador no admite este entorno de Python :
En estos casos, debe usar el depurador antiguo (que es el valor predeterminado en Visual Studio 2017 15.7 y
versiones anteriores). Seleccione el comando del menú Herramientas > Opciones , navegue a Python >
Depuración y seleccione la opción Usar el depurador heredado .
Si ha instalado una versión anterior de ptvsd en el entorno actual (por ejemplo, una versión 4.0.x anterior de una
versión 3.x necesaria para la depuración remota), es posible que Visual Studio muestre un error o una
advertencia.
El error No se pudo cargar el paquete de depurador aparece cuando se ha instalado ptvsd 3.x:
En este caso, seleccione Usar el depurador heredado para establecer la opción Usar el depurador
heredado y reiniciar el depurador.
La advertencia El paquete del depurador está obsoleto aparece cuando se ha instalado una versión
anterior a 4.x de ptvsd:
IMPORTANT
Aunque puede omitir la advertencia en algunas versiones de ptvsd, es posible que Visual Studio no funcione
correctamente.
Para administrar la instalación de ptvsd:

1. Navegue a la pestaña Paquetes en la ventana Entornos de Python .
2. Escriba "ptvsd" en el cuadro de búsqueda y examine la versión de ptvsd instalada:
3. Si la versión es anterior a 4.1.1a9 (la versión incluida con Visual Studio), seleccione el símbolo X a la
derecha del paquete para desinstalar la versión anterior. Visual Studio usará la versión incluida. (También
puede desinstalarla desde PowerShell mediante pip uninstall ptvsd ).
4. Como alternativa, puede actualizar el paquete de ptvsd a su versión más reciente siguiendo las
instrucciones de la sección Solución de problemas.
Para la actualización de ptvsd de Visual Studio 2019 (versión 16.4 y posteriores)
Si tiene problemas con el depurador, primero actualice su versión del depurador de la siguiente manera:
1. Navegue a la pestaña Paquetes en la ventana Entornos de Python .
2. Escriba ptvsd --upgrade en el cuadro de búsqueda y seleccione Ejecutar comando: pip install ptvsd
--upgrade . (También puede usar el mismo comando desde PowerShell).
Si los problemas persisten, registre un problema en el repositorio de GitHub de PTVS.

NOTE
Para Visual Studio 2019 16.5 y versiones posteriores, debugpy forma parte de la carga de trabajo de Python de
Visual Studio y se actualiza junto con Visual Studio.
Habilitación del registro del depurador

En el transcurso de la investigación de un problema del depurador, Microsoft puede pedirle que habilite y
recopile registros de depurador que ayudan en el diagnóstico.
Los pasos siguientes habilitan la depuración en la sesión actual de Visual Studio:
1. Abra una ventana de comandos en Visual Studio mediante el comando de menú Ver > Otras ventanas
> Ventana Comandos .
2. Escriba el comando siguiente:
DebugAdapterHost.Logging /On /OutputWindow
3. Inicie la depuración y recorra los pasos que sean necesarios para reproducir el problema. Durante este
tiempo, los registros de depuración aparecen en la ventana Salida bajo Registro del host de
adaptador de depuración . Luego puede copiar los registros de esa ventana y pegarlos en un problema
de GitHub, correo electrónico, etc.
4. Si Visual Studio deja de responder o le resulta imposible acceder a la ventana Salida , reinicie
Visual Studio, abra una ventana de comandos y escriba el siguiente comando:
DebugAdapterHost.Logging /On
5. Inicie la depuración y reproduzca el problema de nuevo. Después, puede encontrar los registros del
depurador en %temp%\DebugAdapterHostLog.txt .
Vea también
Para obtener información detallada sobre el depurador de Visual Studio, vea Debugging in Visual Studio
(Depuración en Visual Studio).
Depurar código de Python en Linux de forma
remota
En Visual Studio se pueden iniciar y depurar aplicaciones de Python de manera local y remota en un equipo
Windows (vea Depuración remota). También puede realizar la depuración remota en un sistema operativo, un
dispositivo o una implementación de Python diferentes a CPython mediante la biblioteca ptvsd.
Al usar ptvsd, el código de Python que se depura hospeda el servidor de depuración al que puede asociar Visual
Studio. El hospedaje necesita una pequeña modificación en el código para importar y habilitar al servidor.
Además, es posible que haya que modificar la configuración de la red o del firewall en el equipo remoto para
permitir conexiones TCP.
Para obtener una introducción a la depuración remota, vea Deep Dive: Cross-platform remote
debugging (Profundización: Depuración remota multiplataforma) (youtube.com, 6 minutos 22 segundos), que
se aplica a Visual Studio 2015 y 2017.
Configurar un equipo Linux

Los elementos siguientes son necesarios para seguir este tutorial:
Un equipo remoto que ejecute Python en un sistema operativo como Mac OSX o Linux.
El puerto 5678 (entrada) abierto en el firewall de ese equipo, que es el valor predeterminado para la
depuración remota.
Puede crear fácilmente una máquina virtual de Linux en Azure y acceder mediante Escritorio remoto desde
Windows. Ubuntu para la máquina virtual resulta útil porque Python está instalado de forma predeterminada;
de lo contrario, vea la lista de Instalación de los intérpretes de Python para obtener otras ubicaciones de
descarga de Python.
Para obtener detalles sobre cómo crear una regla de firewall para una máquina virtual de Azure, vea Apertura
de puertos en una máquina virtual con Azure Portal.
Preparar el script para la depuración

1. En el equipo remoto, cree un archivo de Python denominado guessing-game.py con el código siguiente:
import random
guesses_made = 0
name = input('Hello! What is your name?\n')
number = random.randint(1, 20)
print('Well, {0}, I am thinking of a number between 1 and 20.'.format(name))
while guesses_made < 6:

guess = int(input('Take a guess: '))
guesses_made += 1
if guess < number:
print('Your guess is too low.')
if guess > number:
print('Your guess is too high.')
if guess == number:
break
if guess == number:
print('Good job, {0}! You guessed my number in {1} guesses!'.format(name, guesses_made))
else:
print('Nope. The number I was thinking of was {0}'.format(number))
2. Instale el paquete ptvsd en su entorno mediante pip3 install ptvsd .
NOTE
Es buena idea registrar la versión de ptvsd que se instala en caso de necesitarla para solucionar problemas; la lista
de ptvsd también muestra las versiones disponibles.
3. Habilite la depuración remota al agregar el código siguiente al primer punto posible de guessing-
game.py, delante de otro código. (Aunque no es un requisito estricto, es imposible depurar subprocesos
en segundo plano generados antes de la llamada a la función enable_attach ).
import ptvsd
ptvsd.enable_attach()
4. Guarde el archivo y ejecute python3 guessing-game.py . La llamada a enable_attach se ejecuta en

segundo plano y espera las conexiones entrantes mientras se interactúa con el programa. Si lo desea, se
puede llamar a la función wait_for_attach después de enable_attach para bloquear el programa hasta
que se asocie el depurador.
TIP
Además de enable_attach y wait_for_attach , ptvsd también proporciona una función del asistente
break_into_debugger , que actúa como un punto de interrupción de programación si el depurador está asociado.
También hay una función is_attached que devuelve True si el depurador está asociado (tenga en cuenta que no es
necesario comprobar este resultado antes de llamar a cualquier otra función ptvsd ).
Asociar desde Herramientas de Python de forma remota

En estos pasos, estableceremos un punto de interrupción simple para detener el proceso remoto.
1. Cree una copia del archivo remoto en el equipo local y ábralo en Visual Studio. No importa dónde se
encuentre el archivo, pero su nombre debe coincidir con el nombre del script en el equipo remoto.
2. (Opcional) Para tener IntelliSense para ptvsd en el equipo local, instale el paquete de ptvsd en su entorno
de Python.
3. Seleccione Depurar > Asociar al proceso .
4. En el cuadro de diálogo Asociar al proceso que aparece, establezca Tipo de conexión en Depuración
remota de Python (ptvsd) . (En versiones anteriores de Visual Studio estos comandos se denominaban
Transpor te y Depuración remota de Python ).
5. En el campo Destino de la conexión (Calificador en versiones anteriores), escriba
tcp://<ip_address>:5678 , donde <ip_address> es la del equipo remoto (que puede ser una dirección
explícita o un nombre como myvm.cloudapp.net), y :5678 es el número de puerto de depuración
remota.
6. Presione Entrar para rellenar la lista de procesos de ptvsd disponibles en el equipo:
Si inicia otro programa en el equipo remoto después de rellenar esta lista, haga clic en el botón
Actualizar .
7. Seleccione el proceso para depurar y después haga clic en Adjuntar , o haga doble clic en el proceso.
8. Visual Studio cambia después al modo de depuración mientras el script continúa ejecutándose en el
equipo remoto, lo que proporciona todas las capacidades normales de depuración. Por ejemplo,
establezca un punto de interrupción en la línea if guess < number: , después cambie al equipo remoto y
escriba otro intento. Una vez hecho esto, el programa Visual Studio del equipo local se detiene en ese
punto de interrupción, muestra las variables locales, etc.:
9. Al detener la depuración, Visual Studio se desconecta del programa, que continúa ejecutándose en el
equipo remoto. ptvsd también sigue escuchando para conectar depuradores, por lo que se puede volver
a conectar al proceso en cualquier momento.
Solución de problemas de conexión
1. Asegúrese de que ha seleccionado Depuración remota de Python (ptvsd) para el Tipo de conexión
(Depuración remota de Python para Transpor te con versiones anteriores).
2. Compruebe que el secreto en Destino de la conexión (o Calificador ) coincide exactamente con el
secreto en el código remoto.
3. Compruebe que la dirección IP en Destino de la conexión (o Calificador ) coincide exactamente con la
del equipo remoto.
4. Compruebe que esté abierto el puerto de depuración remota en el equipo remoto y que ha incluido el
sufijo de puerto en el destino de la conexión, por ejemplo :5678 .
Si necesita usar un puerto diferente, puede especificarlo en la llamada a enable_attach mediante el
argumento address , como en ptvsd.enable_attach(address = ('0.0.0.0', 8080)) . En este caso, abra
ese puerto concreto en el firewall.
5. Compruebe que la versión de ptvsd instalada en el equipo remoto, tal como la devuelve pip3 list ,
coincide con la que usa la versión de las herramientas de Python que se usa en Visual Studio en la tabla
siguiente. Si es necesario, actualice ptvsd en el equipo remoto.
VERSIÓ N DE VISUA L ST UDIO VERSIÓ N DE L A S H ERRA M IEN TA S DE P Y T H O N / P T VSD
2017 15.8 4.1.1a9 (depurador heredado: 3.2.1.0)
2017 15.7 4.1.1a1 (depurador heredado: 3.2.1.0)
2017 15.4, 15.5, 15.6 3.2.1.0

VERSIÓ N DE VISUA L ST UDIO VERSIÓ N DE L A S H ERRA M IEN TA S DE P Y T H O N / P T VSD
2017 15.3 3.2.0
2017 15.2 3.1.0
2017 15.0, 15.1 3.0.0
2015 2.2.6
2013 2.2.2
2012, 2010 2.1
Uso de ptvsd 3.x

La información siguiente solo se aplica a la depuración remota con ptvsd 3.x, que contiene ciertas características
que se quitaron en ptvsd 4.x.
1. Con ptvsd 3.x, la función enable_attach que requiere que pase un "secreto" como el primer argumento
que restringe el acceso al script en ejecución. Este secreto se escribe cuando se adjunta el depurador
remoto. Aunque no se recomienda, puede permitir que cualquiera se conecte, mediante
enable_attach(secret=None) .
2. La dirección URL de destino de conexión es tcp://<secret>@<ip_address>:5678 , donde <secret> es la

cadena enable_attach que se pasa en el código de Python.
De forma predeterminada, la conexión al servidor de depuración remota de ptvsd 3.x solo está protegida por el
secreto y todos los datos se pasan como texto sin formato. Para una conexión más segura, ptvsd 3.x admite SSL
con el protocolo tcsp , que se configura de la siguiente manera:
1. En el equipo remoto, genere archivos de certificado autofirmado y de clave independientes con openssl:
openssl req -new -x509 -days 365 -nodes -out cert.cer -keyout cert.key
Cuando se le solicite, use el nombre de host o la dirección IP (lo que use para conectarse) para el
Nombre común cuando se lo solicite openssl.
(Vea Certificados autofirmados en la documentación del módulo ssl de Python para obtener más
detalles. Tenga en cuenta que en esa documentación el comando solo genera un único archivo
combinado).
2. En el código, modifique la llamada a enable_attach para incluir los argumentos certfile y keyfile
usando los nombres de archivo como valores (estos argumentos tienen el mismo significado que para la
función estándar ssl.wrap_socket de Python):
ptvsd.enable_attach(secret='my_secret', certfile='cert.cer', keyfile='cert.key')
También puede realizar el mismo cambio en el archivo de código en el equipo local, pero dado que este
código no se ejecuta realmente, no es estrictamente necesario.
3. Reinicie el programa de Python en el equipo remoto, para prepararlo para la depuración.
4. Proteja el canal agregando el certificado a la CA raíz de confianza en el equipo Windows con Visual
Studio:
a. Copie el archivo de certificado desde el equipo remoto al equipo local.
b. Abra el Panel de Control y vaya a Herramientas administrativas > Administrar cer tificados
de equipo .
c. En la ventana que aparece, expanda Entidades de cer tificación raíz de confianza en el lado
izquierdo, haga clic con el botón derecho en Cer tificados y seleccione Todas las tareas >
Impor tar .
d. Vaya al archivo .cer copiado desde el equipo remoto, selecciónelo y, después, haga clic en los cuadros
de diálogo para completar la importación.
5. Repita el proceso de asociación en Visual Studio como se ha descrito anteriormente y ahora use tcps://
como protocolo para el Destino de la conexión (o Calificador ).
6. Visual Studio le avisará sobre posibles problemas de certificado cuando se conecta a través de SSL.
Puede pasar por alto las advertencias y continuar, pero aunque el canal sigue cifrado frente a la
intercepción, puede estar abierto a ataques de tipo "Man in the middle".
a. Si ve la siguiente advertencia El cer tificado remoto no es de confianza , significa que no ha
agregado correctamente el certificado a la CA raíz de confianza. Compruebe esos pasos y vuelve a
intentarlo.
b. Si ve la siguiente advertencia El nombre del cer tificado remoto no coincide con el nombre
de host , significa que no se han usado la dirección IP o el nombre de host correctos como
Nombre común al crear el certificado.
En Visual Studio se pueden iniciar y depurar aplicaciones de Python de manera local y remota en un equipo
Windows (vea Depuración remota). También puede realizar la depuración remota en un sistema operativo, un
dispositivo o una implementación de Python diferentes a CPython mediante la biblioteca debugpy.
Al usar debugpy, el código de Python que se depura hospeda el servidor de depuración al que puede asociar
Visual Studio. El hospedaje necesita una pequeña modificación en el código para importar y habilitar al servidor.
Además, es posible que haya que modificar la configuración de la red o del firewall en el equipo remoto para
permitir conexiones TCP.
NOTE
En Visual Studio 2019 16.4 y versiones anteriores, se usó la biblioteca ptvsd. La biblioteca debugpy reemplazó a ptvsd 4
en Visual Studio 2019 16.5.
Configurar un equipo Linux

Los elementos siguientes son necesarios para seguir este tutorial:
Un equipo remoto que ejecute Python en un sistema operativo como Mac OSX o Linux.
El puerto 5678 (entrada) abierto en el firewall de ese equipo, que es el valor predeterminado para la
depuración remota.
NOTE
Este tutorial se basa en Visual Studio 2019 16.6.
Puede crear fácilmente una máquina virtual de Linux en Azure y acceder mediante Escritorio remoto desde
Windows. Ubuntu para la máquina virtual resulta útil porque Python está instalado de forma predeterminada;
de lo contrario, vea la lista de Instalación de los intérpretes de Python para obtener otras ubicaciones de
descarga de Python.
Para obtener detalles sobre cómo crear una regla de firewall para una máquina virtual de Azure, vea Apertura
de puertos en una máquina virtual con Azure Portal.
Preparar el script para la depuración

1. En el equipo remoto, cree un archivo de Python denominado guessing-game.py con el código siguiente:
import random
guesses_made = 0
name = input('Hello! What is your name?\n')
number = random.randint(1, 20)
print('Well, {0}, I am thinking of a number between 1 and 20.'.format(name))
while guesses_made < 6:

guess = int(input('Take a guess: '))
guesses_made += 1
if guess < number:
print('Your guess is too low.')
if guess > number:
print('Your guess is too high.')
if guess == number:
break
if guess == number:
print('Good job, {0}! You guessed my number in {1} guesses!'.format(name, guesses_made))
else:
print('Nope. The number I was thinking of was {0}'.format(number))
2. Instale el paquete debugpy en su entorno mediante pip3 install debugpy .
NOTE
Es buena idea registrar la versión de debugpy que se instala en caso de necesitarla para solucionar problemas; la
lista de debugpy también muestra las versiones disponibles.
3. Habilite la depuración remota al agregar el código siguiente al primer punto posible de guessing-
game.py, delante de otro código. (Aunque no es un requisito estricto, es imposible depurar subprocesos
en segundo plano generados antes de la llamada a la función listen ).
import debugpy
debugpy.listen(5678)
4. Guarde el archivo y ejecute python3 guessing-game.py . La llamada a listen se ejecuta en segundo plano
y espera las conexiones entrantes mientras se interactúa con el programa. Si lo desea, se puede llamar a
la función wait_for_client después de listen para bloquear el programa hasta que se asocie el
depurador.
TIP
Además de listen y wait_for_client , debugpy también proporciona una función del asistente breakpoint , que
actúa como un punto de interrupción de programación si el depurador está asociado. También hay una función
is_client_connected que devuelve True si el depurador está asociado (tenga en cuenta que no es necesario
comprobar este resultado antes de llamar a cualquier otra función debugpy ).
Asociar desde Herramientas de Python de forma remota

En estos pasos, estableceremos un punto de interrupción simple para detener el proceso remoto.
1. Cree una copia del archivo remoto en el equipo local y ábralo en Visual Studio. No importa dónde se
encuentre el archivo, pero su nombre debe coincidir con el nombre del script en el equipo remoto.
2. (Opcional) Para tener IntelliSense para debugpy en el equipo local, instale el paquete de debugpy en su
entorno de Python.
3. Seleccione Depurar > Asociar al proceso .
4. En el cuadro de diálogo Asociar al proceso que aparece, establezca Tipo de conexión en Depuración
remota de Python (debugpy) .
5. En el campo Destino de la conexión , escriba tcp://<ip_address>:5678 , donde <ip_address> es la del
equipo remoto (que puede ser una dirección explícita o un nombre como myvm.cloudapp.net), y :5678
es el número de puerto de depuración remota.
6. Presione Entrar para rellenar la lista de procesos de debugpy disponibles en el equipo:
Si inicia otro programa en el equipo remoto después de rellenar esta lista, haga clic en el botón
Actualizar .
7. Seleccione el proceso para depurar y después haga clic en Adjuntar , o haga doble clic en el proceso.
8. Visual Studio cambia después al modo de depuración mientras el script continúa ejecutándose en el
equipo remoto, lo que proporciona todas las capacidades normales de depuración. Por ejemplo,
establezca un punto de interrupción en la línea if guess < number: , después cambie al equipo remoto y
escriba otro intento. Una vez hecho esto, el programa Visual Studio del equipo local se detiene en ese
punto de interrupción, muestra las variables locales, etc.:
9. Al detener la depuración, Visual Studio se desconecta del programa, que continúa ejecutándose en el
equipo remoto. debugpy también sigue escuchando para conectar depuradores, por lo que se puede
volver a conectar al proceso en cualquier momento.
Solución de problemas de conexión
1. Asegúrese de haber seleccionado Remota de Python (debugpy) para Tipo de conexión
2. Compruebe que el secreto en Destino de la conexión coincide exactamente con el secreto en el código
remoto.
3. Compruebe que la dirección IP en Destino de la conexión coincide exactamente con la del equipo
remoto.
4. Compruebe que ha abierto el puerto de depuración remota en el equipo remoto y que ha incluido el
sufijo de puerto en el destino de la conexión, por ejemplo :5678 .
Si necesita usar un puerto diferente, puede especificarlo en listen , como en
debugpy.listen((host, port)) . En este caso, abra ese puerto concreto en el firewall.
5. Compruebe que la versión de debugpy instalada en el equipo remoto, tal como la devuelve pip3 list ,
coincide con la que usa la versión de las herramientas de Python que se usa en Visual Studio en la tabla
siguiente. Si es necesario, actualice debugpy en el equipo remoto.
VERSIÓ N DE DEB UGP Y O DE L A S H ERRA M IEN TA S DE

VERSIÓ N DE VISUA L ST UDIO PYT H ON
2019 16.6 1.0.0b5
2019 16.5 1.0.0b1

NOTE
Las versiones de Visual Studio 2019 16.0 a 16.4 usaban ptvsd, no debugpy. El proceso de este tutorial para esas versiones
es similar, pero los nombres de función son diferentes. Visual Studio 2019 16.5 usa debugpy, pero los nombres de función
eran los mismos que los de ptvsd. En lugar de listen , usaría enable_attach . En lugar de wait_for_client , usaría
wait_for_attach . En lugar de breakpoint , usaría break_into_debugger .
Uso de ptvsd 3.x para la depuración heredada

Visual Studio 2017 15.8 y versiones posteriores usan un depurador basado en ptvsd 4.1+.
Visual Studio 2019 16.5 y las versiones posteriores usan un depurador basado en debugpy. Estas versiones del
depurador son compatibles con Python 2.7 y Python 3.5+. Si usa Python 2.6, 3.1 hasta 3.4 o IronPython,
Visual Studio muestra el error El depurador no admite este entorno de Python . La siguiente información
solo se aplica a la depuración remota con ptvsd 3.x.
1. Con ptvsd 3.x, la función enable_attach que requiere que pase un "secreto" como el primer argumento
que restringe el acceso al script en ejecución. Este secreto se escribe cuando se adjunta el depurador
remoto. Aunque no se recomienda, puede permitir que cualquiera se conecte, mediante
enable_attach(secret=None) .
2. La dirección URL de destino de conexión es tcp://<secret>@<ip_address>:5678 , donde <secret> es la

cadena enable_attach que se pasa en el código de Python.
De forma predeterminada, la conexión al servidor de depuración remota de ptvsd 3.x solo está protegida por el
secreto y todos los datos se pasan como texto sin formato. Para una conexión más segura, ptvsd 3.x admite SSL
con el protocolo tcsp , que se configura de la siguiente manera:
1. En el equipo remoto, genere archivos de certificado autofirmado y de clave independientes con openssl:
openssl req -new -x509 -days 365 -nodes -out cert.cer -keyout cert.key
Cuando se le solicite, use el nombre de host o la dirección IP (lo que use para conectarse) para el
Nombre común cuando se lo solicite openssl.
(Vea Certificados autofirmados en la documentación del módulo ssl de Python para obtener más
detalles. Tenga en cuenta que en esa documentación el comando solo genera un único archivo
combinado).
2. En el código, modifique la llamada a enable_attach para incluir los argumentos certfile y keyfile
usando los nombres de archivo como valores (estos argumentos tienen el mismo significado que para la
función estándar ssl.wrap_socket de Python):
ptvsd.enable_attach(secret='my_secret', certfile='cert.cer', keyfile='cert.key')
También puede realizar el mismo cambio en el archivo de código en el equipo local, pero dado que este
código no se ejecuta realmente, no es estrictamente necesario.
3. Reinicie el programa de Python en el equipo remoto, para prepararlo para la depuración.
4. Proteja el canal agregando el certificado a la CA raíz de confianza en el equipo Windows con Visual
Studio:
a. Copie el archivo de certificado desde el equipo remoto al equipo local.
b. Abra el Panel de Control y vaya a Herramientas administrativas > Administrar cer tificados
de equipo .
c. En la ventana que aparece, expanda Entidades de cer tificación raíz de confianza en el lado
izquierdo, haga clic con el botón derecho en Cer tificados y seleccione Todas las tareas >
Impor tar .
d. Vaya al archivo .cer copiado desde el equipo remoto, selecciónelo y, después, haga clic en los cuadros
de diálogo para completar la importación.
5. Repita el proceso de asociación en Visual Studio como se ha descrito anteriormente y ahora use tcps://
como protocolo para el Destino de la conexión (o Calificador ).
6. Visual Studio le avisará sobre posibles problemas de certificado cuando se conecta a través de SSL.
Puede pasar por alto las advertencias y continuar, pero aunque el canal sigue cifrado frente a la
intercepción, puede estar abierto a ataques de tipo "Man in the middle".
a. Si ve la siguiente advertencia El cer tificado remoto no es de confianza , significa que no ha
agregado correctamente el certificado a la CA raíz de confianza. Compruebe esos pasos y vuelve a
intentarlo.
b. Si ve la siguiente advertencia El nombre del cer tificado remoto no coincide con el nombre
de host , significa que no se han usado la dirección IP o el nombre de host correctos como
Nombre común al crear el certificado.
Actualmente, Python es compatible con Azure App Service para Linux y se pueden publicar aplicaciones con la
implementación de Git y los contenedores, tal como se describe en este artículo.
NOTE
La compatibilidad de Python con Azure App Service para Windows oficialmente entró en desuso. Como resultado, el
comando Publish de Visual Studio solo se admite oficialmente para un destino de IIS y la depuración remota de Azure
App Service ya no se admite de manera oficial.
Sin embargo, las características de publicación en App Service en Windows sigue funcionando por el momento, porque las
extensiones de Python para App Service en Windows siguen disponibles, pero no se actualizarán ni atenderán.
Publicación en App Service en Linux mediante la implementación de

Git
La implementación de Git conecta una instancia de App Service en Linux con una rama específica de un
repositorio Git. La confirmación de código en esa rama se implementa de manera automática en la instancia de
App Service y App Service instala automáticamente cualquier dependencia que aparece en requirements.txt. En
este caso, App Service en Linux ejecuta el código en una imagen de contenedor configurada previamente que
usa el servidor web Gunicorn. Actualmente, este servicio está en versión preliminar y no es compatible con su
uso en producción.
Para más información, consulte los artículos siguientes en la documentación de Azure:
Inicio rápido: Creación de una aplicación web de Python en Azure App Service brinda un breve tutorial del
proceso de implementación de Git mediante una aplicación Flask sencilla e implementación desde un
repositorio Git local.
El artículo sobre cómo configurar Python describe las características del contenedor de App Service en Linux
y cómo personalizar el comando de inicio de Gunicorn para la aplicación.
Publicación en App Service en Linux mediante los contenedores

En lugar de confiar en el contenedor creado previamente con App Service en Linux, puede proporcionar su
propio contenedor. Esta opción permite elegir qué servidores web se usarán y personalizar el comportamiento
del contenedor.
Existen dos opciones para crear, administrar e insertar contenedores:
Use Visual Studio Code y las extensiones de Docker, tal como se describe en el artículo sobre la
implementación de Python con contenedores de Docker. Incluso si no usa Visual Studio Code, en el
artículo se proporcionan detalles útiles sobre cómo compilar imágenes de contenedor para aplicaciones
de Flask o Django con los servidores web uwsgi y nginx preparados para el entorno de producción.
Luego puede implementar esos mismos contenedores con la CLI de Azure.
Use la línea de comandos y la CLI de Azure, tal como se describe en este artículo sobre el uso de una
imagen personalizada de Docker de la documentación de Azure. Esta guía es genérica, pero no específica
para Python.
Publicación en IIS
Desde Visual Studio, puede publicar en una máquina virtual Windows u otro equipo compatible con IIS con el
comando Publish . Cuando use IIS, asegúrese de crear o modificar un archivo web.config en la aplicación que
indique a IIS dónde encontrar el intérprete de Python. Para más información, consulte el artículo sobre cómo
configurar aplicaciones web para IIS.
Los módulos escritos en C++ (o C) se usan normalmente para ampliar las funciones de un intérprete de Python.
También se usan para habilitar el acceso a las funcionalidades de sistema operativo de bajo nivel.
Hay tres tipos principales de módulos:
Módulos de acelerador : como Python es un lenguaje interpretado, puede escribir módulos de acelerador
en C++ para un mayor rendimiento.
Módulos de contenedor : exponen las interfaces de C o C++ existentes a código de Python, o bien exponen
una API más propia de Python que se pueda usar fácilmente con este código.
Módulos de acceso al sistema de bajo nivel : puede crear estos módulos para acceder a características
de bajo nivel del tiempo de ejecución de CPython , el sistema operativo o el hardware subyacente.
Este artículo le guía por la compilación de un módulo de extensión de C++ para CPython que calcula la
tangente hiperbólica y la llama desde código de Python. Primero, se implementa la rutina en Python para
demostrar la mejora relativa del rendimiento de la implementación de la misma rutina en C++.
En este artículo también se muestran dos formas de hacer que la extensión de C++ esté disponible para Python:
Usar las extensiones de CPython estándar, como se describe en la documentación de Python.
Usar PyBind11, que es la recomendación para C++11 debido a su sencillez.
Encontrará el ejemplo completo de este tutorial en GitHub, en python-samples-vs-cpp-extension.
Prerrequisitos
Visual Studio 2017 o posterior, con la carga de trabajo Desarrollo de Python instalada. La carga de trabajo
incluye las herramientas de desarrollo nativas de Python, que proporcionan la carga de trabajo de C++ y
los conjuntos de herramientas necesarios para las extensiones nativas.
NOTE
Al instalar la carga de trabajo Aplicaciones de ciencia de datos y de análisis , se instalan de forma
predeterminada Python y la opción Herramientas de desarrollo nativo de Python .
Para obtener más información sobre las opciones de instalación, vea Instalación de la compatibilidad con Python
en Visual Studio. Si instala Python por separado, asegúrese de seleccionar Download debugging symbols
(Descargar símbolos de depuración) en Opciones avanzadas en el programa de instalación. Esta opción es
necesaria para usar la depuración en modo mixto entre el código de Python y el código nativo.
Crear la aplicación de Python

1. Cree un proyecto de Python en Visual Studio. Para ello, seleccione Archivo > Nuevo > Proyecto .
Busque Python , seleccione la plantilla Aplicación de Python , escriba un nombre y una ubicación, y
seleccione Aceptar .
2. En el archivo .py del proyecto, pegue el código siguiente. Para experimentar algunas de las características
de edición de Python, pruebe a escribir el código manualmente.
Este código calcula una tangente hiperbólica sin usar la biblioteca matemática, y es lo que se acelerará
con las extensiones nativas.
TIP
Escriba el código en Python puro antes de volver a escribirlo en C++. De este modo, puede comprobar más
fácilmente que el código nativo es correcto.
from random import random

from time import perf_counter
COUNT = 500000 # Change this value depending on the speed of your computer
DATA = [(random() - 0.5) * 3 for _ in range(COUNT)]
e = 2.7182818284590452353602874713527
def sinh(x):
return (1 - (e ** (-2 * x))) / (2 * (e ** -x))
def cosh(x):
return (1 + (e ** (-2 * x))) / (2 * (e ** -x))
def tanh(x):
tanh_x = sinh(x) / cosh(x)
return tanh_x
def test(fn, name):

start = perf_counter()
result = fn(DATA)
duration = perf_counter() - start
print('{} took {:.3f} seconds\n\n'.format(name, duration))
for d in result:
assert -1 <= d <= 1, " incorrect values"
if __name__ == "__main__":
print('Running benchmarks with COUNT = {}'.format(COUNT))
test(lambda d: [tanh(x) for x in d], '[tanh(x) for x in d] (Python implementation)')
3. Para ver los resultados, seleccione Depurar > Iniciar sin depurar o presione Ctrl+F5 para ejecutar el
programa.
Puede ajustar la variable COUNT para cambiar el tiempo que tarda en ejecutarse la prueba comparativa.
Para los fines de este tutorial, establezca el contador para que la prueba comparativa tarde
aproximadamente dos segundos.
TIP
Al ejecutar pruebas comparativas, use siempre Depurar > Iniciar sin depurar . Esto ayuda a evitar la sobrecarga
que se genera al ejecutar el código dentro del depurador de Visual Studio.
Crear los proyectos principales de C++

Siga las instrucciones de esta sección para crear dos proyectos de C++ idénticos, superfastcode y
superfastcode2. Más adelante, usará un enfoque distinto en cada proyecto para exponer el código de C++ en
Python.
1. En el Explorador de soluciones , haga clic con el botón derecho en la solución y seleccione Agregar >
Nuevo proyecto . Una solución de Visual Studio puede contener proyectos de Python y C++, una de las
ventajas de utilizar Visual Studio para Python.
2. Busque C++ , seleccione Proyecto vacío , especifique superfastcode para el primer proyecto o
superfastcode2 para el segundo y, después, seleccione Aceptar .
TIP
Como alternativa, con las herramientas de desarrollo nativo de Python instaladas en Visual Studio, puede
comenzar con la plantilla Módulo de extensión de Python. La plantilla ya incluye gran parte de lo que se describe a
continuación.
En este tutorial partiremos de un proyecto vacío para mostrar la compilación del módulo de extensión paso a
paso. Después de comprender el proceso, puede usar la plantilla para ahorrar tiempo cuando escriba extensiones
propias.
3. Para crear un archivo de C++ en el nuevo proyecto, haga clic con el botón derecho en el nodo Archivos
de origen y, después, seleccione Agregar > Nuevo elemento .
4. Seleccione Archivo de C++ , asígnele el nombre module.cpp y, después, seleccione Aceptar .
IMPORTANT
Para activar las páginas de propiedades de C++ en los pasos siguientes, es necesario un archivo con la extensión
.cpp.
5. En la barra de herramientas principal, use el menú desplegable para realizar una de las acciones
siguientes:
Para un entorno de ejecución de Python de 64 bits, active la configuración de x64 .
Para un entorno de ejecución de Python de 32 bits, active la configuración de Win32 .
6. En el Explorador de soluciones , haga clic con el botón derecho en el proyecto de C++, seleccione
Propiedades y, después, haga lo siguiente:
a. En Configuración , escriba Activo (Depurar) .
b. En Plataforma , escriba Activo (x64) o Activo (Win32) , en función de la selección del paso anterior.
NOTE
Al crear proyectos propios, querrá establecer las configuraciones de depuración y versión. En esta unidad, solo se
configura la configuración de depuración y se establece para usar una compilación de versión de CPython. Esta
configuración deshabilita algunas características de depuración del tiempo de ejecución de C++, incluidas las
aserciones. Para usar archivos binarios de depuración de CPython (python_d.exe) se necesita otra configuración.
7. Establezca las propiedades como se describe en la tabla siguiente:
P ESTA Ñ A P RO P IEDA D VA LO R
General Nombre de destino Especifique el nombre del módulo

para hacerle referencia desde
Python en las instrucciones
from...import . Use este mismo
nombre en el código de C++ al
definir el módulo para Python. Para
usar el nombre del proyecto como
nombre del módulo, deje el valor
predeterminado $<ProjectName>
. Para python_d.exe , agregue _d
al final del nombre.
Tipo de configuración Biblioteca dinámica (.dll)
Opciones avanzadas > .pyd

Extensión de archivo de
destino
Valores predeterminados del Biblioteca dinámica (.dll)

proyecto > Tipo de
configuración
C/C++ > General Directorios de inclusión Agregue la carpeta include de

adicionales Python según sea necesario para la
instalación (por ejemplo,
c:\Python36\include ).
C/C++ > Preprocesador Definiciones de preprocesador Si está presente, cambie el valor

_DEBUG por NDEBUG para que
coincida con la versión que no es de
depuración de CPython. Si usa
python_d.exe, no cambie este valor.
C/C++ > Generación de código Biblioteca en tiempo de DLL multiproceso (/MD) para
ejecución que coincida con la versión que no
es de depuración de CPython. Si usa
python_d.exe, deje este valor como
DLL de depuración
multiproceso (/MDd) .
Enlazador > General Directorios de bibliotecas Agregue la carpeta libs de Python

adicionales que contiene archivos .lib según sea
necesario para la instalación (por
ejemplo, c:\Python36\libs).
Asegúrese de apuntar a la carpeta
libs que contiene los archivos .lib, y
no a la carpeta Lib que contiene los
archivos .py.
General General > Nombre de destino Especifique el nombre del módulo

para hacerle referencia desde
Python en las instrucciones
from...import . Use este mismo
nombre en el código de C++ al
definir el módulo para Python. Para
usar el nombre del proyecto como
nombre del módulo, deje el valor
predeterminado $<ProjectName>
. Para python_d.exe , agregue _d
al final del nombre.
General > Extensión de destino .pyd
Valores predeterminados del Biblioteca dinámica (.dll)

proyecto > Tipo de
configuración
C/C++ > General Directorios de inclusión Agregue la carpeta include de

adicionales Python según sea necesario para la
instalación; (por ejemplo,
c:\Python36\include).
C/C++ > Preprocesador Definiciones de preprocesador Si está presente, cambie el valor

_DEBUG por NDEBUG para que
coincida con la versión que no es de
depuración de CPython . Cuando
use python_d.exe , deje este valor
sin cambios.
C/C++ > Generación de código Biblioteca en tiempo de DLL multiproceso (/MD) para
ejecución que coincida con la versión que no
es de depuración de CPython .
Cuando use python_d.exe , deje
este valor sin cambios.
Enlazador > General Directorios de bibliotecas Agregue la carpeta libs de Python

adicionales que contiene archivos .lib según sea
necesario para la instalación (por
ejemplo, c:\Python36\libs).
Asegúrese de apuntar a la carpeta
libs que contiene los archivos .lib, y
no a la carpeta Lib que contiene los
archivos .py.
NOTE
Si la pestaña C/C++ no se muestra en las propiedades del proyecto, el proyecto no contiene ningún archivo que
identifique como archivos de código fuente de C/C++. Esta condición se puede producir si crea un archivo de
código fuente sin una extensión .c o .cpp.
Por ejemplo, si ha escrito accidentalmente module.coo en lugar de module.cpp en el anterior cuadro de diálogo
Nuevo elemento, Visual Studio crea el archivo, pero no establece el tipo de archivo en Código de C/C++ , que es
lo que activa la pestaña de propiedades de C/C++. Este error de identificación se mantiene incluso si cambia el
nombre del archivo con una extensión .cpp.
Para establecer el tipo de archivo correctamente, haga clic con el botón derecho en el archivo en el Explorador
de soluciones y seleccione Propiedades . Después, en Tipo de archivo , seleccione Código de C/C++ .
8. Seleccione Aceptar .
9. Para probar las configuraciones (tanto de Depuración como de Versión), haga clic con el botón derecho
en el proyecto de C++ y seleccione Compilar .
Encontrará los archivos .pyd en la carpeta solution de Depuración y Versión, no en la carpeta del proyecto
de C++.
10. Agregue el código siguiente al archivo module.cpp del proyecto de C++:
#include <Windows.h>
#include <cmath>
const double e = 2.7182818284590452353602874713527;
double sinh_impl(double x) {
return (1 - pow(e, (-2 * x))) / (2 * pow(e, -x));
}
double cosh_impl(double x) {
return (1 + pow(e, (-2 * x))) / (2 * pow(e, -x));
}
double tanh_impl(double x) {
return sinh_impl(x) / cosh_impl(x);
}
11. Compile el proyecto de C++ para confirmar que el código es correcto.

12. Si todavía no lo ha hecho, repita los pasos anteriores para crear un segundo proyecto denominado
superfastcode2 con una configuración idéntica.
Convertir los proyectos de C++ en extensiones para Python

Para convertir el archivo DLL de C++ en una extensión para Python, primero debe modificar los métodos
exportados para que interactúen con tipos de Python. Después, debe agregar una función que exporte el
módulo, junto con las definiciones de los métodos del módulo.
En las secciones siguientes se explica cómo realizar estos pasos con las extensiones CPython y PyBind11.
Uso de las extensiones CPython
Para obtener más información sobre el código que se muestra en esta sección, vea el Manual de referencia de la
API de Python/C y, en concreto, la página Objetos de módulo. Asegúrese de seleccionar la versión de Python en
la lista desplegable de la esquina superior derecha.
1. En la parte superior del archivo module.cpp, incluya Python.h:
#include <Python.h>
2. Modifique el método tanh_impl para aceptar y devolver tipos de Python (es decir, PyObject* ):
PyObject* tanh_impl(PyObject* /* unused module reference */, PyObject* o) {

double x = PyFloat_AsDouble(o);
double tanh_x = sinh_impl(x) / cosh_impl(x);
return PyFloat_FromDouble(tanh_x);
}
3. Agregue una estructura que defina la manera en que la función tanh_impl de C++ se muestra en
Python:
static PyMethodDef superfastcode_methods[] = {

// The first property is the name exposed to Python, fast_tanh
// The second is the C++ function with the implementation
// METH_O means it takes a single PyObject argument
{ "fast_tanh", (PyCFunction)tanh_impl, METH_O, nullptr },
// Terminate the array with an object containing nulls.

{ nullptr, nullptr, 0, nullptr }
};
4. Agregue una estructura que defina el módulo como quiera que se haga referencia a él en el código de
Python, en concreto cuando use la instrucción from...import .
El nombre que se importa en este código debe coincidir con el valor de las propiedades del proyecto en
Propiedades de configuración > General > Nombre del destino .
En el ejemplo siguiente, el nombre de módulo "superfastcode" significa que puede usar
from superfastcode import fast_tanh en Python, porque fast_tanh se define en superfastcode_methods .
Los nombres de archivo que son internos del proyecto de C++, como module.cpp, no son esenciales.
static PyModuleDef superfastcode_module = {

PyModuleDef_HEAD_INIT,
"superfastcode", // Module name to use with Python import statements
"Provides some functions, but faster", // Module description
0,
superfastcode_methods // Structure that defines the methods of the module
};
5. Agregue un método al que Python llame cuando cargue el módulo, que debe denominarse
PyInit_<module-name> , donde <module-name> coincide exactamente con la propiedad General >
Nombre de destino del proyecto de C++. Es decir, coincide con el nombre del archivo .pyd creado por
el proyecto.
PyMODINIT_FUNC PyInit_superfastcode() {
return PyModule_Create(&superfastcode_module);
}
6. Compile de nuevo el proyecto de C++ para verificar el código. Si se producen errores, vea la sección
"Solución de problemas".
Uso de PyBind11
Si ha completado los pasos descritos en la sección anterior, sin duda ha observado que usa una gran cantidad
de código reutilizable para crear las estructuras de módulo necesarias para el código de C++. PyBind11
simplifica el proceso mediante macros en un archivo de encabezado de C++ que consigue el mismo resultado,
pero con mucho menos código.
Para obtener más información sobre el código de esta sección, vea Conceptos básicos de PyBind11.
1. Instale PyBind11 mediante pip: pip install pybind11 o py -m pip install pybind11 .
Como alternativa, puede instalar PyBind11 con la ventana Entornos de Python y, después, usar su
comando Abrir en PowerShell para el paso siguiente.
2. En el mismo terminal, ejecute python -m pybind11 --includes o py -m pybind11 --includes .
Esto imprime una lista de rutas de acceso que debe agregar a la propiedad C/C++ > General >
Directorios de inclusión adicionales del proyecto. Asegúrese de quitar el prefijo -I , si está presente.
3. En la parte superior de un archivo module.cpp nuevo que no incluya ninguno de los cambios de la
sección anterior, incluya pybind11.h:
#include <pybind11/pybind11.h>
4. En la parte inferior de module.cpp, use la macro PYBIND11_MODULE para definir el punto de entrada a la
función de C++:
namespace py = pybind11;
PYBIND11_MODULE(superfastcode2, m) {
m.def("fast_tanh2", &tanh_impl, R"pbdoc(
Compute a hyperbolic tangent of a single argument expressed in radians.
)pbdoc");
#ifdef VERSION_INFO
m.attr("__version__") = VERSION_INFO;
#else
m.attr("__version__") = "dev";
#endif
}
5. Compile el proyecto de C++ para verificar el código. Si se producen errores, vea la sección siguiente,
"Solución de problemas de compilación", para obtener soluciones.
Solución de problemas de compilación
Es posible que se produzca un error de compilación en el módulo de C++ por las razones siguientes:
Error: No se puede encontrar Python.h (E1696: no se puede abrir el archivo de código fuente
"Python.h" o C1083: No se puede abrir el archivo de inclusión: "Python.h": no existe en
archivo o directorio )
Solución: compruebe que la ruta de acceso de C/C++ > General > Directorios de inclusión
adicionales de las propiedades del proyecto apunta a la carpeta include de la instalación de Python.
Consulte el paso 6 en Crear el proyecto de C++ principal.
Error: No se pueden encontrar las bibliotecas de Python
Solución: compruebe que la ruta de acceso de C/C++ > General > Directorios de biblioteca
adicionales de las propiedades del proyecto apunta a la carpeta libs de la instalación de Python.
Consulte el paso 6 en Crear el proyecto de C++ principal.
Errores del enlazador relacionados con la arquitectura de destino
Solución: cambie la arquitectura del proyecto del destino de C++ para que coincida con la de la
instalación de Python. Por ejemplo, si el destino es Win32 con el proyecto de C++, pero la instalación de
Python es de 64 bits, cambie el proyecto de C++ a x64.
Probar el código y comparar los resultados

Ahora que tiene los archivos DLL estructurados como extensiones de Python, puede hacerles referencia desde el
proyecto de Python, importar los módulos y usar sus métodos.
Poner el archivo DLL a disposición de Python
Puede hacer que el archivo DLL esté disponible para Python de varias maneras. Estos son dos enfoques que se
deben tener en cuenta:
Este primer método funciona si el proyecto de Python y el de C++ se encuentran en la misma solución.
Haga lo siguiente:
1. En el Explorador de soluciones , haga clic con el botón derecho en el nodo Referencias del
proyecto de Python y, después, seleccione Agregar referencia .
2. En el cuadro de diálogo que aparecerá, seleccione la pestaña Proyectos , los proyectos
superfastcode y superfastcode2 y Aceptar .
Un método alternativo instala el módulo en el entorno de Python, lo que hace que el módulo también
esté disponible para otros proyectos de Python. Para obtener más información, vea la Documentación del
proyecto setuptools . Haga lo siguiente:
1. Cree un archivo denominado setup.py en el proyecto de C++; para ello, haga clic con el botón
derecho en el proyecto y seleccione Agregar > Nuevo elemento .
2. Seleccione Archivo de C++ (.cpp) , asigne el nombre setup.py al archivo y, después, seleccione
Aceptar .
Al asignar un nombre al archivo con la extensión .py, Visual Studio lo reconoce como un archivo
de Python a pesar del uso de la plantilla de archivo de C++.
Cuando el archivo aparezca en el editor, pegue el código siguiente en él, en función de lo que
corresponda al método de extensión:
Para las extensiones de CPython (proyecto superfastcode) :
from setuptools import setup, Extension
sfc_module = Extension('superfastcode', sources = ['module.cpp'])
setup(
name='superfastcode',
version='1.0',
description='Python Package with superfastcode C++ extension',
ext_modules=[sfc_module]
)
Para PyBind11 (proyecto superfastcode2) :
from setuptools import setup, Extension

import pybind11
cpp_args = ['-std=c++11', '-stdlib=libc++', '-mmacosx-version-min=10.7']
sfc_module = Extension(
'superfastcode2',
sources=['module.cpp'],
include_dirs=[pybind11.get_include()],
language='c++',
extra_compile_args=cpp_args,
)
setup(
name='superfastcode2',
version='1.0',
description='Python package with superfastcode2 C++ extension (PyBind11)',
ext_modules=[sfc_module],
)
3. Cree un segundo archivo denominado pyproject.toml en el proyecto de C++ y pegue el código

siguiente en él:
[build-system]
requires = ["setuptools", "wheel", "pybind11"]
build-backend = "setuptools.build_meta"
4. Para compilar la extensión, haga clic con el botón derecho en la pestaña pyproject.toml abierta y,
después, seleccione Copiar ruta de acceso completa . Eliminará el nombre pyproject.toml de la
ruta de acceso antes de usarla.
5. En el Explorador de soluciones , haga clic con el botón derecho en el entorno de Python activo y
seleccione Administrar paquetes de Python .
TIP
Si ya ha instalado el paquete, verá que aparece aquí. Antes de continuar, haga clic en la X para
desinstalarlo.
6. En el cuadro de búsqueda, pegue la ruta de acceso copiada, elimine pyproject.toml de la parte final
y, después, presione Entrar para instalar el módulo desde ese directorio.
TIP
Si se produce un error en la instalación debido a un error de permisos, agregue --user al final y vuelva a
probar el comando.
Llamar al archivo DLL desde Python

Una vez que el archivo DLL está disponible para Python, como se ha descrito en la sección anterior, puede llamar
a las funciones superfastcode.fast_tanh y superfastcode2.fast_tanh2 desde el código de Python y comparar su
rendimiento con la implementación de Python. Para llamar al archivo DLL, haga lo siguiente:
1. Agregue las líneas siguientes en el archivo .py para llamar a los métodos que se han exportado desde los
archivos DLL y mostrar sus salidas:
from superfastcode import fast_tanh

test(lambda d: [fast_tanh(x) for x in d], '[fast_tanh(x) for x in d] (CPython C++ extension)')
from superfastcode2 import fast_tanh2

test(lambda d: [fast_tanh2(x) for x in d], '[fast_tanh2(x) for x in d] (PyBind11 C++ extension)')
2. Para ejecutar el programa de Python, seleccione Depurar > Iniciar sin depurar o presione Ctrl+F5.
NOTE
Si el comando Iniciar sin depurar está deshabilitado, haga clic con el botón derecho en el proyecto de Python
en el Explorador de soluciones y seleccione Establecer como proyecto de inicio .
Observe que las rutinas de C++ se ejecutan aproximadamente de cinco a veinte veces más rápido que la
implementación de Python. El resultado típico se muestra de la manera siguiente:
Running benchmarks with COUNT = 500000

[tanh(x) for x in d] (Python implementation) took 0.758 seconds
[fast_tanh(x) for x in d] (CPython C++ extension) took 0.076 seconds
[fast_tanh2(x) for x in d] (PyBind11 C++ extension) took 0.204 seconds
3. Intente aumentar la variable COUNT para que las diferencias sean más pronunciadas.
Una compilación de depuración del módulo de C++ también se ejecuta de forma más lenta que una
compilación de versión, ya que la de depuración está menos optimizada y contiene varias
comprobaciones de errores. No dude en cambiar entre esas configuraciones para ver la comparación,
pero recuerde volver y actualizar las propiedades que ha establecido antes para la configuración de
versión.
En la salida, es posible que vea que la extensión de PyBind11 no es tan rápida como la de CPython, aunque
debería ser mucho más rápida que la implementación pura de Python. Esta diferencia se debe en gran medida a
que ha usado la llamada METH_O , que no admite varios parámetros, nombres de parámetros o argumentos de
palabras clave. PyBind11 genera código ligeramente más complejo para proporcionar a los autores de la
llamada una interfaz más similar a Python. Pero como el código de prueba llama 500 000 veces a la función, es
posible que los resultados aumenten considerablemente esa sobrecarga.
Podría reducir todavía más la sobrecarga si mueve el bucle for al código nativo. Este enfoque supondría usar
el protocolo de iterador (o el tipo py::iterable de PyBind11 para el parámetro de función) a fin de procesar
cada elemento. Quitar las transiciones repetidas entre Python y C++ es una manera eficaz de reducir el tiempo
que se necesita para procesar la secuencia.
Solución de problemas de importación
Si recibe un mensaje ImportError al intentar importar el módulo, puede resolverlo de una de las maneras
siguientes:
Al realizar la compilación mediante una referencia de proyecto, asegúrese de que las propiedades del
proyecto de C++ coincidan con el entorno de Python activado para el proyecto de Python, especialmente
los directorios Include y Library.
Asegúrese de que el archivo de salida se denomina superfastcode.pyd. Cualquier otro nombre o
extensión impedirá que se importe.
Si ha instalado el módulo mediante el archivo setup.py, compruebe que ha ejecutado el comando pip en
el entorno de Python activado para el proyecto de Python. Al expandir el entorno de Python en el
Explorador de soluciones se debe mostrar una entrada para superfastcode.
Depurar el código de C++

Visual Studio admite la depuración de código Python y C++ de forma conjunta. En esta sección, recorrerá el
proceso mediante el proyecto superfastcode. El proceso es el mismo para el proyecto superfastcode2.
1. En el Explorador de soluciones , haga clic con el botón derecho en el proyecto de Python, seleccione
Propiedades , elija la pestaña Depurar y, después, seleccione la opción Depurar > Habilitar
depuración de código nativo .
TIP
Al habilitar la depuración de código nativo, la ventana de salida de Python podría cerrarse de inmediato al
completarse el programa, sin ofrecer la pausa habitual Presione cualquier tecla para continuar .
Solución: para forzar una pausa después de habilitar la depuración de código nativo, agregue la opción -i al
campo Ejecutar > Argumentos del intérprete de la pestaña Depurar . Este argumento coloca el intérprete de
Python en modo interactivo después de ejecutar el código, momento en el que espera a que presione Ctrl+Z y
después Entrar para cerrar la ventana.
Como alternativa, si no le importa modificar el código de Python, puede agregar instrucciones import os y
os.system("pause") al final del programa. Este código duplica la petición de pausa original.
2. Seleccione Archivo > Guardar para guardar los cambios de propiedad.

3. En la barra de herramientas de Visual Studio, establezca la configuración de compilación en Depuración .
4. Como normalmente el código tarda más tiempo en ejecutarse en el depurador, puede que le interese
cambiar la variable COUNT del archivo .py por un valor que sea unas cinco veces más pequeño que el
predeterminado. Por ejemplo, puede cambiarlo de 500 000 a 100 000 .
5. En el código de C++, establezca un punto de interrupción en la primera línea del método tanh_impl y,
después, presione F5 o seleccione Depurar > Iniciar depuración para iniciar el depurador.
El depurador se detendrá cuando se llame al punto de interrupción. Si no se alcanza el punto de
interrupción, compruebe que la configuración esté establecida en Depuración y que ha guardado el
proyecto, lo que no se realiza automáticamente al iniciar al depurador.
6. En el punto de interrupción, puede ejecutar paso a paso el código de C++, examinar las variables, etc.
Para obtener más información sobre estas características, vea Depuración conjunta de Python y C++.
Enfoques alternativos
Existen diversos métodos para crear extensiones de Python, como se describe en la tabla siguiente. En este
artículo se describen las dos primeras filas, CPython y PyBind11 .
EN F O Q UE VIN TA GE USUA RIO S REP RESEN TAT IVO S
Módulos de extensión de C/C++ para 1991 biblioteca estándar

CPython
PyBind11 (recomendado para C++) 2015
Cython (recomendado para C) 2007 gevent, kivy
HPy 2019
mypyc 2017
ctypes 2003 oscrypto
cffi 2013 cryptography, pypy
SWIG 1996 crfsuite
Boost.Python 2002
cppyy 2017
Consulte también
Encontrará el ejemplo completo de este tutorial en GitHub, en python-samples-vs-cpp-extension.
Depurar Python y C++ de forma conjunta
La mayoría de los depuradores normales de Python admiten la depuración de código de Python exclusivamente.
En la práctica, sin embargo, Python se usa junto con C o C++ en escenarios que requieren alto rendimiento o la
posibilidad de invocar directamente las API de plataforma. (Vea Creación de una extensión de C++ para Python
para obtener un tutorial).
Visual Studio proporciona depuración en modo mixto simultánea e integrada para Python y C o C++ nativo.
Para usar esta función, seleccione la opción Herramientas de desarrollo nativo Python para la carga de
trabajo Desarrollo de Python en el instalador de Visual Studio.
NOTE
La depuración en modo mixto no está disponible con Herramientas de Python para Visual Studio 1.x en Visual Studio
2015 y versiones anteriores.
Las características de depuración en modo mixto incluyen las siguientes opciones, tal y como se explica en este
artículo:
Pilas de llamadas combinada
Transición entre código de Python y nativo
Puntos de interrupción en ambos tipos de código
Vea las representaciones de Python de objetos en marcos nativos y viceversa.
Depuración en el ámbito de los proyectos de Python o C++
Para obtener una introducción a la compilación, las pruebas y la depuración de módulos de C nativos
con Visual Studio, vea Deep Dive: Create Native Modules (Profundización: Creación de módulos nativos)
(youtube.com, 9 minutos 09 segundos). El vídeo se aplica a Visual Studio 2015 y 2017.
Habilitación de la depuración en modo mixto en un proyecto de

Python
1. Haga clic con el botón derecho en el proyecto de Python en el Explorador de soluciones , seleccione
Propiedades , seleccione la pestaña Depurar y luego Habilitar depuración de código nativo . Esta
opción habilita el modo mixto para todas las sesiones de depuración.
TIP
Cuando se habilita la depuración de código nativo, la ventana de resultados de Python podría desaparecer de
inmediato al completarse el programa, sin ofrecer la pausa habitual Presione cualquier tecla para continuar .
Para forzar una pausa, agregue la opción -i al campo Ejecutar > Argumentos del intérprete en la pestaña
Depurar al habilitar la depuración de código nativo. Este argumento coloca al intérprete de Python en modo
interactivo cuando finaliza el código, momento en que espera a que presione Ctrl+Z > Entrar para salir.
2. Al asociar el depurador en modo mixto a un proceso existente (Depurar > Asociar al proceso ), use el
botón Seleccionar para abrir el cuadro de diálogo Seleccionar tipo de código . A continuación,
establezca la opción Depurar estos tipos de código y seleccione Nativo y Python en la lista:
La configuración del tipo de código es permanente, por lo que si quiere deshabilitar la depuración en
modo mixto cuando asocie a otro proceso más adelante, borre el tipo de código Python .
Es posible seleccionar otros tipos de código además de Nativo , o en lugar de este. Por ejemplo, si una
aplicación administrada hospeda CPython, que, a su vez, usa módulos de extensión nativa, y desea
depurar los tres, puede activar Python , Nativo y Administrado juntos para obtener una experiencia de
depuración unificada que incluye pilas de llamadas combinadas y transición entre los tres tipos de
tiempos de ejecución.
3. Al iniciar la depuración en modo mixto por primera vez, es posible que vea un cuadro de diálogo Se
necesitan símbolos de Python (consulte Símbolos para la depuración en modo mixto). Debe instalar
los símbolos solo una vez para cualquier entorno de Python. Los símbolos se incluyen automáticamente
si instala la compatibilidad con Python mediante el instalador de Visual Studio (Visual Studio 2017 y
versiones posteriores).
4. Para que el código fuente de Python estándar esté disponible durante la depuración, visite
https://www.python.org/downloads/source/, descargue el archivo correspondiente a la versión y
extráigalo en una carpeta. Después, apunte Visual Studio a los archivos específicos de esa carpeta en el
momento en el que se le pida.
Habilitación de la depuración en modo mixto en un proyecto de C o

C++
Visual Studio (2017 versión 15.5 y posteriores) admite la depuración en modo mixto desde un proyecto de C o
C++ (por ejemplo, al insertar Python en otra aplicación, tal y como se describe en python.org). Para habilitar la
depuración en modo mixto, configure el proyecto de C o C++ para que inicie Depuración nativa/Python :
1. Haga clic con el botón derecho en el proyecto de C o C++ en el Explorador de soluciones y seleccione
Propiedades .
2. Haga clic en la pestaña Depuración , Depuración nativa/Python en Depurador para iniciar y haga
clic en Aceptar .
NOTE
Si no tiene la opción de seleccionar Depuración nativa/Python , debe instalar en primer lugar las herramientas de
desarrollo nativo de Python mediante el instalador de Visual Studio. Lo encontrará como opción en la carga de
trabajo de desarrollo de Python. Para obtener información adicional, consulte Instalación de la compatibilidad con Python
en Visual Studio en Windows.
Con este método, tenga en cuenta que no se puede depurar el propio iniciador py.exe, ya que genera un proceso
secundario python.exe al que no se asocia el depurador. Si quiere iniciar python.exe directamente con
argumentos, cambie la opción Comando de las propiedades de Depuración nativa/Python (se muestra en la
imagen anterior) para especificar la ruta de acceso completa a python.exe. Luego especifique los argumentos en
Argumentos de comandos .
Asociación del depurador en modo mixto
En todas las versiones anteriores de Visual Studio, la depuración en modo mixto directa está habilitada solo al
iniciar un proyecto de Python en Visual Studio, ya que los proyectos de C o C++ solo usan el depurador nativo.
Sin embargo, puede asociar el depurador por separado:
1. Inicie el proyecto de C++ sin depurar (Depurar > Iniciar sin depurar o Ctrl +F5 ).
2. Seleccione Depurar > Asociar al proceso . En el cuadro de diálogo que aparece, seleccione el proceso
adecuado y después use el botón Seleccionar para abrir el cuadro de diálogo Seleccionar tipo de
código , donde puede seleccionar Python :
3. Seleccione Aceptar para cerrar ese cuadro de diálogo y, después, seleccione Asociar para iniciar el
depurador.
4. Puede que necesite especificar una pausa adecuada o un retraso en la aplicación de C++ para garantizar
que no llama al código de Python que quiere depurar antes de que pueda asociar el depurador.
Características específicas del modo mixto

Pila de llamadas combinada
Vista de valores PyObject en código nativo
Vista de valores nativos en el código de Python
Pila de llamadas combinada
La ventana Pila de llamadas muestra marcos de pila nativos y de Python intercalados, con marcas de
transiciones entre los dos:
Las transiciones aparecen como [Código externo] , sin especificar la dirección de la transición, siempre que la
opción Herramientas > Opciones > Depuración > General > Habilitar Solo mi código esté establecida.
Al hacer doble clic en cualquier marco de llamada se vuelve activo y se abre el código fuente adecuado, si está
disponible. Si el código fuente no está disponible, el marco sigue activo y se pueden inspeccionar las variables
locales.
Cuando se usan los comandos Depurar paso a paso por instrucciones (F11 ) o Paso a paso para salir
(Mayús +F11 ), el depurador en modo mixto controla correctamente los cambios entre tipos de código. Por
ejemplo, cuando Python llama a un método de un tipo que está implementado en C, al depurar paso a paso por
instrucciones en una llamada a ese método, se detiene al comienzo de la función nativa que implementa el
método. Igualmente, cuando se llama a alguna función de API de Python mediante código nativo, se invoca
código de Python. Por ejemplo, la depuración paso a paso por instrucciones de PyObject_CallObject en un valor
de función que se definió originalmente en Python, se detiene al comienzo de la función de Python. También es
posible pasar de código de Python a nativo para funciones nativas invocadas desde Python mediante ctypes.
Vista de valores PyObject en código nativo
Cuando está activo un marco nativo (C o C++), sus variables locales se muestran en la ventana Variables
locales del depurador. En los módulos de extensión nativa de Python, muchas de estas variables son de tipo
PyObject (que es una declaración typedef para _object ), o algunos otros tipos de Python fundamentales (vea
la lista siguiente). En la depuración en modo mixto, estos valores presentan un nodo secundario adicional con la
etiqueta [Vista de Python] . Cuando se expande, este nodo muestra la representación de Python de la variable,
idéntica a lo que vería si una variable local que hace referencia al mismo objeto estuviera presente en un marco
de Python. Los elementos secundarios de este nodo son editables.
Para deshabilitar esta característica, haga clic con el botón derecho en cualquier parte de la ventana Variables
locales y cambie la opción de menú Python > Mostrar nodos de vista de Python :
Tipos de C que muestran nodos [Vista de Python] (si está habilitada esta característica):
PyObject
PyVarObject
PyTypeObject
PyByteArrayObject
PyBytesObject
PyTupleObject
PyListObject
PyDictObject
PySetObject
PyIntObject
PyLongObject
PyFloatObject
PyStringObject
PyUnicodeObject
[Vista de Python] no aparece automáticamente para los tipos que crea el usuario. Al crear extensiones para
Python 3.x, esto no suele ser un problema, ya que cualquier objeto tiene en última instancia un campo ob_base
de uno de los tipos anteriores, lo que hace que aparezca [Vista de Python] .
Para Python 2.x, sin embargo, cada tipo de objeto declara normalmente su encabezado como una colección de
campos insertados y no hay ninguna asociación entre los tipos personalizados creados y PyObject en el nivel
de sistema de tipos en código de C o C++. Para habilitar los nodos [Vista de Python] para dichos tipos
personalizados, edite el archivo PythonDkm.natvis en el directorio de instalación de herramientas de Python y
agregue otro elemento en el código XML para el struct de C o la clase de C++.
Una opción alternativa (y mejor) es seguir PEP 3123 y usar un campo PyObject ob_base; explícito en lugar de
PyObject_HEAD , si bien puede que esto no sea siempre posible por motivos de compatibilidad con versiones
anteriores.
Vista de valores nativos en el código de Python
Al igual que en la sección anterior, puede habilitar una [Vista de C++] para valores nativos en la ventana
Variables locales cuando un marco de Python está activo. Esta característica no está habilitada de forma
predeterminada; para activarla, es necesario hacer clic con el botón derecho en la ventana Variables locales y
cambiar la opción de menú Python > Mostrar nodos de vista de C++ .
El nodo [Vista de C++] proporciona una representación de la estructura de C o C++ subyacente de un valor,
idéntica a la que se vería en un marco nativo. Por ejemplo, muestra una instancia de _longobject (para el que
PyLongObject es una declaración typedef) de un entero largo de Python, e intenta inferir tipos para clases
nativas que haya creado usted mismo. Los elementos secundarios de este nodo son editables.
Si un campo secundario de un objeto es de tipo PyObject o de uno de los otros tipos admitidos, tiene un nodo
de representación [Vista de Python] (si esas representaciones están habilitadas), lo que hace que sea posible
desplazarse por gráficos de objetos donde los vínculos no se exponen directamente a Python.
A diferencia de los nodos [Vista de Python] , que usan metadatos de objetos de Python para determinar el
tipo del objeto, no hay ningún mecanismo similar confiable para [Vista de C++] . Por lo general, dado un valor
de Python (es decir, una referencia PyObject ), no es posible determinar con seguridad qué estructura de C o
C++ lo respalda de manera confiable. El depurador en modo mixto intenta adivinar ese tipo examinando los
distintos campos del tipo del objeto (como la referencia a PyTypeObject por su campo ob_type ) que tienen
tipos de puntero de función. Si uno de esos punteros de función hace referencia a una función que se puede
resolver, y esa función tiene un parámetro self con un tipo más específico que PyObject* , se asume que ese
tipo es el tipo de respaldo. Por ejemplo, si ob_type->tp_init de un objeto dado señala a la siguiente función:
static int FobObject_init(FobObject* self, PyObject* args, PyObject* kwds) {

return 0;
}
el depurador puede deducir correctamente que el tipo de C del objeto es FobObject . Si no puede determinar un
tipo más preciso a partir de tp_init , continúa con los demás campos. Si no puede deducir el tipo a partir de
ninguno de esos campos, el nodo [Vista de C++] presenta el objeto como una instancia de PyObject .
Para obtener siempre una representación útil de los tipos personalizados creados, es mejor registrar al menos
una función especial cuando se registra el tipo y usar un parámetro self fuertemente tipado. Es obvio que la
mayoría de los tipos cumplen este requisito; si no fuera así, tp_init es habitualmente la entrada más
conveniente que se puede usar con esta finalidad. Una implementación ficticia de tp_init para un tipo que está
presente exclusivamente para permitir la inferencia del tipo de depurador solo puede devolver cero
inmediatamente, como en el ejemplo de código anterior.
Diferencias con la depuración estándar de Python

El depurador en modo mixto se diferencia del depurador estándar de Python en que presenta algunas
características adicionales, pero carece de algunas funcionalidades relativas a Python:
Características no admitidas: puntos de interrupción condicionales, ventana Interactiva de depuración y
depuración remota entre plataformas.
Ventana Inmediato : está disponible, pero con un subconjunto limitado de su funcionalidad, incluidas todas
las limitaciones aquí indicadas.
Admite versiones de Python: solo CPython 2.7 y 3.3 +.
Visual Studio Shell: cuando se usa Python con Visual Studio Shell (por ejemplo, si se ha instalado con el
instalador integrado), Visual Studio no puede abrir proyectos de C++ y la experiencia de edición de archivos
de archivos de C++ es simplemente la de un editor de texto básico. Sin embargo, la depuración de C/C++ y
la depuración en modo mixto se admiten completamente en Shell con código fuente, depuración paso a paso
por instrucciones del código nativo y evaluación de expresiones de C++ en ventanas del depurador.
Visualización y expansión de objetos: al visualizar objetos de Python en las ventanas de herramientas del
depurador Variables locales e Inspección , el depurador en modo mixto muestra solo la estructura de los
objetos. No evalúa automáticamente las propiedades ni muestra atributos calculados. Para colecciones, solo
muestra elementos para tipos de colección integrados ( tuple , list , dict , set ). Los tipos de colección
personalizados no se visualizan como colecciones, a menos que se hereden de algún tipo de colección
integrado.
Evaluación de expresiones: consulte a continuación.
Evaluación de expresiones
El depurador estándar de Python permite la evaluación de expresiones de Python arbitrarias en las ventanas
Inspección e Inmediato cuando el proceso depurado se detiene en cualquier punto del código, siempre que
no esté bloqueado en una operación de E/S u otra llamada del sistema similar. En la depuración en modo mixto,
las expresiones arbitrarias pueden evaluarse solo cuando se detienen en el código de Python, después de un
punto de interrupción o cuando depuran paso a paso por instrucciones el código. Las expresiones solo pueden
evaluarse en el subproceso en el que se ha producido el punto de interrupción o la operación de depuración
paso a paso por instrucciones.
Cuando se detiene en código nativo o en código Python donde las condiciones anteriores no se aplican (por
ejemplo, después de una operación paso a paso para salir o en un subproceso diferente), la evaluación de
expresiones se limita al acceso a las variables locales y globales en el ámbito del marco seleccionado
actualmente, el acceso a sus campos y la indexación de los tipos de colección integrados con literales. Por
ejemplo, la siguiente expresión se puede evaluar en cualquier contexto (siempre y cuando todos los
identificadores hagan referencia a variables existentes y campos de los tipos adecuados):
foo.bar[0].baz['key']
El depurador en modo mixto también resuelve tales expresiones de forma diferente. Todas las operaciones de
acceso a miembros buscan solamente campos que son parte directamente del objeto (como una entrada en su
__dict__ o , o un campo de un struct nativo que se expone a Python mediante tp_members ), y omite
__slots__
cualquier __getattr__ , __getattribute__ o lógica de descriptor. De igual forma, todas las operaciones de
indexación omiten __getitem__ y acceden directamente a la estructuras de datos internas de las colecciones.
Por motivos de coherencia, este esquema de resolución de nombres se usa con todas las expresiones que
coincidan con las restricciones de la evaluación limitada de expresiones, con independencia de si se permiten
expresiones arbitrarias en el punto de detención actual. Para forzar la semántica de Python apropiada cuando un
evaluador completo está disponible, encierre la expresión entre paréntesis:
(foo.bar[0].baz['key'])
Instalación de símbolos de depuración para
intérpretes de Python
Para proporcionar una experiencia de depuración completa, el depurador en modo mixto de Python en Visual
Studio necesita depurar símbolos para el intérprete de Python que se está usando y así analizar numerosas
estructuras de datos internas. Para python27.dll, por ejemplo, el archivo de símbolos correspondiente es
python27.pdb; para python36.dll, el archivo de símbolos es python36.pdb. Cada versión del intérprete también
proporciona archivos de símbolos para diferentes módulos.
Con Visual Studio 2017 y versiones posteriores, los intérpretes Python 3 y Anaconda 3 instalan
automáticamente sus símbolos respectivos y Visual Studio los buscará automáticamente. Para Visual Studio
2015 y versiones anteriores, o al usar otros intérpretes, es necesario descargar los símbolos por separado y,
después, apuntar Visual Studio a ellos a través del cuadro de diálogo Herramientas > Opciones en la pestaña
Depuración > Símbolos . Estos pasos se detallan en las secciones siguientes.
Es posible que Visual Studio le solicite los símbolos cuando los necesite, normalmente al iniciar una sesión de
depuración en modo mixto. En este caso, muestra un cuadro de diálogo con dos opciones:
Abrir cuadro de diálogo de configuración de símbolos abre el cuadro de diálogo Opciones en la
pestaña Depuración > Símbolos .
Descargar símbolos para el intérprete abre esta página de documentación actual, en cuyo caso,
seleccione Herramientas > Opciones y navegue hasta la pestaña Depuración > Símbolos para
continuar.
Descargar símbolos
Python 3.5 y versiones posteriores: adquiera los símbolos de depuración a través del programa de
instalación de Python. Seleccione Instalación personalizada , haga clic en Siguiente para acceder a
Opciones avanzadas y después active las casillas Download debugging symbols (Descargar
símbolos de depuración) y Download debug binaries (Descargar archivos binarios de depuración):
Los archivos de símbolos (.pdb) se encuentran en la carpeta raíz de la instalación (los archivos de
símbolos para módulos individuales también se encuentran en la carpeta DLL). Por este motivo, Visual
Studio los encontrará automáticamente y no se necesita realizar ningún paso adicional.
Python 3.4.x y versiones anteriores: los símbolos están disponibles como archivos .zip que se pueden
descargar desde las distribuciones oficiales o Enthought Canopy. Después de descargarlos, extraiga los
archivos en una carpeta local para continuar, como una carpeta Símbolos dentro de la carpeta de Python.
IMPORTANT
Los símbolos difieren entre compilaciones menores de Python y entre las compilaciones de 32 y 64 bits, por lo
que querrá que las versiones coincidan. Para comprobar el intérprete que se va a usar, expanda el nodo Entornos
de Python en el proyecto en el Explorador de soluciones y anote el nombre del entorno. Después, cambie a
la ventana Entornos de Python y anote la ubicación de la instalación. Luego, abra una ventana de comandos en
esa ubicación e inicie python.exe, que muestra la versión exacta y si es de 32 o 64 bits.
Para otras distribuciones de Python de terceros, como ActiveState Python: póngase en contacto con los
autores de la distribución para solicitarles los símbolos. En el caso de WinPython, incorpora el intérprete
de Python estándar sin cambios, así que use los símbolos de la distribución oficial para el número de
versión correspondiente.
Apuntar Visual Studio a los símbolos

Si ha descargado los símbolos por separado, siga estos pasos para hacer que Visual Studio sea consciente de
ellos. Si ha instalado los símbolos a través del instalador de Python 3.5 o una versión posterior, Visual Studio los
encontrará automáticamente.
1. Seleccione el menú Herramientas > Opciones y después vaya a Depuración > Símbolos .
2. Haga clic en el botón Agregar de la barra de herramientas (descrito a continuación), escriba la carpeta
donde ha expandido los símbolos descargados (que es donde se encuentra python.pdb; por ejemplo
c:\python34\Símbolos, como se muestra a continuación) y haga clic en Aceptar .
3. Durante una sesión de depuración, es posible que Visual Studio también le pida la ubicación de un
archivo de origen para el intérprete de Python. Si ha descargado los archivos de origen (desde
python.org/downloads/, por ejemplo), entonces también puede apuntar hacia ellos.
NOTE
Las características de almacenamiento en caché de símbolos que se muestran en el cuadro de diálogo se usan para crear
una caché local de símbolos obtenidos de un origen en línea. Estas características no son necesarias con los símbolos del
intérprete de Python, pues ya hay símbolos presentes localmente. En cualquier caso, consulte Specify Symbols and Source
Files in the Visual Studio Debugger (Especificar símbolos y archivos de origen en el depurador de Visual Studio) para
obtener más detalles.
Distribuciones oficiales
VERSIÓ N DE P Y T H O N DESC A RGA S
3.5 y versiones posteriores Instale los símbolos mediante el programa de instalación de

Python.
3.4.4 32 bits - 64 bits
3.4.3 32 bits - 64 bits
3.4.2 32 bits - 64 bits
3.4.1 32 bits - 64 bits
3.4.0 32 bits - 64 bits
3.3.5 32 bits - 64 bits
3.3.4 32 bits - 64 bits
3.3.3 32 bits - 64 bits

VERSIÓ N DE P Y T H O N DESC A RGA S
3.3.2 32 bits - 64 bits
3.3.1 32 bits - 64 bits
3.3.0 32 bits - 64 bits
2.7.18 32 bits - 64 bits
2.7.17 32 bits - 64 bits
2.7.16 32 bits - 64 bits
2.7.15 32 bits - 64 bits
2.7.14 32 bits - 64 bits
2.7.13 32 bits - 64 bits
2.7.12 32 bits - 64 bits
2.7.11 32 bits - 64 bits
2.7.10 32 bits - 64 bits
2.7.9 32 bits - 64 bits
2.7.8 32 bits - 64 bits
2.7.7 32 bits - 64 bits
2.7.6 32 bits - 64 bits
2.7.5 32 bits - 64 bits
2.7.4 32 bits - 64 bits
2.7.3 32 bits - 64 bits
2.7.2 32 bits - 64 bits
2.7.1 32 bits - 64 bits
Enthought Canopy
Enthought Canopy ofrece símbolos para sus archivos binarios, a partir de la versión 1.2. Se instalan
automáticamente junto con la distribución, pero tendrá que agregar manualmente la carpeta que los contiene
en la ruta de acceso a los símbolos, como se ha descrito anteriormente. Para una instalación por usuario típica
de Canopy, los símbolos se encuentran en %UserProfile%\AppData\Local\Enthought\Canopy\User\Scripts para
la versión de 64 bits y %UserProfile%\AppData\Local\Enthought\ Canopy32\User\Scripts para la versión de 32
bits.
Enthought Canopy 1.1 y las versiones anteriores y Enthought Python Distribution (EPD) no proporcionan
símbolos para el intérprete y, por tanto, no son compatibles con la depuración en modo mixto.
Generación de perfiles de código de Python
Puede generar perfiles de una aplicación de Python al usar intérpretes de CPython (vea Generación de perfiles
de la matriz de características para conocer la disponibilidad de esta característica en las distintas versiones de
Visual Studio).
Generación de perfiles para intérpretes basados en CPython

La generación de perfiles se inicia a través del comando de menú Depurar > Iniciar la generación de
perfiles de Python , que abre un cuadro de diálogo de configuración:
Al seleccionar Aceptar , el generador de perfiles se ejecuta y abre un informe de rendimiento a través del cual
puede explorar cómo se emplea el tiempo en la aplicación:
NOTE
Al generar perfiles de una aplicación de Python, Visual Studio recopila datos durante la vigencia del proceso. Actualmente
no es posible pausar la generación de perfiles. Nos encantaría recibir sus comentarios sobre las funcionalidades futuras.
Use el botón Comentarios sobre el producto que está en la parte inferior de esta página.
Generación de perfiles para IronPython

Dado que IronPython no es un intérprete basado en CPython, la característica de generación de perfiles anterior
no funciona.
En su lugar, utilice el generador de perfiles de Visual Studio. NET iniciando ipy.exe directamente como la
aplicación de destino y usando los argumentos apropiados para iniciar el script de inicio. Incluya -X:Debug en la
línea de comandos para asegurarse de que todo el código Python se pueda depurar y permita la generación de
perfiles. Este argumento genera un informe de rendimiento que incluye el tiempo invertido tanto en el runtime
de IronPython como en el código. El código se identifica con nombres alterados.
Como alternativa, IronPython tiene algunas de sus propias características de generación de perfiles integradas,
pero actualmente no hay un buen visualizador para ellas. Consulte An IronPython Profiler (Un generador de
perfiles de Python) (blogs de MSDN) para saber lo que está disponible.
Configuración de pruebas unitarias para código de
Python
Las pruebas unitarias son fragmentos de código que prueban otras unidades de código de una aplicación,
normalmente funciones aisladas, clases, etc. Cuando una aplicación supera todas sus pruebas unitarias, al
menos puede confiar en que su función de bajo nivel es correcta.
Python utiliza pruebas unitarias ampliamente para validar escenarios durante el diseño de un programa. La
compatibilidad de Python en Visual Studio incluye características para descubrir, ejecutar y depurar pruebas
unitarias dentro del contexto de su proceso de desarrollo, sin tener que ejecutar pruebas independientemente.
En este artículo se proporciona una descripción breve de las funcionalidades de las pruebas unitarias en Visual
Studio con Python. Para más información sobre las pruebas unitarias en general, vea Hacer una prueba unitaria
del código.
Detección y visualización de pruebas

Por convención, Visual Studio identifica las pruebas como métodos cuyos nombres empiezan por test . Para
ver este comportamiento, realice lo siguiente:
1. Abra un proyecto Python cargado en Visual Studio, haga clic con el botón derecho en el proyecto,
seleccione Agregar > Nuevo elemento y luego seleccione Prueba unitaria de Python y Agregar .
2. Esta acción crea un archivo test1.py con código que importa el módulo estándar unittest , deriva una
clase de prueba de unittest.TestCase e invoca unittest.main() si ejecuta el script directamente:
import unittest
class Test_test1(unittest.TestCase):
def test_A(self):
self.fail("Not implemented")
if __name__ == '__main__':
unittest.main()
3. Si es necesario, guarde el archivo y luego abra el Explorador de pruebas con el comando de menú
Prueba > Windows > Explorador de pruebas .
4. El Explorador de pruebas busca las pruebas en el proyecto y las mostrará como se muestra a
continuación. Haga doble clic en una prueba para abrir su archivo de origen.
5. A medida que agrega más pruebas para el proyecto, puede organizar la vista en el Explorador de
pruebas mediante el menú Agrupar por de la barra de herramientas:
6. También puede escribir texto en el campo de búsqueda para filtrar pruebas por nombre.
Para más información sobre el módulo unittest y las pruebas de escritura, vea la documentación de
Python 2.7 o la documentación de Python 3.7 (python.org).
Ejecutar pruebas
En el Explorador de pruebas puede ejecutar pruebas de varias maneras:
Ejecutar todas claramente ejecuta todas las pruebas mostradas (sujeto a filtros).
El menú Ejecutar proporciona comandos para ejecutar pruebas con error, superadas o no ejecutadas como
un grupo.
Puede seleccionar una o varias pruebas, hacer clic con el botón derecho y seleccionar Ejecutar pruebas
seleccionadas .
Las pruebas se ejecutan en segundo plano y el Explorador de pruebas actualiza el estado de todas las
pruebas a medida que se completan:
Las pruebas superadas muestran una marca de verificación verde y el tiempo dedicado a ejecutar la
prueba:
Las pruebas con error muestran una cruz roja con un vínculo Salida que muestra la salida de la consola
y la salida unittest de la serie de pruebas:
Depuración de pruebas
Dado que las pruebas unitarias son fragmentos de código, están sujetas a errores como cualquier otro código y,
en ciertas ocasiones, necesitan ejecutarse en un depurador. En el depurador puede establecer puntos de
interrupción, examinar variables y recorrer el código. Visual Studio también proporciona herramientas de
diagnóstico para las pruebas unitarias.
Para iniciar la depuración, establezca un punto de interrupción inicial en el código y luego haga clic con el botón
derecho en la prueba (o una selección) en el Explorador de pruebas y seleccione Depurar pruebas
seleccionadas . Visual Studio inicia el depurador de Python como lo haría para el código de la aplicación.
También puede usar Analizar cober tura de código para las pruebas seleccionadas . Para obtener más
información, vea Usar cobertura de código para determinar la cantidad de código que se está probando.
Problemas conocidos
Al iniciar la depuración, Visual Studio aparece para iniciar y detener la depuración, y luego la inicia de nuevo.
Este comportamiento es normal.
Al depurar varias pruebas, cada una de ellas se ejecuta de manera independiente, lo que interrumpe la sesión
de depuración.
Visual Studio produce un error de manera intermitente al iniciar una prueba durante la depuración.
Normalmente, si intenta depurar la prueba de nuevo, la operación se realiza correctamente.
Al depurar, es posible que salir de una prueba en la implementación de unittest . Normalmente, el siguiente
paso ejecuta el programa hasta el final y detendrá la depuración.
Selección del marco de pruebas de un proyecto de Python

Visual Studio admite dos marcos de pruebas con Python, unittest y pytest (disponibles a partir de la versión 16.3
de Visual Studio 2019). Ninguno de los marcos se selecciona de forma predeterminada cuando se crea un
proyecto de Python. Para especificar un marco, haga clic con el botón derecho en el nombre del proyecto en el
Explorador de soluciones y seleccione Propiedades . Se abrirá el diseñador de proyectos, donde puede
configurar las pruebas a través de la pestaña Prueba . En esta pestaña, puede seleccionar el marco de pruebas
que quiere usar en el proyecto.
En el marco unittest , el directorio raíz del proyecto se usa para la detección de pruebas. Esta ubicación, así
como el patrón de texto para identificar pruebas, se pueden modificar en la pestaña Prueba por los valores
especificados por el usuario.
En el marco pytest , las opciones de prueba como la ubicación de las pruebas y los patrones de nombre de
archivo se especifican mediante el archivo de configuración estándar pytest.ini. Vea la documentación de
referencia de pytest para más información.
Una vez que haya guardado la selección y la configuración del marco de trabajo, la detección de pruebas se
inicia en el Explorador de pruebas. Si la ventana Explorador de pruebas todavía no está abierta, vaya a la barra
de herramientas y seleccione Prueba > Explorador de pruebas .
Configuración de pruebas para Python sin un proyecto

Visual Studio permite ejecutar y probar el código de Python existente sin un proyecto, simplemente abriendo
una carpeta con código de Python. En estas circunstancias, deberá usar un archivo PythonSettings.json para
configurar las pruebas.
1. Abra el código de Python existente con la opción Abrir una carpeta local .
2. En la ventana de Explorador de soluciones, haga clic en el icono Mostrar todos los archivos para
mostrar todos los archivos de la carpeta actual.
3. Vaya al archivo PythonSettings.json dentro de la carpeta Configuración local . Si no ve este archivo

en la carpeta Configuración local , créelo manualmente.
4. Agregue el campo TestFramework al archivo de configuración y establézcalo en pytest o en unittest ,
según cuál sea el marco de pruebas que quiera usar.
{
"TestFramework": "unittest",
"UnitTestRootDirectory": "testing",
"UnitTestPattern": "test_*.py"
}
NOTE
En el marco unittest , si los campos UnitTestRootDirector y y UnitTestPattern no están especificados en el
archivo PythonSettings.json, se agregan y se les asignan los valores predeterminados "." y "test*.py"
respectivamente.
5. Si la carpeta contiene un directorio src que es independiente de la carpeta que contiene las pruebas,
especifique la ruta de acceso a la carpeta src mediante el campo SearchPaths del archivo
PythonSettings.json .
{
"TestFramework": "unittest",
"UnitTestRootDirectory": "testing",
"UnitTestPattern": "test_*.py",
"SearchPaths": [ ".\\src"]
}
6. Guarde los cambios en el archivo PythonSettings.json para iniciar la detección de pruebas del marco
especificado.
NOTE
Si la ventana Explorador de pruebas ya está abierta, Ctrl + R,A también desencadena la detección.
Detección y visualización de pruebas

Visual Studio identifica de forma predeterminada las pruebas de unittest y pytest como métodos cuyos
nombres empiezan por test . Haga lo siguiente para ver la detección de pruebas:
1. Abra un proyecto de Python.
2. Una vez cargado el proyecto en Visual Studio, haga clic con el botón derecho en él en Explorador de
soluciones y seleccione el marco unittest o pytest en las propiedades de la pestaña Prueba .
NOTE
Si usa el marco pytest, puede especificar la ubicación de las pruebas y los patrones de nombre de archivo
mediante el archivo de configuración estándar pytest.ini. De forma predeterminada, se usa la carpeta del proyecto
o del área de trabajo, con un patrón de test_*py y *_test.py . Vea la documentación de referencia de pytest
3. Una vez seleccionado el marco, vuelva a hacer clic con el botón derecho en el proyecto, seleccione
Agregar > Nuevo elemento y, después, seleccione Prueba unitaria de Python seguido de Agregar .
4. Esta acción crea un archivo test_1.py con código que importa el módulo estándar unittest , deriva una
clase de prueba de unittest.TestCase e invoca unittest.main() si ejecuta el script directamente:
import unittest
class Test_test1(unittest.TestCase):
def test_A(self):
self.fail("Not implemented")
if __name__ == '__main__':
unittest.main()
5. Si es necesario, guarde el archivo y luego abra el Explorador de pruebas con el comando de menú
Prueba > Explorador de pruebas .
6. El Explorador de pruebas busca las pruebas en el proyecto y las mostrará como se muestra a
continuación. Haga doble clic en una prueba para abrir su archivo de origen.
7. A medida que agrega más pruebas para el proyecto, puede organizar la vista en el Explorador de
pruebas mediante el menú Agrupar por de la barra de herramientas:
8. También puede escribir texto en el campo de búsqueda para filtrar pruebas por nombre.
Para más información sobre el módulo unittest y las pruebas de escritura, vea la documentación de
Python 2.7 o la documentación de Python 3.7 (python.org).
Ejecutar pruebas
En el Explorador de pruebas puede ejecutar pruebas de varias maneras:
Ejecutar todas claramente ejecuta todas las pruebas mostradas (sujeto a filtros).
El menú Ejecutar proporciona comandos para ejecutar pruebas con error, superadas o no ejecutadas como
un grupo.
Puede seleccionar una o varias pruebas, hacer clic con el botón derecho y seleccionar Ejecutar pruebas
seleccionadas .
Las pruebas se ejecutan en segundo plano y el Explorador de pruebas actualiza el estado de todas las
pruebas a medida que se completan:
Las pruebas superadas muestran una marca de verificación verde y el tiempo dedicado a ejecutar la
prueba:
Las pruebas con error muestran una cruz roja con un vínculo Salida que muestra la salida de la consola
y la salida unittest de la serie de pruebas:
Depuración de pruebas
Dado que las pruebas unitarias son fragmentos de código, están sujetas a errores como cualquier otro código y,
en ciertas ocasiones, necesitan ejecutarse en un depurador. En el depurador puede establecer puntos de
interrupción, examinar variables y recorrer el código. Visual Studio también proporciona herramientas de
diagnóstico para las pruebas unitarias.
NOTE
De forma predeterminada, la depuración de prueba usa el depurador de ptvsd 4 para Visual Studio 2017 (versiones 15.8 y
posteriores) y debugpy para Visual Studio 2019 (versiones 16.5 y posteriores). Si quiere usar ptvsd 3 en su lugar, puede
seleccionar la opción Usar depurador heredado en Herramientas > Opciones > Python > Depuración .
Para iniciar la depuración, establezca un punto de interrupción inicial en el código y luego haga clic con el botón
derecho en la prueba (o una selección) en el Explorador de pruebas y seleccione Depurar pruebas
seleccionadas . Visual Studio inicia el depurador de Python como lo haría para el código de la aplicación.
También puede usar Analizar cober tura de código para las pruebas seleccionadas . Para obtener más
información, vea Usar cobertura de código para determinar la cantidad de código que se está probando.
Cookiecutter proporciona una interfaz gráfica de usuario para descubrir plantillas, opciones de plantilla de
entrada y crear proyectos y archivos. Se incluye con Visual Studio 2017 y versiones posteriores y puede
instalarse por separado en versiones anteriores de Visual Studio.
Cookiecutter requiere Python 3.3 o posterior (32 o 64 bits) o Anaconda 3 4.2 o posterior (32 o 64 bits). Si no se
dispone de un intérprete de Python adecuado, Visual Studio mostrará una advertencia. Si instala un intérprete
de Python mientras se está ejecutando Visual Studio, seleccione el botón de inicio en la barra de herramientas
de Cookiecutter para detectar el intérprete recién instalado. (Vea Entornos de Python para obtener más
información sobre los entornos en general).
Una vez instalado, seleccione View > Cookiecutter Explorer (Ver > Explorador de Cookiecutter) para abrir la
ventana:
Flujo de trabajo Cookiecutter

Trabajar con Cookiecutter es un proceso que implica explorar y seleccionar una plantilla, clonarla en el equipo
local, configurar opciones y luego crear código a partir de esa plantilla, tal como se describe en las secciones
siguientes.
Examinar plantillas
La página de inicio de Cookiecutter muestra una lista de plantillas para elegir, organizada en los siguientes
grupos:
A GRUPA R DESC RIP T IO N

A GRUPA R DESC RIP T IO N
Instalado Plantillas que se han instalado en el equipo local. Cuando se

usa una plantilla en línea, su repositorio se clona
automáticamente en una subcarpeta de ~/.cookiecutters.
Puede eliminar una plantilla instalada seleccionada
presionando Suprimir .
Recomendado Plantillas cargadas desde la fuente recomendada. Microsoft

mantiene la fuente predeterminada. Consulte Opciones de
Cookiecutter a continuación para más información sobre
cómo personalizar la fuente.
GitHub Resultados de búsqueda de GitHub de la palabra clave

cookiecutter. Los resultados de GitHub vuelven paginados; si
hay más resultados disponibles, aparece Load More
(Cargar más) al final de la lista.
Custom Cuando se especifica una ubicación personalizada en el

cuadro de búsqueda, aparece en este grupo. Puede escribir
una ruta de acceso completa al repositorio de GitHub, o la
ruta de acceso completa a una carpeta de su disco local.
Clonación
Al seleccionar una plantilla y luego hacer clic en Next (Siguiente), Cookiecutter hace una copia local con la que
trabaja.
Si selecciona una plantilla de los grupos Recomendado o GitHub , o escribe una URL personalizada en el
cuadro de búsqueda y selecciona esa plantilla, esta se clona e instala en el equipo local. Si esa plantilla se instaló
en una sesión anterior de Visual Studio, se elimina automáticamente y se clona la versión más reciente.
Si selecciona una plantilla del grupo Instalado o escribe una ruta de acceso personalizada a una carpeta en el
cuadro de búsqueda y seleccione esa plantilla, Visual Studio carga esa plantilla sin clonarla.
IMPORTANT
Las plantillas de Cookiecutter se clonan en una sola carpeta ~/.cookiecutters. Cada subcarpeta se nombra después del
nombre del repositorio GIT, que no incluye el nombre de usuario de GitHub. Pueden surgir conflictos si clona distintas
plantillas con el mismo nombre que proceden de diferentes autores. En este caso, Cookiecutter le impide sobrescribir la
plantilla existente con una plantilla diferente del mismo nombre. Para instalar la otra plantilla, primero debe eliminar la
existente.
Establecimiento de opciones de plantilla

Después de que la plantilla está instalada localmente, Cookiecutter muestra una página de opciones donde
puede especificar, entre otras opciones, dónde desea que Cookiecutter genere los archivos:
Cada plantilla de Cookiecutter define su propio conjunto de opciones y especifica un valor predeterminado para
cada una (se muestra como el texto sugerido en cada campo de entrada). Un valor predeterminado puede ser
un fragmento de código, normalmente cuando es un valor dinámico que usa otras opciones.
Es posible personalizar los valores predeterminados para opciones específicas con un archivo de configuración
de usuario. Cuando la extensión Cookiecutter detecta un archivo de configuración de usuario, sobrescribe los
valores predeterminados de la plantilla con los valores predeterminados de la configuración de usuario. Esto se
explica en la sección User Config (Configuración de usuario) de la documentación de Cookiecutter.
Si la plantilla especifica tareas de Visual Studio concretas para ejecutar después de la generación de código,
aparece una opción adicional Run additional tasks on completion (Ejecutar tareas adicionales al terminar)
que le permite optar por esas tareas. El uso más común de tareas es abrir un explorador web, abrir archivos en
el editor, instalar dependencias, etc.
Crear
Una vez configuradas las opciones, seleccione Crear para generar el código (aparece una advertencia si la
carpeta de salida no está vacía). Si está familiarizado con la salida de la plantilla y no le importa sobrescribir los
archivos, puede pasarla por alto. En caso contrario, seleccione Cancel (Cancelar), especifique una carpeta vacía y
luego copie manualmente los archivos creados en la carpeta de salida que no está vacía.
Después de que los archivos se crean correctamente, Cookiecutter proporciona una opción para abrirlos en el
Explorador de soluciones :
Opciones de Cookiecutter
Las opciones de Cookiecutter están disponibles en Tools > Options > Cookiecutter (Herramientas >
Opciones > Cookiecutter):
O P C IÓ N DESC RIP T IO N
Recommended Feed URL (URL de fuente recomendada) La ubicación de la fuente de plantillas recomendadas. Puede
ser una dirección URL o una ruta de acceso a un archivo
local. Deje en blanco la dirección URL para usar la fuente
protegida por Microsoft predeterminada. La fuente
proporciona una sencilla lista de ubicaciones de plantillas,
separadas por nuevas líneas. Para solicitar cambios en la
fuente protegida, realice una solicitud de extracción contra el
origen de GitHub.
Show Help (Mostrar ayuda) Controla la visibilidad de la barra de información de ayuda

en la parte superior de la ventana de Cookiecutter.
Optimización de plantillas de Cookiecutter para Visual Studio

Para información sobre los aspectos básicos de la creación de una plantilla de Cookiecutter, consulte la
documentación de Cookiecutter. La extensión Cookiecutter para Visual Studio admite plantillas creadas por
Cookiecutter v1.4.
La representación predeterminada de variables de plantilla depende del tipo de datos (cadena o lista):
Cadena: etiqueta para el nombre de variable, cuadro de texto para escribir el valor y una marca de agua que
muestra el valor predeterminado. La información sobre herramientas en el cuadro de texto muestra el valor
predeterminado.
Lista: etiqueta para nombre de variable, cuadro combinado para seleccionar un valor. La información sobre
herramientas en el cuadro combinado muestra el valor predeterminado.
Se pueden realizar mejoras adicionales en esta representación mediante la especificación de metadatos
adicionales en el archivo cookiecutter.json que es específico de Visual Studio (y la CLI de Cookiecutter lo omite).
Todas las propiedades son opcionales:
P RO P ERT Y DESC RIP T IO N

P RO P ERT Y DESC RIP T IO N
Etiqueta Especifica lo que aparece encima del editor para la variable,

en lugar del nombre de la variable.
Description Especifica la información sobre herramientas que aparece en

el control de edición, en lugar del valor predeterminado de
esa variable.
Resolución Transforma la etiqueta en un hipervínculo, con una

información sobre herramientas que muestra la URL. Al
seleccionar el hipervínculo se abrirá el explorador
predeterminado del usuario con esa dirección URL.
Selector Permite la personalización del editor de una variable.

Actualmente se admiten los siguientes selectores:
string : cuadro de texto estándar, de forma
predeterminada para las cadenas.
list : cuadro combinado estándar, de forma
predeterminada para las listas.
yesno : cuadro combinado elegir entre y y n ,
para las cadenas.
odbcConnection : cuadro de texto con un botón ...
que hace que muestra cuadro de diálogo de conexión
de base de datos.
Ejemplo:
{
"site_name": "web-app",
"python_version": ["3.5.2"],
"use_azure": "y",
"_visual_studio": {
"site_name": {
"label": "Site name",
"description": "E.g. <site-name>.azurewebsites.net (can only contain alphanumeric characters and
`-`)"
},
"python_version": {
"label": "Python version",
"description": "The version of Python to run the site on"
},
"use_azure" : {
"label": "Use Azure",
"description": "Include Azure deployment files",
"selector": "yesno",
"url": "https://azure.microsoft.com"
}
}
}
Ejecución de tareas de Visual Studio

Cookiecutter presenta una característica llamada Post-Generate Hooks (Enlaces posteriores a la generación) que
permite ejecutar código de Python arbitrario después de que se generan los archivos. Aunque flexible, no
permite un acceso fácil a Visual Studio.
Por ejemplo, puede que quiera abrir un archivo en el editor de Visual Studio o en su explorador web, o activar la
interfaz de usuario de Visual Studio que pide al usuario que cree un entorno virtual e instale los requisitos de
paquete.
Para permitir estos escenarios, Visual Studio busca metadatos extendidos en cookiecutter.json que describen los
comandos que se ejecutarán después de que el usuario abra los archivos generados en el Explorador de
soluciones o después de que los archivos se agreguen a un proyecto existente. (Nuevamente, el usuario puede
optar por ejecutar las tareas si desactiva Ejecutar tareas adicionales después de la finalización en las
opciones de plantilla).
Ejemplo:
"_visual_studio_post_cmds": [
{
"name": "File.OpenFile",
"args": "{{cookiecutter._output_folder_path}}\\readme.txt"
},
{
"name": "Cookiecutter.ExternalWebBrowser",
"args": "https://docs.microsoft.com"
},
{
"name": "Python.InstallProjectRequirements",
"args": "{{cookiecutter._output_folder_path}}\\dev-requirements.txt"
}
]
Los comandos se especifican por nombre y deben usar el nombre no localizado (en inglés) para funcionar en
instalaciones localizadas de Visual Studio. Puede probar y detectar nombres de comando en la ventana de
comandos de Visual Studio.
Si desea pasar un solo argumento, puede especifíquelo como una cadena, como en el ejemplo anterior.
Si no necesita pasar un argumento, deje una cadena vacía u omítalo de JSON:
{
"name": "View.WebBrowser"
}
]
Use una matriz para varios argumentos. Para modificadores, divida el modificador y su valor en argumentos
distintos y use el entrecomillado correcto. Por ejemplo:
{
"name": "File.OpenFile",
"args": [
"{{cookiecutter._output_folder_path}}\\read me.txt",
"/e:",
"Source Code (text) Editor"
]
}
]
Los argumentos pueden hacer referencia a otros variables de Cookiecutter. En los ejemplos anteriores, la
variable interna _output_folder_path se usa para formar una ruta de acceso absoluta a los archivos generados.
Tenga en cuenta que el comando Python.InstallProjectRequirements funciona solo al agregar archivos a un
proyecto existente. Esta limitación existe porque el comando se procesa mediante el proyecto de Python en el
Explorador de soluciones , y no hay ningún proyecto para recibir el mensaje mientras se está en Explorador
de soluciones - vista de carpetas . Esperamos eliminar la limitación en una versión futura (y proporcionar
mejor compatibilidad con la vista de carpetas en general).
Error al cargar la plantilla
Puede que algunas plantillas usen tipos de datos no válidos, como booleanos, en sus archivos cookiecutter.json.
Informe sobre estas instancias al autor de la plantilla haciendo clic en el vínculo Problemas .
Error de script de enlace
Algunas plantillas pueden usar scripts posteriores a la generación que no son compatibles con la interfaz de
usuario de Cookiecutter. Por ejemplo, se producirá un error en los scripts que consultan la entrada del usuario
por no tener una consola de terminal.
Script de enlace no admitido en Windows
Si el script posterior es .sh, puede que no esté asociado con una aplicación del equipo Windows. Es posible que
vea un diálogo de Windows que le pide que busque una aplicación compatible en la Tienda Windows.
Plantillas con problemas conocidos
Errores de clonación:
wildfish/cookiecutter-django-crud (carácter no válido | en nombre de subcarpeta)
cookiecutter-pyvanguard (carácter no válido | en nombre de subcarpeta)
Errores de carga:
chrisdev/wagtail-cookiecutter-foundation (usa un tipo booleano en cookiecutter.json)
quintoandar/cookiecutter-android (ninguna carpeta de plantilla)
Errores de ejecución:
iknite/cookiecutter-ansible-role (script de enlace posterior que requiere entrada de consola)
benregn/cookiecutter-django-ansible (error de Jinja)
Usa bash (no fatal):
openstack-dev/cookiecutter
Plantillas de elementos de Python
Las plantillas de elementos están disponibles en proyectos de Python a través del comando de menú Proyecto
> Agregar nuevo elemento o el comando Agregar > Nuevo elemento en el menú contextual del
Explorador de soluciones .
Con el nombre que proporcione para el elemento, una plantilla suele crear uno o varios archivos y carpetas
dentro de la carpeta actualmente seleccionada en el proyecto (al hacer clic con el botón derecho en una carpeta
para que aparezca el menú contextual se selecciona automáticamente esa carpeta). Al agregar un elemento, lo
incluye en el proyecto de Visual Studio y aparecerá en el Explorador de soluciones .
En la tabla siguiente se explica brevemente el efecto de cada plantilla de elemento dentro de un proyecto de
Python:
P L A N T IL L A Q UÉ C REA L A P L A N T IL L A
Archivo de Python vacío Un archivo vacío con la extensión .py.
Clase de Python Un archivo .py que contiene una única definición de clase
vacía de Python.
Paquete de Python Una carpeta que contiene un archivo __init__.py.
Prueba unitaria de Python Un archivo .py con una sola prueba unitaria basada en la
plataforma unittest , junto con una llamada a
unittest.main() para ejecutar las pruebas en el archivo.
Página HTML Un archivo .html con una estructura de página sencilla que
consta de un elemento <head> y <body> .
JavaScript Un archivo .js vacío.
Hoja de estilos Un archivo .css que contiene un estilo vacío para body .
Archivo de texto Un archivo .txt vacío.
Aplicación Django 1.9 Una carpeta con el nombre de la aplicación, que contiene los
Aplicación Django 1.4 archivos principales de una aplicación de Django como se
explica en Información acerca de Django en Visual Studio,
paso 2.2 para Django 1.9. En el caso de Django 1.4, no se
incluyen la carpeta migrations ni los archivos admin.py y
apps.py.
Ventana de WPF de IronPython Una ventana de WPF que consta de dos archivos paralelos:
un archivo .xaml que define un <Window> con un elemento
<Grid> vacío, y un archivo .py asociado que carga el
archivo XAML mediante la biblioteca wpf . Suele usarse
dentro de un proyecto creado con una de las plantillas de
proyecto de IronPython. Vea Proyectos de Python -
Plantillas de proyecto.
Archivos auxiliares de rol web Una carpeta bin en la raíz del proyecto (independientemente
de la carpeta seleccionada en el proyecto). La carpeta
contiene un script de implementación predeterminado y un
archivo web.config para los roles web del Servicio en la nube
de Azure. La plantilla también incluye un archivo
readme.html donde se explican los detalles.
Archivos de compatibilidad de rol de trabajo Una carpeta bin en la raíz del proyecto (independientemente
de la carpeta seleccionada en el proyecto). La carpeta
contiene el script de implementación e inicio
predeterminado, junto con un archivo web.config, para los
roles de trabajo del servicio en la nube de Azure. La plantilla
también incluye un archivo readme.html donde se explican
los detalles.
web.config de Azure (FastCGI) Un archivo web.config que contiene las entradas para las
aplicaciones con un objeto WSGI para controlar las
conexiones entrantes. Este archivo normalmente se
implementa en la raíz de un servidor web que ejecuta IIS.
Para más información, consulte Configure an app for IIS
(Configurar una aplicación para IIS).
web.config de Azure (HttpPlatformHandler) Un archivo web.config que contiene las entradas para las
aplicaciones que escuchan en un socket para las conexiones
entrantes. Este archivo normalmente se implementa en la
raíz de un servidor web que ejecuta IIS, por ejemplo, Azure
App Service. Para más información, consulte Configure an
app for IIS (Configurar una aplicación para IIS).
web.config de archivos estáticos de Azure Un archivo web.config que normalmente se agrega a una
carpeta static (u otra carpeta que contiene elementos
estáticos) para deshabilitar el control de Python para esa
carpeta. Este archivo de configuración funciona junto con
uno de los archivos de configuración FastCGI o
HttpPlatformHandler anteriores. Para más información,
consulte Configure an app for IIS (Configurar una aplicación
para IIS).
web.config de depuración remota de Azure En desuso (se usaba para depuración remota en Azure App
Service para Windows, que ya no se admite).
Consulte también
Proyectos de Python: plantillas de proyecto
Plantillas de proyecto web de Python
Opciones de Python en Visual Studio
Para ver las opciones de Python, use el comando de menú Herramientas > Opciones , asegúrese de que la
opción Mostrar todas las configuraciones está seleccionada y, después, vaya a Python :
También hay opciones adicionales específicas de Python en la pestaña Editor de texto > Python > Opciones
avanzadas y en la pestaña Entorno > Fuentes y colores del grupo Editor de texto .
NOTE
El grupo Experimental contiene opciones de características que están aún en desarrollo y no se documentan aquí. A
menudo, se habla de ellas en entradas del blog de ingeniería de Python en Microsoft.
Opciones generales
(Pestaña Herramientas > Opciones > Python ).
O P C IÓ N DEFA ULT DESC RIP C IÓ N
Mostrar la Ventana de salida al Activado Desactívela para evitar que aparezca la

crear entornos vir tuales ventana de salida .
Mostrar la ventana de salida al Activado Desactívela para evitar que aparezca la

instalar o desinstalar paquetes ventana de salida .
Mostrar barra de notificaciones Activado Solo Visual Studio 2019. Cuando se

para crear entornos establece esta opción y el usuario abre
un proyecto que contiene un archivo
requirements.txt o environment.yml,
Visual Studio muestra una barra de
información con sugerencias para crear
un entorno virtual o un entorno de
Conda, respectivamente, en lugar de
usar el entorno global predeterminado.
Mostrar barra de notificaciones Activado Solo Visual Studio 2019. Cuando se

para instalar paquetes establece esta opción y el usuario abre
un proyecto que contiene un archivo
requirements.txt (y no usa el entorno
global predeterminado), Visual Studio
compara esos requisitos con los
paquetes instalados en el entorno
actual. Si falta algún paquete, Visual
Studio pide instalar esas dependencias.
Ejecutar siempre los Desactivado Siempre eleva pip install y

administradores de paquetes operaciones de administrador de
como administrador paquetes similares de todos los
entornos. Al instalar paquetes, Visual
Studio solicita privilegios de
administrador si el entorno está
situado en un área protegida del
sistema de archivos como c:\Program
Files. En esa solicitud, puede elegir
elevar siempre el comando de
instalación solo para ese entorno.
Consulte la pestaña Paquetes.
Generar automáticamente la base Activado Se aplica a Visual Studio 2017, versión

de datos de finalización en el 15.5 y anteriores, y a versiones
primer uso posteriores cuando se utiliza una base
de datos de IntelliSense. Prioriza la
finalización de la base de datos de una
biblioteca cuando escribe código que la
usa. Para más información, consulte la
pestaña IntelliSense.
Omitir las variables PYTHONPATH Activado PYTHONPATH se omite de manera

de todo el sistema predeterminada porque Visual Studio
proporciona un medio más directo
para especificar rutas de búsqueda en
entornos y proyectos. Consulte Rutas
de acceso de búsqueda para más
detalles.
Actualizar rutas de búsqueda al Activado Cuando se establece, agregar un

agregar archivos vinculados archivo vinculado a un proyecto
actualiza las rutas de búsqueda de
manera que IntelliSense pueda incluir
el contenido de la carpeta del archivo
vinculado en su base de datos de
finalización. Desactive esta opción para
excluir dicho contenido de la base de
datos de finalización.
Mostrar adver tencia si no se Activado Desactive esta opción para suprimir las
encuentra el módulo impor tado advertencias cuando sepa que un
módulo importado no está disponible
actualmente pero, de otro modo, no
afecta a la operación de código.
Informar de sangría incoherente Adver tencias Como el intérprete de Python depende

como totalmente de la sangría adecuada
para determinar el ámbito, Visual
Studio genera advertencias de manera
predeterminada cuando detecta
sangrías incoherentes que pueden
indicar errores de codificación. Se
establece en Errores para ser incluso
más estricto, lo que provoca que el
programa se cierre en dichos casos.
Para deshabilitar este comportamiento
conjunto, seleccione No .
Buscar encuestas o noticias Una vez a la semana Visual Studio 2017 y versiones
anteriores. Establece la frecuencia con
la que permite que Visual Studio pueda
abrir una ventana que contiene una
página web con elementos de noticias
y encuestas relacionados con Python,
si está disponible. Las opciones son
Nunca , Una vez al día , Una vez a
la semana y Una vez al mes .
Restablecer todos los cuadros de N/D Los diferentes cuadros de diálogo

diálogo ocultos de forma proporcionan opciones como No
permanente (botón) volver a mostrar . Use este botón
para desactivar esas opciones y hacer
que los cuadros de diálogo vuelvan a
aparecer.
Opciones de Conda
(Pestaña Herramientas > Opciones > Python > Conda ).

Ruta de acceso de ejecutable de (en blanco) Especifica una ruta de acceso exacta al
Conda ejecutable conda.exe en lugar de
depender de la instalación
predeterminada de Miniconda que se
incluye con la carga de trabajo de
Python. Si aquí se indica otra ruta de
acceso, tiene prioridad sobre la
instalación predeterminada y sobre
cualquier otro ejecutable conda.exe
que se especifique en el registro.
Puede cambiar esta configuración si
instala manualmente una versión más
reciente de Anaconda o Miniconda o si
quiere usar una distribución de 32 bits
en lugar de la distribución
predeterminada de 64 bits.
Opciones de depuración
(Pestaña Herramientas > Opciones > Python > Depuración ).
Preguntar antes de ejecutar si Activado Cuando se establece, le pide que

hay errores confirme que quiere ejecutar código
que contiene errores. Desactive esta
opción para deshabilitar la advertencia.
Esperar a la entrada cuando el Activado (para ambos) Un programa de Python iniciado desde
proceso termine de forma Visual Studio se ejecuta en su propia
anómala ventana de consola. De manera
predeterminada, la ventana espera a
Esperar a la entrada cuando el que presione una tecla antes de
proceso termine de manera cerrarla independientemente de cómo
correcta finaliza el programa. Para quitar ese
mensaje y cerrar la ventana
automáticamente, desactive una o
ambas opciones.
Resultado del programa tee en la Activado Muestra el resultado del

ventana de salida de depuración programa en una ventana de
consola independiente y en la
ventana de salida de Visual
Studio . Desactive esta opción para
mostrar el resultado solo en la ventana
de consola independiente.
Interrumpir en la excepción Desactivado Si se establece, detiene el depurador

SystemExit con el código de en esta excepción. Cuando se
salida de cero desactiva, el depurador se cierra sin
interrupción.
Habilitar el depurado de la Desactivado Hace posible la depuración paso a

biblioteca estándar de Python paso por instrucciones del código
fuente de biblioteca estándar durante
la depuración, pero aumenta el tiempo
que tarda el depurador en comenzar.
Mostrar el valor devuelto de la Activado Solo Visual Studio 2019. Muestra los
función valores devueltos de función en la
ventana Locals (Variables locales) y
luego pasa por encima de una llamada
de función en el depurador (F10).
Usar el depurador heredado Desactivado Solo Visual Studio 2019. Indica a Visual
Studio que use el depurador heredado
de manera predeterminada. Para más
información, consulte Depuración: usar
el depurador heredado.
Opciones de diagnóstico
(Pestaña Herramientas > Opciones > Python > Diagnósticos ).
Incluir registros de análisis Activado Incluye registros detallados

relacionados con el análisis de los
entornos de Python instalados al
guardar el diagnóstico en un archivo o
copiarlo en el Portapapeles mediante
los botones. Esta opción puede
aumentar significativamente el tamaño
del archivo generado, pero a menudo
es necesaria para diagnosticar
problemas de IntelliSense.
Guardar diagnóstico en archivo N/D Solicita un nombre de archivo y, a

(botón) continuación, guarda el registro en un
archivo de texto.
Copiar diagnóstico en N/D Coloca la totalidad del registro en el

Por tapapeles (botón) Portapapeles; esta operación puede
tardar algún tiempo según el tamaño
del registro.
Opciones de las ventanas interactivas

(Pestaña Herramientas > Opciones > Python > Windows interactivo ).
Scripts N/D Especifica una carpeta general para los

scripts de inicio que se van a aplicar a
las ventanas interactivas en todos los
entornos. Vea Scripts de inicio. En
cambio, tenga en cuenta que esta
característica no funciona actualmente.
Usar flechas arriba o abajo para Activado Usa las teclas de flecha para navegar
navegar por el historial por el historial en la ventana
interactiva . Desactive esta opción
para usar las teclas de flecha para
navegar dentro del resultado de la
ventana interactiva en su lugar.
Modo de finalización Solo se evalúan expresiones sin El proceso de determinar los miembros
llamadas de función disponibles en una expresión en la
ventana interactiva puede necesitar
la evaluación de la expresión actual sin
terminar, lo que puede provocar
efectos secundarios o funciones que se
llaman varias veces. La opción
predeterminada, Solo evaluar las
expresiones sin llamadas de
función excluye expresiones que
aparecen para llamar a una función,
pero evalúa otras expresiones. Por
ejemplo, evalúa a.b pero no a().b .
Nunca evaluar expresiones evita
los efectos secundarios usando solo el
motor de IntelliSense normal para las
sugerencias. Evaluar todas las
expresiones evalúa la expresión
completa para obtener sugerencias,
independientemente de los efectos
secundarios.
Ocultar sugerencias de análisis Desactivado Cuando se establece, muestra solo

estático sugerencias que se obtienen
evaluando la expresión. Si se combina
con el modo de finalización Nunca
evaluar expresiones , no aparecen
finalizaciones útiles en la ventana
interactiva .
Opciones del servidor de lenguaje

(Pestaña Herramientas > Opciones > Python > Ser vidor de lenguaje ).
Deshabilitar las finalizaciones Desactivado Por lo general, Visual Studio

desde Typeshed IntelliSense usa una versión
empaquetada de Typeshed (un
conjunto de archivos .pyi) para
encontrar las sugerencias de tipo para
la biblioteca estándar y las bibliotecas
de terceros para Python 2 y Python 3.
Establecer esta opción deshabilita el
comportamiento de TypeShed
empaquetado.
Ruta de acceso de Typeshed (en blanco) Si se establece, Visual Studio usa los
personalizada archivos de Typeshed en esta ruta de
acceso en lugar de su versión
empaquetada. Omita si la opción
Deshabilitar las finalizaciones
desde Typeshed está establecida.
Opciones avanzadas del editor de Python

(Pestaña Herramientas > Opciones > Editor de texto > Python > Opciones avanzadas ).
Resultados de finalización
Mostrar la intersección de los Desactivado Cuando se establece, muestra solo

miembros tras su finalización finalizaciones admitidas por todos los
tipos posibles.
Filtrar la lista según una cadena Activado Aplica el filtrado de las sugerencias de
de búsqueda finalización a medida que escribe (está
activada de manera predeterminada).
Mostrar automáticamente Activado Desactive esta opción para deshabilitar

finalizaciones para todos los las finalizaciones en las ventanas
identificadores interactivas y en el editor.
Selección en la lista de finalización

Confirmado escribiendo los {}[]().,:;+-*/%&|^~=<>#@\ Normalmente, estos caracteres siguen

siguientes caracteres un identificador que puede
seleccionarse de una lista de
finalización, por lo que es conveniente
confirmar la finalización simplemente
escribiendo un carácter. Puede quitar o
agregar caracteres específicos a la lista
según se quiera.
Entrar confirma la finalización Activado Cuando se establece, la tecla Entrar

actual selecciona y aplica la finalización
seleccionada actualmente como sucede
con los caracteres anteriores (pero, por
supuesto, no existe un carácter para
Entrar por lo que no puede estar en
esa lista directamente).
Agregar nueva línea con Entrar al Desactivado De manera predeterminada, si escribe

final de palabras completas la palabra completa que aparece en el
elemento emergente de finalización y
presiona Entrar , confirma esa
finalización. Al establecer esta opción,
las finalizaciones se confirman de
manera eficaz al dejar de escribir el
identificador, de manera que Entrar
inserta una línea nueva.
Otras opciones
Especificar el modo de Activado Activa automáticamente la

esquematización al abrir los característica de esquematización de
archivos Visual Studio en el editor al abrir un
archivo de código de Python.
Quitar mensajes de REPL al pegar Activado Quita >>> y ... del texto pegado, lo
que permite una transferencia sencilla
de código de la ventana interactiva al
editor. Desactive esta opción si necesita
conservar esos caracteres al pegar
desde otros orígenes.
Nombres de colores basados en Activado Habilita los colores de la sintaxis en el

tipos código de Python.
Opciones de fuentes y colores
(Pestaña Entorno > Fuentes y colores dentro del grupo Editor de texto ).
Los nombres de las opciones de Pyhton están precedidas por Python y se explican por sí mismos. La fuente
predeterminada para todos los temas de color de Visual Studio es Consolas de 10 puntos, normal (no negrita).
Los colores predeterminados varían según el tema. Normalmente, una fuente o un color se cambia si le resulta
difícil de leer texto con la configuración predeterminada.

Python

Cargado por

Copyright:

Formatos disponibles

Python

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Python

Cargado por

Copyright:

Formatos disponibles

Contents

Python en Visual Studio

Compatibilidad con diversos intérpretes

Edición enriquecida, IntelliSense y comprensión del código

Sistema de proyecto y plantillas de proyecto y de elemento

Depuración repleta de características

Herramientas de generación de perfiles con informes completos

Para obtener más información:

Para obtener más información:

SDK de Azure para Python

GEN ERA C 2013

Características de productividad populares

Subrayados ondulados y Acciones rápidas

Características eficaces de Python

Interacción con C++

Integración de SQL Server

Para obtener más información:

Servicios y SDK adicionales

Visual Studio 2019 y Visual Studio 2017

Distribuciones de Python Elija cualquier combinación de las opciones disponibles,

Herramientas de desarrollo nativo de Python Instala el compilador de C++ y otros componentes

Distribuciones de Python Elija cualquier combinación de las opciones disponibles,

Herramientas de desarrollo nativo de Python Instala el compilador de C++ y otros componentes

Visual Studio 2015

Visual Studio 2013 y anterior

De manera predeterminada, la instalación de la carga de trabajo de desarrollo de Python en Visual Studio de

CPython Intérprete "nativo" y que se usa con más frecuencia,

IronPython Implementación de .NET de Python, disponible en versiones

Anaconda Plataforma de ciencia de datos abierta con tecnología de

PyPy Implementación JIT de seguimiento de alto rendimiento de

Jython Implementación de Python en la Máquina virtual Java (JVM).

<a name="create-the-project">Crear el proyecto

1. Abra Visual Studio 2022.

Instalación de la biblioteca de Flask

Agregar un archivo de código

from flask import Flask

# Create an instance of the Flask class that is the WSGI application.

# Flask route decorators map / and /hello to the hello function.

from flask import Flask

# Create an instance of the Flask class that is the WSGI application.

# Flask route decorators map / and /hello to the hello function.

Si un explorador no se abre automáticamente, inicie el explorador que quiera y vaya a localhost:4449 .

from flask import Flask

Pregunta: ¿Qué otras plantillas de Python ofrece Visual Studio?

8. La salida del programa aparece en una ventana de comandos independiente:

Establecimiento de un directorio de trabajo

1. Inicie Visual Studio y seleccione Archivo > Nuevo > Proyecto .

Instalación de la extensión de GitHub para Visual Studio

Trabajo con GitHub en Visual Studio

12. Abra python3/koans/about_asserts.py desde el Explorador de soluciones y haga doble clic en el

self.assertTrue(True) # This should be True

4. Seleccione la plantilla Microsoft/python-sklearn-classifier-cookiecutter y, después, haga clic en

Paso 1: Crear un proyecto de Python

En el nivel superior se encuentra la solución, que, de forma predeterminada, tiene el mismo

Profundizar un poco más

Paso anterior : Crear un nuevo proyecto de Python

4. Complete la instrucción para que coincida con lo siguiente:

print("Hello, Visual Studio")

9. Escriba o seleccione sys para completar la línea.

init.py El archivo que identifica la aplicación como un paquete.

init.py El archivo que identifica la aplicación como un paquete.