Python Visual Studio

Contents
Python no Visual Studio

Visão geral
Visão geral do suporte do Python
Fazer um tour pelo IDE do Visual Studio
Carga de trabalho de aplicativos analíticos e de ciência de dados
Instalação
Instalação
Instalar interpretadores do Python
Inícios rápidos
Criar um aplicativo Web com Flask
Criar um projeto por meio de um modelo
Abrir e executar código Python em uma pasta
Criar um projeto com base no código existente
Criar um projeto por meio de um repositório
Criar um projeto por meio de um modelo do Cookiecutter
Tutoriais
0 – Instalar o suporte do Python
1 – Criar um projeto do Python
2 – Gravar e executar código
3 – Usar uma janela interativa REPL
4 – Executar o código no depurador
5 – Instalar pacotes e gerenciar ambientes do Python
6 – Trabalhar com o Git
Saiba mais sobre Django no Visual Studio
1 – Criar um projeto e solução
2 – Criar um aplicativo Django
3 – Servir arquivos estáticos e adicionar páginas
4 – Usar o modelo Projeto Web Django
5 - Autenticar usuários
6 – Usar o modelo Pesquisa Projeto Web Django
Conheça o Flask no Visual Studio
1 – Criar um projeto e solução
2 – Criar um aplicativo Flask
3 – Servir arquivos estáticos e adicionar páginas
4 – Usar o modelo Projeto Web Flask
5 – Usar o modelo Pesquisas Projeto Web Flask
Conceitos
Projetos do Python
Projetos do Python
Modelos de projeto Web
Modelo de projeto Web Django
Modelo de serviço de nuvem do Azure
SDK do Azure para Python
Guias de instruções
Gerenciar ambientes do Python
Selecionar um interpretador para um projeto
Usando requirements.txt para dependências
Caminhos de pesquisa
Referência da janela do ambiente
Configurar aplicativos Web para IIS
Editar código do Python
Código de formatação
Refatorar o código
Usar PyLint
Definir comandos de menu personalizados
Python interativo (REPL)
Python interativo (REPL)
Usando o IPython REPL
Depuração
Depuração
Depurando código em computadores remotos Linux
Como publicar no Serviço de Aplicativo do Azure no Linux
Interagir com C++
Criando uma extensão do C++ para o Python
Depuração de modo misto do Python/C++
Símbolos para a depuração de modo misto
Criação de perfil
Teste de unidade
Usando a extensão Cookiecutter
Referência
Modelos de itens
Opções
Trabalhar com Python no Visual Studio no Windows
23/03/2020 • 26 minutes to read • Edit Online
O Python é uma linguagem de programação popular confiável, flexível, fácil de aprender, de uso gratuito em todos
os sistemas operacionais e com suporte em uma sólida comunidade de desenvolvedores e várias bibliotecas
gratuitas. O Python permite todas as formas de desenvolvimento, incluindo aplicativos Web, serviços Web,
aplicativos de área de trabalho, scripts e computação científica, além de ser usado por diversas universidades,
cientistas, desenvolvedores amadores e também desenvolvedores profissionais. Saiba mais sobre a linguagem em
python.org e em Python para iniciantes.
O Visual Studio é um IDE do Python poderoso no Windows. O Visual Studio é compatível com software livre para a
linguagem Python por meio de cargas de trabalho de Desenvolvimento em Python e de Ciência de Dados
(Visual Studio 2017 e posteriores) e a extensão gratuita das Ferramentas Python para Visual Studio (Visual Studio
2015 e anteriores).
No momento, o Python não tem suporte no Visual Studio para Mac, mas está disponível no Mac e no Linux por
meio do Visual Studio Code (veja as perguntas e respostas).
Introdução:
Siga as instruções de instalação para configurar a carga de trabalho Python.
Familiarize-se com os recursos do Python no Visual Studio examinando as seções neste artigo.
Realize ou mais Guias de Início Rápido para criar um projeto. Se você não tiver certeza, comece com Criar um
aplicativo Web com o Flask.
Realize ou mais Guias de Início Rápido para criar um projeto. Se você não tiver certeza, comece com Quickstart:
Abra e execute o código Python em uma pasta ou Crie um aplicativo web com o Flask.
Siga o tutorial Trabalhar com o Python no Visual Studio para ter uma experiência completa de ponta a ponta.
NOTE
O Visual Studio suporta a versão Python 2.7, bem como a versão 3.5 a 3.7. Embora seja possível usar o Visual Studio para
editar código escrito em outras versões do Python, essas versões não são oficialmente aceitas, e recursos como o IntelliSense
e a depuração podem não funcionar. O suporte ao Python versão 3.8 ainda está em desenvolvimento, detalhes específicos
sobre o suporte podem ser vistos neste problema de rastreamento no GitHub.
Suporte para vários interpretadores

A janela Ambientes do Python do Visual Studio (mostrada abaixo em uma exibição ampla, expandida) fornece
um único local para gerenciar todos os ambientes do Python globais, os ambientes do Conda e os ambientes
virtuais. O Visual Studio detecta automaticamente as instalações do Python em locais padrão e permite que você
configure instalações personalizadas. Em cada ambiente, é possível gerenciar pacotes, abrir uma janela interativa
desse ambiente e acessar as pastas do ambiente facilmente.
Use o comando Abrir janela interativa para executar o Python de maneira interativa no contexto do Visual
Studio. Use o comando Abrir no PowerShell para abrir uma janela Comando separada na pasta do ambiente
selecionado. Nessa janela Comando, você pode executar qualquer script de Python.
Para mais informações:
Referência aos ambientes do Python
Edição avançada, IntelliSense e compreensão do código

O Visual Studio oferece um editor de Python de primeira classe, incluindo coloração de sintaxe, preenchimento
automático em todo o código e em todas as bibliotecas, formatação de código, ajuda de assinatura, refatoração,
dicas de tipo e linting. O Visual Studio também oferece recursos exclusivos como exibição de classe, Go to
Definition, Find All References e code snippets. A integração direta com a janela Interactive ajuda você a
desenvolver rapidamente o código Python que já está salvo em um arquivo.
Docs: Editar o código Python
Docs: Formatar o código
Docs: Refatorar o código
Docs: Usar um linter
Documentos de recursos gerais do Visual Studio: Recursos do editor de código
Janela Interativa
Para cada ambiente do Python conhecido para o Visual Studio, você pode abrir facilmente o mesmo ambiente
interativo (REPL) de um interpretador de Python diretamente no Visual Studio, em vez de usar um prompt de
comando separado. Também é possível mudar facilmente de ambiente. (Para abrir um prompt de comando
separado, selecione o ambiente desejado na janela Ambientes do Python e, em seguida, selecione o comando
Abrir no PowerShell , conforme explicado anteriormente em Suporte para vários intérpretes.)
O Visual Studio também oferece uma integração apertada entre o editor de código Python e a janela Interactive.
O atalho de teclado Ctrl +Enter envia convenientemente a linha atual de código (ou bloco de código) no editor
para a janela Interativa e, em seguida, passa para a próxima linha (ou bloquear). O Ctrl +Enter permite que você
passe facilmente pelo código sem ter que executar o depurador. Você também pode enviar código selecionado
para a janela Interativa com o mesmo tecla e colar facilmente código da janela Interativa para o editor. Juntos,
esses recursos permitem que você elabore detalhes para um segmento de código na janela Interativo e salve
facilmente os resultados em um arquivo no editor.
O Visual Studio também é compatível com IPython/Jupyter no REPL, incluindo gráficos embutidos, .NET e WPF
(Windows Presentation Foundation).
Janela interativa
IPython no Visual Studio
Sistema de projeto e modelos de projeto e de item

NOTE
O Visual Studio 2019 dá suporte à abertura de uma pasta que contém o código do Python e à execução do código sem criar
arquivos de projeto e solução do Visual Studio. Para obter mais informações, consulte Quickstart: Abra e execute o código
Python em uma pasta. No entanto, há benefícios em usar um arquivo de projeto, conforme explicado nesta seção.
O Visual Studio ajuda você a gerenciar a complexidade de um projeto à medida que ele cresce ao longo do tempo.
Um projeto do Visual Studio é muito mais do que uma estrutura de pastas: ele inclui um reconhecimento de como
diferentes arquivos são usados e como se relacionam entre si. O Visual Studio ajuda a diferenciar código do
aplicativo, código de teste, páginas da Web, JavaScript, scripts de build e assim por diante, o que permite usar os
recursos apropriados para cada arquivo. Além disso, uma solução do Visual Studio ajuda você a gerenciar vários
projetos relacionados, como um projeto Python e um projeto de extensão C++.
Modelos de projeto e de item automatizam o processo de configuração de diferentes tipos de projetos e arquivos,
economizando tempo e eliminando a necessidade de gerenciar detalhes complexos e propensos a erros. O Visual
Studio fornece modelos para projetos da Web, do Azure, de ciência de dados, de console e de outros tipos,
juntamente com modelos de arquivos, como classes do Python, testes de unidade, configuração da Web do Azure,
HTML e até mesmo aplicativos Django.
Docs: Gerenciar projetos Python
Documentos: referência de modelos de item
Docs: Modelos de projeto Python
Docs: Trabalhar com C++ e Python
Docs de recursos gerais do Visual Studio: Modelos de projeto e de item
General Visual Studio apresenta docs: Soluções e projetos no Visual Studio
Depuração completa
Um dos pontos fortes do Visual Studio é seu depurador avançado. Para Python especificamente, o Visual Studio
inclui depuração de modo misto Python/C++, depuração remota no Linux, depuração dentro da janela Interativa
e depuração de testes de unidade do Python.
No Visual Studio 2019, é possível executar e depurar código sem a necessidade de um arquivo de projeto do
Visual Studio. Consulte Quickstart: Abra e execute o código Python em uma pasta, por exemplo.
Docs: Depurar o Python
Docs: Depuração de modo misto Python/C++
Docs: Depuração remota no Linux
Geral Visual Studio feature docs: Feature tour do Visual Studio Debugger
Ferramentas de criação de perfil com relatórios abrangentes

A criação de perfil explora como o tempo está sendo gasto no aplicativo. O Visual Studio permite a criação de perfil
com interpretadores baseados em CPython e inclui a capacidade de comparar o desempenho entre diferentes
execuções de criação de perfil.

Docs: Ferramentas de criação de perfil do Python
Docs de recursos gerais do Visual Studio: Tour do recurso de criação de perfil. (Nem todos os recursos de
criação de perfil do Visual Studio estão disponíveis para Python).
Ferramentas de teste de unidade
Descubra, execute e gerencie testes no Visual Studio Test Explorer e depura facilmente testes unitários.

Docs: Ferramentas de teste de unidade do Python
Docs de recursos gerais do Visual Studio: Execute teste de unidade no código.
SDK do Azure para Python

As bibliotecas do Azure para Python simplificam o consumo de serviços do Azure em aplicativos do Windows, do
Mac OS X e do Linux. Você pode usá-las para criar e gerenciar recursos do Azure, bem como para se conectar aos
serviços do Azure.
Para obter mais informações, confira SDK do Azure para Python e Bibliotecas do Azure para Python.
Perguntas e respostas
P. O supor te ao Python está disponível no Visual Studio para Mac?
a. Não no momento, mas você pode votar na solicitação em Comunidade de Desenvolvedores. A documentação do
Visual Studio para Mac identifica os tipos atuais de desenvolvimento aos quais dá suporte. Enquanto isso, o Visual
Studio Code no Windows, Mac e Linux funciona bem com o Python por meio das extensões disponíveis.
P. O que posso usar para construir ui com Python?
a. A oferta principal nessa área é o Projeto Qt, com associações de Python conhecidas como PySide (a associação
oficial) (consulte também Downloads do PySide) e PyQt. No momento, o suporte do Python no Visual Studio não
inclui quaisquer ferramentas específicas para desenvolvimento da interface do usuário.
P. Um projeto Python pode produzir um executável autônomo?
a. Geralmente, o Python é uma linguagem interpretada, com a qual o código é executado sob demanda em um
ambiente compatível com o Python, como o Visual Studio e servidores Web. No momento, o Visual Studio não
fornece meios para criar um executável autônomo, o que, basicamente, é um programa com um interpretador de
Python incorporado. No entanto, a comunidade do Python forneceu maneiras diferentes de criar executáveis,
conforme descrito em StackOverflow. O CPython também suporta ser incorporado em um aplicativo nativo,
conforme descrito na postagem do blog, usando o arquivo zip incorporável do CPython.
Suporte a recursos
Os recursos do Python podem ser instalados nas seguintes edições do Visual Studio, conforme é descrito no guia
de instalação:
Visual Studio 2019 (todas as edições)
Visual Studio 2013 Community Edition
Visual Studio 2013 Express para Web, Atualização 2 ou posterior
Visual Studio 2013 Express para Área de Trabalho, Atualização 2 ou posterior
Visual Studio 2013 (edição Pro ou superior)
Visual Studio 2012 (edição Pro ou superior)
Visual Studio 2010 SP1 (edição Pro ou superior; o .NET 4.5 é necessário)
O Visual Studio 2015 e as versões anteriores estão disponíveis em visualstudio.microsoft.com/vs/older-
downloads/.
IMPORTANT
Somente há suporte e manutenção completos para os recursos na versão mais recente do Visual Studio. Os recursos estão
disponíveis nas versões mais antigas, mas não recebem manutenção ativa.
SUP O RT E
PA RA 2013 2013 2013 2012 2010 SP 1
PYT H ON 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Gerenciar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
vários
interpreta
dores
Detecção ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
automátic
a de
interpreta
dores
populares
Adição de ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
interpreta
dores
personaliz
ados
Ambiente ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
s Virtuais
PIP/Fácil ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
instalação
SIST EM A
DE 2013 2013 2013 2012 2010 SP 1
P RO JETO 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Novo ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
projeto
com base
em um
código
existente
Mostrar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
todos os
arquivos
Controle ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
do
código-
fonte
Integraçã ✔ ✔ ✔ ✔ ✔ ✔ ✔1 ✗
o do Git
2013 2013 2013 2012 2010 SP 1

EDIÇ Ã O 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Realce de ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
sintaxe
Preenchi ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
mento
automátic
o
Ajuda da ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
assinatura
Informaçõ ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
es rápidas
Modo de ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
exibição
de
classe/pes
quisador
de
objetos
Barra de ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
navegaçã
o
Ir para ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
Definição
2013 2013 2013 2012 2010 SP 1
EDIÇ Ã O 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Navegar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
para
Localizar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
Todas as
Referência
s
Recuo ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
automátic
o
Formataç ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
ão de
código
Refatorar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
–
renomear
Refatorar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
– extrair
método
Refatorar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
–
adicionar
ou
remover
importaçã
o
PyLint ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
JA N EL A
IN T ERAT I 2013 2013 2013 2012 2010 SP 1
VA 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Janela ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
Interativa
IPython ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
com
grafos
embutido
s
2013 2013 2013 2012 2010 SP 1
DESK TO P 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Aplicativo ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
de
console/d
o
Windows
WPF do ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
IronPytho
n (com o
designer
XAML)
Windows ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
Forms do
IronPytho
n
2013 2013 2013 2012 2010 SP 1

W EB 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Projeto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
Web do
Django
Projeto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
Web do
Bottle
Projeto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
Web do
Flask
Projeto ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
Web
genérico
2013 2013 2013 2012 2010 SP 1

A Z URE 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Implantar ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔2
no site da
Web
Implantar ✔ ✔ ✔ ✗ ✔4 ✔4 ✔3 ✗
na função
Web
Implantar ? ? ? ✗ ✔4 ✔4 ✔3 ✗
na função
de
trabalho
2013 2013 2013 2012 2010 SP 1
A Z URE 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Execução ? ? ? ✗ ✔4 ✔4 ✔3 ✗
no
emulador
do Azure
Depuraçã ✔ ✔ ✔ ✗ ✔6 ✔8 ✔8 ✗
o remota
Anexar o ✔ ✔ ✔ ✗ ✔7 ✔7 ✗ ✗
Gerenciad
or de
Servidores
M O DELO S
DO 2013 2013 2013 2012 2010 SP 1
DJA N GO 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Depuraçã ✔ ✔ ✔ ✗ ✔ ✔ ✔ ✔
o
Preenchi ✔ ✔ ✔ ✗ ✔5 ✔5 ✔ ✔
mento
automátic
o
Preenchi ✔ ✔ ✔ ✗ ✔5 ✔5 ✗ ✗
mento
automátic
o para
CSS e
JavaScript
DEP URA Ç 2013 2013 2013 2012 2010 SP 1

ÃO 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Depuraçã ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
o
Depuraçã ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
o sem um
projeto
Depuraçã ✔ ✔ ✔ ✔ ✗ ✔ ✔ ✔
o–
anexação
à edição
Depuraçã ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
o de
modo
misto
DEP URA Ç 2013 2013 2013 2012 2010 SP 1
ÃO 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Depuraçã ✔ ✔ ✔ ✔ ✗ ✔ ✔ ✔
o remota
(Windows,
Mac OS
X, Linux)
Depurar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✔
janela
Interativa
C RIA Ç Ã O 2013 2013 2013 2012 2010 SP 1

DE P ERF IL 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Criação ✔ ✔ ✔ ✗ ✗ ✔ ✔ ✔
de perfil
2013 2013 2013 2012 2010 SP 1

T EST E 2017+ 2015 C OMM DESK TO P 2013 W EB P RO + P RO + P RO +
Gerenciad ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
or de
testes
Executar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
teste
Depurar ✔ ✔ ✔ ✔ ✔ ✔ ✔ ✗
teste
1. O suporte do Git para o Visual Studio 2012 está disponível na extensão Ferramentas do Visual Studio para
Git, disponível no Visual Studio Marketplace.
2. A implantação no Site do Azure exige o SDK do Azure para .NET 2.1 – Visual Studio 2010 SP1. Versões
posteriores não dão suporte ao Visual Studio 2010.
3. O suporte à Função Web e à Função de Trabalho do Azure exige o SDK do Azure para .NET 2.3 – VS 2012 ou
posterior.
4. O suporte à Função Web e à Função de Trabalho do Azure exige o SDK do Azure para .NET 2.3 – VS 2013 ou
posterior.
5. O editor de modelos do Django no Visual Studio 2013 apresenta alguns problemas conhecidos que foram
resolvidos com a instalação da Atualização 2.
6. Exige o Windows 8 ou posterior. O Visual Studio 2013 Express for Web não tem a caixa de diálogo 'Anexar
ao processo', mas a depuração remota do Site do Azure ainda é possível usando o comando Attach
Debugger (Python) no Ser ver Explorer . A depuração remota exige o SDK do Azure para .NET 2.3 –
Visual Studio 2013 ou posterior.
7. Exige o Windows 8 ou posterior. O comando Anexar Depurador (Python) no Gerenciador de
Ser vidores exige o SDK do Azure para .NET 2.3 - Visual Studio 2013 ou posterior.
8. Exige o Windows 8 ou posterior.
Bem-vindo ao IDE do Visual Studio | Python
O ambiente de desenvolvimento integrado do Visual Studio é um painel de inicialização criativo para o Python (e
outras linguagens) que você pode usar para editar, depurar e testar o código e, em seguida, publicar um aplicativo.
Um IDE (ambiente de desenvolvimento integrado) é um programa repleto de recursos que pode ser usado por
muitos aspectos do desenvolvimento de software. Além do editor e do depurador padrão fornecidos pela maioria
dos IDEs, o Visual Studio inclui ferramentas de preenchimento de código, ambientes de REPL interativo e outras
funcionalidades para facilitar o processo de desenvolvimento de software.
Esta imagem mostra o Visual Studio com um projeto aberto do Python e várias janelas de ferramentas importantes
que você provavelmente usará:
O Gerenciador de Soluções (parte superior direita) permite exibir, navegar e gerenciar os arquivos de
código. Gerenciador de soluções pode ajudar a organizar seu código agrupando os arquivos em soluções
e projetos.
Ao lado do Gerenciador de Soluções estão os Ambientes do Python , nos quais você gerencia os
diferentes interpretadores do Python instalados no computador.
Também é possível abrir e executar código Python em uma pasta sem criar arquivos de projeto e solução
do Visual Studio. Para obter mais informações, consulte início rápido: abrir e executar o código Python
em uma pasta.
A janela do editor (parte central), na qual você provavelmente passará a maior parte do tempo, exibe o
conteúdo do arquivo. É nela que você edita o código Python, navega na estrutura de código e define pontos
de interrupção durante as sessões de depuração. Com o Python, você também pode selecionar o código e
pressionar Ctrl+Enter para executar o código em uma janela de REPL interativo.
A Janela de Saída (parte central inferior) é o local em que o Visual Studio envia notificações, como
mensagens de erro e de depuração, avisos, mensagens de status da publicação, entre outros. Cada fonte de
mensagem tem uma guia própria.
Uma janela de REPL Interativo do Python é exibida na mesma área da Janela de Saída.
O Team Explorer (canto inferior direito) permite que você acompanhe itens de trabalho e compartilhe o
código com outras pessoas usando tecnologias de controle de versão como o Git e o TFVC (Controle de
Versão do Team Foundation).
Edições
O Visual Studio está disponível para o Windows e o Mac; no entanto, o suporte ao Python está disponível apenas
no Visual Studio para Windows.
Há três edições do Visual Studio no Windows: Comunidade, Professional e Enterprise. Veja Comparar IDEs do
Visual Studio para saber quais recursos são compatíveis com cada edição.
Recursos de produtividade populares

Alguns dos recursos populares no Visual Studio que ajudam você a ser mais produtivo durante o desenvolvimento
de software incluem:
IntelliSense
IntelliSense é um termo usado para um conjunto de recursos que exibe informações sobre o código
diretamente no editor e, em alguns casos, escreve pequenos trechos de código para você. É como ter a
documentação básica embutida no editor, o que evita que você tenha que consultar informações de tipo em
outro lugar. As funcionalidades do IntelliSense variam de acordo com a linguagem e o artigo Editando o
código Python traz detalhes sobre o Python. A seguinte ilustração mostra como o IntelliSense exibe uma
lista de membros para um tipo:
Refatoração
Se você clicar com o botão direito do mouse em uma parte do código e selecionar Ações rápidas e
Refatorações , o Visual Studio fornecerá operações como renomeação inteligente de variáveis, extração de
uma ou mais linhas de código em um novo método, alteração da ordem dos parâmetros de método, entre
outros.
Linting
O linting verifica se há erros e problemas comuns no código Python, incentivando você a usar bons padrões
de codificação do Python.
Caixa de pesquisa
O Visual Studio pode parecer assustador, às vezes, com tantas propriedades, opções e menus. A caixa de
pesquisa é uma ótima maneira de encontrar rapidamente o que você precisa no Visual Studio. Quando você
começa a digitar o nome de algo que está procurando, o Visual Studio lista resultados que levam você
exatamente para o local em que precisa ir. Caso você precise adicionar uma funcionalidade ao Visual Studio,
por exemplo, para adicionar suporte a outra linguagem de programação, a caixa de pesquisa fornecerá
resultados que abrem o Instalador do Visual Studio para instalar uma carga de trabalho ou um componente
individual.
Rabiscos e Ações Rápidas

Rabiscos são sublinhados ondulados que alertam você sobre erros ou problemas potenciais no código
durante a digitação. Essas pistas visuais permitem que você corrija os problemas imediatamente sem
esperar que o erro seja descoberto durante o build ou quando você executar o programa. Se você focalizar
um rabisco, verá informações adicionais sobre o erro. Uma lâmpada também pode ser exibida na margem
esquerda com ações, conhecidas como Ações Rápidas, para corrigir o erro.
Acessar e Escolher Definição

O recurso ir para definição leva você diretamente para o local onde uma função ou tipo é definido. O
comando Inspecionar Definição exibe a definição em uma janela sem abrir um arquivo separado. O
comando Localizar Todas as Referências também fornece uma maneira útil de descobrir em que local
um identificador especificado foi definido e usado.
Funcionalidades avançadas do Python

Executar código sem um projeto
A partir do Visual Studio 2019, você pode abrir uma pasta que contém o código Python para aproveitar
recursos como IntelliSense e depuração sem precisar criar um projeto do Visual Studio para o código.
Colaborar usando o Visual Studio
O Visual Studio Live Share permite que você edite e depure de forma colaborativa com outras pessoas em
tempo real, independente da linguagem de programação usada ou dos tipos de aplicativo criados.
REPL Interativo do Python
O Visual Studio fornece uma janela interativa REPL (leitura-avaliação-impressão-loop) para cada um dos
ambientes do Python, que é uma melhoria do REPL obtido com python.exe na linha de comando. Na janela
Interativa , você pode inserir um código Python arbitrário e ver resultados imediatos.
Depuração
O Visual Studio fornece uma experiência de depuração abrangente para Python, incluindo anexar a
processos em execução, avaliar expressões na inspeção e janelas imediatas , inspecionar variáveis locais,
pontos de interrupção, instruções Step in/out/over, definir a próxima instrução e muito mais. Você
também pode depurar um código Python remoto executado em computadores Linux.
Interagindo com o C++

Muitas bibliotecas criadas para o Python são escritas em C++ para um desempenho ideal. O Visual Studio
fornece funcionalidades sofisticadas para o desenvolvimento de extensões em C++, incluindo a depuração
de modo misto.
Criação de perfil
Ao usar um interpretador baseado em CPython, você pode avaliar o desempenho do código Python no
Visual Studio.
Testes de unidade
O Visual Studio fornece suporte integrado para descoberta, execução e depuração de testes de unidade,
tudo no contexto do IDE.
Próximas etapas
Explore ainda mais o Python no Visual Studio seguindo um destes tutoriais ou inícios rápidos:
Início rápido: criar um aplicativo Web com o Flask
Trabalhar com o Python no Visual Studio
Introdução à estrutura da Web do Django no Visual Studio
Introdução à estrutura da Web Flask no Visual Studio
Confira também
Descubra mais recursos do Visual Studio
Visite visualstudio.microsoft.com
Leia The Visual Studio blog (O blog do Visual Studio)
Instalar o suporte para ciência de dados no Visual
Studio
A carga de trabalho de Aplicativos de Ciência de Dados e Analíticos, selecionada e instalada por meio do Instalador
do Visual Studio, reúne várias linguagens e suas respectivas distribuições de runtime:
Python e Anaconda
F# com o .NET Framework
R e Microsoft R Client
Python
F# com o .NET Framework
O Python e o R são duas das linguagens de script principais usadas para ciência de dados. Essas duas linguagens
são fáceis de aprender e compatíveis com um rico ecossistema de pacotes. Esses pacotes abordam uma ampla
variedade de cenários, como aquisição de dados, limpeza, treinamento de modelo, implantação e criação de
gráficos. O F# também é uma linguagem avançada do .NET que prima pela funcionalidade e é adequada a uma
ampla variedade de tarefas de processamento de dados.
O Python é uma das linguagens de script principais usadas para ciência de dados. O Python é fácil de aprender e é
compatível com um rico ecossistema de pacotes. Esses pacotes abordam uma ampla variedade de cenários, como
aquisição de dados, limpeza, treinamento de modelo, implantação e criação de gráficos. O F# também é uma
linguagem avançada do .NET que prima pela funcionalidade e é adequada a uma ampla variedade de tarefas de
processamento de dados. (Para a linguagem R, recomendamos o Azure Notebooks.)
Opções de carga de trabalho
Por padrão, a carga de trabalho instala as opções a seguir, que você pode modificar na seção de resumo da carga
de trabalho no Instalador do Visual Studio:
Suporte à linguagem F# da área de trabalho
Python:
Suporte da linguagem Python
Suporte Web do Python
Suporte à linguagem F#
Python:
Suporte da linguagem Python
Anaconda3 de 64 bits, uma distribuição Python que inclui bibliotecas de ciência de dados abrangentes e
um interpretador Python.
Suporte Web do Python
Suporte do modelo Cookiecutter
R:
Suporte à linguagem R
Suporte de runtime para ferramentas de desenvolvimento do R
Microsoft R Client (O interpretador R totalmente compatível e com suporte da comunidade da Microsoft
com bibliotecas ScaleR para computação mais rápida em nós únicos ou clusters. Você também pode
usar qualquer R do CRAN.)
Integração ao SQL Server

O SQL Server dá suporte ao uso do Python e do R para análises avançadas diretamente no SQL Server. O suporte
ao R é incluído com o SQL Server 2016 e posterior; o suporte ao Python está disponível no SQL Server 2017 CTP
2.0 e posterior.
O SQL Server dá suporte ao uso do Python para análises avançadas diretamente no SQL Server. O suporte ao
Python está disponível no SQL Server 2017 CTP 2.0 e posterior.
Aproveite as seguintes vantagens executando o código no local em que os dados já residem:
Eliminação da movimentação de dados : Em vez de mover dados do banco de dados para seu aplicativo
ou modelo, você pode construir aplicativos no banco de dados. Essa funcionalidade elimina os obstáculos
de segurança, de conformidade, de governança, de integridade, bem como um host de problemas
semelhantes relacionados à movimentação de grandes quantidades de dados. Também consuma conjuntos
de dados que não se ajustam à memória de um computador cliente.
Implantação fácil : Uma vez que você tenha um modelo pronto, implantá-lo na produção é uma questão
simples de incorporá-lo em um script T-SQL. Os aplicativos cliente SQL codificados em qualquer linguagem
poderão aproveitar os modelos e a inteligência por meio de uma chamada de procedimento armazenado.
Nenhuma integração de linguagem específica é necessária.
Desempenho e escala de nível corporativo: Você pode usar os recursos avançados do SQL Server,
como tabela de memória e índices de armazenamento de colunas com as APIs escaláveis de alto
desempenho nos pacotes RevoScale. A eliminação da movimentação de dados também significa que você
evitará restrições de memória do cliente à medida que os dados aumentam ou que você deseja aumentar o
desempenho do aplicativo.
Rich extensibility : Você pode instalar e executar qualquer um dos pacotes de código aberto mais recentes
no SQL Server para criar aplicativos de deep learning e IA em enormes quantidades de dados no SQL
Server. A instalação de um pacote no SQL Server é tão simples quanto instalar um pacote no computador
local.
Ampla disponibilidade sem custo adicional : Integrações linguísticas estão disponíveis em todas as
edições do SQL Server 2017 e posteriores, incluindo a edição Express.
Para aproveitar ao máximo a integração ao SQL Server, use o instalador do Visual Studio para instalar a carga de
trabalho de Processamento e armazenamento de dados com a opção SQL Ser ver Data Tools . A última
opção habilita o SQL IntelliSense, o realce de sintaxe e a implantação.

Trabalhar com o SQL Server e R
Análises avançadas no banco de dados com o R no SQL Server 2016 (blog)
Python no SQL Server 2017: aprendizado de máquina avançado no banco de dados (blog)
SDKs e serviços adicionais

Além do que está diretamente na carga de trabalho aplicativos de ciência de dados e de análise, o serviço Azure
Notebooks e o SDK do Azure para Python também são úteis para ciência de dados.
O SDK do Azure para Python facilita o consumo e gerenciamento de serviços do Microsoft Azure em aplicativos
executados no Windows, Mac e Linux. Para obter mais informações, veja SDK do Azure para Python.
O Azure Notebooks (atualmente em versão prévia) fornece acesso online gratuito aos blocos de anotações do
Jupyter em execução na nuvem no Microsoft Azure. Como introdução, o serviço inclui blocos de anotações de
exemplo em Python, em R e em F#. Visite notebooks.azure.com.
Como instalar o suporte do Python no Visual
Studio no Windows
Para instalar o suporte do Python para Visual Studio (também conhecido como Ferramentas Python para
Visual Studio ou PTVS), siga as instruções na seção que corresponda à sua versão do Visual Studio:
Visual Studio 2017 e Visual Studio de 2019
Visual Studio 2015
Visual Studio 2013 e anterior
Para testar rapidamente o suporte do Python após seguir as etapas de instalação, abra a janela do Python
Interactive pressionando ALT + I e inserindo 2+2 . Se você não vir a saída de 4 , verifique as etapas
novamente.
TIP
A carga de trabalho do Python inclui a extensão útil Cookiecutter, que fornece uma interface gráfica do usuário para
descobrir modelos e opções de modelo de entrada e criar projetos e arquivos. Para obter detalhes, confira Usar o
Cookiecutter.
NOTE
O suporte ao Python não está disponível atualmente no Visual Studio para Mac, mas está disponível no Mac e no
Linux por meio do Visual Studio Code. Confira Perguntas e respostas.
Visual Studio 2019 e Visual Studio de 2017

1. Baixe e execute o Instalador do Visual Studio mais recente. Se já tiver o Visual Studio instalado, execute
o Instalador do Visual Studio, selecione a opção Modificar (consulte Modificar o Visual Studio) e vá
para a etapa 2.
Instalar a Comunidade do Visual Studio 2019
TIP
A edição Community é para desenvolvedores individuais, aprendizado em sala de aula, pesquisa acadêmica e
desenvolvimento de software livre. Para outros usos, instale o Visual Studio 2019 Professional ou o Visual
Studio 2019 Enterprise.
2. O instalador apresenta uma lista de cargas de trabalho, que são grupos de opções relacionadas para
áreas de desenvolvimento específicas. Para Python, selecione a carga de trabalho Desenvolvimento
do Python .
Opcional: se estiver trabalhando com ciência de dados, considere também a carga de trabalho para
Aplicativos de ciência de dados e análise . Essa carga de trabalho inclui suporte para as
linguagens Python, R e F#. Para obter mais informações, veja Carga de trabalho para Aplicativos de
ciência de dados e análise.
NOTE
As cargas de trabalho para Python e para Ciência de dados estão disponíveis apenas com a versão Visual
Studio 2017 15.2 e posterior.
Opcional: se estiver trabalhando com ciência de dados, considere também a carga de trabalho para
Aplicativos de ciência de dados e análise . Essa carga de trabalho inclui suporte para as
linguagens Python e F#. Para obter mais informações, veja Carga de trabalho para Aplicativos de
ciência de dados e análise.
3. No lado direito do instalador, escolha opções adicionais se desejado. Ignore essa etapa para aceitar as
opções padrão.
OPÇ ÃO DESC RIÇ Ã O

Distribuições do Python Escolha qualquer combinação de opções disponíveis,

como variantes de 32 bits e de 64 bits das distribuições
do Python 2, do Python 3, do Miniconda, do
Anaconda2 e do Anaconda3 com as quais planeja
trabalhar. Cada uma delas inclui o interpretador, o
runtime e as bibliotecas da distribuição. O Anaconda,
especificamente, é uma plataforma de ciência de dados
aberta que inclui uma grande variedade de pacotes
pré-instalados. (Você pode retornar ao instalador do
Visual Studio a qualquer momento para adicionar ou
remover distribuições.) Obser vação : se você tiver
instalado uma distribuição fora do instalador do Visual
Studio, não será necessário verificar a opção
equivalente aqui. O Visual Studio automaticamente
detecta as instalações existentes do Python. Confira A
janela Ambientes do Python. Além disso, se uma versão
mais nova que a mostrada no instalador do Python
estiver disponível, você poderá instalar essa versão
separadamente, e o Visual Studio a detectará.
Supor te do modelo Cookiecutter Instala a interface gráfica do usuário Cookiecutter para

descobrir modelos, inserir opções de modelo e criar
projetos e arquivos. Confira Usar a extensão
Cookiecutter.
Supor te Web do Python Instala as ferramentas para desenvolvimento para a

Web, incluindo suporte à edição HTML, CSS e
JavaScript, juntamente com modelos para projetos que
usam as estruturas Bottle, Flask e Django. Veja
Modelos de projeto Web do Python.
Supor te ao Python IoT Compatível com o desenvolvimento do Windows IoT

Core usando Python.
Ferramentas de desenvolvimento nativo do Instala o compilador do C++ e outros componentes

Python necessários para desenvolver extensões nativas para
Python. Confira Criar uma extensão do C++ para o
Python. Além disso, instale a carga de trabalho
Desenvolvimento de área de trabalho C++ para
obter suporte total a C++.
Principais ferramentas dos Ser viços de Nuvem Fornece suporte adicional para os Serviços de Nuvem
do Azure do Azure do desenvolvedor no Python. Consulte
projetos de serviço de nuvem do Azure.

Distribuições do Python Escolha qualquer combinação de opções disponíveis,

como variantes de 32 bits e de 64 bits das distribuições
do Python 2, do Python 3, do Miniconda, do
Anaconda2 e do Anaconda3 com as quais planeja
trabalhar. Cada uma delas inclui o interpretador, o
runtime e as bibliotecas da distribuição. O Anaconda,
especificamente, é uma plataforma de ciência de dados
aberta que inclui uma grande variedade de pacotes
pré-instalados. (Você pode retornar ao instalador do
Visual Studio a qualquer momento para adicionar ou
remover distribuições.) Obser vação : se você tiver
instalado uma distribuição fora do instalador do Visual
Studio, não será necessário verificar a opção
equivalente aqui. O Visual Studio automaticamente
detecta as instalações existentes do Python. Confira A
janela Ambientes do Python. Além disso, se uma versão
mais nova que a mostrada no instalador do Python
estiver disponível, você poderá instalar essa versão
separadamente, e o Visual Studio a detectará.
Supor te do modelo Cookiecutter Instala a interface gráfica do usuário Cookiecutter para

descobrir modelos, inserir opções de modelo e criar
projetos e arquivos. Confira Usar a extensão
Cookiecutter.
Supor te Web do Python Instala as ferramentas para desenvolvimento para a

Web, incluindo suporte à edição HTML, CSS e
JavaScript, juntamente com modelos para projetos que
usam as estruturas Bottle, Flask e Django. Veja
Modelos de projeto Web do Python.
Ferramentas de desenvolvimento nativo do Instala o compilador do C++ e outros componentes

Python necessários para desenvolver extensões nativas para
Python. Confira Criar uma extensão do C++ para o
Python. Além disso, instale a carga de trabalho
Desenvolvimento de área de trabalho C++ para
obter suporte total a C++.
Principais ferramentas dos Ser viços de Nuvem Fornece suporte adicional para os Serviços de Nuvem
do Azure do Azure do desenvolvedor no Python. Consulte
projetos de serviço de nuvem do Azure.
4. Após a instalação, o instalador fornece opções para modificar, iniciar, reparar ou desinstalar o Visual
Studio. O botão Modificar transforma-se em Atualizar quando há atualizações do Visual Studio
disponíveis para os componentes instalados. (A opção Modificar está disponível no menu suspenso.)
Você também pode iniciar o Visual Studio e o instalador no menu Iniciar do Windows pesquisando
"Visual Studio".
Solução de problemas
Se você encontrar problemas ao instalar ou executar o Python no Visual Studio, tente o seguinte:
Determine se o mesmo erro ocorre usando a CLI do Python, ou seja, executando python.exe em um
prompt de comando.
Use a opção reparar no instalador do Visual Studio.
Repare ou reinstale o Python por meio de configurações > aplicativos & recursos no Windows.
Erro de exemplo : Falha ao iniciar o processo interativo: System.ComponentModel.Win32Exception
(0x80004005): erro desconhecido (0xc0000135) em
Microsoft.PythonTools.Repl.PythonInteractiveEvaluator.d__43.MoveNext().
Visual Studio 2015

1. Execute o instalador do Visual Studio por meio do Painel de Controle > Programas e Recursos ,
selecionando Microsoft Visual Studio 2015 e, em seguida, Alterar .
2. No instalador, selecione Modificar .
3. Selecione linguagens de programação > ferramentas Python para Visual Studio e, em
seguida, Avançar :
4. Depois que a instalação do Visual Studio for concluída, instale um interpretador do Python de sua
escolha. O Visual Studio 2015 oferece suporte somente para o Python 3.5 e anteriores; as versões
posteriores geram uma mensagem como Versão 3.6 do Python incompatível . Se você já tiver um
interpretador instalado e o Visual Studio não o detectar automaticamente, consulte Identificar
manualmente um ambiente existente.
Visual Studio 2013 e anterior

1. Instale a versão apropriada das Ferramentas Python para Visual Studio para sua versão do Visual
Studio:
Visual Studio 2013: PTVS 2.2.2 para Visual Studio 2013. A caixa de diálogo arquivo > novo
projeto no Visual Studio 2013 fornece um atalho para esse processo.
Visual Studio 2010 e 2012: PTVS 2.1.1 para Visual Studio 2010 e 2012
2. Instale um interpretador do Python de sua escolha. Se você já tiver um interpretador instalado e o
Visual Studio não o detectar automaticamente, consulte Identificar manualmente um ambiente
existente.
Locais de instalação
Por padrão, o suporte do Python é instalado para todos os usuários em um computador.
Para o Visual Studio 2019 e Visual Studio 2017, a carga de trabalho do Python é instalada em
%ProgramFiles(x86)%\Microsoft Visual Studio\<VS_version>\
<VS_edition>Common7\IDE\Extensions\Microsoft\Python, em que <version> é 2019 ou 2017 e
<VS_edition> é Community, Professional ou Enterprise.
Para o Visual Studio 2015 e anterior, os caminhos de instalação são os seguintes:
32 bits:
Caminho: % arquivos de programas (x86)% \ Microsoft Visual Studio <VS_ver>
\Common7\IDE\Extensions\Microsoft\Python Tools for Visual Studio \<PTVS_ver>
Local do caminho no Registro: HKEY_LOCAL_MACHINE\Software\Microsoft\PythonTools\
<VS_ver>\InstallDir
64 bits:
Caminho: % Program Files%\Microsoft Visual Studio <VS_ver>
\Common7\IDE\Extensions\Microsoft\Python Tools for visual studio \<PTVS_ver>
Local do caminho no Registro:
HKEY_LOCAL_MACHINE\Software\Wow6432Node\Microsoft\PythonTools\
<VS_ver>\InstallDir
onde:
<VS_ver> é:
14.0 para Visual Studio 2015
<PTVS_ver > é um número de versão, como 2.2.2, 2.1.1, 2,0, 1,5, 1,1 ou 1,0.
Instalações específicas ao usuário (1.5 e anterior)
As Ferramentas Python para Visual Studio 1.5 e anterior permitiam a instalação apenas para o usuário atual e,
nesse caso, o caminho da instalação é %LocalAppData%\Microsoft\VisualStudio\
<VS_ver>\Extensions\Microsoft\Ferramentas Python para Visual Studio\<PTVS_ver>, em que <VS_ver> e
<PTVS_ver> são iguais ao descrito acima.
Por padrão, a instalação da carga de trabalho de desenvolvimento do Python no Visual Studio 2017 e versões
posteriores também instala o Python 3 (64 bits). Você pode optar por instalar as versões de 32 e 64 bits do
Python 2 e do Python 3, juntamente com o Miniconda (Visual Studio 2019) ou o Anaconda 2/Anaconda 3 (Visual
Studio 2017), conforme descrito em Instalação.
Como alternativa, você pode instalar interpretadores padrão do Python na caixa de diálogo Adicionar
Ambiente . Selecione o comando Adicionar Ambiente na janela Ambientes do Python ou na barra de
ferramentas Python, selecione a guia Instalação do Python , indique quais interpretadores instalar e selecione
Instalar .
Você também pode instalar manualmente qualquer um dos interpretadores listados na tabela abaixo fora do
instalador do Visual Studio. Por exemplo, se você instalar o Anaconda 3 antes de instalar o Visual Studio, não
será necessário instalar novamente usando o instalador do Visual Studio. Você também pode instalar um
interpretador manualmente se, por exemplo, houver uma versão mais recente disponível que ainda não aparece
no instalador do Visual Studio.
NOTE
O Visual Studio dá suporte ao Python versão 2.7, bem como à versão 3.5 e posterior. Embora seja possível usar o Visual
Studio para editar código escrito em outras versões do Python, essas versões não são oficialmente aceitas, e recursos
como o IntelliSense e a depuração podem não funcionar.
Para o Visual Studio 2015 e anterior , você deve instalar manualmente um dos interpretadores.
O Visual Studio (todas as versões) detecta automaticamente cada interpretador Python instalado e seu ambiente
verificando o Registro, de acordo com o PEP 514 – registro do Python no Registro do Windows. Geralmente, as
instalações do Python se encontram em HKEY_LOCAL_MACHINE\SOFTWARE\Python (32 bits) e
HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Python (64 bits) e, em seguida, dentro de nós para
a distribuição, como PythonCore (CPython) e ContinuumAnalytics (Anaconda).
Se o Visual Studio não detectar um ambiente instalado, consulte Identificar manualmente um ambiente
existente.
O Visual Studio mostra todos os ambientes conhecidos na janela Ambientes do Python e detecta
automaticamente as atualizações para os interpretadores existentes.
IN T ERP RETA DO R DESC RIÇ Ã O
CPython O interpretador “nativo” e mais usado, disponível em versões

de 32 e 64 bits (o recomendado é 32 bits). Inclui os últimos
recursos de linguagem, a compatibilidade máxima com
pacotes do Python, suporte de depuração completo e
interoperabilidade com o IPython. Consulte também: devo
usar o Python 2 ou o Python 3?. Observe que o Visual
Studio 2015 e os anteriores não dão suporte ao Python 3.6
ou posteriores e podem gerar erros, como Python versão
3.6 sem supor te . Use o Python 3.5 ou anteriores.
IN T ERP RETA DO R DESC RIÇ Ã O
IronPython Uma implementação do .NET do Python, disponível em

versões de 32 e 64 bits, que fornece interoperabilidade do
C#/F#/Visual Basic, acesso às APIs do .NET, depuração
padrão do Python (mas não a depuração de modo misto do
C++) e a depuração mista do IronPython/C#. No entanto, o
IronPython não dá suporte a ambientes virtuais.
Anaconda Uma plataforma aberta de ciência de dados do Python, além

de incluir a última versão do CPython e a maioria dos
pacotes difíceis de serem instalados. Recomendamos usá-la,
caso você esteja indeciso sobre qual plataforma deverá usar.
PyPy Uma implementação JIT de rastreamento de alto

desempenho do Python que é boa para programas de
execução longa e situações em que é possível identificar
problemas de desempenho, mas em que não é possível
encontrar outras resoluções. Funciona com o Visual Studio,
mas com suporte limitado para recursos de depuração
avançados.
Jython Uma implementação do Python na JVM (Máquina Virtual

Java). Semelhante ao IronPython, o código em execução no
Jython pode interagir com classes e bibliotecas Java, mas
poderá não usar várias bibliotecas destinadas ao CPython.
Funciona com o Visual Studio, mas com suporte limitado
para recursos de depuração avançados.
Para os desenvolvedores que desejam fornecer novas formas de detecção para ambientes do Python, consulte
Detecção para ambiente da PTVS (github.com).
Mover um interpretador
Se você mover um interpretador existente para um novo local usando o sistema de arquivos, o Visual Studio
não detectará automaticamente a alteração.
Se você especificou originalmente o local do interpretador por meio da janela Ambientes do Python ,
edite o ambiente usando a guia Configurar nessa janela para identificar o novo local. Consulte
Identificar manualmente um ambiente existente.
Se você instalou o interpretador usando um programa de instalação, use as etapas a seguir para
reinstalar o interpretador no novo local:
1. Restaure o interpretador do Python para o local original.
2. Desinstale-o usando o instalador, que limpa as entradas do Registro.
3. Reinstale o interpretador no local desejado.
4. Reinicie o Visual Studio, que deve detectar automaticamente o novo local em vez de o local antigo.
Esse processo garante que as entradas do Registro que identificam o local do interpretador, usado pelo Visual
Studio, sejam atualizadas corretamente. O uso de um instalador também lida com outros efeitos colaterais que
possam existir.
Consulte também
Usar requirements.txt para dependências
Referência da janela de ambientes do Python
Início rápido: crie seu primeiro aplicativo Web
Python usando o Visual Studio
Nesta introdução de 5 a 10 minutos do Visual Studio como um IDE do Python, você criará um aplicativo Web
Python simples na estrutura Flask. Crie o projeto por meio de etapas simples para ajudarão a saber mais sobre
os recursos básicos do Visual Studio.
Se você ainda não instalou o Visual Studio, vá para a página de downloads do Visual Studio para instalá-lo
gratuitamente. No instalador, selecione a carga de trabalho de Desenvolvimento de Python .
Se você ainda não instalou o Visual Studio, vá para a página de downloads do Visual Studio para instalá-lo
gratuitamente. No instalador, selecione a carga de trabalho de Desenvolvimento de Python .
Criar o projeto
As seguintes etapas criam um projeto vazio que serve como um contêiner para o aplicativo:
1. Abra o Visual Studio 2017.
2. Na barra de menus superior, escolha Arquivo > Novo > Projeto .
3. Na caixa de diálogo Novo Projeto , digite "Projeto Web Python" no campo de pesquisa no canto superior
direito, escolha Projeto Web na lista do meio, nomeie o projeto como "HelloPython" e escolha Ok .
Se você não vir os modelos de projeto do Python, execute o Instalador do Visual Studio , selecione
Mais > Modificar , selecione a carga de trabalho de desenvolvimento do Python e, em seguida,
escolha Modificar .
4. O novo projeto será aberto no Gerenciador de Soluções no painel direito. O projeto está vazio neste
momento porque ele não contém outros arquivos.
1. Abra o Visual Studio 2019.

2. Na tela inicial, selecione Criar um novo projeto .
3. Na caixa de diálogo Criar um novo projeto , digite "Python Web"no campo de pesquisa na parte
superior, escolha Projeto Web na lista do meio, depois selecione Avançar :
Se você não vir os modelos de projeto do Python, execute o Instalador do Visual Studio , selecione
Mais > Modificar , selecione a carga de trabalho de desenvolvimento do Python e, em seguida,
escolha Modificar .
4. Na caixa de diálogo Configurar seu novo projeto , insira "HelloPython" para Nome do projeto ,
especifique um local e selecione Criar . (O Nome da solução é definido automaticamente para
corresponder ao Nome do projeto .)
5. O novo projeto será aberto no Gerenciador de Soluções no painel direito. O projeto está vazio neste
momento porque ele não contém outros arquivos.
Pergunta: Qual é a vantagem de criar um projeto no Visual Studio para um aplicativo de Python?
Resposta : Os aplicativos Python costumam ser definidos usando somente arquivos e pastas, mas essa estrutura
simples pode se tornar complexa conforme os aplicativos aumentam e talvez envolvem arquivos gerados
automaticamente, JavaScript para aplicativos Web e assim por diante. Um projeto do Visual Studio ajuda a
gerenciar essa complexidade. O projeto (um arquivo .pyproj) identifica todos os arquivos de origem e de
conteúdo associados ao projeto, contém informações de build de cada arquivo, mantém as informações para a
integração com sistemas de controle de código-fonte e ajuda a organizar o aplicativo em componentes lógicos.
Pergunta: O que é a "solução" mostrada no Gerenciador de Soluções?
Resposta : Uma solução do Visual Studio é um contêiner que ajuda você a gerenciar um ou mais projetos
relacionados como um grupo e armazena configurações que não são específicas de um projeto. Os projetos em
uma solução também podem fazer referência uns aos outros, para que a execução de um projeto (um aplicativo
do Python) cria automaticamente um segundo projeto (como uma extensão de C++ usada no aplicativo do
Python).
Instalar a biblioteca Flask

Aplicativos Web em Python quase sempre usam uma das muitas bibliotecas Python disponíveis para lidar com
detalhes de baixo nível como o roteamento de solicitações da Web e formatação de respostas. Para essa
finalidade, o Visual Studio fornece uma variedade de modelos para aplicativos Web, e um deles você usará mais
adiante neste Início Rápido.
Aqui, use as etapas a seguir para instalar a biblioteca Flask no "ambiente global" padrão que o Visual Studio usa
para este projeto.
1. Expanda o nó Ambiente do Python no projeto para ver o ambiente padrão para o projeto.
2. Clique com o botão direito do mouse no ambiente e selecione Instalar pacote Python . Esse comando
abre a janela Ambientes de Python na guia Pacotes .
3. Insira “flask” no campo de pesquisa e selecione pip install flask from PyPI . Aceite os prompts de
privilégios de administrador e observe o andamento na janela Saída janela no Visual Studio. (Um prompt
para elevação é exibido quando a pasta de pacotes do ambiente global está localizada em uma área
protegida como C:\Arquivos de Programas.)
1. Expanda o nó Ambiente do Python no projeto para ver o ambiente padrão para o projeto.
2. Clique com o botão direito do mouse no ambiente e selecione Gerenciar pacotes Python.... Este
comando abre a janela Ambientes Python na guia Pacotes (PyPI).
3. Insira "flask" no campo de pesquisa. Se Flask aparece abaixo da caixa de pesquisa, você pode ignorar esta
etapa. Caso contrário, selecione Executar o comando: pip install flask . Aceite os prompts de
privilégios de administrador e observe o andamento na janela Saída janela no Visual Studio. (Um prompt
para elevação é exibido quando a pasta de pacotes do ambiente global está localizada em uma área
protegida como C:\Arquivos de Programas.)
4. Uma vez instalada, a biblioteca aparece no ambiente em Gerenciador de Soluções , o que significa que
você pode utilizá-la no código Python.
NOTE
Em vez de instalar as bibliotecas no ambiente global, os desenvolvedores geralmente criam um “ambiente virtual” no qual
instalar bibliotecas para um projeto específico. Modelos do Visual Studio geralmente oferecem essa opção, conforme
discutido em Início Rápido: criar um projeto de Python usando um modelo.
Pergunta: Onde posso saber mais sobre outros pacotes do Python disponíveis?
Resposta : Acesse o Índice de pacotes do Python.
Adicionar um arquivo de código
Agora você está pronto para adicionar um pouco de código Python para implementar um aplicativo Web
mínimo.
1. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Adicionar >
Novo Item .
2. Na caixa de diálogo exibida, selecione Arquivo Python vazio , nomeie-o como app.py e selecione
Adicionar . O Visual Studio abre o arquivo automaticamente em uma janela do editor.
3. Copie o código a seguir e cole-o em 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)
4. Você deve ter notado que a caixa de diálogo Adicionar > Novo item exibe muitos outros tipos de
arquivos que você pode adicionar a um projeto Python, incluindo uma classe Python, um pacote Python,
um teste de unidade Python, arquivos web.config e muito mais. Em geral, esses modelos de item, como
são chamados, são uma ótima maneira de criar rapidamente arquivos com código clichê útil.
Pergunta: Onde posso saber mais sobre o Flask?
Resposta : Consulte a documentação do Flask, começando pelo Início Rápido do Flask.
Executar o aplicativo
1. Clique com o botão direito do mouse em app.py no Gerenciador de Soluções e selecione Definir
como arquivo de inicialização . Esse comando identifica o arquivo de código para iniciar em Python ao
executar o aplicativo.
2. Clique com o botão direito do mouse no projeto no Solution Explorer e selecione Propriedades .
Selecione a guia Depurar e defina a propriedade Número da por ta para 4449 . Essa etapa garante que
o Visual Studio inicie um navegador com localhost:4449 para corresponder aos argumentos app.run no
código.
3. Selecione Depurar > Iniciar Sem Depuração (Ctrl +F5), que salva alterações em arquivos e executa o
aplicativo.
4. Uma janela de comando aparece com a mensagem Executando em https://localhost:4449 , e uma
janela do navegador deve abrir para localhost:4449 onde você vê a mensagem: "Olá, Python!" A
solicitação GET também aparece na janela de comando com um status 200.
Se um navegador não for aberto automaticamente, inicie o navegador de sua escolha e navegue até
localhost:4449 .
Caso apareça somente o shell interativo do Python na janela de comando ou se essa janela piscar
brevemente na tela, verifique se você definiu app.py como o arquivo de inicialização na etapa 1 acima.
5. Navegue até localhost:4449/hello para testar se o decorador do recurso /hello também funciona.
Novamente, a solicitação GET aparece na janela de comando com um status 200. Fique à vontade para
experimentar algumas outras URLs para ver se elas exibem os códigos de status 404 na janela de
comando.
6. Feche a janela de comando para interromper o aplicativo e, em seguida, feche a janela do navegador.
Pergunta: Qual é a diferença entre o comando Iniciar Sem Depuração e Iniciar Depuração?
Resposta : Use Iniciar Depuração para executar o aplicativo no contexto do depurador do Visual Studio, o que
permite que você defina pontos de interrupção, examine variáveis e depure seu código linha por linha. Os
aplicativos podem ser executados mais lentamente no depurador devido aos vários ganchos que possibilitam a
depuração. Iniciar Sem Depuração , por outro lado, executa o aplicativo diretamente, como se fosse executado
na linha de comando, sem nenhum contexto de depuração, e também inicia automaticamente um navegador e
navega para a URL especificada na guia ** Depurar** das propriedades do projeto.
Próximas etapas
Parabéns por executar seu primeiro aplicativo do Python no Visual Studio. Você aprendeu um pouco sobre como
usar o Visual Studio como um IDE do Python!
Implantar o aplicativo no Serviço de Aplicativo do Azure
Como as etapas seguidas neste Início Rápido são razoavelmente genéricas, você provavelmente percebeu que
elas podem e devem ser automatizadas. Essa automação é a função dos modelos de projeto do Visual Studio.
Acompanhe o Início Rápido – Criar um projeto Python usando um modelo para obter uma demonstração que
cria um aplicativo Web semelhante ao que você criou neste artigo, mas com menos etapas.
Para continuar com um tutorial mais completo sobre o Python no Visual Studio, incluindo o uso da janela
interativa, da depuração, da visualização de dados e o trabalho com o Git, acompanhe o Tutorial: Introdução ao
Python no Visual Studio.
Para explorar mais do que o Visual Studio tem a oferecer, selecione os links abaixo.
Saiba mais sobre os Modelos de aplicativo Web Python no Visual Studio.
Saiba mais sobre Depuração de Python
Saiba mais sobre o IDE do Visual Studio de modo geral.
Início Rápido: criar um projeto do Python com base
em um modelo no Visual Studio
Depois de instalar o suporte ao Python no Visual Studio, é fácil criar um projeto do Python usando uma variedade
de modelos. Neste Início Rápido, crie um aplicativo simples em Flask usando um modelo. O projeto resultante é
semelhante ao projeto que você cria manualmente em Início Rápido: criar um aplicativo Web com o Flask.
1. Inicie o Visual Studio.
2. Na barra de menu superior, escolha Arquivo > Novo > Projeto, em seguida, na pesquisa de diálogo
Novo Projeto para "frasco em branco", selecione o modelo de Projeto Web do frasco em branco na lista
do meio, dê um nome ao projeto e selecione OK :
3. O Visual Studio solicita-lhe uma caixa de diálogo que diz que este projeto requer pacotes externos.
Essa caixa de diálogo aparece porque o modelo inclui um arquivo requirements.txt que especifica uma
dependência do Flask. O Visual Studio pode instalar os pacotes automaticamente e oferece a opção de
instalá-los em um ambiente virtual. É recomendável usar um ambiente virtual na instalação em um
ambiente global, portanto, selecione Instalar em um ambiente vir tual para continuar.
4. O Visual Studio exibe a caixa de diálogo Adicionar Ambiente Vir tual . Aceite o padrão e selecione Criar ,
depois aprove todas as solicitações de elevação.
TIP
Quando você inicia um projeto, é altamente recomendável criar um ambiente virtual imediatamente, como a maioria
dos modelos do Visual Studio solicita. Ambientes virtuais mantêm os requisitos exatos do projeto ao longo do
tempo, conforme você adiciona e remove bibliotecas. É possível gerar facilmente um arquivo requirements.txt, que
você usa para reinstalar essas dependências em outros computadores de desenvolvimento (como quando usar
controle do código-fonte) e ao implantar o projeto em um servidor de produção. Para saber mais sobre ambientes
virtuais e seus benefícios, veja Usar ambientes virtuais e Gerenciar os pacotes necessários com requirements.txt.
5. Depois que o Visual Studio criar esse ambiente, examine o Gerenciador de Soluções para ver se há um
arquivo app.py junto com requirements.txt. Abra app.py para ver se o modelo forneceu um código como
em Início Rápido: criar um aplicativo Web com o Flask, com algumas seções adicionadas. Todo o código
mostrado abaixo é criado pelo modelo, portanto você não precisa colar nada no app.py por conta própria.
O código começa com as importações necessárias:

Em seguida está a linha seguinte que pode ser útil ao implantar um aplicativo em um host da Web:
wsgi_app = app.wsgi_app
Depois, vem o decorador de rota em uma função simples que define uma exibição:
@app.route('/')
def hello():
"""Renders a sample page."""
return "Hello World!"
Por fim, o código de inicialização abaixo permite que você defina o host e a porta por meio de variáveis de
ambiente em vez de fazer o hard-coding deles. Esse código permite controlar facilmente a configuração
nos computadores de desenvolvimento e produção sem alterar o 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. Selecione Depurar > Iniciar sem Depuração para localhost:5555 executar o aplicativo e abrir um
navegador para .
Pergunta: Quais outros modelos de Python o Visual Studio oferece?
Resposta : Com a carga de trabalho de Python instalada, o Visual Studio fornece uma variedade de modelos de
projeto, inclusive para as estruturas da Web Flask, Bottle e Django, serviços de nuvem do Azure, diferentes
cenários de aprendizado de máquina e até mesmo um modelo para criar um projeto a partir de uma estrutura de
pasta existente que contenha um aplicativo do Python. Você os acessa através da caixa de diálogo Arquivo >
Novo > Projeto selecionando o nó de linguagem Python e seus nós filho.
O Visual Studio também fornece uma variedade de modelos de arquivos ou itens para criar rapidamente uma
classe Python, um pacote Python, um teste de unidade Python, arquivos web.config e muito mais. Quando você
tem um projeto Python aberto, você acessa modelos de itens através do comando Project > Add New Item
menu. Consulte a referência de modelos de item.
O uso de modelos pode economizar um tempo significativo ao iniciar um projeto ou criar um arquivo, além de
ser uma ótima maneira de aprender sobre os diferentes tipos de aplicativo e estruturas de código. É útil levar
reservar alguns minutos para criar projetos e itens a partir de vários modelos para se familiarizar com o que eles
oferecem.
Pergunta: Também é possível usar modelos do Cookiecutter?
Resposta : Sim! Na verdade, o Visual Studio oferece integração direta com o Cookiecutter, que você pode
aprender através do Quickstart: Crie um projeto a partir de um modelo Cookiecutter.
Próximas etapas
Tutorial: trabalhar com Python no Visual Studio
Confira também
Identificar manualmente um interpretador Python existente
Instalar o suporte para Python no Visual Studio 2015 e anterior
Instalar locais
Quickstart: Abra e execute o código Python em
uma pasta
Depois de instalar o suporte ao Python no Visual Studio 2019, é fácil executar o código de Python existente no
Visual Studio 2019 sem criar um projeto do Visual Studio.
NOTE
O Visual Studio 2017 e anteriores exigiam que você criasse um projeto do Visual Studio para executar o código Python, o
que você pode fazer facilmente usando um modelo de projeto interno. Ver Quickstart: Crie um projeto Python a partir do
código existente
1. Para este passo a passo, use qualquer pasta com o código do Python que desejar. Para acompanhar o
exemplo mostrado aqui, clone o repositório do GitHub gregmalcolm/python_koans em seu computador
usando o comando git clone https://github.com/gregmalcolm/python_koans em uma pasta apropriada.
2. Inicie o Visual Studio de 2019 e, na janela de início, selecione Abrir na parte inferior da coluna
Introdução . Alternativamente, se você já tiver o Visual Studio em execução, selecione o comando File >
Open > Folder.
3. Navegue até a pasta que contém o código do Python e escolha Selecionar Pasta . Se estiver usando o
código python_koans, selecione a pasta python3 dentro da pasta de clone.
4. O Visual Studio exibe a pasta no Gerenciador de Soluções no que é chamado de Exibição de Pasta .
Você pode expandir e recolher pastas usando as setas nas bordas esquerdas dos nomes de pasta:
5. Ao abrir uma pasta do Python, o Visual Studio cria várias pastas ocultas para gerenciar as configurações
relacionadas ao projeto. Para ver essas pastas (e quaisquer outros arquivos e pastas ocultos, como a pasta
.git), selecione o botão da barra de ferramentas Mostrar Todos os Arquivos :
6. Para executar o código, primeiro você precisa identificar o arquivo de programa principal ou de
inicialização. No exemplo mostrado aqui, o arquivo de inicialização contemplate-koans.py. Clique com o
botão direito do mouse nesse arquivo e selecione Definir como Arquivo de Inicialização .
IMPORTANT
Se o item de inicialização não estiver localizado na raiz da pasta que você abriu, você também deverá adicionar
uma linha para o arquivo JSON de configuração de inicialização conforme descrito na seção Definir um diretório de
trabalho.
7. Execute o código pressionando Ctrl +F5 ou selecionando Debug > Star t sem depuração . Você
também pode selecionar o botão de barra de ferramentas que mostra o item de inicialização com o botão
play, que executa o código no depurador do Visual Studio. Em todos os casos, o Visual Studio detecta que
seu item de inicialização é um arquivo Python; portanto, ele executa automaticamente o código no
ambiente Python padrão. (Esse ambiente é mostrado à direita do item de inicialização na barra de
ferramentas).
8. A saída do programa aparece em uma janela de comando separada:
9. Para executar o código em um ambiente diferente, selecione o ambiente do controle de lista suspensa na
barra de ferramentas e inicie novamente o item de inicialização.
10. Para fechar a pasta no Visual Studio, selecione o comando Menu > menupasta File Close.
Definir um diretório de trabalho

Por padrão, o Visual Studio executa um projeto do Python aberto como uma pasta na raiz da mesma pasta. O
código em seu projeto, no entanto, pode pressupor que o Python está sendo executado em uma subpasta. Por
exemplo, suponha que você abra a pasta raiz do repositório python_koans e, em seguida, defina o arquivo
python3/contemplar-koans.py como item de inicialização. Se você executar o código, verá um erro dizendo que
o arquivo koans.txt não foi encontrado. Esse erro ocorre porque contemplate-koans.py pressupõe que o Python
está sendo executado na pasta python3 em vez da raiz do repositório.
Nesses casos, você também deve adicionar uma linha ao arquivo JSON de configuração de inicialização para
especificar o diretório de trabalho:
1. Clique com o botão direito do mouse no arquivo de inicialização do Python (.py) no Gerenciador de
Soluções e selecione Configurações de Depuração e de Inicialização .
2. Na caixa de diálogo Selecionar depurador que aparece, selecione Padrão e escolha Selecionar .
NOTE
Se você não vir Padrão como opção, verifique se clicou com o botão direito em um arquivo .py do Python ao
selecionar o comando Configurações de depuração e inicialização . O Visual Studio usa o tipo de arquivo
para determinar as opções do depurador para exibir.
3. O Visual Studio abre um arquivo chamado launch.vs.json, que está localizado na pasta .vs oculta. Este
arquivo descreve o contexto de depuração para o projeto. Para especificar um diretório de trabalho,
adicione um valor de "workingDirectory" , como em "workingDirectory": "python3" para o exemplo 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. Salve o arquivo e inicie o programa novamente, que agora é executado na pasta especificada.
Próximas etapas
Confira também
Início Rápido: Criar um projeto do Python com base em código existente
Quickstart: Crie um projeto Python a partir de um repositório
Início Rápido: Criar um projeto do Python com base
em código existente
Depois de instalar o suporte ao Python no Visual Studio, é fácil colocar código de Python existente em um projeto
do Visual Studio.
IMPORTANT
O processo descrito aqui não move ou copia os arquivos de origem. Se você quiser trabalhar com uma cópia, basta primeiro
duplicar a pasta.
1. Inicie o Visual Studio e selecione File > New > Project .

2. Na caixa de diálogo Novo Projeto , pesquise "Python", selecione o modelo Com base no Código Python
Existente , forneça um nome e um local para o projeto e selecione OK .
3. No assistente que é exibido, defina o caminho para o código existente, defina um filtro para os tipos de
arquivo e especifique os caminhos de pesquisa que seu projeto requer. Em seguida, selecione Avançar . Se
você não souber o que são caminhos de pesquisa, deixe esse campo em branco.
4. Na próxima caixa de diálogo, escolha o arquivo de inicialização do projeto e selecione Avançar . (Se desejar,
selecione um ambiente; caso contrário, aceite os padrões.) Observe que a caixa de diálogo mostra apenas
arquivos na pasta raiz; se o arquivo que você deseja estiver em uma subpasta, deixe o arquivo de
inicialização em branco e defina-o mais tarde no Solution Explorer (descrito abaixo).
5. Selecione o local em que deseja salvar o arquivo de projeto (que é um arquivo .pyproj no disco). Caso se
aplique, também será possível incluir a detecção automática de ambientes virtuais e personalizar o projeto
para outras estruturas da Web. Se você não tiver certeza sobre essas opções, deixe-as com as
configurações padrão.
6. Selecione Concluir e o Visual Studio criará o projeto e o abrirá no Gerenciador de Soluções . Caso
deseje mover o arquivo .pyproj para outro lugar, selecione-o no Gerenciador de Soluções e escolha
Arquivo > Salvar Como . Essa ação atualiza as referências de arquivo no projeto, mas não move nenhum
arquivo de código.
7. Para definir um arquivo de inicialização diferente, localize o arquivo no Gerenciador de Soluções , clique
com o botão direito do mouse e selecione Definir como Arquivo de Inicialização .
Se desejar, execute o programa pressionando Ctrl +F5 ou selecionando Debug > Star t sem depuração .
Próximas etapas
Confira também
Instalar locais
Início Rápido: clonar um repositório de código do
Depois de instalar o suporte do Python no Visual Studio, adicione a extensão do GitHub para Visual Studio. A
extensão permite que você clone facilmente um repositório de código Python e crie um projeto usando-o de
dentro do IDE. Também é possível clonar repositórios na linha de comando e, em seguida, trabalhar com eles no
Visual Studio.
Instale a extensão do GitHub para o Visual Studio

Para trabalhar com repositórios do GitHub de dentro do VS, você precisará instalar a extensão do GitHub para
Visual Studio. Para isso, execute o instalador do Visual Studio, selecione Modificar e selecione a guia
Componentes Individuais. Role até a seção Ferramentas de código, selecione a extensão GitHub para O
Visual Studio e selecione Modificar .
Trabalhe com o GitHub no Visual Studio

2. Selecione O Explorador > da equipe de exibição para abrir a janela Team Explorer na qual você pode se
conectar aos Reptórios GitHub ou Azure ou clonar um repositório. Se a página Conectar não estiver exibida
abaixo, selecione o ícone de plug na barra de ferramentas superior, que levará você à página.
3. Em Repositórios Git Locais , selecione o comando Clonar , insira
https://github.com/gregmalcolm/python_koans no campo de URL, insira uma pasta para os arquivos clonados
e selecione o botão Clonar .
TIP
A pasta especificada no Team Explorer é a pasta exata para receber os arquivos clonados. Ao contrário do comando
git clone , a criação de um clone no Team Explorer não cria automaticamente uma subpasta com o nome do
repositório.
4. Após a conclusão da clonagem, o repositório será exibido na lista Repositórios Git Locais . Clique duas
vezes em que nome para navegar até o dashboard do repositório no Team Explorer .
5. Em Soluções , selecione Novo .
6. Na caixa de diálogo Novo projeto que aparece, navegue até a linguagem Python (ou pesquise em
"Python"), selecione Código Python existente, especifique um nome para o projeto, defina a localização
para a mesma pasta que o repositório e selecione OK . No assistente que é exibido, selecione Concluir .
7. Selecione > 'Exibir'explorador de soluções no menu.' View
8. No Gerenciador de Soluções , expanda o nó python3 , clique com botão direito do mouse em
contemplate_koans.py e selecione Definir como Arquivo de Inicialização . Esta etapa informa ao
Visual Studio qual arquivo deve ser usado ao executar o projeto.
9. Selecione Propriedades > do Projeto Koans no menu, selecione a guia Geral e defina O Diretório de
Trabalho como "python3". Esta etapa é necessária porque, por padrão, o Visual Studio define o diretório
de trabalho como a raiz do projeto em vez da localização do arquivo de inicialização
(python3\contemplate_koans.py, que você também pode ver nas propriedades do projeto). O código do
programa procurará um arquivo koans.txt na pasta de trabalho, portanto sem a alteração desse valor, você
verá um erro de runtime.
10. Pressione Ctrl +F5 ou selecione Debug > Star t sem depuração para executar o programa. Se você
encontrar um FileNotFoundError para koans.txt, verifique a configuração do diretório de trabalho
conforme descrito na etapa anterior.
11. Quando o programa é executado com êxito, ele exibe um erro de asserção na linha 17 do
python3/koans/about_asserts.py. Isso é intencional: o programa foi projetado para ensinar Python, fazendo
com que você corrija todos os erros intencionais. (Mais detalhes são encontrados em Ruby Koans, que
inspirou os Koans do Python).
12. Abra python3/koans/about_asserts.py, navegando até ele no Gerenciador de Soluções e clique duas
vezes no arquivo. Observe que os números de linha não aparecem no editor por padrão. Para alterar isso,
selecioneOpções de ferramentas, > selecione Mostrar todas as configurações na parte inferior da
caixa de diálogo e navegue até o Editor de > textoPython > General e selecione Números de linha :
13. Corrija o erro, alterando o argumento False na linha 17 para True . A linha deve ficar assim:
self.assertTrue(True) # This should be True
14. Execute o programa novamente. Se o Visual Studio alertar sobre erros, responder com Sim para continuar
a execução do código. Você verá que a primeira verificação é bem-sucedida e o programa é interrompido
no próximo koan. Continue corrigindo os erros e executando novamente o programa se quiser.
IMPORTANT
Neste Início Rápido, você criou um clone direto do repositório python_koans no GitHub. Esse tipo de repositório é protegido
pelo autor contra alterações diretas, portanto, a tentativa de confirmar as alterações no repositório falhará. Na prática, os
desenvolvedores criam fork desse tipo de repositório em suas próprias contas do GitHub, fazem as alterações ali mesmo e,
em seguida, criam solicitações de pull para enviar essas alterações para o repositório original. Quando você tiver seu próprio
fork, use a URL dele em vez da URL do repositório original usada anteriormente.
Próximas etapas
Confira também
Como instalar o suporte do Python no Visual Studio no Windows
Instalar locais
Início Rápido: criar um projeto por meio de um
modelo do Cookiecutter
Depois de instalar o suporte ao Python no Visual Studio, é fácil criar um projeto com base em um modelo do
Cookiecutter, incluindo os vários modelos que estão publicados no GitHub. O Cookiecutter fornece uma interface
gráfica do usuário para descobrir modelos e opções de modelo de entrada e criar projetos e arquivos. Ele é
incluído no Visual Studio 2017 e posterior e pode ser instalado separadamente em versões anteriores do Visual
Studio.
1. Para este guia de início rápido, primeiro instale a distribuição Anaconda3 do Python, que inclui os pacotes
do Python necessários para o modelo do Cookiecutter que será mostrado aqui. Execute o instalador do
Visual Studio, escolha Modificar , expanda as opções de Desenvolvimento do Python no lado direito e
escolha Anaconda3 (32 bits ou 64 bits). Observe que a instalação poderá levar algum tempo, dependendo
da velocidade da Internet, mas essa é a maneira mais simples de instalar os pacotes necessários.
3. Selecione Arquivo > novo > do Cookiecutter . Esse comando abre uma janela no Visual Studio, na qual
você pode procurar modelos.
4. Escolha o modelo Microsoft/python-sklearn-classifier-cookiecutter e escolha Avançar . (O processo

poderá levar vários minutos na primeira vez que você usar um modelo específico, pois o Visual Studio
instala os pacotes do Python necessários.)
5. Na próxima etapa, defina um local para o novo projeto no campo Criar Para e, em seguida, selecione Criar
e Abrir Projeto .
6. Quando o processo estiver concluído, você verá a mensagem com sucesso criado arquivos usando
modelo.... O projeto é aberto no Solution Explorer automaticamente.
7. Pressione Ctrl +F5 ou selecione Debug > Star t sem depuração para executar o programa.
Próximas etapas
Confira também
Usar a extensão Cookiecutter
Instalar locais
Instalar o suporte ao Python no Visual Studio
NOTE
O suporte ao Python está atualmente disponível apenas no Visual Studio para Windows; no Mac e Linux, o suporte ao
Python está disponível através do Visual Studio Code.
1. Baixe e execute o instalador do Visual Studio mais recente para Windows (o suporte ao Python está
presente na versão 15.2 e posteriores). Se você já tiver o Visual Studio instalado, execute o instalador do
Visual Studio e vá para a etapa 2.
Instalar o Visual Studio Community
TIP
A edição Community é para desenvolvedores individuais, aprendizado em sala de aula, pesquisa acadêmica e
desenvolvimento de software livre. Para outros usos, instale o Visual Studio Professional ou o Visual Studio
Enterprise.
2. O instalador apresenta uma lista de cargas de trabalho, que são grupos de opções relacionadas para áreas
de desenvolvimento específicas. Para Python, selecione a carga de trabalho Desenvolvimento do Python
e selecione Instalar :
3. Para testar rapidamente o suporte ao Python, inicie o Visual Studio, pressione Alt +I para abrir a janela
Python Interactive e digite 2+2 . Se você não vir a saída de 4 , verifique as etapas novamente.
Próxima etapa
Etapa 1: criar um projeto do Python
Confira também
Instalar locais
Tutorial: Trabalhar com Python no Visual Studio
O Python é uma linguagem de programação popular confiável, flexível, fácil de aprender, de uso gratuito em
todos os sistemas operacionais e com suporte em uma sólida comunidade de desenvolvedores e várias
bibliotecas gratuitas. A linguagem é compatível com todas as formas de desenvolvimento, incluindo aplicativos
Web, serviços Web, aplicativos de área de trabalho, scripts e computação científica e, da mesma forma, é usada
por diversas universidades, vários cientistas e desenvolvedores casuais e profissionais.
O Visual Studio fornece suporte de linguagem de primeira classe para o Python. Este tutorial orienta você nas
seguintes etapas:
Etapa 0: instalação
Etapa 1: criar um projeto do Python (este artigo)
Etapa 2: escrever e executar código para ver o IntelliSense do Visual Studio funcionando
Passo 3: Crie mais código na janela REPL interativa
Etapa 4: executar o programa concluído no depurador do Visual Studio
Etapa 5: instalar pacotes e gerenciar ambientes do Python
Etapa 6: Trabalhar com o Git
Pré-requisitos
Visual Studio 2017 com a carga de trabalho do Python instalada. Para obter instruções, confira Como
trabalhar com o Python no Visual Studio – Etapa 0.
Visual Studio 2019 com a carga de trabalho do Python instalada. Para obter instruções, confira Como
trabalhar com o Python no Visual Studio – Etapa 0.
Você também pode usar uma versão anterior do Visual Studio com as Ferramentas Python para Visual Studio
instaladas. Confira Instalar o suporte para Python no Visual Studio.
Etapa 1: criar um novo projeto do Python

Um projeto é a forma como o Visual Studio gerencia todos os arquivos que são reunidos para produzir um
único aplicativo, incluindo código-fonte, recursos, configurações e assim por diante. Um projeto formaliza e
mantém a relação entre todos os arquivos do projeto, bem como os recursos externos que são compartilhados
entre vários projetos. Sendo assim, os projetos permitem que seu aplicativo expanda facilmente e cresça de
maneira muito mais fácil do que simplesmente gerenciar relacionamentos de um projeto em pastas ad-hoc,
scripts, arquivos de texto e até mesmo em sua própria mente.
Neste tutorial você começará com um projeto simples, contendo um único arquivo de código vazio.
1. No Visual Studio, selecione File > New > Project (Ctrl +Shift +N), que traz à tona a caixa de diálogo
Novo Projeto. Aqui você pode procurar modelos em diversas linguagens, selecionar um para o seu
projeto e especificar o local em que o Visual Studio colocará os arquivos.
2. Para exibir modelos Python, selecione > Python instalado à esquerda ou procure por "Python". O uso
da pesquisa é uma ótima maneira de localizar um modelo quando você não se lembra da localização na
árvore de linguagens.
Observe como o suporte do Python no Visual Studio inclui uma variedade de modelos de projeto,
incluindo aplicativos Web usando as estruturas Bottle, Flask e Django. No entanto, para as finalidades
deste passo a passo, vamos começar com um projeto vazio.
3. Selecione o modelo Aplicativo Python , especifique um nome para o projeto e selecione OK .
4. Após alguns instantes, o Visual Studio mostrará a estrutura do projeto na janela Gerenciador de
Soluções (1). O arquivo de código padrão será aberto no editor (2). A janela Propriedades (3) também
parece mostrar informações adicionais para qualquer item selecionado no Solution Explorer , incluindo
sua localização exata no disco.
5. Tire alguns momentos para se familiarizar com o Solution Explorer , que é onde você navega arquivos
e pastas em seu projeto.
(1) Destacado em negrito é o seu projeto, usando o nome que você deu no diálogo Projeto Novo. No
disco, esse projeto é representado por um arquivo .pyproj na pasta do projeto.
(2) No nível superior está uma solução que, por padrão, tem o mesmo nome que o seu projeto. Uma
solução, representada por um arquivo .sln no disco, é um contêiner para um ou mais projetos
relacionados. Por exemplo, se você escreve uma extensão de C++ para o seu aplicativo Python, o projeto
de C++ poderá residir na mesma solução. A solução também pode conter um projeto para um serviço
Web, juntamente com projetos para programas de teste dedicados.
(3) No seu projeto, você vê os arquivos de origem, neste caso, um único arquivo .py. Selecionar um
arquivo exibe suas propriedades na janela Propriedades. Ao clicar duas vezes em um arquivo, ele será
aberto da forma que for apropriada para esse arquivo.
(4) Também no projeto está o nó Ambientes do Python . Quando expandido, você verá os
interpretadores de Python que estão disponíveis. Expanda um nó de interpretador para ver as bibliotecas
que estão instaladas naquele ambiente (5).
Clique com o botão direito do mouse em qualquer nó ou item no Solution Explorer para acessar um
menu de comandos aplicáveis. Por exemplo, o comando Renomear permite que você altere o nome de
qualquer nó ou item, incluindo o projeto e a solução.
Próxima etapa
Escrever e executar o código
Aprofunde-se um pouco mais

Projetos Python no Visual Studio.
Saiba mais sobre a linguagem Python em python.org
Python para iniciantes (python.org)
Etapa 2: Escrever e executar código
Etapa anterior : Criar um novo projeto do Python

Embora o Solution Explorer seja onde você gerencia arquivos de projeto, a janela do editor é tipicamente onde
você trabalha com o conteúdo de arquivos, como código-fonte. O editor tem reconhecimento contextual do tipo
de arquivo que você está editando, incluindo a linguagem de programação (com base na extensão do arquivo) e
oferece recursos apropriados para essa linguagem, como a coloração de sintaxe e o preenchimento automático
usando o IntelliSense.
1. Depois de criar um novo projeto do "Aplicativo Python", um arquivo vazio padrão chamado
PythonApplication1.py é aberto no editor do Visual Studio.
2. No editor, comece digitando print("Hello, Visual Studio") e observe como o Visual Studio IntelliSense
exibe opções de preenchimento automático durante a digitação. A opção delineada na lista de desímpara
das audações é a conclusão padrão usada quando você pressiona a tecla Tab. As conclusões são mais úteis
quando instruções ou identificadores mais longos estão envolvidos.
3. O IntelliSense mostra diferentes informações, dependendo da instrução que está sendo usada, da função
que está sendo chamada e assim por diante. Com a função print , ao digitar ( depois de print para
indicar uma chamada função, as informações de uso completas dessa função são exibidas. O pop-up do
IntelliSense também mostra o argumento atual em negrito (valor conforme mostrado aqui):
4. Preencha a instrução para que ela corresponda ao seguinte:
print("Hello, Visual Studio")
5. Observe a coloração de sintaxe que diferencia a instrução print do argumento "Hello Visual Studio" .
Além disso, exclua temporariamente a última " na cadeia de caracteres e observe como o Visual Studio
mostra um sublinhado vermelho para o código que contém erros de sintaxe. Então, substitua o " para
corrigir o código.
TIP
Como o ambiente de desenvolvimento é uma questão muito pessoal, o Visual Studio oferece controle total sobre a
aparência e o comportamento do Visual Studio. Selecione o comando de menuOpções de ferramentas > e
explore as configurações nas guias Ambiente e Editor de Texto. Por padrão, você vê somente um número limitado
de opções; para ver todas as opções de todas as linguagens de programação, selecione Mostrar todas as
configurações na parte inferior da caixa de diálogo.
6. Execute o código que você escreveu até agora pressionando Ctrl +F5 ou selecionando Debug > Star t sem
depuração do item do menu. O Visual Studio avisará se ainda houver erros em seu código.
7. Quando você executa o programa, uma janela de console aparece exibindo os resultados, assim como seria
se você executasse um interpretador do Python com PythonApplication1.py, usando a linha de comando.
Pressione uma tecla para fechar a janela e retornar ao editor do Visual Studio.
8. Além das conclusões para instruções e funções, o IntelliSense fornece preenchimentos para instruções
import e from do Python. Esses preenchimentos ajudam você a descobrir com facilidade quais módulos
estão disponíveis no ambiente e os membros desses módulos. No editor, exclua a linha print e comece a
digitar import . Uma lista de módulos é exibida quando você digita o espaço:
9. Preencha a linha digitando ou selecionando sys .

10. Na próxima linha, digite from para ver uma lista de módulos novamente:
11. Selecione ou digite math e continue digitando com um espaço e import , o que exibe os membros do
módulo:
12. Conclua com a importação dos membros sin , cos e radians , observando os preenchimentos
automáticos disponíveis para cada um. Quando terminar, o código deverá ser exibido da seguinte maneira:
import sys
from math import cos, radians
TIP
Os preenchimentos trabalham com subcadeias de caracteres durante a digitação, encontrando a correspondência de
partes de palavras, letras no início de palavras e até mesmo caracteres ignorados. Confira Editar o código –
Preenchimentos para obter detalhes.
13. Adicione um pouco mais de código para imprimir os valores de cosseno para 360 graus:
for i in range(360):
print(cos(radians(i)))
14. Execute o programa novamente com Ctrl +F5 ou Debug > Star t sem depuração . Quando terminar, feche
a janela de saída.
Próxima etapa
Use a janela REPL interativa

Editar código
Código de formatação
Código de refatoração
Usar PyLint
Etapa 3: usar a janela interativa REPL
Etapa anterior : Gravar e executar código

A janela Visual Studio Interactive for Python oferece uma rica experiência de leitura-avaliação-print-loop (REPL)
que encurta consideravelmente o ciclo usual de edição-build-debug. A janela Interativa fornece todos os
recursos da experiência de REPL da linha de comando do Python. Ela também facilita a troca de código com
arquivos de origem no editor do Visual Studio, o que seria difícil com a linha de comando.
NOTE
Para problemas com REPL, verifique se os pacotes ipython e ipykernel estão instalados e, para obter ajuda na
instalação dos pacotes, confira a guia de pacotes de ambientes Python.
1. Abra a janela Interativa clicando com o botão direito do mouse no ambiente de projeto do Python no
Gerenciador de Soluções (como Python 3.6 (32 bits) , mostrado em um gráfico anterior) e
selecionando Abrir Janela Interativa . Você pode selecionar alternadamente Exibir > Outros Windows
> Python Interactive Windows no menu principal do Visual Studio.
2. A janela Interativa abre-se abaixo do editor com o prompt padrão de REPL do Python >>> . A lista
suspensa Ambiente permite selecionar um intérprete específico com o qual trabalhar. Se você também
quiser deixar a janela Interativa maior, arraste o separador entre as duas janelas:
TIP
Você pode redimensionar todas as janelas no Visual Studio, arrastando os separadores de bordas. Você também
pode arrastar e retirar janelas para fora do quadro do Visual Studio e reorganizá-las da forma que quiser dentro do
quadro. Para obter detalhes completos, confira Personalizar layouts de janela.
3. Insira algumas instruções, como print("Hello, Visual Studio") , e expressões, como 123/456 , para ver
resultados imediatos:
4. Ao começar a escrever uma instrução de várias linhas, como uma definição de função, a janela Interativa
mostrará o prompt ... do Python para linhas em continuação, o que, ao contrário do REPL de linha de
comando, proporcionará recuo automático:
5. A janela Interativa fornece um histórico completo de tudo o que você inseriu e melhora a linha de
comando REPL com itens de histórico multilinha. Por exemplo, com facilidade, é possível cancelar toda a
definição da função f como uma única unidade e alterar o nome para make_double , em vez de recriar a
função linha por linha.
6. O Visual Studio pode enviar várias linhas de código de uma janela do editor para a janela Interativa . Essa
capacidade permite que você mantenha o código em um arquivo de origem e envie facilmente partes
específicas dele para a janela Interativa . Assim, você poderá trabalhar com esses fragmentos de código no
ambiente REPL rápido em vez de ter que executar o programa inteiro. Para ver esse recurso, primeiro
substitua o loop for no arquivo PythonApplication1.py pelo seguinte:
# 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. Selecione import from as make_dot_string instruções de função e as instruções no arquivo .py, clique com
o botão direito do mouse e selecione Enviar para Interativo (ou pressione Ctrl +Enter ). O fragmento
de código será imediatamente colado na janela Interativa e executado. Como o código definiu uma
função, você pode testar rapidamente essa função chamando-a algumas vezes:
TIP
Usando Ctrl+Enter no editor sem uma seleção executa a linha de código atual na janela Interativa e coloca
automaticamente o caret na próxima linha. Com este recurso, pressionar Ctrl+Enter repetidamente fornece uma
maneira conveniente de passar pelo seu código que não é possível apenas com a linha de comando Python. Isso
também permitirá que você percorra o código sem executar o depurador e sem, necessariamente, começar desde o
início do programa.
8. Você também pode copiar e colar várias linhas de código de qualquer fonte na janela Interativa , como no
snippet a seguir, o que é difícil fazer com o REPL da linha de comando do Python. Ao colar, a janela
Interativa executa o código como se você o tivesse digitado:
for i in range(360):
s = make_dot_string(i)
print(s)
9. Como você pode ver, esse código funciona bem, mas a saída não é muito interessante. Um valor de etapa
diferente no loop for mostraria mais da curva do cosseno. Felizmente, como todo o loop for está no
histórico do REPL como uma única unidade, é fácil voltar e fazer as alterações desejadas e, em seguida,
testar a função novamente. Pressione a seta para cima para, primeiro, recuperar o loop for . Em seguida,
pressione as setas à esquerda ou direita para iniciar a navegação no código (até que você faça isso, as setas
para baixo e para cima continuam a percorrer o histórico). Navegue até a especificação range e altere-a
para range(0, 360, 12) . Em seguida, pressione Ctrl +Enter (em qualquer lugar do código) para executar
toda a declaração novamente:
10. Repita o processo para fazer experiências com configurações de etapas diferentes, até encontrar um valor
que você mais goste. Você também pode fazer a curva se repetir, aumentando o intervalo, por exemplo,
range(0, 1800, 12) .
11. Quando estiver satisfeito com o código escrito na janela Interativa , selecione-o, clique com o botão direito
do mouse e selecione Copiar Código (Ctrl +Shift +C ) e cole-o no editor. Observe como esse recurso
especial do Visual Studio omite automaticamente qualquer saída, bem como os prompts >>> e ... . Por
exemplo, a imagem abaixo mostra o uso do comando Copiar Código em uma seleção que inclui os
prompts e a saída:
Ao colar no editor, você obtém somente o código:
for i in range(0, 1800, 12):

print(s)
Se quiser copiar o conteúdo exato da janela Interativa , incluindo os prompts e a saída, basta usar o
comando Copiar padrão.
12. O que você acabou de fazer é usar o ambiente de REPL rápido da janela Interativa para trabalhar em
detalhes de uma pequena parte de código e adicionou convenientemente esse código ao arquivo de
origem do seu projeto. Quando você agora executa o código novamente com Ctrl +F5 (ou Debug > Star t
sem depuração), você vê os resultados exatos que você queria.
Próxima etapa
Executar o código no depurador

Usar a Janela Interativa
Usar o IPython REPL
Etapa 4: Executar o código no depurador
Etapa anterior : usar a janela interativa REPL

Além de gerenciar projetos, oferecer uma rica experiência de edição e a janela Interactive, o Visual Studio fornece
depuração completa para código Python. No depurador, você pode executar seu código passo a passo, incluindo
cada iteração de um loop. Você também pode pausar o programa sempre que determinadas condições são
verdadeiras. A qualquer momento em que o programa estiver em pausa no depurador, você poderá examinar
todo o estado do programa e alterar o valor de variáveis. Essas ações são essenciais para a localização de bugs do
programa e também fornecem recursos muito úteis para seguir com cuidado o fluxo exato do programa.
1. Substitua o código no arquivo PythonApplication1.py pelo seguinte. Essa variação do código expande o
make_dot_string para que você possa examinar as etapas distintas no depurador. Ela também coloca o loop
for em uma função main e executa-o explicitamente, chamando essa função:
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(radians(x)) + 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. Verifique se o código funciona corretamente pressionando F5 ou selecionando o comando de menu

Depurar > Iniciar Depuração . Esse comando executa o código no depurador, mas como você não fez
nada para pausar o programa enquanto ele está em execução, ele apenas imprime um padrão de onda para
algumas iterações. Pressione qualquer tecla para fechar a janela de saída.
TIP
Para fechar a janela de saída automaticamente quando o programa for concluído, selecione o comandoMenu
Opções de ferramentas, > expanda o nó Python, selecione Depuração e, em seguida, limpe a opção Aguarde a
entrada quando o processo sair normalmente :
3. Defina um ponto for de ruptura na declaração clicando uma vez na margem cinza por essa linha, ou
colocando o caret nessa linha e usando o comando Debug > Toggle Breakpoint (F9). Um ponto
vermelho é exibido na margem cinza para indicar o ponto de interrupção (conforme indicado pela seta
abaixo):
4. Inicie o depurador novamente (F5 ) e veja se a execução do código pára na linha com esse ponto de ruptura.
Aqui você pode inspecionar a pilha de chamadas e examinar variáveis. As variáveis que estão no escopo
aparecem na janela Autos quando elas estão definidas. Você também pode alternar para a exibição Locais
na parte inferior dessa janela para mostrar todas as variáveis que o Visual Studio localiza no escopo atual
(incluindo funções), antes mesmo que elas sejam definidas:
5. Observe a barra de ferramentas de depuração (mostrada abaixo) na parte superior da janela do Visual
Studio. Essa barra de ferramentas fornece acesso rápido aos comandos de depuração mais comuns (que
também podem ser encontrados no menu Depurar ):
Os botões, da esquerda para a direita, são os seguintes:

Continuar (F5 ) executa o programa, até o próximo ponto de interrupção ou até a conclusão do
programa.
Break All (Ctrl +Alt +Break) pausa um programa de longa duração.
Pare de depurar (Shift +F5) interrompe o programa onde quer que esteja e sai do depurador.
Reiniciar (Ctrl +Shift +F5 ) interrompe o programa no ponto em que está e o reinicia no depurador.
Mostrar Próxima Instrução (Alt +Num * ) alterna para a próxima linha de código a ser executada. Isso
é mais útil quando você navega em seu código durante uma sessão de depuração e deseja retornar
rapidamente ao ponto em que o depurador está em pausa.
Step Into (F11) executa a próxima linha de código, entrando em funções chamadas.
Step Over (F10) executa a próxima linha de código sem entrar nas chamadas funções.
Step Out (Shift +F11 ) executa o restante da função atual e faz pausas no código de chamada.
6. Contorne a instrução for usando Contornar . Passo a passo significa que o depurador executa a linha de
código atual, incluindo todas as chamadas de função e, em seguida, imediatamente entra em pausa outra
vez. Observe como a variável i agora está definida nas janelas Locais e Autos .
7. Contorne a próxima linha de código, que chama make_dot_string e entra em pausa. Step Over here
especificamente significa que o make_dot_string depurador executa o todo e faz uma pausa quando
retorna. O depurador não é interrompido dentro dessa função, a menos que exista nela outro ponto de
interrupção.
8. Continue depurando o código passo a passo mais algumas vezes e observe como os valores na janela
Locais ou Autos se alteram.
9. Na janela Locais ou Autos , clique duas vezes na coluna Valor das variáveis i ou s para editar o valor.
Pressione Enter ou clique fora desse valor para aplicar quaisquer alterações.
10. Continuar percorrendo o código passo a passo, usando Inter vir . Step Into significa que o depurador entra
em qualquer chamada de make_dot_string função para a qual tenha informações de depuração, tais como .
Uma vez dentro do make_dot_string , você pode examinar as variáveis locais e percorrer o código
especificamente.
11. Continue pisando com Step Into e observe make_dot_string que quando você chegar for ao final do , s
o próximo passo retorna ao loop com o novo valor de retorno na variável. Ao pisar novamente print na
declaração, observe print que o Passo A passo não entra nessa função. Isso ocorre porque print não
está escrita em Python, mas é código nativo dentro do runtime do Python.
12. Continue usando step into até que make_dot_string você esteja novamente em meio caminho em . Então,
use Sair e observe que você retornará ao loop for . Com Step Out , o depurador executa o restante da
função e, em seguida, pausa automaticamente no código de chamada. Isso é muito útil quando você
percorreu algumas partes de uma função longa que deseja depurar, mas não deseja percorrer o restante e
não quer definir um ponto de interrupção explícito no código de chamada.
13. Para continuar executando o programa até que o próximo ponto de ruptura seja alcançado, use Continue
(F5 ). Como há um ponto de interrupção no loop for , você interrompe na próxima iteração.
14. Percorrer centenas de iterações de um loop pode ser entediante, portanto, o Visual Studio permite que você
adicione uma condição a um ponto de interrupção. Assim, o depurador só pausa o programa no ponto de
interrupção quando a condição é satisfeita. Por exemplo, você pode usar uma condição com o ponto de
interrupção na instrução for para que ele faça uma pausa somente quando o valor de i exceder 1600.
Para definir essa condição, clique com o botão direito do mouse no ponto de interrupção e selecione
Condições (Alt +F9 > C ). Na janela pop-up Configurações de Ponto de Interrupção exibida, insira
i > 1600 como a expressão e selecione Fechar . Pressione F5 para continuar e observe que o programa
executa muitas iterações antes do próximo intervalo.
15. Para executar o programa até o final, desabilite o ponto de ruptura clicando com o botão direito e
selecionando Desativar o breakpoint (Ctrl +F9). Em seguida, selecione Continuar (ou pressione F5 )
para executar o programa. Quando o programa for finalizado, o Visual Studio interromperá a sessão de
depuração e retornará para o modo de edição. Observe que você também pode excluir o ponto de
interrupção ao clicar em seu ponto, mas isso também excluirá qualquer condição que você definiu.
TIP
Em algumas situações, como uma falha ao iniciar o interpretador do Python em si, a janela de saída poderá aparecer apenas
rapidamente e fechar-se automaticamente, sem dar uma oportunidade de ver as mensagens de erros. Se isso acontecer,
clique com o botão direito do mouse no projeto -i no Solution Explorer , selecione Propriedades, selecione a guia
Depuração e adicione ao campo Argumentos do Intérprete. Esse argumento faz com que o intérprete entre no modo
interativo após a conclusão de um programa, mantendo assim a janela aberta até que você digite Ctrl+Z > Enter para sair.
Próxima etapa
Instalar pacotes no ambiente do Python

Depuração
Depuração no Visual Studio oferece uma documentação completa sobre os recursos de depuração do Visual
Studio.
Etapa 5: Instalar pacotes no ambiente do Python
Etapa anterior : executar o código no depurador

A comunidade de desenvolvedores do Python produziu milhares de pacotes úteis que você pode incorporar em
seus próprios projetos. O Visual Studio oferece uma interface do usuário para gerenciar pacotes em seus
ambientes do Python.
Exibir ambientes
1. Selecione o comando Exibir > outrosambientes python do Windows. > A janela Ambientes de
Python será aberta como um par com o Gerenciador de Soluções e mostrará os diferentes ambientes
disponíveis para você. A lista mostra os dois ambientes que você instalou usando o instalador do Visual
Studio e aqueles que você instalou separadamente. Isso inclui ambientes globais, virtuais e conda. O
ambiente em negrito é o ambiente padrão, que é usado para novos projetos. Para obter informações
adicionais sobre como trabalhar com ambientes, consulte Como criar e gerenciar ambientes Python em
ambientes do Visual Studio.
NOTE
Você também pode abrir a janela Ambientes Python clicando na janela Do Solution Explorer e usando o atalho de
teclado Ctrl+K, Ctrl+'. Se o atalho não funcionar e você não conseguir encontrar a janela Ambientes Python no
menu, é possível que você não tenha instalado a carga de trabalho python. Veja como instalar o suporte ao Python
no Visual Studio para obter orientações sobre como instalar o Python.
2. A guia Visão Geral do ambiente fornece acesso rápido a uma janela Interativa para esse ambiente,
juntamente com a pasta de instalação do ambiente e intérpretes. Por exemplo, selecione Abrir janela
interativa e uma janela Interativa para esse ambiente específico aparece no Visual Studio.
3. Agora, crie um novo projeto com o File > New > Project, selecionando o modelo do Aplicativo Python.
No arquivo de código que aparece, cole o seguinte código, que cria uma onda cossena como as etapas do
tutorial anterior, só que desta vez plotado graficamente. Alternativamente, você pode usar o projeto que
você criou anteriormente e substituir o 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. Com um projeto Python aberto, você também pode abrir a janela Ambientes Python do Solution Explorer
clicando com o botão direito em Ambientes Python e selecionando Exibir todos os ambientes Python
5. Olhando para a janela do editor, você notará que se você passar o tempo sobre as numpy declarações de
importação e matplotlib importar que elas não estão resolvidas. Isso porque os pacotes não foram
instalados no ambiente global padrão.
Instale pacotes usando a janela Ambientes Python
1. Na janela Ambientes Python, clique no ambiente padrão para novos projetos Python e selecione a guia
Pacotes. Em seguida, você verá uma lista de pacotes que estão atualmente instalados no ambiente.
2. Instale matplotlib inserindo seu nome no campo de pesquisa e, em seguida, selecionando o comando
Executar : pip instalar matplotlib opção. Isso será matplotlib instalado, assim como quaisquer pacotes
que dependam numpy (neste caso, que inclui ).
3. Dê permissão para a elevação, se for solicitado.
4. Depois que o pacote é instalado, ele aparece na janela Ambientes Python. O X à direita do pacote serve
para desinstalá-lo.
NOTE
Uma pequena barra de progresso pode aparecer embaixo do ambiente para indicar que o Visual Studio está
construindo seu banco de dados IntelliSense para o pacote recém-instalado. A guia IntelliSense também mostra
mais informações detalhadas. Esteja ciente de que até que esse banco de dados esteja completo, os recursos do
IntelliSense, como a verificação automática de conclusão e sintaxe, não estarão ativos no editor para esse pacote.
Visual Studio 2017 versão 15.6 e posteriorusa um método diferente e mais rápido para trabalhar com o IntelliSense,
e exibe uma mensagem para esse efeito na guia IntelliSense.
Execute o programa
1. Agora que o matplotlib está instalado, execute o programa com (F5 ) ou sem o depurador (Ctrl +F5 ) para
ver a saída:
Próxima etapa
Trabalhe com Git

Ambientes do Python
Saiba mais sobre Django no Visual Studio
Conheça o Flask no Visual Studio
Etapa 6: Trabalhar com o Git
Etapa anterior : instalar pacotes e gerenciar o ambiente do Python

O Visual Studio fornece integração direta com repositórios locais do GIT e repositórios remotos em serviços como
o GitHub e o Azure Repos. A integração inclui clonagem de um repositório, confirmação de alterações e
gerenciamento de branches.
Este artigo fornece uma visão geral básica da criação de um repositório Git local para um projeto existente e visa
familiarizar você com alguns dos recursos do Visual Studio relacionados ao Git.
1. Com um projeto aberto no Visual Studio, como o projeto da etapa anterior, clique com o botão direito do
mouse na solução e selecione Adicionar Solução ao Controle do Código-Fonte . O Visual Studio cria
um repositório local do Git que contém o código do projeto.
2. Quando o Visual Studio detecta que o projeto é gerenciado em um repositório do Git, controles
relacionados com o Git também aparecem na parte inferior direita da janela do Visual Studio. Os controles
mostram confirmações pendentes, alterações, o nome do repositório e o branch. Passe o mouse sobre os
controles para ver informações adicionais.
3. Quando você cria um novo repositório ou seleciona qualquer um dos controles do Git, o Visual Studio abre
a janela Team Explorer . (Você pode abrir a janela a qualquer momento com o comando Do menu >
Do'Soturação do Explorador de exibição.) View A janela tem três painéis principais, que você alterna
entre usar o drop-down no cabeçalho do Team Explorer. O painel Sync, que fornece operações de
publicação, também aparece quando você seleciona o controle Push (o ícone da seta para cima):
4. Selecione Alterações (ou o controle do Git como ícone de lápis) para examinar as alterações não
confirmadas e confirmá-las quando desejado.
Clique duas vezes em um arquivo na lista Alterações para abrir um modo de exibição de comparação do
arquivo:
5. Selecione Branches (ou o controle do Git com um nome de branch) para examinar os branches e executar
operações de mesclagem e troca de base:
6. Selecionando o controle Git com o nome do repositório (CosineWave em uma imagem anterior), o Team
Explorer mostra uma interface Connect com a qual você pode mudar rapidamente para outro repositório
inteiramente.
7. Ao usar um repositório local, as alterações confirmadas vão diretamente para o repositório. Se você estiver
conectado a um repositório remoto, selecione o cabeçalho de baixa no Team Explorer, escolha
Sincronizar para alternar para a seção Sincronização e trabalhe com os comandos Pull and Fetch
apresentados lá.
Para um breve passo a passo da criação de um projeto a partir de um repositório remoto do Git, consulte
Quickstart: Clone um repositório de código Python no Visual Studio.
Para obter um tutorial muito mais abrangente, incluindo informações sobre como lidar com conflitos de
mesclagem, revisar código com solicitações de pull, trocar a base e fazer cherry-picking de alterações entre
branches, confira Introdução ao GIT e ao Azure Repos.
Análise do tutorial
Parabéns por concluir este tutorial sobre Python no Visual Studio. Neste tutorial, você aprendeu como:
Criar projetos e exibir o conteúdo do projeto.
Use o editor de código e executar um projeto.
Use a janela Interativa para desenvolver um novo código e copie facilmente esse código para o editor.
Executar um programa concluído no depurador do Visual Studio.
Instalar pacotes e gerenciar ambientes do Python.
Trabalhar com o código em um repositório do Git.
Agora, explore os Conceitos e guias de Instruções, incluindo os seguintes artigos:
Criar uma extensão do C++ para o Python
Publicar no Serviço de Aplicativo do Azure
Criação de perfil
Teste de unidade
Tutorial: Introdução à estrutura da Web do Django
no Visual Studio
O Django é uma estrutura do Python de alto nível projetada para um desenvolvimento da Web rápido, seguro e
escalonável. Este tutorial explora a estrutura do Django no contexto dos modelos de projeto que o Visual Studio
fornece para simplificar a criação de aplicativos Web baseados no Django.
Neste tutorial, você aprenderá como:
Criar um projeto básico do Django em um repositório Git usando o modelo "Projeto Web em Branco do
Django" (etapa 1)
Criar um aplicativo do Django com uma página e renderizar essa página usando um modelo (etapa 2)
Fornecer arquivos estáticos, adicionar páginas e usar a herança do modelo (etapa 3)
Usar o modelo Projeto Web do Django para criar um aplicativo com várias páginas e design responsivo (etapa
4)
Autenticar usuários (etapa 5)
Usar o modelo Pesquisas Projeto Web do Django para criar um aplicativo que usa modelos, migrações de
banco de dados e personalizações na interface administrativa (etapa 6)
Pré-requisitos
Visual Studio 2017 ou posteriores no Windows com as seguintes opções:
A carga de trabalho desenvolvimento do Python (guia Carga de Trabalho no instalador). Para
obter instruções, confira Instalar o suporte do Python no Visual Studio.
GIT para Windows e Extensão GitHub para Visual Studio na guia Componentes individuais
em Code Tools .
Os modelos de projeto do Django também estão incluídos em todas as versões anteriores das Ferramentas
Python para Visual Studio, embora os detalhes possam ser diferentes dos que são discutidos neste tutorial
(especialmente diferentes nas versões anteriores da estrutura do Django).
No momento, não há suporte para o desenvolvimento do Python no Visual Studio para Mac. No Mac e no Linux,
use a Extensão Python no Visual Studio Code.
"Projetos do Visual Studio" e "Projetos do Django"
Na terminologia do Django, um "projeto do Django" é composto de vários arquivos de configuração do nível de
site, juntamente com um ou mais "aplicativos" que você implementa em um host Web para criar um aplicativo
Web completo. Um projeto do Django pode conter vários aplicativos e o mesmo aplicativo pode estar presente
em vários projetos do Django.
Um projeto do Visual Studio, por sua vez, pode conter o projeto do Django juntamente com vários aplicativos.
Para simplificar, sempre que este tutorial referir-se apenas a um "projeto," ele estará se referindo ao projeto do
Visual Studio. Quando se referir ao "projeto do Django" do aplicativo Web, ele usará "projeto do Django"
especificamente.
No decorrer deste tutorial, você criará uma única solução do Visual Studio que contém três projetos
independentes do Django, cada um contendo um único aplicativo do Django. Se você mantiver os projetos na
mesma solução, poderá facilmente alternar entre diferentes arquivos para comparação.
Etapa 1-1: Criar uma solução e um projeto do Visual Studio
Ao trabalhar com o Django na linha de comando, você geralmente inicia um projeto executando o comando
django-admin startproject <project_name> . No Visual Studio, se você usar o modelo "Projeto Web em Branco do
Django", fornecerá a mesma estrutura em uma solução e projeto do Visual Studio.
1. No Visual Studio, selecione File > New > Project , procure por "Django", e selecione o modelo de Projeto
Web de Django em branco. (O modelo também é encontrado naWeb Python > na lista à esquerda.)
2. Nos campos, na parte inferior da caixa de diálogo, insira as informações a seguir (conforme mostrado no
gráfico anterior) e, em seguida, escolha OK :
Nome : defina o nome do projeto Visual Studio como BasicProject . Esse nome também é usado para o
projeto do Django.
Local : especifique um local no qual criar o projeto e a solução do Visual Studio.
Solução: deixe este controle definido como padrão Criar nova opção de solução.
Nome da solução : definido como LearningDjango , que é apropriado para a solução como um
contêiner para vários projetos neste tutorial.
Criar diretório para a solução : deixar definido (o padrão).
Criar um novo repositório Git : escolha essa opção (que é clara por padrão) para que o Visual Studio
crie um repositório Git local quando criar a solução. Caso essa opção não seja exibida, execute o
instalador do Visual Studio e adicione o GIT para Windows e a Extensão do GitHub para Visual
Studio à guia Componentes individuais em Ferramentas de código .
3. Depois de um momento, o Visual Studio solicita-lhe uma caixa de diálogo dizendo que este projeto
requer pacotes externos (mostrado abaixo). Essa caixa de diálogo é exibida porque o modelo inclui um
arquivo requirements.txt que referencia o último pacote do Django 1.x. Escolha Mostrar pacotes
necessários para ver as dependências exatas.
4. Escolha a opção Eu vou instalá-los sozinho . Crie o ambiente virtual logo em seguida para garantir que
ele será excluído do controle do código-fonte. (O ambiente pode ser sempre criado com base em
requirements.txt.)
Etapa 1-2: Examinar os controles do Git e publicar em um repositório

remoto
Como você marcou a opção Criar novo repositório Git na caixa de diálogo Novo Projeto , o projeto já ficará
confirmado no controle do código-fonte local assim que o processo de criação for concluído. Nesta etapa,
familiarize-se com os controles do Git do Visual Studio e a janela do Team Explorer onde você trabalha com o
controle do código-fonte.
1. Observe os controles do Git no canto inferior da janela principal do Visual Studio. Da esquerda para direita,
esses controles mostram confirmações não enviadas, as alterações não confirmadas, o nome do
repositório e a ramificação atual:
NOTE
Se você não marcar a opção Criar novo repositório Git na caixa de diálogo Novo Projeto , os controles do Git
mostrarão apenas um comando Adicionar ao controle do código-fonte que criará um repositório local.
2. Marque o botão de alterações e o Visual Studio abrirá a janela do Team Explorer na página Alterações .
Como o projeto recém-criado já está automaticamente confirmado no controle do código-fonte, você não
verá as alterações pendentes.
3. Na barra de status do Visual Studio, selecione o botão de confirmação não pressionado (a seta para cima
com 2 ) para abrir a página Sincronização no Team Explorer . Como você tem apenas um repositório
local, a página oferece opções simples para publicar o repositório em diferentes repositórios remotos.
Você pode escolher o serviço que desejar para seus próprios projetos. Este tutorial mostra o uso do
GitHub, em que o código de exemplo concluído do tutorial é mantido no repositório Microsoft/python-
sample-vs-learning-django.
4. Ao selecionar qualquer um dos controles Publicar , o Team Explorer solicitará mais informações. Por
exemplo, ao publicar o exemplo deste tutorial, o próprio repositório teve que ser criado primeiro, caso em
que a opção Enviar por Push para o Repositório Remoto foi usada com a URL do repositório.
Se você não tiver um repositório, as opções Publicar no GitHub e Enviar por Push para o Azure
DevOps permitirão criar um repositório diretamente no Visual Studio.
5. Ao trabalhar com este tutorial, adquira o hábito de usar periodicamente os controles no Visual Studio para
confirmar e enviar alterações por push. Este tutorial envia-lhe lembretes nos pontos apropriados.
TIP
Para navegar rapidamente no Team Explorer, selecione o cabeçalho (que lê Alterações ou Empurre nas imagens acima)
para ver um menu pop-up das páginas disponíveis.
Pergunta: Quais são algumas vantagens de usar o controle do código -fonte a partir do início de um projeto?
Resposta: Em primeiro lugar, se você usar o controle do código-fonte desde o início, especialmente se também
usar um repositório remoto, terá um backup regular em um local fora do projeto. Em vez de manter um projeto
apenas em um sistema de arquivos local, o controle do código-fonte também oferece um histórico de alterações
completo e facilita a reversão de um único arquivo ou todo o projeto para um estado anterior. O histórico de
alterações ajuda a determinar a causa das regressões (falhas de teste). Além disso, o controle do código-fonte é
essencial se várias pessoas estiverem trabalhando em um projeto, pois ele gerencia substituições e fornece a
resolução de conflitos. Por fim, o controle do código-fonte, que é basicamente uma forma de automação, deixa
você preparado para automatizar o gerenciamento de compilações, testes e versões. Esse recurso realmente
representa o primeiro passo no uso de DevOps em um projeto e, como os obstáculos para entrar são muito
baixos, realmente não há motivos para não usar o controle do código-fonte desde o início.
Para uma discussão mais aprofundada sobre o controle do código-fonte usado como automação, confira A
origem da verdade: a função dos repositórios no DevOps, um artigo da MSDN Magazine destinado a aplicativos
móveis, mas que também se aplica a aplicativos Web.
Pergunta: É possível evitar que o Visual Studio confirme automaticamente um novo projeto?
Resposta: Sim. Para desabilitar a confirmação automática, vá para a página Configurações no Team Explorer ,
escolha Git > Configurações Globais , desmarque o opção rotulada como Confirmar alterações após
mesclagem por padrão e, em seguida, escolha Atualizar .
Etapa 1-3: Criar o ambiente virtual e excluí-lo do controle do código-

fonte
Agora que você configurou o controle do código-fonte para o projeto, é possível criar o ambiente virtual que
contém os pacotes necessários do Django para o projeto. Você pode usar o Team Explorer para excluir a pasta
do ambiente do controle do código-fonte.
1. No Gerenciador de Soluções , clique com o botão direito do mouse no nó Ambientes do Python e
escolha Adicionar Ambiente Vir tual .
2. Uma caixa de diálogo Adicionar ambiente vir tual é exibida, com uma mensagem dizendo que
encontramos um arquivo requirements.txt. Esta mensagem indica que o Visual Studio usa esse
arquivo para configurar o ambiente virtual.
3. Escolha Criar para aceitar os padrões. (Se desejar, o nome do ambiente virtual pode ser alterado. Essa ação
alterará apenas o nome da subpasta, mas env é uma convenção padrão).
4. Caso seja solicitado, concorde com os privilégios de administrador e aguarde alguns minutos enquanto o
Visual Studio faz o download e instala pacotes. Para o Django isso significa expandir vários milhares de
arquivos em muitas subpastas! Você pode ver o progresso na janela Saída no Visual Studio. Enquanto
você aguarda, analise as seções de perguntas a seguir.
5. Nos controles do GIT do Visual Studio (na barra de status), selecione o indicador de alterações (mostrando
99* ) que abre a página Alterações no Team Explorer .
A criação do ambiente virtual apresentou milhares de alterações, mas nenhuma delas precisará ser incluída
no controle do código-fonte já que você (ou qualquer outra pessoa que venha a clonar o projeto) poderá
sempre recriar o ambiente com base em requirements.txt.
Para excluir o ambiente virtual, clique com o botão direito do mouse na pasta env e selecione Ignorar
estes itens locais .
6. Depois de excluir o ambiente virtual, as únicas alterações restantes são as referentes ao arquivo de projeto
e a .gitignore. O arquivo .gitignore contém uma entrada adicional para a pasta do ambiente virtual. Você
pode clicar duas vezes no arquivo para ver uma comparação.
7. Digite uma mensagem de confirmação, escolha o botão Confirmar Todos e, se desejar, envie as
confirmações por push para o repositório remoto.
Pergunta: Por que criar um ambiente virtual?
Resposta: Um ambiente virtual é uma ótima maneira de isolar as dependências exatas do seu aplicativo. Esse
isolamento evita conflitos em um ambiente global do Python e auxilia nos testes e na colaboração. Com o tempo,
à medida que desenvolver um aplicativo, invariavelmente, você introduzirá muitos pacotes úteis do Python.
Mantendo os pacotes em um ambiente virtual específico do projeto, você pode atualizar com facilidade o arquivo
requirements.txt do projeto que descreve esse ambiente, incluído no controle do código-fonte. Quando o projeto
é copiado para outros computadores, incluindo servidores de build, servidores de implantação e outros
computadores de desenvolvimento, é fácil recriar o ambiente usando apenas o requirements.txt (é por isso que o
ambiente não precisa estar no controle do código-fonte). Para obter mais informações, confira Usar ambientes
virtuais.
Pergunta: Como faço para remover um ambiente virtual que já está confirmado no controle do código -fonte?
Resposta: Primeiro, edite o arquivo .gitignore para excluir a pasta: localize a seção ao final com o comentário
# Python Tools for Visual Studio (PTVS) e adicione uma nova linha à pasta do ambiente virtual, como
/BasicProject/env . (Como o Visual Studio não mostra o arquivo no Gerenciador de Soluções , abra-o
diretamente usando o comando de menu Arquivo > Abrir > Arquivo . Abra também o arquivo no Team
Explorer : na página Configurações , selecione Configurações do Repositório , vá para a seção Arquivos
Ignorar e de Atributos e, em seguida, selecione o link Editar ao lado de .gitignore .)
Em segundo lugar, abra uma janela Comando, navegue para a pasta, como BasicProject, que contém a pasta do
ambiente virtual, como env, e execute git rm -r env . Em seguida, confirme essas alterações na linha de comando
( git commit -m 'Remove venv' ) ou confirme na página Alterações do Team Explorer .
Etapa 1-4: Examinar o código de texto clichê

Após concluir a criação do projeto, analise o código do projeto do Django de texto clichê (que é novamente o
mesmo gerado pelo comando django-admin startproject <project_name> da CLI).
1. Na raiz do projeto está manage.py, o utilitário administrativo de linha de comando do Django que o Visual
Studio define automaticamente como o arquivo de inicialização do projeto. Execute o utilitário na linha de
comando usando python manage.py <command> [options] . Para tarefas comuns do Django, o Visual Studio
fornece comandos de menu apropriados. Clique com o botão direito do mouse no projeto no
Gerenciador de Soluções e escolha Python para ver a lista. Você encontrará alguns desses comandos
no decorrer deste tutorial.
2. Em seu projeto, é uma pasta com o mesmo nome do projeto. Ela contém os arquivos do projeto básico do
Django:
__init.py: um arquivo vazio que informa o Python se essa pasta é um pacote do Python.
wsgi.py: um ponto de entrada para os servidores Web compatíveis com WSGI para atender ao
projeto. Este arquivo normalmente fica como está, pois ele fornece os ganchos para os servidores
Web de produção.
settings.py: contém as configurações do projeto do Django, que você modifica no decorrer do
desenvolvimento de um aplicativo Web.
urls.py: contém um sumário do projeto do Django, que você também modifica no decorrer do
desenvolvimento.
3. Conforme observado anteriormente, o modelo do Visual Studio também adiciona um arquivo
requirements.txt ao projeto especificando a dependência de pacote do Django. A presença desse arquivo é
que faz com que você seja convidado a criar um ambiente virtual ao desenvolver o projeto pela primeira
vez.
Pergunta: O Visual Studio pode gerar um arquivo requirements.txt a partir de um ambiente virtual depois de
instalar outros pacotes?
Resposta: Sim. Expanda o nó Ambientes do Python , clique com o botão direito do mouse no ambiente virtual e
escolha o comando Gerar requirements.txt . É recomendável usar esse comando periodicamente conforme
você modifica o ambiente e confirma as alterações em requirements.txt no controle do código-fonte, juntamente
com outras alterações de código que dependem desse ambiente. Se você configurar a integração contínua em um
servidor de compilação, deverá gerar o arquivo e confirmar as alterações sempre que modificar o ambiente.
Etapa 1-5: Executar o projeto vazio do Django

1. No Visual Studio, selecione Debug > Star t Debugging (F5) ou use o botão Do Ser vidor Web na barra
de ferramentas (o navegador que você vê pode variar):
2. Executar o servidor significa executar o comando manage.py runserver <port> , que inicia o servidor de
desenvolvimento interno do Django. Se o Visual Studio informar Falha ao iniciar o depurador com uma
mensagem que alerta para a ausência de um arquivo de inicialização, clique com o botão direito do mouse
em manage.py no Gerenciador de Soluções e selecione Definir como Arquivo de Inicialização .
3. Ao iniciar o servidor, você vê uma janela do console aberta que também exibe o log do servidor. O Visual
Studio abre automaticamente um navegador com a página http://localhost:<port> . No entanto, como o
projeto do Django não tem aplicativos, o Django exibe apenas uma página padrão para confirmar que o
que você tem até agora está funcionando corretamente:
4. Quando terminar, pare o servidor fechando a janela do console ou usando o comando Debug > Stop
Debugging no Visual Studio.
Pergunta: O Django é um servidor Web além de ser uma estrutura?
Resposta: Sim e não. O Django tem um servidor Web interno que é usado para fins de desenvolvimento. Esse
servidor Web é o que é usado quando você executa o aplicativo Web localmente, por exemplo, durante a
depuração no Visual Studio. Porém, quando você implanta em um host Web, o Django usa o servidor Web do
host. O módulo wsgi.py no projeto do Django cuida da conexão com os servidores de produção.
Pergunta: Qual é a diferença entre usar os comandos do menu Depuração e os comandos do servidor no
submenu do Python do projeto?
Resposta: Além dos comandos do menu Depurar e dos botões da barra de ferramentas, você também pode
iniciar o servidor usando os comandos Python > Executar ser vidor ou Python > Executar o ser vidor de
depuração no menu de contexto do projeto. Os dois comandos abrem uma janela de console na qual você vê a
URL local (localhost:port) do servidor em execução. Mesmo assim, abra manualmente um navegador usando essa
URL já que a execução do servidor de depuração não inicia automaticamente o depurador do Visual Studio. Você
pode anexar um depurador ao processo de execução mais tarde, se quiser, usando o comando Debug > Attach
to Process.
Próximas etapas
Neste ponto, o projeto básico do Django não possui aplicativos. Crie um aplicativo na próxima etapa. Como você
normalmente trabalha mais com aplicativos do Django do que com o projeto do Django, no momento, não será
necessário saber mais sobre os arquivos de texto clichê.
Criar um aplicativo do Django com modos de exibição e modelos de página

Código do projeto do Django: Como gravar seu primeiro aplicativo do Django, parte 1
(docs.djangoproject.com)
Utilitário administrativo: django-admin e manage.py (docs.djangoproject.com)
Código-fonte do tutorial no GitHub: Microsoft/python-sample-vs-learning-django
Etapa 2: Criar um aplicativo Django com exibição e
modelos de página
Etapa anterior : Criar uma solução e um projeto do Visual Studio

O que você tem até o momento no projeto do Visual Studio são apenas os componentes do nível do site de um
projeto do Django, que pode executar um ou mais aplicativos de Django. A próxima etapa é criar seu primeiro
aplicativo com uma única página.
Nesta etapa, você aprenderá a:
Criar um aplicativo do Django com uma única página (etapa 2-1)
Executar o aplicativo do projeto do Django (etapa 2-2)
Renderizar um modo de exibição usando HTML (etapa 2-3)
Renderizar um modo de exibição usando um modelo de página do Django (etapa 2-4)
Etapa 2-1: Criar um aplicativo com uma estrutura padrão

Um aplicativo do Django é um pacote separado em Python que contém um conjunto de arquivos relacionados
para uma finalidade específica. Um projeto do Django pode conter qualquer número de aplicativos, o que reflete o
fato de que um host da Web pode servir qualquer número de pontos de entrada separados de um único nome de
domínio. Por exemplo, um projeto do Django para um domínio como contoso.com pode conter um aplicativo para
www.contoso.com , um segundo aplicativo para support.contoso.com e um aplicativo de terceiro para
docs.contoso.com. Nesse caso, o projeto do Django manipula o roteamento de URL e as configurações no nível do
site (nos arquivos urls.py e settings.py), enquanto cada aplicativo tem seu próprio estilo e comportamento
distintos por meio de seus roteamentos, exibições, modelos, arquivos estáticos e interfaces administrativas
internas.
Um aplicativo do Django normalmente começa com um conjunto padrão de arquivos. O Visual Studio fornece
modelos de item para inicializar um aplicativo do Django dentro de um projeto do Django, junto com um
comando de menu integrado que tem a mesma finalidade:
Modelos: no Gerenciador de Soluções , clique com botão direito do mouse no projeto e selecione
Adicionar > Novo item . Na caixa de diálogo Adicionar novo item, selecione o modelo do aplicativo
Django 1.9, especifique o nome do aplicativo no campo Nome e selecione OK .
Integrado comando: no Gerenciador de Soluções , clique com o botão direito no projeto e selecione
Adicionar > Aplicativo do Django . Esse comando solicita um nome e cria um aplicativo do Django 1.9.
Usando qualquer método, crie um aplicativo com o nome "HelloDjangoApp". O resultado é uma pasta no seu
projeto com o nome que contém itens conforme descrito na tabela a seguir.
IT EM DESC RIÇ Ã O
__init__.py O arquivo que identifica o aplicativo como um pacote.

migrações Uma pasta na qual o Django armazena scripts que atualizam

o banco de dados para se alinhar com as alterações nos
modelos. Em seguida, as ferramentas de migração do Django
aplicam as alterações necessárias a qualquer versão anterior
do banco de dados para que corresponda aos modelos atuais.
Com as migrações, você mantém o foco nos seus modelos e
permite que o Django lide com o esquema de banco de dados
subjacente. As migrações são discutidas na etapa 6; por
enquanto, a * _ ___* pasta simplesmente contém um arquivo
init .py (indicando que a pasta define seu próprio pacote
Python).
Modelos Uma pasta para modelos de página do Django que contém

um único arquivo index.html dentro de uma pasta que
corresponde ao nome do aplicativo. (No Visual Studio 2017
15.7 e anterior, o arquivo está contido diretamente em
modelos e a etapa 2-4 instrui você a criar a subpasta.) Os
modelos são blocos de HTML nos quais as exibições podem
adicionar informações para renderizar dinamicamente uma
página. "Variáveis" de modelos de página, como
{{ content }} em index.html, são espaços reservados para
valores dinâmicos, conforme explicado mais adiante neste
artigo (etapa 2). Normalmente, os aplicativos do Django criam
um namespace para seus modelos, colocando-os em uma
subpasta que corresponda ao nome do aplicativo.
admin.py O arquivo Python no qual você estende a interface

administrativa do aplicativo (veja a etapa 6), que é usada para
propagar e editar dados em um banco de dados. Inicialmente,
esse arquivo contém apenas a instrução
from django.contrib import admin . Por padrão, o Django
inclui uma interface administrativa padrão por meio de
entradas no arquivo settings.py do projeto do Django, que
você pode ativar removendo a marca de comentário das
entradas existentes em urls.py.
apps.py Um arquivo Python que define uma classe de configuração

para o aplicativo (veja abaixo, depois desta tabela).
models.py Modelos são objetos de dados, identificados por funções, por

meio dos quais os modos de exibição interagem com o banco
de dados subjacente do aplicativo (veja a etapa 6). O Django
fornece a camada de conexão de banco de dados para que os
aplicativos não precisem se preocupar com esses detalhes. O
arquivo models.py é um local padrão no qual criar os modelos
e, inicialmente, contém apenas a instrução
from django.db import models .
tests.py Um arquivo Python que contém a estrutura básica de testes

de unidade.
views.py Os modos de exibição são o que você normalmente considera

páginas da Web, que recebem uma solicitação HTTP e
retornam uma resposta HTTP. Os modos de exibição
costumam ser renderizados como HTML que os navegadores
da Web conseguem exibir, mas um modo de exibição não
precisa necessariamente ser visível (como um formulário
intermediário). Um modo de exibição é definido por uma
função Python que tem a responsabilidade de renderizar o
HTML para enviar ao navegador. O arquivo views.py é um
local padrão no qual criar exibições e, inicialmente, contém
apenas a instrução from django.shortcuts import render .
O conteúdo do apps.py aparece da seguinte forma ao usar o nome "HelloDjangoApp":
from django.apps import AppConfig
class HelloDjangoAppConfig(AppConfig):
name = 'HelloDjango'
Pergunta: Há alguma diferença entre criar um aplicativo do Django no Visual Studio e criar um aplicativo na linha
de comando?
Resposta: Executar o comando adicionar > aplicativo Django ou usar adicionar > novo item com um modelo
manage.py startapp <app_name> de aplicativo Django produz os mesmos arquivos que o comando Django . A
vantagem de criar o aplicativo no Visual Studio é que a pasta do aplicativo e todos os seus arquivos são
automaticamente integrados ao projeto. Você pode usar o mesmo comando do Visual Studio para criar qualquer
número de aplicativos em seu projeto.
Etapa 2-2: Executar o aplicativo a partir do projeto do Django

Neste ponto, se você executar o projeto novamente no Visual Studio (usando o botão barra de ferramentas
ouDepuração Iniciar depuração), Debug > você ainda verá a página padrão. Nenhum conteúdo do aplicativo é
exibido porque você precisa definir uma página específica do aplicativo e adicionar o aplicativo ao projeto do
Django:
1. Na pasta HelloDjangoApp, modifique views.py para que ele corresponda ao código abaixo, que define uma
exibição chamada "index":
from django.shortcuts import render

from django.http import HttpResponse
def index(request):
return HttpResponse("Hello, Django!")
2. Na pasta BasicProject (criada na etapa 1), modifique urls.py para que ele corresponda, pelo menos, ao
seguinte código (você poderá manter os comentários instrutivos se desejar):
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 padrão de URL descreve as exibições para as quais o Django encaminha URLs relativas do site
específicas (ou seja, a parte que segue https://www.domain.com/ ). A primeira entrada em urlPatterns que
começa com a expressão regular ^$ é o roteamento para a raiz do site, "/". A segunda entrada, ^home$
direcionado especificamente para "/home". É possível ter qualquer número de roteamentos para o mesmo
modo de exibição.
3. Execute o projeto novamente para ver a mensagem Olá, Django! conforme definida pelo modo de
exibição. Pare o servidor ao terminar.
Confirmar o controle do código -fonte
Como você já fez alterações no seu código e as testou com êxito, agora é o momento ideal para revisar e confirmar
as alterações ao controle do código-fonte. As etapas posteriores deste tutorial indicam os momentos apropriados
para fazer a confirmação no controle do código-fonte novamente e direcionam você mais uma vez para esta seção.
1. Selecione o botão de alterações na parte inferior do Visual Studio (circulado abaixo), que encaminha para o
Team Explorer .
2. No Team Explorer , digite uma mensagem de confirmação, como "Criar aplicativo inicial do Django" e
selecione Confirmar Tudo . Quando o commit estiver concluído, você verá uma mensagem Commit
<hash> criada localmente. Sincronize para compar tilhar suas alterações com o ser vidor. Se
você quiser enviar alterações por push para o repositório remoto, selecione Sincronizar , depois selecione
Push em Confirmações de Saída . Também é possível acumular várias confirmações locais antes de
enviar para o repositório remoto.
Pergunta: Para que serve o prefixo 'r' antes das cadeias de caracteres de roteamento?
Resposta: O prefixo "r" em uma cadeia de caracteres em Python significa "raw", que instrui o Python a não escapar
de nenhum caractere dentro da cadeia. Como as expressões regulares usam muitos caracteres especiais, o uso do
prefixo 'r' facilita muito a leitura dessas cadeias de caracteres comparado a se elas contivessem alguns caracteres
de escape '\'.
Pergunta: O que significam os caracteres ^ e $ nas entradas de roteamento de URL?
Resposta: Nas expressões regulares que definem padrões de URL, ^ significa "início de linha" e $ significa "fim de
linha", em que novamente as URLs são relativas à raiz do site (a parte que segue https://www.domain.com/ ). A
expressão regular ^$ efetivamente significa "em branco" e, portanto, corresponde à URL completa
https://www.domain.com/ (nada é adicionado à raiz do site). O padrão ^home$ corresponde exatamente a
https://www.domain.com/home/ . (O Django não usa o / à direita na correspondência de padrões).
Se você não usar um $ à direita em uma expressão regular, assim como em ^home , o padrão de URL
corresponderá a qualquer URL que comece com "home", como "home", "homework", "homestead" e
"home192837".
Para fazer experiências com expressões regulares diferentes, use ferramentas online, como regex101.com em
pythex.org.
Etapa 2-3: Renderizar um modo de exibição usando HTML

A função index que você tem até agora em views.py não gera nada além de uma resposta HTTP de texto sem
formatação para a página. A maioria das páginas da Web reais responde com páginas HTML avançadas que
geralmente incorporam dados dinâmicos. Na verdade, a principal razão para definir uma exibição usando uma
função é poder gerar esse conteúdo dinamicamente.
Como o argumento para HttpResponse é apenas uma cadeia de caracteres, você pode criar qualquer HTML que
quiser em uma cadeia de caracteres. Como um exemplo simples, substitua a função index pelo código a seguir
(mantendo as instruções from existentes), que gera uma resposta HTML usando o conteúdo dinâmico que é
atualizado toda vez que você atualiza a 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)
Execute o projeto novamente para ver uma mensagem como "Olá, Django! na segunda-feira, 16 de abril de
2018, às 16:28:10". Atualize a página para atualizar a hora e confirme que o conteúdo está sendo gerado com cada
solicitação. Pare o servidor ao terminar.
TIP
Um atalho para parar e reiniciar o projeto é usar o comando Debug > Restar t menu (Ctrl+Shift +F5) ou o botão
Reiniciar na barra de ferramentas de depuração:
Etapa 2-4: Renderizar um modo de exibição usando um modelo de

página
Gerar HTML no código funciona bem para páginas muito pequenas, mas à medida que as páginas ficam mais
sofisticadas, normalmente é ideal manter as partes HTML estáticas da sua página ( junto com referências a
arquivos CSS e JavaScript) como "modelos de página" nos quais você insere conteúdo dinâmico gerado por
código. Na seção anterior, apenas a data e a hora da chamada now.strftime são dinâmicas, o que significa que
todos os outros conteúdos podem ser colocados em um modelo de página.
Um modelo de página do Django é um bloco de HTML que pode conter qualquer número de tokens de
substituição chamados "variáveis" que são delineados por {{ e }} , como em {{ content }} . O módulo de
modelagem do Django substitui as variáveis por conteúdo dinâmico que você fornece no código.
As etapas a seguir demonstram o uso de modelos de página:
1. Na pasta BasicProject, que contém o projeto do Django, abra o arquivo settings.py e adicione o nome do
aplicativo, "HelloDjangoApp", à lista INSTALLED_APPS . A adição do aplicativo à lista informa ao projeto do
Django que há uma pasta com esse nome contendo um aplicativo:
INSTALLED_APPS = [
'HelloDjangoApp',
# Other entries...
]
2. Também em settings.py, garanta que o objeto TEMPLATES contenha a seguinte linha (incluída por padrão),
que instrui o Django a procurar modelos na pasta templates de um aplicativo instalado:
'APP_DIRS': True,
3. Na pasta HelloDjangoApp, abra o arquivo de modelo de página templates/HelloDjangoApp/index.html (ou

templates/index.html no VS 2017 15.7 e anteriores), para observar que ele contém uma variável, a
{{ content }} :
<html>
<head><title></title></head>
<body>
{{ content }}
</body>
</html>
4. Na pasta HelloDjangoApp, abra views.py e substitua a função index pelo código a seguir, que usa a função
auxiliar django.shortcuts.render . O auxiliar render fornece uma interface simplificada para trabalhar com
modelos de página. Mantenha todas as instruções 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")
}
)
O primeiro argumento para render , como você pode ver, é o objeto de solicitação, seguido do caminho
relativo para o arquivo de modelo dentro da pasta templates do aplicativo. Um arquivo de modelo recebe o
nome do modo de exibição ao qual ele oferece suporte, se apropriado. O terceiro argumento para render é
um dicionário de variáveis ao qual o modelo se refere. Você pode incluir objetos no dicionário e, nesse caso,
uma variável no modelo pode se referir a {{ object.property }} .
5. Execute o projeto e observe o resultado. Uma mensagem semelhante à da etapa 2-2 deverá ser exibida,
indicando que o modelo funciona.
Observe, no entanto, que o HTML usado na propriedade content é processado apenas como texto simples,
porque a função render escapa automaticamente esse HTML. O escape automático impede
vulnerabilidades acidentais em ataques de injeção: os desenvolvedores geralmente coletam a entrada de
uma página e a usam como um valor em outra por meio de um espaço reservado de modelo. O escape
também funciona como um lembrete de que é melhor novamente manter o HTML no modelo da página e
fora do código. Felizmente, é simples criar variáveis adicionais quando necessário. Por exemplo, altere
index.html com templates para corresponder à seguinte marcação, que adiciona um título de página e
mantém toda a formatação no modelo de página:
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<strong>{{ message }}</strong>{{ content }}
</body>
</html>
Depois, escreva a função do modo de exibição index da seguinte maneira, para fornecer valores para todas
as variáveis no modelo 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. Pare o servidor e reinicie o projeto. Observe que a página agora é renderizada corretamente:
7. Visual Studio 2017 versão 15.7 e anteriores: como etapa final, mova seus modelos para uma subpasta com
o mesmo nome do seu aplicativo, o que cria um namespace e evita possíveis conflitos com outros
aplicativos que você possa adicionar ao projeto. (Os modelos do VS 2017 15.8+ fazem isso
automaticamente.) Ou seja, criar uma subpasta em modelos chamados HelloDjangoApp, mover index
index.html para essa subpasta e modificar a função de exibição para se referir ao novo caminho do modelo,
HelloDjangoApp/index.html. Em seguida, execute o projeto, verifique se a página é renderizada
corretamente e pare o servidor.
8. Confirme suas alterações no controle do código-fonte e atualize seu repositório remoto, se desejado,
conforme descrito na etapa 2-2.
Pergunta: Os modelos de página precisam ficar em um arquivo separado?
Resposta: Embora os modelos geralmente sejam mantidos em arquivos HTML separados, também é possível usar
um modelo embutido. No entanto, é recomendável usar um arquivo separado para manter uma distinção clara
entre marcação e código.
Pergunta: Os modelos precisam usar a extensão de arquivo .html?
Resposta: A extensão .html para arquivos de modelo de página é totalmente opcional, porque você sempre
identifica o caminho relativo exato para o arquivo no segundo argumento para a função render . No entanto, o
Visual Studio (e outros editores) costuma fornecer funcionalidades como preenchimento de código e coloração de
sintaxe com arquivos .html, o que supera o fato de os modelos de página não serem estritamente HTML.
De fato, quando você está trabalhando com um projeto do Django, o Visual Studio detecta automaticamente
quando o arquivo HTML que você está editando é, na verdade, um modelo do Django e fornece determinados
recursos de preenchimento automático. Por exemplo, quando você começa a digitar um comentário de modelo de
página do Django, {# , o Visual Studio fornece automaticamente os caracteres de fechamento #} . Os comandos
Comentar Seleção e Remover Marca de Comentário da Seleção (no menu Editar > Avançado e na barra
de ferramentas) também usam comentários de modelo em vez de comentários em HTML.
Pergunta: Quando executo o projeto, é exibido um erro indicando que não é possível encontrar o modelo. Qual
é o problema?
Resposta: Se forem exibidos erros indicando que o modelo não pode ser encontrado, verifique se você adicionou o
aplicativo a settings.py do projeto do Django na lista INSTALLED_APPS . Sem essa entrada, o Django não saberá o
que procurar na pasta templates do aplicativo.
Pergunta: Por que o namespace do modelo é importante?
Resposta: Quando o Django procura por um modelo referido na função render , ele usa qualquer arquivo
encontrado primeiro que corresponda ao caminho relativo. Se você tiver vários aplicativos do Django no mesmo
projeto que usem as mesmas estruturas de pasta para os modelos, é provável que um aplicativo use
inadvertidamente um modelo de outro aplicativo. Para evitar esses erros, sempre crie uma subpasta na pasta
templates do aplicativo que corresponda ao nome do aplicativo para evitar toda e qualquer duplicação.
Próximas etapas
Fornecer arquivos estáticos, adicionar páginas e usar a herança do modelo

Como gravar seu primeiro aplicativo do Django, parte 1 – (modos de exibição) (docs.djangoproject.com)
Para conhecer mais recursos de modelos do Django, como os elementos inclui e herança, confira A linguagem
de modelos do Django (docs.djangoproject.com)
Treinamento em expressões regulares no inLearning (LinkedIn)
Etapa 3: Fornecer arquivos estáticos, adicionar
páginas e usar a herança do modelo
Etapa anterior : Criar um aplicativo do Django com modos de exibição e modelos de página
Nas etapas anteriores deste tutorial, você aprendeu como criar um aplicativo mínimo em Django com uma única
página HTML autocontido. No entanto, aplicativos Web modernos geralmente são compostos por várias páginas e
usam recursos compartilhados, como arquivos CSS e JavaScript, para fornecer comportamento e estilo
consistentes.
Usar modelos de item do Visual Studio para adicionar rapidamente novos arquivos de diferentes tipos com
código clichê conveniente (etapa 3-1)
Configurar o projeto em Django para fornecer arquivos estáticos (etapa 3-2)
Adicionar mais páginas ao aplicativo (etapa 3-3)
Usar a herança do modelo para criar um cabeçalho e uma barra de navegação usados nas páginas (etapa 3-4)
Etapa 3-1: Familiarizar-se com os modelos de item

À medida que desenvolve um aplicativo do Django, geralmente você adiciona vários outros arquivos Python,
HTML, CSS e JavaScript. Para cada tipo de arquivo (bem como para outros arquivos, como web.config, que podem
ser necessários para a implantação), o Visual Studio fornece modelos de item convenientes para você começar.
Para ver os modelos disponíveis, vá para Gerenciador de Soluções , clique com o botão direito do mouse na
pasta em que você deseja criar o item, selecione Adicionar > Novo Item :
Para usar um modelo, selecione o modelo desejado, especifique um nome para o arquivo e selecione OK . A adição
de um item dessa maneira adiciona automaticamente o arquivo ao projeto do Visual Studio e marca as alterações
para controle do código-fonte.
Pergunta: Como o Visual Studio sabe quais modelos de item oferecer?
Resposta: O arquivo de projeto do Visual Studio (.pyproj) contém um identificador de tipo de projeto que o marca
como um projeto do Python. O Visual Studio usa esse identificador de tipo para mostrar apenas os modelos de
item adequados para o tipo de projeto. Dessa forma, o Visual Studio pode fornecer um conjunto avançado de
modelos de item para muitos tipos de projeto sem solicitar que você os classifique toda vez.
Etapa 3-2: Fornecer arquivos estáticos do seu aplicativo

Em um aplicativo Web criado com Python (usando qualquer estrutura), seus arquivos em Python sempre são
executados no servidor do host da Web e nunca são transmitidos para o computador de um usuário. Mas outros
arquivos, como CSS e JavaScript, são usados exclusivamente pelo navegador, de modo que o servidor do host
simplesmente os entrega como estão sempre que são solicitados. Esses arquivos são chamados de "estáticos", e o
Django pode fornecê-los automaticamente sem que você precise escrever algum código.
Um projeto do Django é configurado por padrão para fornecer arquivos estáticos da pasta static do aplicativo,
graças a estas linhas em settings.py do projeto do 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']))
Você pode organizar os arquivos usando qualquer estrutura de pastas desejada dentro de static e, em seguida,
usar caminhos relativos dentro dessa pasta para referenciar os arquivos. Para demonstrar esse processo, as
seguintes etapas adicionam um arquivo CSS ao aplicativo e, em seguida, usam essa folha de estilos no modelo
index.html:
1. Em Gerenciador de soluções , clique com o botão direito do mouse na pasta HelloDjangoApp no
projeto do Visual Studio, selecione Adicionar > nova pasta e nomeie a pasta static .
2. Clique com o botão direito do mouse na pasta static e selecione Adicionar > Novo item . Na caixa de
diálogo exibida, selecione o modelo de folha de estilos , nomeie o arquivo site.css e selecione OK . O
arquivo site.css é exibido no projeto e aberto no editor. A estrutura de pastas deve ser semelhante à
imagem a seguir:
3. Substitua o conteúdo de site.css pelo seguinte código e salve o arquivo:
.message {
font-weight: 600;
color: blue;
}
4. Substitua o conteúdo do arquivo templates/HelloDjangoApp/index.html do aplicativo pelo código a seguir,

que substitui o elemento <strong> usado na etapa 2 por um <span> que referencia a classe de estilo
message . O uso de uma classe de estilo dessa maneira oferece muito mais flexibilidade ao estilo do
elemento. (Se você ainda não moveu o index.html para uma subpasta nos modelos ao usar o VS 2017 15.7
e anteriores, veja Namespacing de modelo na etapa 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. Execute o projeto para observar os resultados. Pare o servidor quando terminar e confirme as alterações no
controle do código-fonte se desejar (conforme explicado na etapa 2).
Pergunta: Qual é a finalidade da marcação {% load staticfiles %}?
Resposta: A linha {% load staticfiles %} é necessária antes da referência a arquivos estáticos em elementos
como <head> e <body> . No exemplo mostrado nesta seção, "staticfiles" se refere a um conjunto de marcações de
modelo do Django personalizado que permite o uso da sintaxe {% static %} para se referir a arquivos estáticos.
Sem {% load staticfiles %} , você verá uma exceção quando o aplicativo for executado.
Pergunta: Há convenções para organizar arquivos estáticos?
Resposta: Você pode adicionar outros arquivos CSS, JavaScript e HTML à sua pasta static como quiser. Uma
maneira comum de organizar arquivos estáticos é criar subpastas chamadas fonts, scripts e content (para folhas de
estilo e outros arquivos). Em cada caso, lembre-se de incluir essas pastas no caminho relativo para o arquivo nas
referências {% static %} .
Pergunta: posso concluir a mesma tarefa sem usar a marca {% Load staticfiles%}?
Resposta: Sim, você pode.
<html>
<head>
<link rel="stylesheet" type="text/css" href="../../static/site.css" />
</head>
<body>
</body>
</html>
Etapa 3-3: Adicionar uma página ao aplicativo

A adição de outra página ao aplicativo significa o seguinte:
Adicione uma função em Python que defina o modo de exibição.
Adicione um modelo para a marcação da página.
Adicione o roteamento necessário ao arquivo urls.py do projeto do Django.
As etapas a seguir adicionam uma página "Sobre" ao projeto "HelloDjangoApp" e links para essa página na página
inicial:
1. No Gerenciador de Soluções , clique com o botão direito do mouse na pasta
templates/HelloDjangoApp , selecione Adicionar > Novo item , selecione o modelo de item Página
HTML , nomeie o arquivo about.html e selecione OK .
TIP
Se o comando Novo Item não aparecer no menu Adicionar , verifique se que você interrompeu o servidor para que
o Visual Studio saia do modo de depuração.
2. Substitua o conteúdo de about.html pela seguinte marcação (substitua o link explícito para a home page por
uma barra de navegação simples na etapa 3-4):
<html>
<head>
{% load staticfiles %}
</head>
<body>
<div><a href="home">Home</a></div>
{{ content }}
</body>
</html>
3. Abra o arquivo views.py do aplicativo e adicione uma função chamada about que usa o modelo:
def about(request):
return render(
request,
"HelloDjangoApp/about.html",
{
'title' : "About HelloDjangoApp",
'content' : "Example app page for Django."
}
)
4. Abra o arquivo urls.py do projeto do Django e adicione a seguinte linha à matriz urlPatterns :
url(r'âbout$', HelloDjangoApp.views.about, name='about'),
5. Abra o arquivo templates/HelloDjangoApp/index.html e adicione a seguinte linha abaixo do elemento

<body> para criar um link para a página About (novamente, substitua esse link por uma barra de
navegação na etapa 3-4):
<div><a href="about">About</a></div>
6. Salve todos os arquivos usando o comando de menu arquivo > salvar tudo ou apenas pressione Ctrl +
Shift + S . (Tecnicamente, essa etapa não é necessária, pois a execução do projeto no Visual Studio salva os
arquivos automaticamente. No entanto, é bom conhecer esse comando).
7. Execute o projeto para observar os resultados e verificar a navegação entre as páginas. Feche o servidor ao
terminar.
Pergunta: Tentei usar "index" no link para a página inicial, mas não funcionou. Por que?
Resposta: Embora a função de exibição em views.py seja nomeada index , os padrões de roteamento de URL no
arquivo urls.py do projeto do Django não contêm uma expressão regular que corresponda à cadeia de caracteres
"index". Para fazer a correspondência com essa cadeia de caracteres, você precisa adicionar outra entrada para o
padrão îndex$ .
Como mostrado na próxima seção, é muito melhor usar a marcação {% url '<pattern_name>' %} no modelo de
página para se referir ao nome de um padrão, caso em que o Django cria a URL adequada para você. Por exemplo,
substitua <div><a href="home">Home</a></div> em about.html por
<div><a href="{% url 'index' %}">Home</a></div> . O uso de 'index' funciona aqui porque o primeiro padrão de
URL em urls.py é, na verdade, chamado de 'index' (em virtude do argumento name='index' ). Você também pode
usar "home" para se referir ao segundo padrão.
Etapa 3-4: Usar a herança do modelo para criar um cabeçalho e uma

barra de navegação
Em vez de ter links de navegação explícitos em cada página, os aplicativos Web modernos normalmente usam um
cabeçalho de marca e uma barra de navegação que fornece os links de página mais importantes, menus pop-up e
assim por diante. Para garantir que o cabeçalho e a barra de navegação sejam os mesmos em todas as páginas,
não repita o mesmo código em todos os modelos de página. Em vez disso, defina as partes comuns de todas as
páginas em um único local.
O sistema de modelos do Django fornece dois meios para reutilização de elementos específicos em vários
modelos: includes e inheritance.
Includes corresponde a outros modelos de página que você insere em um local específico no modelo de
referência usando a sintaxe {% include <template_path> %} . Você também pode usar uma variável se quiser
alterar o caminho dinamicamente no código. Os elementos Inclui normalmente são usados no corpo de
uma página para extrair o modelo compartilhado em um local específico na página.
Inheritance usa o {% extends <template_path> %} no início de um modelo de página para especificar um
modelo de base compartilhado no qual o modelo de referência se baseará. O elemento Herança costuma
ser usado para definir um layout compartilhado, uma barra de navegação e outras estruturas para as
páginas de um aplicativo, de modo que os modelos de referência tem apenas adicionar ou modificar áreas
específicas do modelo de base chamadas blocks.
Em ambos os casos, <template_path> é relativo à pasta templates do aplicativo ( ../ ou ./ também é permitido).
Um modelo de base delineia blocos usando as marcas {% block <block_name> %} e {% endblock %} . Se um modelo
de referência usar marcações com o mesmo nome de bloco, o conteúdo do bloco substituirá o do modelo de base.
As etapas a seguir demonstram a herança:
1. Na pasta templates/HelloDjangoApp do aplicativo, crie um arquivo HTML (usando o menu de contexto
Adicionar > Novo item ou Adicionar > Página HTML ) chamado layout.html e substitua seu conteúdo
pela marcação abaixo. Veja que esse modelo contém um bloco chamado "conteúdo", que representa tudo o
que as páginas de referência precisam substituir:
<!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. Adicione os seguintes estilos ao arquivo static/site.css do aplicativo (este passo a passo não está tentando
demonstrar o design responsivo; esses estilos servem apenas para gerar um resultado interessante):
.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 se referir ao modelo base e substituir o bloco de

conteúdo. Veja que, usando a herança, esse modelo se torna simples:
{% extends "HelloDjangoApp/layout.html" %}
{% block content %}
{% endblock %}
4. Modifique templates/HelloDjangoApp/about.html para também se referir ao modelo base e substituir o

bloco de conteúdo:
{% extends "HelloDjangoApp/layout.html" %}
{% block content %}
{{ content }}
{% endblock %}
5. Execute o servidor para observar os resultados. Feche o servidor ao terminar.
6. Como você fez alterações significativas no aplicativo, é novamente um bom momento para confirmar suas
alterações no controle do código-fonte.
Próximas etapas
Usar o modelo Projeto Web Django completo

Implantar o aplicativo Web no Serviço de Aplicativo do Azure
Como gravar seu primeiro aplicativo do Django, parte 3 (modos de exibição) (docs.djangoproject.com)
Para conhecer mais recursos de modelos do Django, como o fluxo de controle, confira A linguagem de modelos
do Django (docs.djangoproject.com)
Para obter detalhes completos sobre como usar a marcação {% url %} , confira url dentro de Referência de
marcações de modelo internas e filtros para modelos do Django (docs.djangoproject.com)
Etapa 4: Usar o modelo Projeto Web do Django
completo
Etapa anterior : Fornecer arquivos estáticos, adicionar páginas e usar a herança do modelo
Agora que você explorou as noções básicas do Django ao compilar um aplicativo com o modelo "Projeto Web em
Branco do Django" no Visual Studio, é possível compreender facilmente o aplicativo mais completo produzido pelo
modelo "Projeto Web do Django".
Nesta etapa, agora você poderá:
Criar um aplicativo Web do Django mais completo usando o modelo "Projeto Web do Django" e examinar a
estrutura do projeto (etapa 4-1)
Entender os modos de exibição e os modelos de página criados pelo modelo de projeto, que consistem em três
páginas que são herdadas a partir de um modelo de página de base e que emprega bibliotecas JavaScript
estáticas como jQuery e Bootstrap (etapa 4-2)
Entender o roteamento de URL fornecido pelo modelo (etapa 4-3)
O modelo também fornece a autenticação básica, que é abordada na Etapa 5.
Etapa 4-1: Criar um projeto com base no modelo

1. No Visual Studio, acesse o Gerenciador de Soluções , clique com o botão direito do mouse na solução
LearningDjango criada anteriormente neste tutorial e selecione Adicionar > Novo Projeto .
(Alternativamente, se você quiser usar uma nova solução, selecione File > New > Project em vez disso.)
2. No novo diálogo de projeto, procure e selecione o modelo do Projeto Web Django, chame o projeto de
"DjangoWeb" e selecione OK .
3. Como o modelo novamente inclui um arquivo requirements.txt, o Visual Studio solicita o local em que essas
dependências serão instaladas. Escolha a opção Instalar em um ambiente vir tual e, na caixa de diálogo
Adicionar Ambiente Vir tual , selecione Criar para aceitar os padrões.
4. Quando o Visual Studio concluir a configuração do ambiente virtual, siga as instruções do readme.html
exibido para criar um superusuário do Django (ou seja, um administrador). Basta clicar com o botão direito
do mouse no projeto Do Visual Studio e selecionar o comando Python > Django Create Superuser e,
em seguida, seguir as instruções. Registre seu nome de usuário e senha que usa ao exercitar os recursos de
autenticação do aplicativo.
5. Defina o projeto DjangoWeb como padrão para a solução Visual Studio clicando com o botão direito do
mouse nesse projeto no Solution Explorer e selecionando Set as Star tup Project . O projeto de
inicialização, mostrado em negrito, é o que é executado quando você inicia o depurador.
6. Selecione Depurar Depuração > Star t Debugging (F5) ou use o botão Ser vidor Web na barra de
ferramentas para executar o servidor:
7. O aplicativo criado pelo modelo tem três páginas, Página inicial, Sobre e Contato, que você navega usando
a barra de navegação. Levar um minuto ou dois para examinar as diferentes partes do aplicativo. Para
autenticar com o aplicativo por meio do comando Login , use as credenciais de superusuário criadas
anteriormente.
8. O aplicativo criado pelo modelo "Projeto Web do Django" usa Bootstrap para layout responsivo que
acomoda fatores forma móveis. Para ver essa capacidade de resposta, redimensione o navegador para uma
exibição específica para que o conteúdo seja renderizado verticalmente e a barra de navegação se
transforme em um ícone de menu:
9. Você pode deixar o aplicativo em execução para as seções a seguir.

Caso deseje interromper o aplicativo e confirmar as alterações no controle do código-fonte, primeiro abra a
página Alterações no Team Explorer , clique com o botão direito do mouse na pasta do ambiente virtual
(provavelmente env ) e selecione Ignorar estes itens locais .
Examine o que o modelo cria
No nível mais amplo, o modelo "Projeto Web do Django" cria a seguinte estrutura:
Arquivos na raiz do projeto:
manage.py, o utilitário administrativo do Django.
db.sqlite3, banco de dados SQLite padrão.
requirements.txt contendo uma dependência Django 1.x.
readme.html, um arquivo que é exibido no Visual Studio após a criação do projeto. Conforme observado
na seção anterior, siga as instruções aqui para criar uma conta de superusuário (administrador) para o
aplicativo.
A pasta app contém todos os arquivos do aplicativo, incluindo exibições, modelos, testes, formulários, modelos
e arquivos estáticos (veja a etapa 4-2). Normalmente, você renomeie esta pasta para usar um nome de
aplicativo mais diferente.
A pasta DjangoWeb (projeto Django) contém os arquivos típicos do projeto Django: * _ ___init .py*, settings.py,
urls.pye wsgi.py. Usando o modelo de projeto, settings.py já está configurado para o aplicativo e o arquivo de
banco de dados, e urls.py já está configurado com rotas para todas as páginas de aplicativo, incluindo o
formulário de logon.
Pergunta: É possível compartilhar um ambiente virtual entre projetos do Visual Studio?
Resposta: Sim, mas faça isso sabendo que diferentes projetos provavelmente usam pacotes diferentes ao longo do
tempo e, portanto, um ambiente virtual compartilhado deve conter todos os pacotes para todos os projetos que o
usam.
No entanto, para usar um ambiente virtual existente, faça o seguinte:
1. Quando for solicitado a instalar dependências no Visual Studio, selecione a opção Eu os instalarei por conta
própria opção.
2. No Gerenciador de Soluções , clique com o botão direito do mouse no nó Ambientes do Python e escolha
Adicionar Ambiente Vir tual Existente .
3. Navegue até e selecione a pasta que contém o ambiente virtual e selecione OK .
Etapa 4-2: Entender os modos de exibição e os modelos de página

criados pelo modelo de projeto
Quando você executa o projeto, observe que o aplicativo contém três modos de exibição: Página inicial, Sobre e
Contato. O código dessas exibições é encontrado na pasta app/views. Cada função de exibição simplesmente
chama django.shortcuts.render com o caminho para um modelo e um objeto de dicionário simples. Por exemplo,
a página Sobre é tratada pela função about :
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,
}
)
Os modelos estão localizados na pasta templates/app do aplicativo (e, geralmente, você deseja renomear app com
o nome do aplicativo real). O modelo base, layout.html, é o mais abrangente. Ele se refere a todos os arquivos
estáticos necessários (JavaScript e CSS), define um bloco nomeado "conteúdo" que outras páginas substituem e
fornece outro bloco chamado "scripts". Os seguintes trechos anotados de layout.html mostram essas á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">


<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>
Cada um dos modelos de página individual, about.html, contact.html e index.html, estende o modelo base
layout.html. about.html é o mais simples e mostra as marcações {% extends %} e {% 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 e contact.html usam a mesma estrutura e fornecem mais conteúdo no bloco "conteúdo".
Na pasta templates/app, também se encontra uma quarta página login.html, junto com loginpartial.html, que é
inserida em layout.html com {% include %} . Esses arquivos de modelo são discutidos na etapa 5 na autenticação.
Pergunta: {% block %} e {% endblock %} podem ser recuados no modelo de página do Django?
Resposta: Sim, os modelos de página do Django funcionam bem se você recuar marcas de bloco, talvez para
alinhá-los em seus elementos pai apropriados. Eles não estão recuados nos modelos de página gerados pelo
modelo de projeto do Visual Studio para que você possa ver claramente onde eles estão colocados.
Etapa 4-3: Entender o roteamento de URL criado pelo modelo

O arquivo urls.py do projeto do Django criado pelo modelo "Projeto Web do Django" contém o seguinte código:

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'),
]
Os três primeiros padrões de URL são mapeados diretamente para as exibições home , contact e about no
arquivo views.py do aplicativo. Os padrões ^login/$ e ^logout$ , por outro lado, usam modos de exibição
internos do Django em vez de exibições definidas pelo aplicativo. As chamadas para o método url também
incluem dados adicionais para personalizar o modo de exibição. A Etapa 5 explora essas chamadas.
Pergunta: No projeto que criei, por que o padrão de URL "about" usa 'âbout' em vez de 'âbout$', como
mostrado aqui?
Resposta: A falta do '$' à direita na expressão regular foi um erro simples em várias versões do modelo do projeto.
O padrão de URL funciona perfeitamente bem para uma página chamada "sobre", mas sem o '$' à direita, o
padrão de URL também corresponde a URLs como "about=django", "about09876", "aboutoflaughter" e assim por
diante. O '$' à direita é mostrado aqui para criar um padrão de URL que corresponde a somente "sobre".
Próximas etapas
Autenticar usuários no Django

Como gravar seu primeiro aplicativo do Django, parte 4 – Modos de exibição genéricos e formulários
Etapa 5: Autenticar usuários no Django
Etapa anterior : Usar o modelo Projeto Web completo do Django

Como a autenticação é uma necessidade comum dos aplicativos Web, o modelo "Projeto Web do Django" inclui
um fluxo de autenticação básico. (O modelo "Polls Django Web Project" discutido na etapa 6 deste tutorial também
inclui o mesmo fluxo.) Ao usar qualquer um dos modelos de projeto Django, o Visual Studio inclui todos os
módulos necessários para autenticação no settings.pydo projeto Django .
Nesta etapa, você aprenderá:
Como usar o fluxo de autenticação fornecido em modelos do Visual Studio (etapa 5 – 1)
Etapa 5-1: Usar o fluxo de autenticação

As etapas a seguir acionam o fluxo de autenticação e descrevem as partes envolvidas do projeto:
1. Se você ainda não seguiu as instruções do arquivo readme.html na raiz do projeto para criar uma conta de
superusuário (administrador), faça isso agora.
2. Execute o aplicativo do Visual Studio usando depuração de depuração > Star t Debugging (F5).
Quando o aplicativo aparecer no navegador, observe que a opção Login aparecerá no canto superior
direito da barra de navegação.
3. Abra templates/app/layout.html e observe que o elemento <div class="navbar ...> contém a marcação
{% include app/loginpartial.html %} . A marca {% include %} instrui o sistema de modelos do Django a
efetuar pull do conteúdo do arquivo incluído neste momento no modelo que o contém.
4. Abra templates/app/loginpartial.html e observe como ele usa a marcação condicional
{% if user.is_authenticated %} juntamente com uma marcação {% else %} para renderizar diferentes
elementos da interface do usuário, dependendo se o usuário realizou a autenticação:
{% 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. Como nenhum usuário é autenticado quando você inicia o aplicativo pela primeira vez, esse código de
modelo renderiza apenas o link "Fazer logon" para o caminho relativo "logon". Conforme especificado em
urls.py (mostrado na seção anterior), essa rota é mapeada para a exibição django.contrib.auth.views.login .
Essa exibição recebe os seguintes dados:
{
'template_name': 'app/login.html',
'authentication_form': app.forms.BootstrapAuthenticationForm,
'extra_context':
{
'title': 'Log in',
}
}
Aqui, template_name identifica o modelo da página de logon, nesse caso, templates/app/login.html. A

propriedade extra_context é adicionada aos dados de contexto padrão fornecidos para o modelo. Por fim,
authentication_form especifica uma classe de formulário a ser usada com o logon; no modelo, ele é exibido
como o objeto form . O valor padrão é AuthenticationForm (de django.contrib.auth.views ). Em vez disso, o
modelo de projeto do Visual Studio usa o formulário definido no arquivo forms.py do aplicativo:
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 você pode ver, essa classe de formulário deriva de AuthenticationForm e, especificamente, substitui
os campos de nome de usuário e senha para adicionar texto de espaço reservado. O modelo do Visual
Studio inclui esse código explícito considerando que você possa querer personalizar o formulário, por
exemplo, adicionando uma validação de força de senha.
6. Quando você navega para a página de logon, o aplicativo renderiza o modelo login.html. As variáveis
{{ form.username }} e {{ form.password }} renderizam os formulários CharField de
BootstrapAuthenticationForm . Há também uma seção interna para mostrar erros de validação e um
elemento predefinido para efetuar logons em redes sociais, se você optar por adicionar esses serviços.
{% 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. Quando você envia o formulário, o Django tenta autenticar suas credenciais (como as credenciais do
superusuário). Se a autenticação falhar, você permanecerá na página atual, mas form.errors será definido
como true. Se a autenticação for bem-sucedida, o Django navegará para a URL relativa no campo "avançar",
<input type="hidden" name="next" value="/" /> , que, nesse caso, é a página inicial ( / ).
8. Agora, quando a home page for novamente renderizada, a propriedade user.is_authenticated será
verdadeira quando o modelo loginpartial.html for renderizado. Como resultado, você verá uma mensagem
Olá, (nome de usuário) e Fazer logoff . Você pode usar user.is_authenticated em outras partes do
aplicativo para verificar a autenticação.
9. Para verificar se o usuário autenticado está autorizado a acessar recursos específicos, você precisa recuperar
as permissões específicas do usuário do banco de dados. Para obter mais informações, confira Using the
Django authentication system (Usando o sistema de autenticação do Django) (documentos do Django).
10. O superusuário ou o administrador, em particular, está autorizado a acessar as interfaces de administrador
internas do Django usando as URLs relativas "/admin/" e "/admin/doc/". Para habilitar essas interfaces, faça
o seguinte:
a. Instale o pacote Python docutils em seu ambiente. Uma boa maneira de fazer isso é adicionar
"docutils" ao arquivo requirements.txt e, em seguida, no Gerenciador de Soluções , expandir o
projeto, expandir o nó Ambientes do Python e, em seguida, clicar com o botão direito do mouse
no ambiente que você está usando e selecionar Instalar do requirements.txt .
b. Abra o projeto do Django urls.py e remova os comentários padrão das seguintes 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. No arquivo settings.py do projeto do Django, navegue até a coleção INSTALLED_APPS e adicione

'django.contrib.admindocs' .
d. Quando você reiniciar o aplicativo, navegue até "/admin/" e "/admin/doc/" e execute tarefas, como
criar contas de usuário adicionais.
11. A parte final do fluxo de autenticação é fazer logoff. Como você pode ver em loginpartial.html, o link Fazer
logoff apenas faz um POST para a URL relativa "/login", que é manipulada pela exibição interna
django.contrib.auth.views.logout . Essa exibição não exibe nenhuma interface do usuário e apenas navega
para a home page (conforme mostrado em urls.py para o padrão "^logout$"). Se você quiser exibir uma
página de logoff, primeiro altere o padrão da URL conforme mostrado a seguir para adicionar uma
propriedade "template_name" e remover a propriedade "next_page":
url(r'^logout$',
django.contrib.auth.views.logout,
{
'template_name': 'app/loggedoff.html',
# 'next_page': '/',
},
name='logout')
Em seguida, crie templates/app/loggedoff.html com o seguinte conteúdo (mínimo):

{% block content %}
<h3>You have been logged off</h3>
{% endblock %}
O resultado se parece com o seguinte:
12. Quando terminar, interrompa o servidor e, mais uma vez, confirme suas alterações no controle do código-
fonte.
Pergunta: Qual é a finalidade da marcação {% csrf_token %} exibida nos elementos <form>?
Resposta: A marcação {% csrf_token %} inclui a proteção interna contra solicitações intersites forjadas (csrf) do
Django (documentos do Django). Normalmente, essa marca é adicionada a qualquer elemento que envolva
métodos de solicitação POST, PUT ou DELETE, como um formulário. Em seguida, a função de renderização de
modelo ( render ) insere a proteção necessária.
Próximas etapas
Usar o modelo Pesquisas Projeto Web do Django

Autenticação de usuário no Django (docs.djangoproject.com)
Etapa 6: Usar o modelo Projeto Web do Django de
pesquisas
Etapa anterior : Autenticar usuários em Django

Depois de entender o modelo de "Projeto Web do Django" do Visual Studio, você agora pode examinar o terceiro
modelo do Django, "Pesquisas do projeto Web do Django", que tem como base a mesma base de código e
demonstra o trabalho com um banco de dados.
Criar um projeto do modelo e inicializar o banco de dados (etapa 6-1)
Compreender os modelos de dados (etapa 6-2)
Aplicar migrações (etapa 6-3)
Entender os modos de exibição e os modelos de página criados pelo modelo de projeto (etapa 6-4)
Criar uma interface de administração personalizada (etapa 6-5)
Um projeto criado usando este modelo é semelhante ao que você ganha seguindo o Writing seu primeiro tutorial
de aplicativo Django nos docs do Django. O aplicativo web consiste em um site público que permite que as
pessoas visualizem pesquisas e votem nelas, juntamente com uma interface administrativa personalizada através
da qual você pode gerenciar pesquisas. Ele usa o mesmo sistema de autenticação que o modelo "Projeto Web do
Django" e usa mais o banco de dados implementando modelos do Django conforme explorado nas seções a
seguir.
Etapa 6-1: Criar o projeto e inicializar o banco de dados

1. No Visual Studio, acesse o Gerenciador de Soluções , clique com o botão direito do mouse na solução
LearningDjango criada anteriormente neste tutorial e selecione Adicionar > Novo Projeto .
2. No novo diálogo do projeto, procure e selecione o modelo do Projeto Web polls Django, chame o
projeto de "DjangoPolls" e selecione OK .
3. Como os outros modelos de projeto do Visual Studio, o modelo de "Projeto Web de Votações do Django"
inclui um arquivo requirements.txt. Os prompts do Visual Studio solicitam o local em que essas
4. Quando o Python concluir a configuração do ambiente virtual, siga as instruções no readme.html exibido
para inicializar o banco de dados e criar um superusuário do Django (ou seja, um administrador). As etapas
são primeiro clicar com o botão direito do mouse no projeto DjangoPolls no Solution Explorer,
selecionar o comando Python > Django Migrate, em seguida, clicar com o botão direito do mouse no
projeto novamente, selecionar o comando Python > Django Criar Superusuário e seguir as instruções.
(Se você tentar criar um superusuário pela primeira vez, verá um erro porque o banco de dados não foi
inicializado).
5. Defina o projeto DjangoPolls como padrão para a solução Visual Studio clicando com o botão direito do
7. O aplicativo criado pelo modelo tem três páginas, Página inicial, Sobre e Contato, que você navega usando a
barra de navegação superior. Leve alguns minutos para examinar as diferentes partes do aplicativo (as
páginas Sobre e Contato são muito semelhantes ao "Projeto Web do Django" e não serão mais discutidas).
8. Selecione também o link Administração na barra de navegação, que exibe uma tela de logon para
demonstrar que a interface administrativa é autorizada somente para administradores autenticados. Use as
credenciais de superusuário e você será encaminhado para a página "/admin", que é habilitada por padrão
ao usar este modelo de projeto.

Examine o conteúdo do projeto
Conforme observado anteriormente, quase tudo o que está em um projeto criado a partir do modelo "Pesquisas
do Projeto Web do Django" deverá ser conhecido se você tiver explorado os outros modelos de projeto no Visual
Studio. As etapas adicionais neste artigo resumem as mais alterações e adições mais significativas, ou seja,
modelos de dados e modos de exibição adicionais.
Pergunta: O que faz o comando Django Migrate?
Resposta: O comando Django Migrate especificamente executa o comando manage.py migrate , que executa
todos os scripts na pasta app/migrations que não foram executados anteriormente. Nesse caso, o comando
executa o script 0001_initial.py nessa pasta para configurar o esquema necessário no banco de dados.
O script de migração em si é criado pelo comando manage.py makemigrations , que examina o arquivo models.py do
aplicativo, compara-o com o estado atual do banco de dados e, em seguida, gera os scripts necessários para
migrar o esquema de banco de dados para que ele corresponda aos modelos atuais. Esse recurso do Django é
muito eficiente durante a atualização e modificação dos modelos ao longo do tempo. Ao gerar e executar
migrações, você mantém os modelos e o banco de dados em sincronia com facilidade.
Você trabalha com uma migração na etapa 6-3 neste artigo.
Etapa 6-2: Compreender os modelos de dados

Os modelos do aplicativo, chamados Votação e Opção, são definidos em app/models.py. Cada um é uma classe do
Python que deriva de django.db.models.Model e usa métodos da classe models como CharField e IntegerField
para definir campos no modelo, que são mapeados para colunas de banco de dados.
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 você pode ver, uma Pesquisa mantém uma descrição em seu campo text e uma data de publicação no
pub_date . Esses campos são os únicos que existem para a Pesquisa no banco de dados; o total_votes campo é
calculado em tempo de execução.
Uma Opção está relacionada a uma Pesquisa por meio do campo poll , contém uma descrição no text e mantém
uma contagem para aquela opção no votes . O votes_percentage campo é calculado em tempo de execução e não
é encontrado no banco de dados.
A lista completa de tipos de campo é CharField (texto limitado) TextField (texto ilimitado), EmailField ,
URLField , DateTimeField , IntegerField , DecimalField , BooleanField , ForeignKey e ManyToMany . Cada campo
utiliza alguns atributos, como max_length . O atributo blank=True significa que o campo é opcional; null=true
significa que um valor é opcional. Também há um atributo choices que limita valores a valores em uma matriz de
tuplas de valor de dados/valor de exibição. (Veja a Referência de campo de modelo na documentação do Django).
Você pode confirmar exatamente o que está armazenado no banco de dados examinando o arquivo db.sqlite3 no
projeto usando uma ferramenta como o navegador SQLite. No banco de dados, você verá que um campo de chave
estrangeira como poll no modelo Escolher está armazenado como poll_id ; o Django trata o mapeamento
automaticamente.
Em geral, trabalhar com seu banco de dados no Django significa trabalhar exclusivamente por meio de seus
modelos de forma que o Django possa gerenciar o banco de dados subjacente em seu nome.
Propagar o banco de dados de samples.json
Inicialmente, o banco de dados não contém pesquisas. Você pode usar a interface administrativa na URL "/admin"
para adicionar votações manualmente, e também pode visitar a página "/seed" no site em execução para adicionar
uma semente ao banco de dados com votações definidas no arquivo samples.json do aplicativo.
O urls.py do projeto do Django tem um padrão de URL adicionado, url(r'^seed$', app.views.seed, name='seed'), .
A exibição seed em app/views.py carrega o arquivo samples.json e cria os objetos de modelo necessários. O
Django, em seguida, cria automaticamente os registros correspondentes no banco de dados subjacente.
Observe o uso do decorador @login_required para indicar o nível de autorização para o modo de exibição.
@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 o efeito, execute o aplicativo primeiro para verificar se não há alguma pesquisa. Visite a URL "/seed" e,
quando o aplicativo retornar para a página inicial, você verá que as pesquisas ficaram disponíveis. Novamente,
fique à vontade para examinar o arquivo db.sqlite3 bruto com uma ferramenta como o navegador SQLite.
Pergunta: É possível inicializar o banco de dados usando o utilitário administrativo do Django?
Resposta: Sim, você pode usar o comando django-admin loaddata para realizar a mesma tarefa que a página de
propagação no aplicativo. Ao trabalhar em um aplicativo Web completo, você pode usar uma combinação dos dois
métodos: inicializar um banco de dados da linha de comando e, em seguida, converter a página de propagação
aqui para uma API para a qual você pode enviar qualquer outro JSON arbitrário em vez de depender de um
arquivo codificado.
Etapa 6-3: Usar migrações

Quando você executou o comando manage.py makemigrations (usando o menu de contexto no Visual Studio)
depois de criar o projeto, o Django criou o arquivo app/migrations/0001_initial.py. Esse arquivo contém um script
que cria as tabelas de banco de dados iniciais.
Como você inevitavelmente fará alterações a seus modelos ao longo do tempo, o Django facilitará a atualização do
esquema de banco de dados subjacente com esses modelos. O fluxo de trabalho geral é o seguinte:
1. Faça alterações nos modelos no arquivo models.py.
2. No Visual Studio, clique com o botão direito no projeto no Gerenciador de Soluções e selecione o comando
Python > Django Make Migrations . Conforme descrito anteriormente, esse comando gera scripts no
app/migrations para migrar o banco de dados de seu estado atual para o novo estado.
3. Para aplicar os scripts no banco de dados real, clique com o botão direito do mouse no projeto novamente e
selecione Python > Django Migrate .
O Django controla quais migrações foram aplicadas a qualquer banco de dados determinado, de modo que,
quando você executar o comando de migração, o Django aplicará as migrações necessárias. Se você criar um novo
banco de dados vazio, por exemplo, executar o comando de migração atualiza-o com seus modelos atuais
aplicando todos os scripts de migração. Da mesma forma, se você fizer várias alterações do modelo e gerar
migrações de um computador de desenvolvimento, poderá aplicar as migrações cumulativas ao seu banco de
dados de produção, executando o comando de migração no servidor de produção. O Django novamente aplica-se
apenas a esses scripts de migração que foram gerados desde a última migração do banco de dados de produção.
Para ver o efeito de alterar um modelo, tente as seguintes etapas:
1. Adicionar um campo de autor opcional ao modelo Poll em app/models.py adicionando a seguinte linha
após o campo pub_date para adicionar um campo author opcional:
author = models.CharField(max_length=100, blank=True)
2. Salve o arquivo e clique com o botão direito do mouse no projeto DjangoPolls no Solution Explorer e
selecione o comando Python > Django Make Migrations.
3. Selecione o comando 'Mostrar > todos os arquivos' para ver o script recém-gerado na pasta de
migrações, cujo nome começa com 002_auto_ . Clique com o botão direito no arquivo e selecione
Include In Project . Em seguida, você pode selecionar Project > Show All Files novamente para
restaurar a exibição original. (Veja a segunda pergunta abaixo para obter detalhes sobre esta etapa).
4. Se desejar, abra o arquivo para examinar como os scripts do Django são alterados do estado de modelo
anterior para o novo estado.
5. Clique com o botão direito do mouse no projeto Visual Studio novamente e selecione Python > Django
Migrate para aplicar as alterações no banco de dados.
6. Se desejar, abra o banco de dados em um visualizador apropriado para confirmar a alteração.
Em geral, o recurso de migração do Django significa que você nunca precisa gerenciar seu esquema de banco de
dados manualmente. Basta fazer alterações em seus modelos, gerar scripts de migração e aplicá-las com o
comando de migração.
Pergunta: O que acontece se eu esquecer de executar o comando de migração depois de fazer alterações nos
modelos?
Resposta: Se os modelos não corresponderem ao que está no banco de dados, o Django falha no tempo de
execução com exceções apropriadas. Por exemplo, se você esquecer de migrar a alteração de modelo mostrada na
seção anterior, verá um erro sem tal coluna: app_poll.author :
.
Pergunta: Por que o Gerenciador de Soluções não mostra os scripts gerados recentemente após executar
Django Make Migrations?
Resposta: Embora os scripts recém-gerados estejam na pasta app/migrations e sejam aplicados quando o
comando Django Migrate é executado, eles não são exibidos automaticamente no Gerenciador de Soluções
porque não foram adicionados ao projeto do Visual Studio. Para torná-los visíveis, primeiro selecione o comando
Menu Mostrar > todos os arquivos ou o botão de barra de ferramentas descrito na imagem abaixo. Esse
comando faz o Gerenciador de Soluções mostrar todos os arquivos na pasta do projeto, com um ícone de
contorno pontilhado para itens que não foram adicionados ao projeto em si. Clique com o botão direito nos
arquivos que você deseja adicionar e selecione Include In Project , que também os inclui no controle de origem
com a próxima confirmação.
Pergunta: Posso ver quais migrações serão aplicadas antes de executar o comando de migração?
Resposta: Sim, use o comando django-admin showmigrations.

A maioria dos modos de exibição gerados pelo modelo "Pesquisas de Projeto Web do Django", como os modos de
exibição para as páginas Sobre e Contato, é muito semelhantes a exibições criadas pelo modelo "Projeto Web do
Django" com o qual você trabalhou anteriormente neste tutorial. A diferença no aplicativo de pesquisas de
aplicativo é que sua página inicial usa modelos, assim como várias páginas adicionadas para votação e visualizar
os resultados da pesquisa.
Em primeiro lugar, a primeira linha na matriz urlpatterns do projeto do Django no arquivo urls.py é mais do que
apenas um simples roteamento para uma exibição do aplicativo. Em vez disso, ele efetua pull do próprio arquivo
urls.py do aplicativo:
from django.conf.urls import url, include

import app.views
urlpatterns = [
url(r'^', include('app.urls', namespace="app")),
# ..
]
O arquivo app/urls.py contém um código de roteamento mais interessante (comentários explicativos adicionados):
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'),
]
Se você não estiver familiarizado com as expressões regulares mais complexas usadas aqui, poderá colar a
expressão em regex101.com para obter uma explicação em linguagem simples. (Será necessário escapar as barras
invertidas / adicionando uma barra invertida, \ antes delas; o escape não é necessário no Python devido ao
prefixo r na cadeia de caracteres, que significa "bruto").
No Django, a sintaxe ?P<name>pattern cria um grupo chamado name , que é passado como argumentos para
exibições na ordem em que aparecem. No código mostrado anteriormente, PollsDetailView e PollsResultsView
recebem um argumento denominado pk e app.views.vote recebe um argumento denominado poll_id .
Você também pode ver que a maioria das exibições não é apenas uma referência direta a uma função de exibição
em app/views.py. Em vez disso, a maioria se refere a uma classe no mesmo arquivo que deriva de
django.views.generic.ListView ou django.views.generic.DetailView . As classes base fornecem os métodos
as_view , que levam um argumento template_name para identificar o modelo. A classe base ListView , como
usado para a página inicial, também espera uma propriedade queryset que contém os dados e uma propriedade
context_object_name com o nome de variável pelo qual você deseja se referir aos dados no modelo, nesse caso
latest_poll_list .
Agora você pode examinar a PollListView da home page, que é definida da seguinte maneira em 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
Tudo o que foi feito aqui é para identificar o modelo de que o modo de exibição funciona com (Pesquisa) e
substitui o método get_context_data para adicionar os valores title e year para o contexto.
O núcleo do modelo (templates/app/index.html) é o seguinte:
{% 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 %}
Em suma, o modelo recebe a lista de objetos de pesquisa no latest_poll_list e, em seguida, itera por meio dessa
lista para criar uma linha da tabela que contém um link para cada pesquisa usando o valor text da pesquisa. Na
marcação {% url %} , "app:detail" refere-se ao padrão de URL em app/urls.py chamado "detail", usando poll.id
como argumento. O efeito disso é que o Django cria uma URL usando o padrão apropriado e usa isso para o link.
Essa certa garantia de durabilidade significa que você pode alterar esse padrão de URL a qualquer momento e os
links gerados automaticamente para corresponder.
As classes PollDetailView e PollResultsView em app/views.py (não mostradas aqui) são praticamente idênticas a
PollListView , exceto pelo fato de que derivam de DetailView . Seus respectivos modelos,
app/templates/details.html e app/templates/results.html, colocam então os campos apropriados dos modelos
dentro de vários controles HTML. Uma parte exclusiva em details.html é que as opções para uma votação estão
contidas dentro de um formulário HTML que, quando enviado, executa um POST na URL /vote. Conforme visto
anteriormente, esse padrão de URL é roteado para app.views.vote , que é implementado da seguinte maneira
(observe o argumento poll_id , que é novamente um grupo nomeado na expressão regular usada no roteamento
para este modo de exibição):
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,)))
Aqui o modo de exibição não tem seu próprio modelo correspondente como as outras páginas. Em vez disso, ele
valida a pesquisas selecionada, mostrando 404 se o a pesquisa não existir (no caso de alguém inserir uma URL
como "vote/1a2b3c"). Em seguida, ele verifica se a opção votada é válida para a pesquisa. Caso contrário, o bloco
except processa a página de detalhes novamente com uma mensagem de erro. Se a opção for válida, o modo de
exibição também incluirá o voto e redirecionará para a página de resultados.
Etapa 6-5: Criar uma interface de administração personalizada

As últimas partes do modelo "Pesquisas de Projeto Web do Django" são extensões personalizadas para a interface
administrativa padrão do Django, conforme mostrado anteriormente neste artigo na etapa 6-1. A interface padrão
fornece o usuário e o gerenciamento de grupo, nada mais. O modelo de projeto de pesquisa adiciona recursos que
permitem que você gerencie pesquisas também.
Em primeiro lugar, os padrões de URL em urls.py do projeto do Django tem
url(r'âdmin/', include(admin.site.urls)), incluído por padrão; o padrão "admin/doc" também está incluído,
mas está com marca de comentário.
Em seguida, o aplicativo contém o arquivo admin.py, que o Django executa automaticamente quando você visita a
interface administrativa, graças à inclusão de django.contrib.admin na matriz INSTALLED_APPS de settings.py. O
código nesse arquivo, conforme fornecido pelo modelo de projeto, é o seguinte:
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 você pode ver, a classe PollAdmin deriva de django.contrib.admin.ModelAdmin e personaliza vários de seus
campos usando nomes do modelo Poll , que ele gerencia. Esses campos são descritos nas opções de
ModelAdmin na documentação do Django.
A chamada para admin.site.register em seguida conecta-se a essa classe para o modelo ( Poll ) e a inclui na
interface de administração. O resultado geral é mostrado abaixo:
Próximas etapas
NOTE
Se você tiver confirmando sua solução do Visual Studio para controle de origem ao longo deste tutorial, agora será um bom
momento para fazer outra confirmação. A solução deve corresponder ao código-fonte do tutorial no GitHub:
Microsoft/python-sample-vs-learning-django.
Agora você explorou a totalidade dos modelos de "Projeto em branco da Web do Django", "Projeto da Web do
Django" e "Pesquisas de Projeto Web do Django" no Visual Studio. Você aprendeu as noções básicas do Django
como o uso de modelos e modos de exibição e explorou roteamento, autenticação e uso de modelos de banco de
dados. Agora você deverá ser capaz de criar um aplicativo Web por sua conta com os modos de exibição e os
modelos de que precisar.
A execução de um aplicativo Web no computador de desenvolvimento é apenas uma etapa para disponibilizar o
aplicativo para seus clientes. As próximas etapas podem incluir as seguintes tarefas:
Implante o aplicativo Web em um servidor de produção, como o Serviço de Aplicativo do Azure. Confira
Publicar no Serviço de Aplicativo do Azure.
Personalizar a página 404 criando um modelo chamado templates/404.html. Quando presente, o Django
usa esse modelo, em vez de seu padrão. Para saber mais, veja Modos de exibição de erro na documentação
do Django.
Escreva testes de unidade em tests.py; os modelos de projeto do Visual Studio fornecem pontos iniciais para
eles e mais informações podem ser encontradas em Escrevendo seu primeiro aplicativo do Django, parte 5
– teste e Testando no Django na documentação do Django.
Altere o aplicativo de SQLite para um repositório de dados de nível de produção como PostgreSQL, MySQL
e SQL Server (que pode ser hospedado no Azure). Conforme descrito em Quando usar o SQLite (sqlite.org),
o SQLite funciona bem para sites de tráfego baixo a médio com menos de 100 mil acessos por dia, mas não
é recomendado para volumes maiores. Também é limitado a um único computador, de modo que ele não
pode ser usado em qualquer cenário de vários servidores, como balanceamento de carga e replicação
geográfica. Para obter informações sobre o suporte do Django para outros bancos de dados, veja Instalação
do banco de dados. Você também pode usar o SDK do Azure para Python para trabalhar com serviços de
armazenamento do Azure como tabelas e blobs.
Configure um pipeline de integração contínua/implantação contínua em um serviço como o Azure DevOps.
Além de trabalhar com o controle do código-fonte (por meio do Azure Repos, do GitHub ou em outro local),
você pode configurar um projeto do Azure DevOps para executar automaticamente os testes de unidade
como um pré-requisito para o lançamento, bem como configurar o pipeline para implantação em um
servidor de preparo para testes adicionais antes de implantar na produção. O Azure DevOps, além disso,
integra-se às soluções de monitoramento, como o App Insights e fecha o ciclo de inteiro com ferramentas
ágeis de planejamento. Para saber mais, confira Criar um pipeline de CI/CD para Python com o projeto do
Azure DevOps e também a documentação geral do Azure DevOps.
Tutorial: Introdução à estrutura da Web do Flask no
Visual Studio
O Flask é uma estrutura leve do Python para aplicativos Web que fornece as noções básicas de roteamento de
URL e renderização de página.
O Flask é denominado uma "microestrutura", porque não oferece diretamente funcionalidades como validação de
formulário, abstração de banco de dados, autenticação e assim por diante. Essas funcionalidades são fornecidas
por pacotes especiais do Python chamados extensões do Flask. As extensões integram-se perfeitamente ao Flask
para serem exibidas como se fizessem parte do próprio Flask. Por exemplo, o Flask não oferece um mecanismo de
modelo de página. A modelagem é fornecida por extensões como Jinja e Jade, conforme demonstrado neste
tutorial.
Neste tutorial, você aprenderá como:
Criar um projeto básico do Flask em um repositório GIT usando o modelo "Projeto Web em Branco do Flask"
(etapa 1)
Criar um aplicativo do Flask com uma página e renderizar essa página usando um modelo (etapa 2)
Fornecer arquivos estáticos, adicionar páginas e usar a herança do modelo (etapa 3)
Usar o modelo Projeto Web do Flask para criar um aplicativo com várias páginas e design responsivo (etapa 4)
Use o modelo Pesquisa Projeto Web de Flask para criar um aplicativo de votação que usa uma variedade de
opções de armazenamento (armazenamento do Azure, MongoDB ou memória).
No decorrer dessas etapas, você criará uma única solução do Visual Studio que contém três projetos separados.
Você criará o projeto usando diferentes modelos de projeto do Flask incluídos com o Visual Studio. Se você
mantiver os projetos na mesma solução, poderá facilmente alternar entre diferentes arquivos para comparação.
NOTE
Este tutorial é diferente do Início Rápido do Flask no qual você saberá mais sobre o Flask e como usar os diferentes modelos
de projeto do Flask que fornecem um ponto de início mais amplo para seus próprios projetos. Por exemplo, os modelos de
projeto instalam automaticamente o pacote do Flask ao criar um projeto, em vez de precisar instalar o pacote manualmente,
conforme mostrado no Início Rápido.
Pré-requisitos
Visual Studio 2017 ou posteriores no Windows com as seguintes opções:
A carga de trabalho desenvolvimento do Python (guia Carga de Trabalho no instalador). Para obter
instruções, confira Instalar o suporte do Python no Visual Studio.
GIT para Windows e Extensão GitHub para Visual Studio na guia Componentes individuais em
Code Tools .
Os modelos de projeto do Flask são incluídos com todas as versões anteriores das Ferramentas Python para
Visual Studio, embora os detalhes possam ser diferentes do que foi discutido neste tutorial.
No momento, não há suporte para o desenvolvimento do Python no Visual Studio para Mac. No Mac e no Linux,
use a Extensão Python no Visual Studio Code.
Etapa 1-1: Criar uma solução e um projeto do Visual Studio
1. No Visual Studio, selecione File > New > Project , procure por "Flask" e selecione o modelo de Projeto
Web do Frasco em Branco. (O modelo também é encontrado naWeb Python > na lista à esquerda.)
2. Nos campos, na parte inferior da caixa de diálogo, insira as informações a seguir (conforme mostrado no
gráfico anterior) e, em seguida, escolha OK :
Nome : defina o nome do projeto Visual Studio como BasicProject . Esse nome também é usado para o
projeto do Flask.
Local : especifique um local no qual criar o projeto e a solução do Visual Studio.
Nome da solução : definido como LearningFlask , apropriado para a solução como um contêiner para
vários projetos neste tutorial.
Criar diretório para a solução : deixar definido (o padrão).
Criar um novo repositório Git : escolha essa opção (que é clara por padrão) para que o Visual Studio
crie um repositório Git local quando criar a solução. Caso essa opção não seja exibida, execute o
instalador do Visual Studio e adicione o GIT para Windows e a Extensão do GitHub para Visual
Studio à guia Componentes individuais em Ferramentas de código .
3. Depois de um momento, o Visual Studio solicita-lhe uma caixa de diálogo dizendo que este projeto
requer pacotes externos (mostrado abaixo). Essa caixa de diálogo é exibida porque o modelo inclui um
arquivo requirements.txt que referencia o último pacote do Flask 1.x. Escolha Mostrar pacotes
necessários para ver as dependências exatas.
4. Escolha a opção Eu vou instalá-los sozinho . Crie o ambiente virtual logo em seguida para garantir que
ele será excluído do controle do código-fonte. (O ambiente pode ser sempre criado com base em
requirements.txt.)
Etapa 1-2: Examinar os controles do Git e publicar em um repositório

remoto
Como você marcou a opção Criar novo repositório Git na caixa de diálogo Novo Projeto , o projeto já ficará
confirmado no controle do código-fonte local assim que o processo de criação for concluído. Nesta etapa,
familiarize-se com os controles do Git do Visual Studio e a janela do Team Explorer onde você trabalha com o
controle do código-fonte.
1. Observe os controles do Git no canto inferior da janela principal do Visual Studio. Da esquerda para direita,
esses controles mostram confirmações não enviadas, as alterações não confirmadas, o nome do repositório
e a ramificação atual:
NOTE
Se você não marcar a opção Criar novo repositório Git na caixa de diálogo Novo Projeto , os controles do Git
mostrarão apenas um comando Adicionar ao controle do código-fonte que criará um repositório local.
2. Marque o botão de alterações e o Visual Studio abrirá a janela do Team Explorer na página Alterações .
Como o projeto recém-criado já está automaticamente confirmado no controle do código-fonte, você não
verá as alterações pendentes.
3. Na barra de status do Visual Studio, selecione o botão de confirmação não pressionado (a seta para cima
com 2 ) para abrir a página Sincronização no Team Explorer . Como você tem apenas um repositório
local, a página oferece opções simples para publicar o repositório em diferentes repositórios remotos.
Você pode escolher o serviço que desejar para seus próprios projetos. Este tutorial mostra o uso do GitHub,
em que o código de exemplo concluído do tutorial é mantido no repositório Microsoft/python-sample-vs-
learning-flask.
4. Ao selecionar qualquer um dos controles Publicar , o Team Explorer solicitará mais informações. Por
exemplo, ao publicar o exemplo deste tutorial, o próprio repositório teve que ser criado primeiro, caso em
que a opção Enviar por Push para o Repositório Remoto foi usada com a URL do repositório.
Se você não tiver um repositório, as opções Publicar no GitHub e Enviar por Push para o Azure
DevOps permitirão criar um repositório diretamente no Visual Studio.
5. Ao trabalhar com este tutorial, adquira o hábito de usar periodicamente os controles no Visual Studio para
confirmar e enviar alterações por push. Este tutorial envia-lhe lembretes nos pontos apropriados.
TIP
Para navegar rapidamente no Team Explorer, selecione o cabeçalho (que lê Alterações ou Empurre nas imagens acima)
para ver um menu pop-up das páginas disponíveis.
Pergunta: Quais são algumas vantagens de usar o controle do código -fonte a partir do início de um projeto?
Resposta: Em primeiro lugar, se você usar o controle do código-fonte desde o início, especialmente se também
usar um repositório remoto, terá um backup regular em um local fora do projeto. Em vez de manter um projeto
apenas em um sistema de arquivos local, o controle do código-fonte também oferece um histórico de alterações
completo e facilita a reversão de um único arquivo ou todo o projeto para um estado anterior. O histórico de
alterações ajuda a determinar a causa das regressões (falhas de teste). Além disso, o controle do código-fonte é
essencial se várias pessoas estiverem trabalhando em um projeto, pois ele gerencia substituições e fornece a
resolução de conflitos. Por fim, o controle do código-fonte, que é basicamente uma forma de automação, deixa
você preparado para automatizar o gerenciamento de compilações, testes e versões. Esse recurso realmente
representa o primeiro passo no uso de DevOps em um projeto e, como os obstáculos para entrar são muito
baixos, realmente não há motivos para não usar o controle do código-fonte desde o início.
Para uma discussão mais aprofundada sobre o controle do código-fonte usado como automação, confira A
origem da verdade: a função dos repositórios no DevOps, um artigo da MSDN Magazine destinado a aplicativos
móveis, mas que também se aplica a aplicativos Web.
Pergunta: É possível evitar que o Visual Studio confirme automaticamente um novo projeto?
Resposta: Sim. Para desabilitar a confirmação automática, vá para a página Configurações no Team Explorer ,
escolha Git > Configurações Globais , desmarque o opção rotulada como Confirmar alterações após
mesclagem por padrão e, em seguida, escolha Atualizar .
Etapa 1-3: Criar o ambiente virtual e excluí-lo do controle do código-

fonte
Agora que você configurou o controle do código-fonte para o projeto, é possível criar no ambiente virtual os
pacotes necessários do Flask que o projeto exige. Você pode usar o Team Explorer para excluir a pasta do
ambiente do controle do código-fonte.
1. No Gerenciador de Soluções , clique com o botão direito do mouse no nó Ambientes do Python e
escolha Adicionar Ambiente Vir tual .
2. Uma caixa de diálogo Adicionar ambiente vir tual é exibida, com uma mensagem dizendo que
encontramos um arquivo requirements.txt. Esta mensagem indica que o Visual Studio usa esse
arquivo para configurar o ambiente virtual.
3. Escolha Criar para aceitar os padrões. (Se desejar, o nome do ambiente virtual pode ser alterado. Essa ação
alterará apenas o nome da subpasta, mas env é uma convenção padrão).
4. Caso seja solicitado, concorde com os privilégios de administrador e aguarde alguns minutos enquanto o
Visual Studio baixa e instala pacotes, que, para o Flask e para suas dependências, significa expandir cerca de
mil arquivos em mais de 100 subpastas. Você pode ver o progresso na janela Saída no Visual Studio.
Enquanto você aguarda, analise as seções de perguntas a seguir. Também é possível ver uma descrição das
dependências do Flask na página instalação do Flask (flask.pcocoo.org).
5. Nos controles do GIT do Visual Studio (na barra de status), selecione o indicador de alterações (mostrando
99* ) que abre a página Alterações no Team Explorer .
A criação do ambiente virtual apresentou centenas de alterações, mas nenhuma delas precisará ser incluída
no controle do código-fonte já que você (ou qualquer outra pessoa que venha a clonar o projeto) poderá
sempre recriar o ambiente com base em requirements.txt.
Para excluir o ambiente virtual, clique com o botão direito do mouse na pasta env e selecione Ignorar
estes itens locais .
6. Depois de excluir o ambiente virtual, as únicas alterações restantes são as referentes ao arquivo de projeto
e a .gitignore. O arquivo .gitignore contém uma entrada adicional para a pasta do ambiente virtual. Você
pode clicar duas vezes no arquivo para ver uma comparação.
7. Digite uma mensagem de confirmação, escolha o botão Confirmar Todos e, se desejar, envie as
confirmações por push para o repositório remoto.
Pergunta: Por que criar um ambiente virtual?
Resposta: Um ambiente virtual é uma ótima maneira de isolar as dependências exatas do seu aplicativo. Esse
isolamento evita conflitos em um ambiente global do Python e auxilia nos testes e na colaboração. Com o tempo,
à medida que desenvolver um aplicativo, invariavelmente, você introduzirá muitos pacotes úteis do Python.
Mantendo os pacotes em um ambiente virtual específico do projeto, você pode atualizar com facilidade o arquivo
requirements.txt do projeto que descreve esse ambiente, incluído no controle do código-fonte. Quando o projeto é
copiado para outros computadores, incluindo servidores de build, servidores de implantação e outros
computadores de desenvolvimento, é fácil recriar o ambiente usando apenas o requirements.txt (é por isso que o
ambiente não precisa estar no controle do código-fonte). Para obter mais informações, confira Usar ambientes
virtuais.
Pergunta: Como faço para remover um ambiente virtual que já está confirmado no controle do código -fonte?
Resposta: Primeiro, edite o arquivo .gitignore para excluir a pasta: localize a seção ao final com o comentário
# Python Tools for Visual Studio (PTVS) e adicione uma nova linha à pasta do ambiente virtual, como
/BasicProject/env . (Como o Visual Studio não mostra o arquivo no Gerenciador de Soluções , abra-o
diretamente usando o comando de menu Arquivo > Abrir > Arquivo . Abra também o arquivo no Team
Explorer : na página Configurações , selecione Configurações do Repositório , vá para a seção Arquivos
Ignorar e de Atributos e, em seguida, selecione o link Editar ao lado de .gitignore .)
Em segundo lugar, abra uma janela Comando, navegue para a pasta, como BasicProject, que contém a pasta do
ambiente virtual, como env, e execute git rm -r env . Em seguida, confirme essas alterações na linha de comando
( git commit -m 'Remove venv' ) ou confirme na página Alterações do Team Explorer .
Etapa 1-4: Examinar o código de texto clichê

1. Quando a criação do projeto for concluída, você verá a solução e o projeto no Gerenciador de Soluções ,
em que o projeto contém apenas dois arquivos, app.py e requirements.txt:
2. Conforme observado anteriormente, o arquivo requirements.txt especifica a dependência de pacote do

Flask. A presença desse arquivo é que faz com que você seja convidado a criar um ambiente virtual ao
desenvolver o projeto pela primeira vez.
3. O único arquivo app.py contém três partes. A primeira é uma instrução import do Flask, criando uma
instância da classe Flask , atribuída à variável app e, em seguida, atribuindo uma variável wsgi_app (útil
ao implantar um host da Web, mas não usada no momento):

# Make the WSGI interface available at the top level so wfastcgi can get it.
wsgi_app = app.wsgi_app
4. A segunda parte, ao fim do arquivo, é um trecho do código opcional que inicia o servidor de
desenvolvimento do Flask com valores de porta e de host específicos extraídos de variáveis de ambiente
(padrão para localhost:5555):
if __name__ == '__main__':
import os
try:
except ValueError:
PORT = 5555
app.run(HOST, PORT)
5. A terceira é um breve trecho de código que atribui uma função a uma rota de URL, o que significa que a
função oferece o recurso identificado pela URL. Defina rotas usando o decorador @app.route do Flask, cujo
argumento é a URL relativa da raiz do site. Como é possível ver no código, a função retorna apenas uma
cadeia de caracteres de texto, que é suficiente para um navegador renderizar. Nas etapas seguintes, você
renderizará páginas mais avançadas com HTML.
@app.route('/')
def hello():
Pergunta: Qual é a finalidade do argumento name para a classe do Flask?

Resposta: o argumento é o nome do módulo ou do pacote do aplicativo e informa ao Flask onde procurar
modelos, arquivos estáticos e outros recursos que pertencem ao aplicativo. Para aplicativos contidos em um único
módulo, __name__ é sempre o valor adequado. Também é importante para as extensões que precisam de
informações de depuração. Para obter mais informações, e outros argumentos, confira a documentação de classes
do Flask (flask.pocoo.org).
Pergunta: Uma função pode ter mais de um decorador de rota?
Resposta: sim, será possível usar quantos decoradores você quiser se a mesma função servir para várias rotas. Por
exemplo, para usar a função hello para "/" e "/hello", use o seguinte código:
@app.route('/')
@app.route('/hello')
def hello():
Pergunta: Como o Flask trabalha com rotas de URL de variável e parâmetros de consulta?
Resposta: em uma rota, marque qualquer variável com <variable_name> , e o Flask passará a variável para a função
usando um argumento nomeado. A variável pode fazer parte do caminho da URL ou em um parâmetro de
consulta. Por exemplo, uma rota no formato de '/hello/<name> gera um argumento de cadeia de caracteres
chamado name para a função e o uso de ?message=<msg> na rota analisa o valor fornecido para o parâmetro de
consulta "message=" e o passa para a função como msg :
@app.route('/hello/<name>?message=<msg>')
def hello(name, msg):
return "Hello " + name + "! Message is " + msg + "."
Para alterar o tipo, insira int , float , path à frente da variável (que aceita barras para delinear nomes de pasta)
e uuid . Para obter detalhes, confira Regras de variáveis na documentação do Flask.
Os parâmetros de consulta também estão disponíveis por meio da propriedade request.args , especificamente
por meio do método request.args.get . Para obter mais informações, confira O objeto Request na documentação
do Flask.
Pergunta: O Visual Studio pode gerar um arquivo requirements.txt a partir de um ambiente virtual depois de
instalar outros pacotes?
Resposta: Sim. Expanda o nó Ambientes do Python , clique com o botão direito do mouse no ambiente virtual e
escolha o comando Gerar requirements.txt . É recomendável usar esse comando periodicamente conforme você
modifica o ambiente e confirma as alterações em requirements.txt no controle do código-fonte, juntamente com
outras alterações de código que dependem desse ambiente. Se você configurar a integração contínua em um
servidor de compilação, deverá gerar o arquivo e confirmar as alterações sempre que modificar o ambiente.
Etapa 1-5: Executar o projeto

1. No Visual Studio, selecione Debug > Star t Debugging (F5) ou use o botão Do Ser vidor Web na barra
de ferramentas (o navegador que você vê pode variar):
2. Qualquer comando atribui um número da porta aleatório à variável de ambiente PORT e, em seguida,
executa python app.py . O código inicia o aplicativo usando essa porta dentro do servidor de
desenvolvimento do Flask. Se o Visual Studio informar Falha ao iniciar o depurador com uma
mensagem que alerta para a ausência de um arquivo de inicialização, clique com o botão direito do mouse
em app.py no Gerenciador de Soluções e selecione Definir como Arquivo de Inicialização .
3. Ao iniciar o servidor, você vê uma janela do console aberta que exibe o log do servidor. O Visual Studio
abre automaticamente um navegador para http://localhost:<port> , em que você verá a mensagem
renderizada pela função hello :
4. Quando terminar, pare o servidor fechando a janela do console ou usando o comando Debug > Stop
Debugging no Visual Studio.
Pergunta: Qual é a diferença entre usar os comandos do menu Depuração e os comandos do servidor no
submenu do Python do projeto?
Resposta: Além dos comandos do menu Depurar e dos botões da barra de ferramentas, você também pode
iniciar o servidor usando os comandos Python > Executar ser vidor ou Python > Executar o ser vidor de
depuração no menu de contexto do projeto. Os dois comandos abrem uma janela de console na qual você vê a
URL local (localhost:port) do servidor em execução. Mesmo assim, abra manualmente um navegador usando essa
URL já que a execução do servidor de depuração não inicia automaticamente o depurador do Visual Studio. Você
pode anexar um depurador ao processo de execução mais tarde, se quiser, usando o comando Debug > Attach
to Process.
Próximas etapas
Neste ponto, o projeto básico do Flask contém o código de inicialização e o código de página no mesmo arquivo. É
melhor separar essas duas questões e também separar o HTML e os dados usando modelos.
Criar um aplicativo do Flask com modos de exibição e modelos de página

Início rápido do Flask (flask.pocoo.org)
Código-fonte do tutorial no GitHub: Microsoft/python-sample-vs-learning-flask
Etapa 2: Criar um aplicativo Flask com exibições e
modelos de página
Etapa anterior : Criar uma solução e um projeto do Visual Studio

Na etapa 1 deste tutorial, você tem um aplicativo Flask com uma página e todo o código em um único arquivo.
Para permitir o desenvolvimento futuro, é melhor refatorar o código e criar uma estrutura para modelos de
página. Em particular, separe o código para exibições do aplicativo de outros aspectos como o código de
inicialização.
Refatorar o código do aplicativo para separar exibições do código de inicialização (etapa 2-1)
Renderizar uma exibição usando um modelo de página (etapa 2-2)
Etapa 2-1: Refatorar o projeto para dar suporte ao desenvolvimento

adicional
No código criado pelo modelo "Projeto Web em Branco do Flask", você tem um único arquivo app.py que contém
o código de inicialização junto com uma única exibição. Para permitir o desenvolvimento adicional de um
aplicativo com várias exibições e modelos, é melhor separar essas preocupações.
1. Na pasta do seu projeto, crie uma pasta de aplicativo chamada HelloFlask (clique com o botão direito do
mouse no projeto em Gerenciador de Soluções e selecione Adicionar > Nova Pasta .)
2. Na pasta HelloFlask, crie um arquivo chamado * _ ___init .py* com os seguintes conteúdos que criam a
Flask instância e carrega as visualizações do aplicativo (criadas na próxima etapa):

import HelloFlask.views
3. Na pasta HelloFlask, crie um arquivo chamado views.py com o conteúdo a seguir. O nome views.py é
import HelloFlask.views importante porque você usou * _ _dentro__init .py*; você verá um erro no tempo
de execução se os nomes não coincidirem.

from HelloFlask import app
@app.route('/')
@app.route('/home')
def home():
return "Hello Flask!"
Além de renomear a função home e a rota para , este app código contém o código de renderização da
página de app.py e importa o objeto declarado * _ _init__.py*.
4. Crie uma subpasta em HelloFlask chamada templates, que permanecerá vazia por enquanto.
5. Na pasta raiz do projeto, renomeie app.py como runserver.py e faça o conteúdo corresponder ao seguinte
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. A estrutura do seu projeto deve ser semelhante à da imagem a seguir:
7. Selecione Depurar > Depuração (F5) ou use o botão Do ser vidor web na barra de ferramentas (o
navegador que você vê pode variar) para iniciar o aplicativo e abrir um navegador. Experimente as rotas de
URL / e /home.
8. Também é possível definir pontos de interrupção em várias partes do código e reiniciar o aplicativo para
seguir a sequência de inicialização. Por exemplo, defina um ponto de interrupção nas primeiras linhas de
runserver.py e HelloFlask_ init_.py e na linha return "Hello Flask!" de views.py. Em seguida, reinicie o
aplicativo (Debug > Restar t , Ctrl +F5, ou o botão da barra de ferramentas mostrado abaixo) e passe
(F10) o código, ou execute a partir de cada ponto de ruptura usando F5 .
9. Interrompa o aplicativo ao terminar.

Confirmar o controle do código -fonte
Como você já fez alterações no seu código e as testou com êxito, agora é o momento ideal para revisar e confirmar
as alterações ao controle do código-fonte. As etapas posteriores deste tutorial indicam os momentos apropriados
para fazer a confirmação no controle do código-fonte novamente e direcionam você mais uma vez para esta seção.
1. Selecione o botão de alterações na parte inferior do Visual Studio (circulado abaixo), que encaminha para o
Team Explorer .
2. No Team Explorer , digite uma mensagem de confirmação como "Refatorar código" e selecione Confirmar
Tudo . Quando o commit estiver concluído, você verá uma mensagem Commit <hash> criada
localmente. Sincronize para compar tilhar suas alterações com o ser vidor. Se você quiser enviar
alterações por push para o repositório remoto, selecione Sincronizar , depois selecione Push em
Confirmações de Saída . Também é possível acumular várias confirmações locais antes de enviar para o
repositório remoto.
Pergunta: Com que frequência é necessário fazer a confirmação no controle do código -fonte?
Resposta: A confirmação de alterações no controle do código-fonte cria um registro no log de alterações e um
ponto em que é possível reverter o repositório, se necessário. Cada confirmação também pode ser examinada para
suas alterações específicas. Como as confirmações no GIT não são caras, é melhor realizar confirmações
frequentes do que acumular um grande número de alterações em uma única confirmação. Obviamente, não é
necessário confirmar cada pequena alteração em arquivos individuais. Normalmente, você realiza uma
confirmação ao adicionar uma funcionalidade, alterando uma estrutura como você fez nesta etapa, ou realizar
alguma refatoração do código. Verifique também com outras pessoas da sua equipe para a granularidade de
confirmações que funcionam melhor para todos.
A frequência de confirmação e a frequência de envio de confirmações por push a um repositório remoto são duas
preocupações diferentes. Você pode acumular várias confirmações no seu repositório local antes de enviá-las por
push para o repositório remoto. Novamente, a frequência de confirmação depende de como sua equipe deseja
gerenciar o repositório.
Etapa 2-2: Usar um modelo para renderizar uma página

A função home que você tem até agora em views.py não gera nada além de uma resposta HTTP de texto sem
formatação para a página. No entanto, a maioria das páginas da Web reais respondem com páginas HTML
avançadas que incorporam dados dinâmicos com frequência. Na verdade, a principal razão para definir uma
exibição usando uma função é gerar esse conteúdo dinamicamente.
Como o valor retornado para a exibição é apenas uma cadeia de caracteres, é possível criar qualquer HTML que
desejar dentro de uma cadeia de caracteres, usando conteúdo dinâmico. No entanto, como é melhor separar a
marcação dos dados, é muito melhor inserir a marcação em um modelo e manter os dados no código.
1. Para iniciantes, edite views.py para que ela contenha o seguinte código que usa HTML embutido para a
página com algum conteúdo 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. Execute o aplicativo e atualize a página poucas vezes para ver que a data/hora está atualizada. Interrompa o
aplicativo ao terminar.
3. Para converter a renderização da página para usar um modelo, crie um arquivo chamado index.html na
pasta templates com o seguinte conteúdo, em que {{ content }} é um espaço reservado ou um token de
substituição (também chamado de uma variável de modelo) para o qual você fornece um valor no código:
<html>
<head><title>Hello Flask</title></head>
<body>
{{ content }}
</body>
</html>
4. Modifique a função home para usar render_template para carregar o modelo e fornecer um valor para
"conteúdo", que é feito usando um argumento nomeado correspondente ao nome do espaço reservado. O
Flask procura automaticamente os modelos na pasta templates; portanto o caminho para o modelo é
relativo a essa pasta:
def home():
return render_template(
"index.html",
content = "<strong>Hello, Flask!</strong> on " + formatted_now)
5. Execute o aplicativo para ver os resultados e observe que o HTML embutido no valor content não é
renderizado como HTML, porque o mecanismo de modelagem (Jinja) ignora automaticamente o conteúdo
HTML. O escape automático impede vulnerabilidades acidentais em ataques de injeção: os desenvolvedores
geralmente coletam a entrada de uma página e a usam como um valor em outra por meio de um espaço
reservado de modelo. O escape também funciona como um lembrete de que é melhor novamente manter o
HTML fora do código.
Da mesma forma, examine templates\index.html para conter espaços reservados distintos em cada parte
dos dados dentro da marcação:
<html>
<head>
</head>
<body>
<strong>{{ message }}</strong>{{ content }}
</body>
</html>
Em seguida, atualize a função home para fornecer valores para todos os espaços reservados:
def home():
"index.html",
title = "Hello Flask",
message = "Hello, Flask!",
content = " on " + formatted_now)
6. Execute o aplicativo novamente para ver a saída renderizada corretamente.
7. Confirme suas alterações no controle do código-fonte e atualize seu repositório remoto, se desejado,
conforme descrito em etapa 2-1.
Pergunta: Os modelos de página precisam ficar em um arquivo separado?
Resposta: Embora os modelos geralmente sejam mantidos em arquivos HTML separados, também é possível usar
um modelo embutido. No entanto, é recomendável usar um arquivo separado para manter uma distinção clara
entre marcação e código.
Pergunta: Os modelos precisam usar a extensão de arquivo .html?
Resposta: A extensão .html dos arquivos de modelo de página é totalmente opcional, porque você sempre
identifica o caminho relativo exato para o arquivo no primeiro argumento para a função render_template . No
entanto, o Visual Studio (e outros editores) costuma fornecer funcionalidades como preenchimento de código e
coloração de sintaxe com arquivos .html, o que supera o fato de os modelos de página não serem estritamente
HTML.
De fato, quando você está trabalhando com um projeto do Flask, o Visual Studio detecta automaticamente quando
o arquivo HTML que você está editando é, na verdade, um modelo do Flask e fornece algumas funcionalidades de
preenchimento automático. Por exemplo, quando você começa a digitar um comentário no modelo de página do
Flask, {# , o Visual Studio fornece automaticamente os caracteres de fechamento #} . Os comandos Comentar
Seleção e Remover Marca de Comentário da Seleção (no menu Editar > Avançado e na barra de
ferramentas) também usam comentários de modelo em vez de comentários em HTML.
Pergunta: Os modelos podem ser organizados em subpastas adicionais?
Resposta: Sim. É possível usar subpastas e, em seguida, referir-se ao caminho relativo em templates nas chamadas
a render_template . Isso é uma ótima maneira de criar efetivamente namespaces para os modelos.
Próximas etapas
Fornecer arquivos estáticos, adicionar páginas e usar a herança do modelo

Início rápido do Flask – Renderizando modelos (flask.pocoo.org)
Etapa 3: Fornecer arquivos estáticos, adicionar
páginas e usar a herança do modelo
Etapa anterior : Criar um aplicativo do Flask com modos de exibição e modelos de página
Nas etapas anteriores deste tutorial, você aprendeu como criar um aplicativo mínimo do Flask com uma única
página HTML autocontido. No entanto, aplicativos Web modernos geralmente são compostos por várias páginas e
usam recursos compartilhados, como arquivos CSS e JavaScript, para fornecer comportamento e estilo
consistentes.
Usar modelos de item do Visual Studio para adicionar rapidamente novos arquivos de diferentes tipos com
código clichê conveniente (etapa 3-1)
Fornecer arquivos estáticos do código (etapa 3-2, opcional)
Adicionar mais páginas ao aplicativo (etapa 3-3)
Usar a herança do modelo para criar um cabeçalho e uma barra de navegação usados nas páginas (etapa 3-4)
Etapa 3-1: Familiarizar-se com os modelos de item

À medida que desenvolve um aplicativo do Flask, geralmente você adiciona vários outros arquivos Python, HTML,
CSS e JavaScript. Para cada tipo de arquivo (bem como para outros arquivos, como web.config, que podem ser
necessários para a implantação), o Visual Studio fornece modelos de item convenientes para você começar.
Para ver os modelos disponíveis, vá para Gerenciador de Soluções , clique com o botão direito do mouse na
pasta em que você deseja criar o item, selecione Adicionar > Novo Item :
Para usar um modelo, selecione o modelo desejado, especifique um nome para o arquivo e selecione OK . A adição
de um item dessa maneira adiciona automaticamente o arquivo ao projeto do Visual Studio e marca as alterações
para controle do código-fonte.
Pergunta: Como o Visual Studio sabe quais modelos de item oferecer?
Resposta: O arquivo de projeto do Visual Studio (.pyproj) contém um identificador de tipo de projeto que o marca
como um projeto do Python. O Visual Studio usa esse identificador de tipo para mostrar apenas os modelos de
item adequados para o tipo de projeto. Dessa forma, o Visual Studio pode fornecer um conjunto avançado de
modelos de item para muitos tipos de projeto sem solicitar que você os classifique toda vez.
Etapa 3-2: Fornecer arquivos estáticos do seu aplicativo

Em um aplicativo Web criado com Python (usando qualquer estrutura), seus arquivos em Python sempre são
executados no servidor do host da Web e nunca são transmitidos para o computador de um usuário. Mas outros
arquivos, como CSS e JavaScript, são usados exclusivamente pelo navegador, de modo que o servidor do host
simplesmente os entrega como estão sempre que são solicitados. Esses arquivos são chamados de "estáticos", e o
Flask pode fornecê-los automaticamente sem que você precise escrever código. Dentro de arquivos HTML, por
exemplo, é possível referenciar arquivos estáticos usando um caminho relativo no projeto. A primeira seção desta
etapa adiciona um arquivo CSS ao modelo de página existente.
Quando você precisar entregar um arquivo estático do código, como por meio de uma implementação de ponto
de extremidade de API, o Flask fornecerá um método conveniente que permite a você referenciar arquivos usando
caminhos relativos dentro de uma pasta chamada static (na raiz do projeto). A segunda seção desta etapa
demonstra esse método usando um arquivo de dados estático simples.
Em qualquer caso, você pode organizar os arquivos em static como desejar.
Usar um arquivo estático em um modelo
1. No Solution Explorer, clique com o botão direito do mouse na pasta HelloFlask no projeto Visual Studio,
selecione Adicionar > nova pasta e nomeie a pasta static .
2. Clique com o botão direito do mouse na pasta static e selecione Adicionar > Novo item . Na caixa de
diálogo que aparece, selecione site.css o modelo 'Folha de estilos', nomeie o arquivo e selecione OK . O
arquivo site.css é exibido no projeto e aberto no editor. A estrutura de pastas deve ser semelhante à
imagem a seguir:
3. Substitua o conteúdo de site.css pelo seguinte código e salve o arquivo:
.message {
font-weight: 600;
color: blue;
}
4. Substitua o conteúdo do arquivo templates/index.html do aplicativo pelo código a seguir, que substitui o
elemento <strong> usado na etapa 2 por um <span> que referencia a classe de estilo message . O uso de
uma classe de estilo dessa maneira oferece muito mais flexibilidade ao estilo do elemento.
<html>
<head>
<link rel="stylesheet" type="text/css" href="/static/site.css" />
</head>
<body>
</body>
</html>
5. Execute o projeto para observar os resultados. Interrompa o aplicativo quando terminar e confirme as
alterações no controle do código-fonte se desejar (conforme explicado na etapa 2).
Fornecer um arquivo estático do código
O Flask fornece uma função chamada serve_static_file que você pode chamar por meio do código para
referenciar qualquer arquivo dentro da pasta static do projeto. O processo a seguir cria um ponto de extremidade
de API simples que retorna um arquivo de dados estáticos.
1. Se você ainda não fez isto, crie uma pasta static: no Gerenciador de Soluções , clique com o botão direito
do mouse na pasta HelloFlask no projeto do Visual Studio, selecione Adicionar > Nova pasta e nomeie a
pasta static .
2. Na pasta static, crie um arquivo de dados JSON estático chamado data.json com o seguinte conteúdo
(dados de exemplo sem sentido):
{
"01": {
"note" : "Data is very simple because we're demonstrating only the mechanism."
}
}
3. Em views.py, adicione uma função com a rota /api/data que retorna o arquivo de dados estático usando o
método send_static_file :
@app.route('/api/data')
def get_data():
return app.send_static_file('data.json')
4. Execute o aplicativo e navegue até o ponto de extremidade /api/data para ver se o arquivo estático será
retornado. Interrompa o aplicativo ao terminar.
Pergunta: Há convenções para organizar arquivos estáticos?
Resposta: Você pode adicionar outros arquivos CSS, JavaScript e HTML à sua pasta static como quiser. Uma
maneira comum de organizar arquivos estáticos é criar subpastas chamadas fonts, scripts e content (para folhas de
estilo e outros arquivos).
Pergunta: Como fazer para manipular variáveis de URL e parâmetros de consulta em uma API?
Resposta: Veja a resposta na etapa 1-4 para pergunta: Como o Flask funciona com rotas de URL variáveis e
parâmetros de consulta?
Etapa 3-3: Adicionar uma página ao aplicativo

A adição de outra página ao aplicativo significa o seguinte:
Adicione uma função em Python que defina o modo de exibição.
Adicione um modelo para a marcação da página.
Adicione o roteamento necessário ao arquivo urls.py do projeto do Flask.
As etapas a seguir adicionam uma página "Sobre" ao projeto "HelloFlask" e links para essa página na home page:
1. No Gerenciador de Soluções , clique com o botão direito do mouse na pasta templates , selecione
Adicionar > Novo item , selecione o modelo de item Página HTML , nomeie o arquivo about.html e
selecione OK .
TIP
Se o comando Novo Item não for exibido no menu Adicionar , verifique se você interrompeu o aplicativo para que
o Visual Studio saia do modo de depuração.
2. Substitua o conteúdo de about.html pela seguinte marcação (substitua o link explícito para a home page por
uma barra de navegação simples na etapa 3-4):
<html>
<head>
</head>
<body>
<div><a href="home">Home</a></div>
{{ content }}
</body>
</html>
3. Abra o arquivo views.py do aplicativo e adicione uma função chamada about que usa o modelo:
@app.route('/about')
def about():
"about.html",
title = "About HelloFlask",
content = "Example app page for Flask.")
4. Abra o arquivo templates/index.html e adicione a seguinte linha imediatamente dentro do elemento

<body> para criar um link para a página About (novamente, substitua esse link por uma barra de
navegação na etapa 3-4):
<div><a href="about">About</a></div>
5. Salve todos os arquivos usando o comando File > Save All menu ou apenas pressione Ctrl +Shift +S .
(Tecnicamente, essa etapa não é necessária, pois a execução do projeto no Visual Studio salva os arquivos
automaticamente. No entanto, é bom conhecer esse comando).
6. Execute o projeto para observar os resultados e verificar a navegação entre as páginas. Interrompa o
aplicativo quando terminar.
Pergunta: o nome de uma função de página é importante para o Flask?
Resposta: não, porque ele é o decorador @app.route que determina as URLs para as quais o Flask chama a função
para gerar uma resposta. Normalmente, os desenvolvedores correspondem o nome da função à rota, mas essa
correspondência não é obrigatória.
Etapa 3-4: Usar a herança do modelo para criar um cabeçalho e uma

barra de navegação
Em vez de ter links de navegação explícitos em cada página, os aplicativos Web modernos normalmente usam um
cabeçalho de marca e uma barra de navegação que fornece os links de página mais importantes, menus pop-up e
assim por diante. Para garantir que o cabeçalho e a barra de navegação sejam os mesmos em todas as páginas,
não repita o mesmo código em todos os modelos de página. Em vez disso, defina as partes comuns de todas as
páginas em um único local.
O sistema de modelos do Flask (Jinja por padrão) fornece dois meios para reutilização de elementos específicos
em vários modelos: inclui e herança.
Includes corresponde a outros modelos de página que você insere em um local específico no modelo de
referência usando a sintaxe {% include <template_path> %} . Você também pode usar uma variável se quiser
alterar o caminho dinamicamente no código. Os elementos Inclui normalmente são usados no corpo de
uma página para extrair o modelo compartilhado em um local específico na página.
Inheritance usa o {% extends <template_path> %} no início de um modelo de página para especificar um
modelo de base compartilhado no qual o modelo de referência se baseará. O elemento Herança costuma
ser usado para definir um layout compartilhado, uma barra de navegação e outras estruturas para as
páginas de um aplicativo, de modo que os modelos de referência tem apenas adicionar ou modificar áreas
específicas do modelo de base chamadas blocks.
Em ambos os casos, <template_path> é relativo à pasta templates do aplicativo ( ../ ou ./ também é permitido).
Um modelo base delineia {% endblock %} blocos usando {% block <block_name> %} e tags. Se um modelo de
referência usar marcações com o mesmo nome de bloco, o conteúdo do bloco substituirá o do modelo de base.
As etapas a seguir demonstram a herança:
1. Na pasta templates do aplicativo, crie um arquivo HTML (usando o menu de contexto Adicionar > Novo
item ou Adicionar > Página HTML ) chamado layout.html e substitua o conteúdo pela marcação abaixo.
Veja que esse modelo contém um bloco chamado "conteúdo", que representa tudo o que as páginas de
referência precisam substituir:
<!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. Adicione os seguintes estilos ao arquivo static/site.css do aplicativo (este passo a passo não está tentando
demonstrar o design responsivo; esses estilos servem apenas para gerar um resultado interessante):
.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 se referir ao modelo base e substituir o bloco de conteúdo. Veja que,
usando a herança, esse modelo se torna simples:
{% extends "layout.html" %}
{% block content %}
{% endblock %}
4. Modifique templates/about.html para se referir também ao modelo base e substituir o bloco de conteúdo:
{% block content %}
{{ content }}
{% endblock %}
5. Execute o servidor para observar os resultados. Feche o servidor ao terminar.
6. Como você fez alterações significativas no aplicativo, é novamente um bom momento para confirmar suas
alterações no controle do código-fonte.
Próximas etapas
Usar o modelo completo de Projeto Web do Flask
Para ver mais funcionalidades de modelos Jinja, como o fluxo de controle, confira Jinja Template Designer
Documentation (Documentação de Designer de Modelo do Jinja) ( jinja.pocoo.org)
Para obter detalhes sobre o uso de url_for , confira url_for na documentação do objeto do Aplicativo Flask
(flask.pocoo.org)
Etapa 4: Usar o modelo Projeto Web do Flask
completo
Etapa anterior : Fornecer arquivos estáticos, adicionar páginas e usar a herança do modelo
Agora que você explorou as noções básicas do Flask ao compilar um aplicativo com o modelo "Projeto de
Aplicativo em Branco do Flask" no Visual Studio, é possível compreender facilmente o aplicativo mais completo
produzido pelo modelo "Projeto Web do Flask".
Nesta etapa, agora você poderá:
Criar um aplicativo Web do Flask mais completo usando o modelo "Projeto Web do Flask" e examinar a
estrutura do projeto (etapa 4-1)
Entender os modos de exibição e os modelos de página criados pelo modelo de projeto, que consistem em três
páginas que são herdadas a partir de um modelo de página de base e que emprega bibliotecas JavaScript
estáticas como jQuery e Bootstrap (etapa 4-2)
Entender o roteamento de URL fornecido pelo modelo (etapa 4-3)
Este artigo aplica-se também ao modelo "Projeto Web do Flask/Jade", que produz um aplicativo idêntico ao do
"Projeto Web do Flask" usando o mecanismo de modelagem do Jade, em vez do Jinja. Detalhes adicionais são
incluídos ao fim deste artigo.
Etapa 4-1: Criar um projeto com base no modelo

1. No Visual Studio, vá para Solution Explorer , clique com o botão direito do mouse na solução
LearningFlask criada anteriormente neste tutorial e selecione Adicionar > novo projeto .
2. No novo diálogo de projeto, procure e selecione o modelo do Projeto Web flask , chame o projeto de
"FlaskWeb" e selecione OK .
3. Como o modelo novamente inclui um arquivo requirements.txt, o Visual Studio solicita o local em que essas
4. Assim que o Visual Studio terminar de configurar o ambiente virtual, defina o projeto FlaskWeb como
padrão para a solução Visual Studio clicando com o botão direito do mouse nesse projeto no Solution
Explorer e selecionando Set as Star tup Project . O projeto de inicialização, mostrado em negrito, é o que é
executado quando você inicia o depurador.
6. O aplicativo criado pelo modelo tem três páginas, Página inicial, Sobre e Contato, que você navega usando
a barra de navegação. Levar um minuto ou dois para examinar as diferentes partes do aplicativo. Para
autenticar com o aplicativo por meio do comando Login , use as credenciais de superusuário criadas
anteriormente.
7. O aplicativo criado pelo modelo "Projeto Web do Flask" usa Bootstrap para layout responsivo que acomoda
fatores de forma móveis. Para ver essa capacidade de resposta, redimensione o navegador para uma
exibição específica para que o conteúdo seja renderizado verticalmente e a barra de navegação se
transforme em um ícone de menu:

Examine o que o modelo cria
O modelo "Projeto Web do Flask" cria a estrutura abaixo. O conteúdo é muito semelhante ao que você criou nas
etapas anteriores. A diferença é que o modelo "Projeto Web do Flask" contém mais estrutura na pasta static,
porque ela inclui jQuery e Bootstrap para obter um design responsivo. O modelo também adiciona uma página
Contato. Em geral, se você seguiu as etapas anteriores deste tutorial, você já deve conhecer tudo com base no
modelo.
Arquivos na raiz do projeto:
runserver.py, um script para executar o aplicativo em um servidor de desenvolvimento.
requirements.txt contendo uma dependência do Flask 0.x.
A pasta FlaskWeb contém todos os arquivos de aplicativo:
init.py marca o código do aplicativo como um módulo Python, cria o objeto Flask e importa as
visualizações do aplicativo. * _ __ *
views.py contém o código para renderizar páginas.
A pasta static contém subpastas chamadas content (arquivos CSS), fonts (arquivos de fonte) e scripts
(arquivos JavaScript).
A pasta templates contém um modelo base layout.html juntamente com about.html, contact.html e
index.html, para páginas específicas que estendem layout.html.
Pergunta: É possível compartilhar um ambiente virtual entre projetos do Visual Studio?
Resposta: Sim, mas faça isso sabendo que diferentes projetos provavelmente usam pacotes diferentes ao longo do
tempo e, portanto, um ambiente virtual compartilhado deve conter todos os pacotes para todos os projetos que o
usam.
No entanto, para usar um ambiente virtual existente, faça o seguinte:
1. Quando for solicitado a instalar dependências no Visual Studio, selecione a opção Eu os instalarei por conta
própria opção.
2. No Gerenciador de Soluções , clique com o botão direito do mouse no nó Ambientes do Python e escolha
Adicionar Ambiente Vir tual Existente .
3. Navegue até e selecione a pasta que contém o ambiente virtual e selecione OK .

Quando você executa o projeto, observe que o aplicativo contém três modos de exibição: Página inicial, Sobre e
Contato. O código dessas exibições é encontrado na pasta FlaskWeb/views.py. Cada função de exibição
simplesmente chama flask.render_template com o caminho para um modelo e uma lista de variáveis de
argumentos para os valores darem ao modelo. Por exemplo, a página Sobre é tratada pela função about (cujo
decorador fornece o roteamento de URL):
@app.route('/about')
def about():
"""Renders the about page."""
'about.html',
title='About',
year=datetime.now().year,
message='Your application description page.'
)
As funções home e contact são quase idênticas, com decoradores semelhantes e argumentos ligeiramente
diferentes.
Os modelos estão localizados na pasta templates do aplicativo. O modelo base, layout.html, é o mais abrangente.
Ele se refere a todos os arquivos estáticos necessários (JavaScript e CSS), define um bloco nomeado "conteúdo"
que outras páginas substituem e fornece outro bloco chamado "scripts". Os seguintes trechos anotados de
layout.html mostram essas áreas específicas:
<!DOCTYPE html>
<html>
<head>


<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{{ title }} - My Flask Application</title>
<link rel="stylesheet" type="text/css" href="/static/content/bootstrap.min.css" />

<link rel="stylesheet" type="text/css" href="/static/content/site.css" />
<script src="/static/scripts/modernizr-2.6.2.js"></script>
</head>
<body>

<div class="container body-content">


<hr />
<footer>
<p>© {{ year }} - My Flask Application</p>
</footer>
</div>

<script src="/static/scripts/jquery-1.10.2.js"></script>
<script src="/static/scripts/bootstrap.js"></script>
<script src="/static/scripts/respond.js"></script>
{% block scripts %}{% endblock %}
</body>
</html>
Cada um dos modelos de página individual, about.html, contact.html e index.html, estende o modelo base
layout.html. about.html é o mais simples e mostra as marcações {% extends %} e {% block content %} :
{% block content %}
<h2>{{ title }}.</h2>

<h3>{{ message }}</h3>
<p>Use this area to provide additional information.</p>
{% endblock %}
index.html e contact.html usam a mesma estrutura e fornecem mais conteúdo no bloco "conteúdo".
O modelo Projeto Web do Flask/Jade

Conforme observado no início deste artigo, o Visual Studio fornece um modelo "Projeto Web do Flask/Jade", que
cria um aplicativo visualmente idêntico ao produzido pelo "Projeto Web do Flask". A principal diferença é que ele
usa o mecanismo de modelagem Jade, que é uma extensão do Jinja que implementa os mesmos conceitos com
uma linguagem mais sucinta. Especificamente, o Jade usa palavras-chave em vez de marcas entre delimitadores
{% %}, por exemplo, e permite que você se refira a elementos HTML e estilos CSS usando palavras-chave.
Para habilitar o Jade, o modelo de projeto inclui primeiro o pacote pyjade em requirements.txt.
O arquivo * _ _init__.py* do aplicativo contém uma linha para
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
Na pasta templates, são exibidos arquivos .jade em vez de modelos .html, e as exibições em views.py referenciam
esses arquivos em suas chamadas a flask.render_template . Caso contrário, o código de modos de exibição é o
mesmo.
Abrindo um dos arquivos .jade, você pode ver a expressão mais sucinta de um modelo. Por exemplo, este é o
conteúdo de templates/layout.jade, conforme criado pelo modelo "Projeto Web do Flask/Jade":
doctype html
html
head
meta(charset='utf-8')
meta(name='viewport', content='width=device-width, initial-scale=1.0')
title #{title} - My Flask/Jade Application
link(rel='stylesheet', type='text/css', href='/static/content/bootstrap.min.css')
link(rel='stylesheet', type='text/css', href='/static/content/site.css')
script(src='/static/scripts/modernizr-2.6.2.js')
body
.navbar.navbar-inverse.navbar-fixed-top
.container
.navbar-header
button.navbar-toggle(type='button', data-toggle='collapse', data-target='.navbar-collapse')
span.icon-bar
span.icon-bar
span.icon-bar
a.navbar-brand(href='/') Application name
.navbar-collapse.collapse
ul.nav.navbar-nav
li
a(href='/') Home
li
a(href='/about') About
li
a(href='/contact') Contact
.container.body-content
block content
hr
footer
p © #{year} - My Flask/Jade Application
script(src='/static/scripts/jquery-1.10.2.js')
script(src='/static/scripts/bootstrap.js')
script(src='/static/scripts/respond.js')
block scripts
E este é o conteúdo de templates/about.jade, mostrando o uso de #{ <name>} para espaços reservados:
extends layout
block content
h2 #{title}.
h3 #{message}
p Use this area to provide additional information.
Fique à vontade para fazer experimentos com sintaxes do Jinja e do Jade para ver qual funciona melhor para você.
Próximas etapas
O modelo Pesquisa Projeto Web de Flask
Como gravar seu primeiro aplicativo do Flask, parte 4 – Modos de exibição genéricos e de formulários
Jade no GitHib (Documentação) (github.com)
Etapa 5 – Usar o modelo Projeto Web do Flask de
pesquisas
Etapa anterior : Usar o modelo Projeto Web completo do Flask

Depois de entender o modelo "Projeto Web do Flask" do Visual Studio, agora será possível examinar o terceiro
modelo do Flask, "Pesquisas do Projeto Web do Flask", criado sobre a mesma base de código.
Criar um projeto com base no modelo e inicializar o banco de dados (etapa 5-1)
Compreender os modelos de dados (etapa 5-2)
Compreender os armazenamentos de dados de backup (etapa 5-3)
Compreender os detalhes da votação e as visualizações dos resultados (etapa 5-4)
O Visual Studio também fornece o modelo "Projeto Web de Votações do Flask/Jade", que produz um aplicativo
idêntico, mas usa a extensão do Jade para o mecanismo de modelagem do Jinja. Para obter detalhes, confira Etapa
4 – Modelo Projeto Web do Flask/Jade.
Etapa 5-1: Criar o projeto

1. No Visual Studio, vá para Solution Explorer , clique com o botão direito do mouse na solução
LearningFlask criada anteriormente neste tutorial e selecione Adicionar > novo projeto .
2. No novo diálogo de projeto, procure e selecione o modelo do Projeto Web do Polls Flask , chame o
projeto de "FlaskPolls" e selecione OK .
3. Como os outros modelos de projeto do Visual Studio, o modelo de "Projeto Web de Votações do Flask"
inclui um arquivo requirements.txt. O Visual Studio solicita o local em que essas dependências serão
instaladas. Escolha a opção Instalar em um ambiente vir tual e, na caixa de diálogo Adicionar
Ambiente Vir tual , selecione Criar para aceitar os padrões. (Esse modelo requer o Flask, bem como os
pacotes azure-storage e pymongo; o "Pesquisas do Projeto Web do Flask/Jade" também requerem pyjade.)
4. Defina o projeto FlaskPolls como padrão para a solução Visual Studio clicando com o botão direito do
6. O aplicativo criado pelo modelo tem três páginas, Página inicial, Sobre e Contato, que você navega usando a
barra de navegação superior. Leve alguns minutos para examinar as diferentes partes do aplicativo (as
páginas Sobre e Contato são muito semelhantes ao "Projeto Web do Flask" e não serão mais discutidas).
7. Na home page, o botão Criar Votações de Exemplo inicializa o armazenamento de dados do aplicativo
com três votações diferentes descritas na página models/samples.json. Por padrão, o aplicativo usa um
banco de dados na memória (conforme mostrado na página Sobre), que é redefinido cada vez que o
aplicativo é reiniciado. O aplicativo também contém código para trabalhar com o Armazenamento do Azure
e com o MongoDB, conforme será ainda descrito neste artigo.
8. Depois que você tiver inicializado o armazenamento de dados, poderá votar nas diferentes votações
conforme mostrado na home page (a barra de navegação e o rodapé são omitidos para fins de brevidade):
9. Selecionar uma votação exibe opções específicas:
10. Depois de votar, o aplicativo mostrará uma página de resultados e permitirá que você vote novamente:
Examine o conteúdo do projeto
Conforme observado anteriormente, quase tudo o que está em um projeto criado com base no modelo "Pesquisas
do Projeto Web do Flask" (e o modelo do "Pesquisas do Projeto Web do Flask/Jade) deverá ser conhecido se você
tiver explorado os outros modelos de projeto no Visual Studio. As etapas adicionais neste artigo resumem as mais
alterações e adições mais significativas, ou seja, modelos de dados e modos de exibição adicionais.
Etapa 5-2: Compreender os modelos de dados

Os modelos de dados para o aplicativo são classes Python chamadas Poll and Choice, que são definidas em
modelos/__init__.py. Uma Votação representa uma pergunta, para a qual uma coleção de instâncias de Opção
representam as respostas disponíveis. Uma Votação também mantém o número total de votos (para qualquer
opção) e um método para calcular as estatísticas usadas para gerar exibições:
class Poll(object):
"""A poll object for use in the application views and repository."""
def __init__(self, key=u'', text=u''):
"""Initializes the poll."""
self.key = key
self.text = text
self.choices = []
self.total_votes = None
def calculate_stats(self):
"""Calculates some statistics for use in the application views."""
total = 0
for choice in self.choices:
total += choice.votes
for choice in self.choices:
choice.votes_percentage = choice.votes / float(total) * 100 \
if total > 0 else 0
self.total_votes = total
class Choice(object):
"""A poll choice object for use in the application views and repository."""
def __init__(self, key=u'', text=u'', votes=0):
"""Initializes the poll choice."""
self.key = key
self.text = text
self.votes = votes
self.votes_percentage = None
Esses modelos de dados são abstrações genéricas que permitem que os modos de exibição do aplicativo trabalhar
em diferentes tipos de backup de armazenamentos de dados, que serão descritos na próxima etapa.
Etapa 5-3: Compreender os armazenamentos de dados de backup

O aplicativo criado pelo modelo "Pesquisas do Projeto Web do Flask" pode ser executado em um armazenamento
de dados na memória, no Armazenamento de Tabelas do Azure ou em um banco de dados MongoDB.
O mecanismo de armazenamento de dados funciona da seguinte maneira:
1. O tipo de repositório é especificado por meio da variável de ambiente REPOSITORY_NAME , que pode ser
definida como "memory", "azuretablestore" ou "mongodb". Um trecho de código em settings.py recupera o
nome, usando "memória" como o padrão. Se desejar alterar o repositório de backup, será necessário definir
a variável de ambiente e reiniciar o aplicativo.
from os import environ

REPOSITORY_NAME = environ.get('REPOSITORY_NAME', 'memory')
2. Em seguida, o código settings.py inicializa um objeto REPOSITORY_SETTINGS . Se desejar usar o repositório de

tabelas do Azure ou o MongoDB, será necessário inicializar primeiro os armazenamentos de dados em
outro lugar e então definir as variáveis de ambiente necessárias que informarão ao aplicativo como se
conectar ao armazenamento:
if REPOSITORY_NAME == 'azuretablestorage':
REPOSITORY_SETTINGS = {
'STORAGE_NAME': environ.get('STORAGE_NAME', ''),
'STORAGE_KEY': environ.get('STORAGE_KEY', ''),
'STORAGE_TABLE_POLL': environ.get('STORAGE_TABLE_POLL', 'polls'),
'STORAGE_TABLE_CHOICE': environ.get('STORAGE_TABLE_CHOICE', 'choices'),
}
elif REPOSITORY_NAME == 'mongodb':
REPOSITORY_SETTINGS = {
'MONGODB_HOST': environ.get('MONGODB_HOST', None),
'MONGODB_DATABASE': environ.get('MONGODB_DATABASE', 'polls'),
'MONGODB_COLLECTION': environ.get('MONGODB_COLLECTION', 'polls'),
}
elif REPOSITORY_NAME == 'memory':
REPOSITORY_SETTINGS = {}
else:
raise ValueError('Unknown repository.')
3. Em views.py, o aplicativo chama um método de fábrica para inicializar um objeto Repository usando o
nome e as configurações do armazenamento de dados:
from FlaskPolls.models import PollNotFound

from FlaskPolls.models.factory import create_repository
from FlaskPolls.settings import REPOSITORY_NAME, REPOSITORY_SETTINGS
repository = create_repository(REPOSITORY_NAME, REPOSITORY_SETTINGS)
4. O método factory.create_repository é encontrado em models\factory.py, que apenas importa o módulo

de repositório adequado e cria uma instância de Repository :
def create_repository(name, settings):

"""Creates a repository from its name and settings. The settings
is a dictionary where the keys are different for every type of repository.
See each repository for details on the required settings."""
if name == 'azuretablestorage':
from .azuretablestorage import Repository
elif name == 'mongodb':
from .mongodb import Repository
elif name == 'memory':
from .memory import Repository
else:
raise ValueError('Unknown repository.')
return Repository(settings)
5. As implementações da classe Repository que são específicas de cada armazenamento de dados podem ser
encontradas em models\azuretablestorage.py, models\mongodb.py e models\memory.py. A
implementação de Armazenamento do Azure usa o pacote azure-storage; a implementação do banco de
dados Mongo usa o pacote pymongo. Conforme observado na etapa 5-1, ambos os pacotes são incluídos
no arquivo requirements.txt do modelo de projeto. Explorar os detalhes é um exercício para o leitor.
Em resumo, a classe Repository resume as especificidades do armazenamento de dados, e o aplicativo usa
variáveis de ambiente em tempo de execução para selecionar e configurar quais das três implementações usar.
As etapas a seguir adicionam suporte a um armazenamento de dados diferente dos três fornecidos pelo modelo
de projeto se desejado:
1. Copie memory.py para um novo arquivo para ter a interface básica para a classe Repository .
2. Modifique a implementação da classe conforme seja adequado para o armazenamento de dados que você está
usando.
3. Modifique factory.py para adicionar outro caso elif que reconheça o nome do armazenamento de dados
adicionado e importe o módulo apropriado.
4. Modifique settings.py para reconhecer outro nome na variável de ambiente REPOSITORY_NAME e inicializar
REPOSITORY_SETTINGS adequadamente.
Propagar o armazenamento de dados de samples.json

Inicialmente, qualquer armazenamento de dados escolhido não contém pesquisas, então a página inicial do
aplicativo mostra a mensagem Nenhuma pesquisa disponível junto com o botão Criar pesquisas de
amostra. No entanto, depois de selecionar o botão, o modo de exibição é alterado para exibir as votações
disponíveis. Essa opção ocorre por meio de marcas condicionais em templates\index.html (algumas linhas em
branco foram omitidas para fins de brevidade):
{% block content %}
<h2>{{title}}.</h2>
{% if polls %}
<table class="table table-hover">
<tbody>
{% for poll in polls %}
<tr>
<td>
<a href="/poll/{{poll.key}}">{{poll.text}}</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% else %}
<p>No polls available.</p>
<br />
<form action="/seed" method="post">
<button class="btn btn-primary" type="submit">Create Sample Polls</button>
</form>
{% endif %}
{% endblock %}
A variável polls no modelo vem de uma chamada a repository.get_polls , que não retorna nada até que o
armazenamento de dados seja inicializado.
Selecionar o botão Criar Votações de Exemplo navega até a URL /seed. O manipulador para essa rota é
definido em views.py:
@app.route('/seed', methods=['POST'])
def seed():
"""Seeds the database with sample polls."""
repository.add_sample_polls()
return redirect('/')
A chamada a repository.add_sample_polls() termina em uma das implementações Repository específicas para

seu armazenamento de dados escolhido. Cada implementação _load_samples_json chama o método encontrado
nos modelos__init__.py para carregar o arquivo models\samples.json na memória, então itera através desse dado
para criar os objetos necessários Poll no Choice armazenamento de dados.
Após a conclusão desse processo, a instrução redirect('/') no método seed navega de volta para a home page.
Como agora repository.get_polls retorna um objeto de dados, as marcas condicionais em templates\index.html
agora renderizam uma tabela que contém as votações.
Pergunta: como adicionar novas votações ao aplicativo?
Resposta: o aplicativo, conforme fornecido por meio do modelo de projeto, não inclui uma facilidade para
adicionar ou editar votações. É possível modificar models\samples.json para criar dados de inicialização, mas fazer
isso significará redefinir o armazenamento de dados. Para implementar funcionalidades de edição, é necessário
estender a interface de classe Repository com métodos para criar as instâncias Choice e Poll necessárias. Em
seguida, implemente uma interface do usuário em outras páginas que usam esses métodos.
Etapa 5-4: Compreender os detalhes da votação e as visualizações dos

resultados
A maioria dos modos de exibição gerados pelos modelos "Pesquisas do Projeto Web do Flask" e "Pesquisas do
Projeto Web do Flask/Jade", como os modos de exibição para as páginas Sobre e Contato, é muito semelhantes
aos modos de exibição criados pelo modelo "Projeto Web do Flask" (ou "Projeto Web do Flask/Jade") com o qual
você trabalhou anteriormente neste tutorial. Na seção anterior você também aprendeu como a home page é
implementada para mostrar o botão de inicialização ou a lista de votações.
O que sobra aqui é examinar os votos (detalhes) e a visualização dos resultados de uma votação individual.
Quando você seleciona uma votação na home page, o aplicativo navega até a URL /poll/<chave>, em que chave é
o identificador exclusivo de uma votação. Em views.py, é possível ver que a função details é atribuída para
manipular esse roteamento de URL para GET e solicitações. Também é possível ver que o uso de <key> na rota de
URL mapeia qualquer rota desse formulário para a mesma função e gera um argumento para a função do mesmo
nome:
@app.route('/poll/<key>', methods=['GET', 'POST'])

def details(key):
"""Renders the poll details page."""
error_message = ''
if request.method == 'POST':
try:
choice_key = request.form['choice']
repository.increment_vote(key, choice_key)
return redirect('/results/{0}'.format(key))
except KeyError:
error_message = 'Please make a selection.'
'details.html',
title='Poll',
poll=repository.get_poll(key),
error_message=error_message,
)
Para mostrar uma votação (solicitações GET), essa função apenas chama templates\details.html, que itera pela
matriz choices da votação, criando um botão de opção para cada uma.
{% block content %}
<h2>{{poll.text}}</h2>
<br />
{% if error_message %}
<p class="text-danger">{{error_message}}</p>
{% endif %}
<form action="/poll/{{poll.key}}" method="post">

{% for choice in poll.choices %}
<div class="radio">
<label>
<input type="radio" name="choice" id="choice{{choice.key}}" value="{{choice.key}}" />
{{ choice.text }}
</label>
</div>
{% endfor %}
<br />
<button class="btn btn-primary" type="submit">Vote</button>
</form>
{% endblock %}
Como o botão Votar tem type="submit" , selecioná-lo gera uma solicitação POST de volta para a mesma URL
roteada para a função details mais uma vez. Desta vez, no entanto, ela extrai a opção dos dados do formulário e
redireciona para /results/<opção>.
A URL /results/<key> é então encaminhada para a função results em views.py, que, por sua vez, chama o
método calculate_stats da votação e emprega templates\results.html para a renderização:
@app.route('/results/<key>')
def results(key):
"""Renders the results page."""
poll = repository.get_poll(key)
poll.calculate_stats()
'results.html',
title='Results',
poll=poll,
)
O modelo results.html, por sua vez, apenas itera por meio das opções da votação e gera uma barra de progresso
para cada uma:
{% block content %}
<h2>{{poll.text}}</h2>
<br />
{% for choice in poll.choices %}

<div class="row">
<div class="col-sm-5">{{choice.text}}</div>
<div class="col-sm-5">
<div class="progress">
<div class="progress-bar" role="progressbar" aria-valuenow="{{choice.votes}}" aria-valuemin="0"
aria-valuemax="{{poll.total_votes}}" style="width: {{choice.votes_percentage}}%;">
{{choice.votes}}
</div>
</div>
</div>
</div>
{% endfor %}
<br />
<a class="btn btn-primary" href="/poll/{{poll.key}}">Vote again?</a>
{% endblock %}
Próximas etapas
NOTE
Se você tiver confirmando sua solução do Visual Studio para controle de origem ao longo deste tutorial, agora será um bom
momento para fazer outra confirmação. Sua solução deve corresponder ao código-fonte do tutorial no GitHub:
Microsoft/python-sample-vs-learning-flask.
Agora você explorou a totalidade dos modelos "Projeto Web em Branco do Flask", "Projeto Web do Flask[/Jade]" e
"Pesquisa Projeto Web de Flask[/Jade]" no Visual Studio. Você conheceu todas as noções básicas do Flask, como
usar modos de exibição, modelos e roteamento, e viu como usar armazenamentos de dados de backup. Agora
você poderá começar a usar um aplicativo Web por sua conta com os modos de exibição e modelos de que
precisar.
A execução de um aplicativo Web no computador de desenvolvimento é apenas uma etapa para disponibilizar o
aplicativo para seus clientes. As próximas etapas podem incluir as seguintes tarefas:
Implante o aplicativo Web em um servidor de produção, como o Serviço de Aplicativo do Azure. Confira
Publicar no Serviço de Aplicativo do Azure.
Adicione uma implementação de repositório que usa outro armazenamento de dados em nível de produção
como o PostgreSQL, o MySQL e o SQL Server (que podem ser hospedados no Azure). Também é possível
usar o SDK do Azure para Python para trabalhar com serviços de armazenamento do Azure como tabelas e
blobs, bem como o Cosmos DB.
Configure um pipeline de integração contínua/implantação contínua em um serviço como o Azure DevOps.
Além de trabalhar com o controle do código-fonte (por meio do Azure Repos, do GitHub ou em outro local),
você pode configurar um projeto do Azure DevOps para executar automaticamente os testes de unidade
como um pré-requisito para o lançamento, bem como configurar o pipeline para implantação em um
servidor de preparo para testes adicionais antes de implantar na produção. O Azure DevOps, além disso,
integra-se às soluções de monitoramento, como o App Insights e fecha o ciclo de inteiro com ferramentas
ágeis de planejamento. Saiba mais em Criar um pipeline de CI/CD para Python com o projeto do Azure
DevOps e também a documentação geral do Azure DevOps.
Projetos do Python no Visual Studio
Normalmente, os aplicativos do Python são definidos com o uso somente de arquivos e pastas, mas essa
estrutura pode se tornar complexa conforme os aplicativos ficam maiores e talvez envolvam arquivos gerados
automaticamente, JavaScript para aplicativos Web e assim por diante. Um projeto do Visual Studio ajuda a
gerenciar essa complexidade. O projeto (um arquivo .pyproj) identifica todos os arquivos de origem e de
conteúdo associados ao projeto, contém informações de build de cada arquivo, mantém as informações para a
integração com sistemas de controle de código-fonte e ajuda a organizar o aplicativo em componentes lógicos.
Além disso, os projetos são sempre gerenciados em uma solução do Visual Studio, que pode conter vários
projetos que podem se referenciar mutuamente. Por exemplo, um projeto em Python pode fazer referência a um
projeto em C++ que implementa um módulo de extensão. Com essa relação, o Visual Studio compila
automaticamente o projeto em C++ (se for necessário) ao iniciar a depuração do projeto em Python. (Para obter
uma discussão geral, confira Soluções e projetos no Visual Studio.)
O Visual Studio fornece uma variedade de modelos de projeto do Python para configurar diversas estruturas de
aplicativo rapidamente, incluindo um modelo para criar um projeto com base em uma árvore de pastas existente
e um modelo para criar um projeto limpo e vazio. Veja Modelos de projeto para obter um índice.
TIP
O Visual Studio 2019 dá suporte à abertura de uma pasta que contém o código do Python e à execução do código sem
criar arquivos de projeto e solução do Visual Studio. Para obter mais informações, consulte Quickstart: Abra e execute o
código Python em uma pasta. No entanto, há benefícios em usar um arquivo de projeto, conforme explicado nesta seção.
TIP
Sem um projeto, todas as versões do Visual Studio funcionam bem com o código Python. Por exemplo, é possível abrir um
arquivo Python sozinho e aproveitar o preenchimento automático, o IntelliSense e a depuração (clicando com o botão
direito do mouse no editor e selecionando Iniciar com Depuração ). No entanto, como esse código sempre usa o
ambiente global padrão, talvez você veja preenchimentos incorretos ou erros, caso o código se destine a outro ambiente.
Além disso, o Visual Studio analisa todos os arquivos e pacotes na pasta da qual o arquivo individual é aberto, o que pode
consumir tempo considerável de CPU.
É simples criar um projeto do Visual Studio com base em um código existente, conforme descrito em Criar um projeto com
base em arquivos existentes.
Deep Dive: Use controle de origem com projetos Python

(youtube.com, 8m 55s).
Adicionar arquivos, atribuir um arquivo de inicialização e definir os

ambientes
À medida que você desenvolve seu aplicativo, normalmente, você precisa adicionar novos arquivos de diferentes
tipos ao projeto. A adição desses arquivos é feita clicando com o botão direito do mouse no projeto e
selecionando Adicionar > item existente com o qual você navega por um arquivo para adicionar, ou
Adicionar > novoitem, o que traz uma caixa de diálogo com uma variedade de modelos de itens. Conforme
descrito na referência de modelos de item, as opções incluem arquivos vazios do Python, uma classe do Python,
um teste de unidade e vários arquivos relacionados a aplicativos Web. Explore essas opções com um projeto de
teste para saber o que está disponível em sua versão do Visual Studio.
Cada projeto do Python tem um arquivo de inicialização atribuído, mostrado em negrito no Gerenciador de
Soluções . O arquivo de inicialização é o arquivo executado quando você inicia a depuração (F5 ou Debug >
Star t Debugging) ou quando você executa seu projeto na janela Interactive (Shift +Alt F5 +F5 ou Debug >
Execute Project in Python Interactive ). Para alterar, clique com o botão direito do mouse no novo arquivo e
selecione Definir como Item de Inicialização (ou Definir como Arquivo de Inicialização em versões mais
antigas do Visual Studio).
TIP
Se você remover o arquivo de inicialização selecionado de um projeto e não selecionar um novo, o Visual Studio não saberá
com qual arquivo do Python iniciar quando tentar executar o projeto. Nesse caso, o Visual Studio 2017 versão 15.6 e
posterior mostra um erro; as versões anteriores abrem uma janela de Saída com o interpretador do Python em execução ou
você vê a janela de Saída aparecer, mas, em seguida, desaparecer quase imediatamente. Se você observar algum desses
comportamentos, verifique se haverá um arquivo de inicialização atribuído.
Se quiser manter a janela de saída aberta por qualquer motivo, clique com o botão direito do mouse no projeto, selecione
Propriedades , selecione a guia Depurar e, em seguida, adicione -i ao campo Argumentos do Interpretador . Esse
argumento faz com que o intérprete entre no modo interativo após a conclusão de um programa, mantendo assim a janela
aberta até que você digite Ctrl+Z > Enter para sair.
Um novo projeto sempre é associado ao ambiente global padrão do Python. Para associar o projeto a outro
ambiente (incluindo ambientes virtuais), clique com o botão direito do mouse no nó Ambientes do Python do
projeto, selecione Adicionar/Remover Ambientes do Python e selecione os ambientes desejados.
Um novo projeto sempre é associado ao ambiente global padrão do Python. Para associar o projeto a outro
ambiente (incluindo ambientes virtuais), clique com o botão direito do mouse no nó Ambientes do Python do
projeto, selecione Adicionar Ambiente... e selecione os ambientes desejados. Você também pode usar o
controle de lista suspensa de ambientes na barra de ferramentas para selecionar um ambiente ou adicionar outro
ao projeto.
Para alterar o ambiente ativo, clique com o botão direito do mouse no ambiente desejado no Gerenciador de
Soluções e selecione Ativar Ambiente , conforme mostrado abaixo. Para obter mais informações, confira
Selecionar um ambiente para um projeto.
Modelos de projeto
O Visual Studio fornece várias maneiras para configurar um projeto do Python, do zero ou com base em um
código existente. Para usar um modelo, selecione o comando de menu Arquivo > Novo > Projeto ou clique
com o botão direito do mouse na solução no Solution Explorer e selecione Adicionar > novoprojeto, ambos
com o diálogo Novo Projeto abaixo. Para ver modelos específicos do Python, pesquise em "Python" ou selecione
o nóPython instalado: >
A seguinte tabela resume os modelos disponíveis no Visual Studio 2017 e posterior (nem todos os modelos estão
disponíveis em todas as versões anteriores):
M O DELO DESC RIÇ Ã O
Com base em um código existente do Python Cria um projeto do Visual Studio com base em um código
existente do Python em uma estrutura de pastas.
Aplicativo do Python Uma estrutura de projeto básica para um novo aplicativo do

Python com um único arquivo de origem vazio. Por padrão, o
projeto é executado no interpretador do console do ambiente
global padrão, que pode ser alterado com a atribuição de
outro ambiente.
Ser viço de nuvem azure Um projeto para um serviço de nuvem do Azure escrito em
Python.
Projetos web Projetos para aplicativos Web baseados em várias estruturas,

incluindo Bottle, Django e Flask.
Aplicativo do IronPython Semelhante ao modelo de Aplicativo do Python, mas usa o

IronPython, por padrão, habilitando a interoperabilidade do
.NET e a depuração de modo misto com as linguagens .NET.
Aplicativo WPF do IronPython Uma estrutura de projeto que usa o IronPython com
arquivos XAML do Windows Presentation Foundation para a
interface do usuário do aplicativo. O Visual Studio fornece um
designer de interface do usuário XAML, code-behind pode ser
escrito no Python e o aplicativo é executado sem exibir um
console.
Página da Web do IronPython Silverlight Um projeto do IronPython executado em um navegador

usando o Silverlight. O código do aplicativo do Python é
incluído na página da Web como um script. Uma marca de
script de texto clichê puxa um código JavaScript que inicializa
o IronPython em execução dentro do Silverlight, no qual o
código do Python pode interagir com o DOM.
Aplicativo do Windows Forms do IronPython Uma estrutura de projeto que usa o IronPython com a
interface do usuário criada usando o código com o Windows
Forms. O aplicativo é executado sem exibir um console.
Aplicativo em segundo plano (IoT) Dá suporte à implantação de projetos do Python a serem

executados como serviços em segundo plano em dispositivos.
Visite a Central de desenvolvedores do Windows IoT para
obter mais informações.
Módulo de Extensão do Python Esse modelo é exibido no Visual C++ se você instalou as
ferramentas de desenvolvimento nativo do Python
com a carga de trabalho do Python no Visual Studio 2017 ou
posteriores (consulte Instalação). Ele fornece a estrutura
principal para uma DLL de extensão do C++, semelhante ao
que é descrito em Criar uma extensão do C++ para o Python.
NOTE
Como Python é uma linguagem interpretada, os projetos em Python no Visual Studio não produzem um executável
autônomo como outros projetos de linguagem compilada (C#, por exemplo). Para saber mais, confira Perguntas e respostas.
Criar um projeto com base em um código existente
IMPORTANT
O processo descrito aqui não move ou copia os arquivos de origem. Se você quiser trabalhar com uma cópia, basta
primeiro duplicar a pasta.
1. Inicie o Visual Studio e selecione File > New > Project .

2. Na caixa de diálogo Novo Projeto , pesquise "Python", selecione o modelo Com base no Código
Python Existente , forneça um nome e um local para o projeto e selecione OK .
3. No assistente que é exibido, defina o caminho para o código existente, defina um filtro para os tipos de
arquivo e especifique os caminhos de pesquisa que seu projeto requer. Em seguida, selecione Avançar . Se
você não souber o que são caminhos de pesquisa, deixe esse campo em branco.
4. Na próxima caixa de diálogo, escolha o arquivo de inicialização do projeto e selecione Avançar . (Se
desejar, selecione um ambiente; caso contrário, aceite os padrões.) Observe que a caixa de diálogo mostra
apenas arquivos na pasta raiz; se o arquivo que você deseja estiver em uma subpasta, deixe o arquivo de
inicialização em branco e defina-o mais tarde no Solution Explorer (descrito abaixo).
5. Selecione o local em que deseja salvar o arquivo de projeto (que é um arquivo .pyproj no disco). Caso se
aplique, também será possível incluir a detecção automática de ambientes virtuais e personalizar o projeto
para outras estruturas da Web. Se você não tiver certeza sobre essas opções, deixe-as com as
configurações padrão.
6. Selecione Concluir e o Visual Studio criará o projeto e o abrirá no Gerenciador de Soluções . Caso
deseje mover o arquivo .pyproj para outro lugar, selecione-o no Gerenciador de Soluções e escolha
Arquivo > Salvar Como . Essa ação atualiza as referências de arquivo no projeto, mas não move nenhum
arquivo de código.
7. Para definir um arquivo de inicialização diferente, localize o arquivo no Gerenciador de Soluções , clique
com o botão direito do mouse e selecione Definir como Arquivo de Inicialização .
Arquivos vinculados
Os arquivos vinculados são aqueles que são inseridos em um projeto, mas que geralmente residem fora das
pastas do projeto do aplicativo. Eles são exibidos no Gerenciador de Soluções como arquivos normais com um
ícone de atalho sobreposto:
Os arquivos vinculados são especificados no arquivo .pyproj usando o elemento <Compile Include="..."> . Os
arquivos vinculados estão implícitos se eles usam um caminho relativo fora da estrutura do diretório, ou
explícitos se eles usam caminhos dentro do Solution Explorer :
<Compile Include="..\test2.py">
<Link>MyProject\test2.py</Link>
</Compile>
Arquivos vinculados são ignorados em uma das seguintes condições:

O arquivo vinculado contém metadados do Link e o caminho especificado no atributo Include reside no
diretório do projeto
O arquivo vinculado duplica um arquivo que existe na hierarquia do projeto
O arquivo vinculado contém metadados do Link e o caminho do Link é um caminho relativo fora da hierarquia
do projeto
O caminho do link tem raiz
Trabalhar com arquivos vinculados
Para adicionar um item existente como um link, clique com o botão direito do mouse na pasta no projeto onde
deseja adicionar o arquivo e, em seguida, selecione Adicionar > item existente . Na caixa de diálogo exibida,
selecione um arquivo e escolha Adicionar como Link no menu suspenso do botão Adicionar . Desde que não
existam arquivos conflitantes, esse comando criará um link na pasta selecionada. No entanto, o link não será
adicionado se já existir um arquivo com o mesmo nome ou se já existir um link para esse arquivo no projeto.
Se você tentar vincular a um arquivo que já existe nas pastas do projeto, ele será adicionado como um arquivo
normal e não como um link. Para converter um arquivo em um link, selecione 'Salvar arquivos' > como para
salvar o arquivo em um local fora da hierarquia do projeto; O Visual Studio converte-o automaticamente em um
link. Da mesma forma, um link pode ser convertido de volta usando o File > Save As para salvar o arquivo em
algum lugar dentro da hierarquia do projeto.
Se você mover um arquivo vinculado no Gerenciador de Soluções , o link será movido, mas o arquivo real não
será afetado. Da mesma forma, a exclusão de um link removerá o link sem afetar o arquivo.
Os arquivos vinculados não podem ser renomeados.
Referências
Os projetos do Visual Studio dão suporte à adição de referências a projetos e extensões, que são exibidas no nó
Referências do Gerenciador de Soluções :
Geralmente, referências de extensão indicam dependências entre projetos e são usadas para fornecer o
IntelliSense em tempo de design ou a vinculação em tempo de compilação. Os projetos do Python usam
referências de forma semelhante, mas devido à natureza dinâmica do Python, elas são usadas principalmente em
tempo de design para fornecer um IntelliSense avançado. Elas também podem ser usadas para implantação no
Microsoft Azure para instalar dependências adicionais.
Módulos de extensão
Uma referência a um arquivo .pyd habilita o IntelliSense no módulo gerado. O Visual Studio carrega o arquivo
.pyd no interpretador do Python e examina seus tipos e suas funções. Ele também tenta analisar as cadeias de
caracteres doc em funções para fornecer ajuda da assinatura.
Se, a qualquer momento, o módulo de extensão é atualizado em disco, o Visual Studio analisa o módulo
novamente em segundo plano. Esta ação não tem efeito sobre o comportamento de tempo de execução, mas
algumas conclusões não estão disponíveis até que a análise esteja concluída.
Talvez você também precise adicionar um caminho de pesquisa à pasta que contém o módulo.
Projetos do .NET
Ao trabalhar com o IronPython, é possível adicionar referências aos assemblies do .NET para habilitar o
IntelliSense. Para projetos do .NET na solução, clique com o botão direito do mouse no nó Referências do
projeto do Python, selecione Adicionar Referência , selecione a guia Projetos e procure o projeto desejado.
Para as DLLs baixadas separadamente, selecione a guia Procurar e procure a DLL desejada.
Como as referências no IronPython não estão disponíveis até uma chamada para
clr.AddReference('<AssemblyName>') ser feita, você também precisará adicionar uma chamada apropriada para
clr.AddReference ao assembly, normalmente no início do seu código. Por exemplo, o código criado pelo modelo
de projeto Aplicativo Windows Forms do IronPython no Visual Studio inclui duas chamadas na parte
superior do arquivo:
import clr
clr.AddReference('System.Drawing')
clr.AddReference('System.Windows.Forms')
from System.Drawing import *

from System.Windows.Forms import *
# Other code omitted
Projetos do WebPI
É possível adicionar referências a entradas de produto do WebPI para implantação nos Serviços de Nuvem do
Microsoft Azure, em que é possível instalar componentes adicionais por meio do feed do WebPI. Por padrão, o
feed exibido é específico ao Python e inclui o Django, o CPython e outros componentes básicos. Você também
pode selecionar seu próprio feed, conforme mostrado abaixo. Ao publicar no Microsoft Azure, uma tarefa de
instalação instala todos os produtos referenciados.
IMPORTANT
Os projetos webpi não estão disponíveis no Visual Studio 2017 ou visual studio 2019.
Modelos de projeto de aplicativo Web Python
O Python no Visual Studio é compatível com o desenvolvimento de projetos da Web nas estruturas Bottle, Flask
e Django por meio de modelos de projeto e um inicializador de depuração que pode ser configurado para
manipular várias estruturas. Esses modelos incluem um arquivo requirements.txt para declarar as dependências
necessárias. Ao criar um projeto com base em um desses modelos, o Visual Studio solicita que você instale esses
pacotes (confira Instalar os requisitos do projeto mais adiante neste artigo).
Você também pode usar o modelo genérico do Projeto Web para outras estruturas, como Pyramid. Nesse
caso, nenhuma estrutura é instalada com o modelo. Em vez disso, instale os pacotes necessários no ambiente
em que você está usando para o projeto (confira Janela de ambientes do Python – guia Pacote).
Para obter informações de como implantar um aplicativo Web do Python no Azure, confira Publicar no Serviço
de Aplicativo do Azure.
Usar um modelo de projeto

Você cria um projeto a partir de um modelo usando o File > New > Project . Para ver modelos para projetos
web, selecione Python > Web no lado esquerdo da caixa de diálogo. Em seguida, selecione um modelo de sua
escolha, fornecendo nomes para o projeto e para a solução, defina opções para um diretório da solução e para o
repositório Git e selecione OK .
O modelo genérico de Projeto Web , mencionado anteriormente, fornece apenas um projeto vazio do Visual
Studio sem nenhum código e nenhuma suposição diferente além de ser um projeto do Python. Para obter
detalhes sobre o modelo Ser viço de Nuvem do Azure , confira Projetos do serviço de nuvem do Azure para o
Python.
Todos os outros modelos se baseiam nas estruturas da Web Bottle, Flask ou Django e se enquadram em três
grupos gerais, conforme descrito nas seções a seguir. Os aplicativos criados por um desses modelos contêm
código suficiente para executar e depurar o aplicativo localmente. Cada um deles também fornece o objeto de
aplicativo WSGI necessário (python.org) para uso com servidores da Web de produção.
Grupo em branco
Todos os modelos de Projeto Web <estrutura> em Branco criam um projeto com um código de texto clichê
mais ou menos mínimo e as dependências necessárias declaradas em um arquivo requirements.txt.
Projeto Web em Branco do Bottle Gera um aplicativo mínimo em app.py com uma home page
do / e uma página /hello/<name> que ecoa <name>
usando um modelo de página embutido muito curto.
Projeto Web em Branco do Django Gera um projeto Django com a estrutura do site principal do
Django, mas não aplicativos Django. Para obter mais
informações, confira Modelos do Django e Etapa 1 do
tutorial – Conheça o Django.
Projeto Web em Branco do Flask Gera um aplicativo mínimo com um único "Olá, Mundo!"
página para / . Este aplicativo é semelhante ao resultado
das seguintes etapas detalhadas em Início rápido: use o
Visual Studio para criar seu primeiro aplicativo Web Python.
Confira também Etapa 1 do tutorial – Conheça o Flask.
Grupo da Web
Todos ** <** os modelos de Projeto Web do Framework> criam um aplicativo web inicial com um design
idêntico, independentemente da estrutura escolhida. O aplicativo tem as páginas Início, Sobre e Contato,
juntamente com uma barra de navegação e um design responsivo usando a Inicialização. Cada aplicativo é
configurado adequadamente para fornecer arquivos estáticos (CSS, JavaScript e fontes) e usa um mecanismo de
modelo de página adequado para a estrutura.
Projeto Web do Bottle Gera um aplicativo cujos arquivos estáticos estão contidos na
pasta static e são manipulados por meio do código em
app.py. O roteamento para as páginas individuais está
contido em routes.py, e a pasta views contém os modelos de
página.
Projeto Web do Django Gera um projeto e um aplicativo do Django com três

páginas, suporte de autenticação e um banco de dados
SQLite (mas nenhum modelo de dados). Para obter mais
informações, confira Modelos do Django e Etapa 4 do
tutorial – Conheça o Django.
Projeto Web do Flask Gera um aplicativo cujos arquivos estáticos estão contidos na
pasta static. O código em views.py manipula o roteamento,
com modelos de página que usam o mecanismo Jinja
contido na pasta templates. O arquivo runserver.py fornece o
código de inicialização. Confira Etapa 4 do tutorial – Conheça
o Flask.
Projeto Web do Flask/Jade Gera o mesmo aplicativo que com o modelo Flask Web
Project, mas usando a extensão Jade para o motor de
templating Jinja.
Grupo de pesquisas
O ** <framework Polls>** modelos do Web Project criam um aplicativo web inicial através do qual os usuários
podem votar em diferentes perguntas de enquete. Cada aplicativo se baseia na estrutura dos modelos de projeto
da Web para usar um banco de dados para gerenciar as pesquisas e as respostas dos usuários. Os aplicativos
incluem modelos de dados adequados e uma página de aplicativo especial (/seed) que carrega votações de um
arquivo samples.json.
Projeto Web de Votações do Bottle Gera um aplicativo que pode ser executado em um banco de
dados em memória, no MongoDB ou no Armazenamento de
Tabelas do Azure, configurado usando a variável de ambiente
do REPOSITORY_NAME . Os modelos de dados e o código do
armazenamento de dados estão contidos na pasta models, e
o arquivo settings.py contém o código para determinar qual
armazenamento de dados é usado.
Projeto Web de Votações do Django Gera um projeto e um aplicativo do Django com três páginas
e um banco de dados SQLite. Inclui personalizações na
interface administrativa do Django para permitir que um
administrador autenticado crie e gerencie pesquisas. Para
obter mais informações, confira Modelos do Django e Etapa
6 do tutorial – Conheça o Django.
Projeto Web de Votações do Flask Gera um aplicativo que pode ser executado em um banco de
dados em memória, no MongoDB ou no Armazenamento de
Tabelas do Azure, configurado usando a variável de ambiente
do REPOSITORY_NAME . Os modelos de dados e o código do
armazenamento de dados estão contidos na pasta models, e
o arquivo settings.py contém o código para determinar qual
armazenamento de dados é usado. O aplicativo usa o
mecanismo Jinja para modelos de página. Confira Etapa 5 do
tutorial – Conheça o Flask.
Pesquisas Projeto Web do Flask/Jade Gera o mesmo aplicativo que com o modelo Polls Flask
Web Project, mas usando a extensão Jade para o motor de
templating Jinja.
Instalar requisitos de projeto

Ao criar um projeto com base em um modelo específico à estrutura, uma caixa de diálogo é exibida para ajudá-
lo a instalar os pacotes necessários usando o PIP. Também recomendamos o uso de um ambiente virtual para
projetos Web, para que as dependências corretas sejam incluídas durante a publicação do site:
Se estiver usando o controle do código-fonte, normalmente, você omitirá a pasta de ambiente virtual, pois esse
ambiente poderá ser recriado usando apenas o requirements.txt. A melhor maneira de excluir a pasta é primeiro
selecionar Eu os instalarei sozinho no prompt mostrado acima. Em seguida, desabilite a confirmação
automática antes de criar o ambiente virtual. Para obter detalhes, confira Tutorial – Conheça o Django – Etapas 1-
2 e 1-3 e Tutorial – Conheça o Flask – Etapas 1-2 e 1-3.
Ao implantar o Serviço de Aplicativo do Microsoft Azure, selecione uma versão do Python como uma extensão
de site e instalar os pacotes manualmente. Além disso, como o Serviço de Aplicativo do Azure não instala
pacotes automaticamente de um arquivo requirements.txt quando implantado por meio do Visual Studio, siga os
detalhes de configuração em aka.ms/PythonOnAppService.
Os Serviços de Nuvem do Microsoft Azure dão suporte ao arquivo requirements.txt. Consulte Azure cloud
service projects (Projetos do Serviço de Nuvem do Azure) para obter detalhes.
Depuração
Quando um projeto Web é iniciado para depuração, o Visual Studio inicia um servidor Web local em uma porta
aleatória e abre seu navegador padrão para esse endereço e porta. Para especificar opções adicionais, clique
com o botão direito do mouse no projeto, selecione Propriedades e selecione a guia Lançador web:
No grupo Depurar :
Caminhos de Pesquisa , Argumentos de Script , Argumentos do Interpretador e Caminho do
Interpretador : essas opções são as mesmas da depuração normal.
URL de Inicialização : especifica a URL que é aberta no navegador. Usa como padrão localhost .
Número da Por ta : a porta a ser usada se nenhuma for especificada na URL (o Visual Studio seleciona uma
automaticamente por padrão). Essa configuração permite substituir o valor padrão da variável de ambiente
SERVER_PORT , que é usada pelos modelos para configurar a porta na qual o servidor de depuração local
escuta.
As propriedades dos grupos Executar Comando do Ser vidor e Depurar Comando do Ser vidor (o último
está abaixo do que é mostrado na imagem) determinam como o servidor Web é iniciado. Como muitas
estruturas exigem o uso de um script fora do projeto atual, o script pode ser configurado aqui e o nome do
módulo de inicialização pode ser passado como um parâmetro.
Comando : pode ser um script do Python (arquivo *.py), um nome de módulo (como em
python.exe -m module_name ) ou uma linha de código individual (como em python.exe -c "code" ). O valor na
lista suspensa indica qual desses tipos é pretendido.
Argumentos : esses argumentos são passados na linha de comando após o comando.
Ambiente : uma lista separada por nova linha de pares <NAME>=<VALUE> que especificam as variáveis de
ambiente. Essas variáveis são definidas após todas as propriedades que podem modificar o ambiente, como
o número da porta e os caminhos de pesquisa e, portanto, podem substituir esses valores.
Qualquer propriedade de projeto ou variável de ambiente pode ser especificada com a sintaxe do MSBuild, por
exemplo: $(StartupFile) --port $(SERVER_PORT) . $(StartupFile) é o caminho relativo para o arquivo de
inicialização e {StartupModule} é o nome importável do arquivo de inicialização. $(SERVER_HOST) e
$(SERVER_PORT) são variáveis normais de ambiente definidas pelas propriedades URL de lançamento e
número de por ta, automaticamente ou pela propriedade Ambiente.
NOTE
Os valores em Executar Comando do Ser vidor são usados com o comando Depurar > Iniciar Ser vidor ou
Ctrl+F5 ; os valores no grupo Depurar Comando do Ser vidor são usados com o comando Depurar > Iniciar
Ser vidor de Depuração ou F5 .
Configuração do Bottle de exemplo

O modelo de Projeto Web Bottle inclui um código de texto clichê que faz a configuração necessária. Um
aplicativo importado do Bottle pode não incluir esse código; no entanto, nesse caso, as seguintes configurações
iniciam o aplicativo usando o módulo bottle instalado:
Grupo Executar Comando do Ser vidor :
Comando bottle : (módulo)
Argumentos : --bind=%SERVER_HOST%:%SERVER_PORT% {StartupModule}:app
Grupo Depurar Comando do Ser vidor :

Comando bottle : (módulo)
Argumentos --debug --bind=%SERVER_HOST%:%SERVER_PORT% {StartupModule}:app
A opção --reload não é recomendada ao usar o Visual Studio para depuração.

Configuração de exemplo do Pyramid
Atualmente, a melhor forma de criar aplicativos do Pyramid é usando a ferramenta de linha de comando
pcreate . Uma vez criado um aplicativo, ele pode ser importado usando o modelo de código Python
existente. Depois de fazer isso, selecione a personalização Projeto Web Genérico para configurar as opções.
Essas configurações presumem que o Pyramid está instalado em um ambiente virtual em ..\env .
Grupo Depurar :
Por ta do Ser vidor : 6543 (ou o que estiver configurado nos arquivos .ini)
Grupo Executar Comando do Ser vidor :
Comando: ..\env\scripts\pserve-script.py (script)
Argumentos: Production.ini
Grupo Depurar Comando do Ser vidor :
Comando: ..\env\scripts\pserve-script.py (script)
Argumentos: Development.ini
TIP
Provavelmente, será necessário configurar a propriedade Diretório de Trabalho do projeto, pois os aplicativos do
Pyramid estão normalmente uma pasta abaixo da raiz do projeto.
Outras configurações
Se você tiver configurações para outra estrutura que gostaria de compartilhar ou se gostaria de solicitar
configurações para outra estrutura, abra um problema no GitHub.
Converter um projeto no Serviço de Nuvem do Azure

O comando Conver t to Microsoft Azure Cloud Ser vice Project (imagem abaixo) adiciona um projeto de
serviço em nuvem à sua solução. Esse projeto inclui as configurações de implantação e a configuração das
máquinas virtuais e dos serviços a serem usadas. Use o comando Publicar no projeto de nuvem para implantar
nos Serviços de Nuvem, o comando Publicar no projeto do Python ainda implanta em Sites. Para obter mais
informações, consulte projetos de serviços em nuvem do Azure.
Confira também
Referência de modelos de item do Python
Modelo de projeto Web Django
O Django é uma estrutura do Python de alto nível projetada para um desenvolvimento da Web rápido, seguro e
escalonável. O suporte do Python no Visual Studio fornece vários modelos de projeto para configurar a estrutura
de um aplicativo Web baseado em Django. Para usar um modelo no Visual Studio, selecione Arquivo > Novo >
Projeto, procure por "Django", e selecione no Projeto Web de Django em branco, projeto Web Django e
modelos do Projeto Web polls Django. Confira o Tutorial – Conheça o Django para obter um passo a passo de
todos os modelos.
O Visual Studio fornece o IntelliSense completo para projetos do Django:
Variáveis de contexto passadas para o modelo:
Marcação e filtragem para elementos internos e definidos pelo usuário:
Realce de sintaxe para CSS e JavaScript inserido:

O Visual Studio também fornece suporte de depuração completo para projetos do Django:
É comum que projetos do Django sejam gerenciados por meio do arquivo manage.py, que é um pressuposto
adotado pelo Visual Studio. Se você parar de usar esse arquivo como o ponto de entrada, basicamente divide o
arquivo de projeto. Nesse caso você precisa recriar o projeto de arquivos existentes sem marcá-lo como um
projeto do Django.
Console de gerenciamento do Django

O console de gerenciamento Django é acessado através de vários comandos no menu Do Projeto ou clicando
com o botão direito do mouse no projeto no Solution Explorer .
Abra o Django Shell : abre um shell no contexto do aplicativo que permite manipular seus modelos:
Banco de Dados de Sincronização do Django : executa manage.py syncdb em uma janela interativa :
Coletar Estáticos : executa manage.py collectstatic --noinput para copiar todos os arquivos estáticos
para o caminho especificado por STATIC_ROOT em settings.py.
Validar : executa manage.py validate , que relata os erros de validação nos modelos instalados
especificados por INSTALLED_APPS em settings.py:
Confira também
Tutorial – Conheça o Django
Projetos do serviço de nuvem do Azure para
Python
O Visual Studio fornece modelos para ajudá-lo a começar a criar Serviços de Nuvem do Azure usando o Python.
Um serviço de nuvem consiste em várias funções de trabalho e funções web, sendo que cada uma executa uma
tarefa separada conceitualmente, mas pode ser replicada separadamente em máquinas virtuais, conforme
necessário para colocação em escala. As funções web fornecem hospedagem para aplicativos Web de front-end.
No que diz respeito ao Python, qualquer estrutura web que suporte o WSGI pode ser usada para escrever tal
aplicativo (conforme suportado pelo modelo de projeto web). As funções de trabalho destinam-se a processos
de execução longa que não interagem diretamente com os usuários. Eles normalmente fazem uso dos pacotes
dentro do pacote "azure", que é instalado com pip install azure .
Este artigo contém detalhes sobre o modelo de projeto e outros tipos de suporte no Visual Studio 2017 e
posterior (as versões anteriores são semelhantes, mas com algumas diferenças). Para obter mais informações
sobre como trabalhar com o Azure no Python, visite a Central de desenvolvedores do Azure Python.
Criar um projeto
1. Instale o Azure .NET SDK para Visual Studio, que é necessário para usar o modelo de serviço em nuvem.
2. No Visual Studio, selecione File > New > Project, depois procure por "Azure Python" e selecione Azure
Cloud Ser vice na lista:
3. Selecione uma ou mais funções a serem incluídas. Projetos de nuvem podem combinar funções escritas
em linguagens diferentes; portanto, é possível escrever com facilidade cada parte do aplicativo na
linguagem mais adequada. Para adicionar novas funções ao projeto após concluir esta caixa de diálogo,
clique com o botão direito do mouse Em Funções no Solution Explorer e selecione um dos itens em
Adicionar .
4. Conforme os projetos de função individuais são criados, você poderá precisar instalar pacotes adicionais
do Python, como as estruturas Django, Bottle ou Flask, caso tenha selecionado uma função que usa uma
delas.
5. Depois de adicionar uma nova função ao projeto, aparecem instruções de configuração. As alterações de
configuração normalmente são desnecessárias, mas podem ser úteis para personalização futura dos
projetos. Observe que, ao adicionar várias funções ao mesmo tempo, somente as instruções para a última
função permanecem abertas. No entanto, é possível encontrar as instruções e dicas de solução de
problemas para outras funções em seus respectivos arquivos readme.mht, localizados na raiz da função
ou na pasta bin.
6. A pasta bin de um projeto também contém um ou dois scripts do PowerShell que são usados para
configurar a máquina virtual remota, incluindo a instalação do Python, qualquer arquivo requirements.txt
no projeto e a configuração do IIS, se necessário. É possível editar esses arquivos conforme desejado para
sua implantação, embora as opções mais comuns possam ser gerenciadas de outras maneiras (confira
Configurar a implantação de função abaixo). Não sugerimos a remoção desses arquivos, pois um script
de configuração herdado será usado no lugar deles, caso os arquivos não estejam disponíveis.
Para adicionar esses scripts de configuração a um novo projeto, clique com o botão direito do mouse no
projeto, selecione Adicionar > novo item e selecione Arquivos de supor te à função da Web ou
arquivos de suporte à função do trabalhador .
Configurar a implantação de função

Os scripts do PowerShell na pasta bin de um projeto de função controlam a implantação da função e podem ser
editados para personalizar a configuração:
ConfigureCloudService.ps1 é usado para funções Web e de trabalho. Geralmente para instalar e configurar
dependências e definir a versão do Python.
LaunchWorker.ps1 é usado somente para funções de trabalho e para alterar o comportamento de
inicialização, adicionar argumentos de linha de comando ou adicionar variáveis de ambiente.
Os dois arquivos contêm instruções de personalização. Você também pode instalar sua própria versão do
Python adicionando outra tarefa ao arquivo ServiceDefinition.csdef principal do projeto do serviço de nuvem,
configurando a variável PYTHON com seu caminho python.exe instalado (ou equivalente). Quando PYTHON for
definido, o Python não será instalado por meio do NuGet.
Uma configuração adicional pode ser feita da seguinte maneira:
1. Instale os pacotes usando pip com a atualização do arquivo requirements.txt no diretório raiz do projeto. O
script ConfigureCloudService.ps1 instala esse arquivo durante a implantação.
2. Defina variáveis de ambiente modificando o arquivo web.config (funções Web) ou a seção Runtime do
arquivo ServiceDefinition.csdef (funções de trabalho).
3. Especifique o script e os argumentos a serem usados em uma função de trabalho modificando a linha de
comando na seção Runtime/EntryPoint do arquivo ServiceDefinitions.csdef.
4. Defina o script principal do manipulador para uma função web por meio do arquivo web.config.
Implantação da função de teste

Ao escrever as funções, é possível testar o projeto de nuvem localmente usando o Emulador do Serviço de
Nuvem. O emulador está incluído nas SDK Tools do Azure e é uma versão limitada do ambiente usado quando o
Serviço de Nuvem é publicado no Azure.
Para iniciar o emulador, primeiro verifique se o projeto de nuvem é o projeto de inicialização na solução clicando
com o botão direito do mouse e selecionando Definir como projeto de inicialização . Em seguida, selecione
Debug > Star t Debugging (F5) ou Debug > Star t sem depuração (Ctrl +F5 ).
Observe que, devido a limitações no emulador, não é possível depurar o código do Python. Portanto,
recomendamos que você depure as funções executando-as de forma independente e, em seguida, use o
emulador para o teste de integração antes da publicação.
Implantar uma função

Para abrir o assistente para Publicação , escolha a função de projeto no Gerenciador de Soluções e marque
Compilar > Publicar no menu principal ou clique com o botão direito do mouse no projeto e escolha
Publicar .
O processo de publicação envolve duas fases. Primeiro, o Visual Studio cria um único pacote que contém todas
as funções para o serviço de nuvem. Esse pacote é o que é implantado no Azure, que inicializa uma ou mais
máquinas virtuais para cada função e implanta a fonte.
Conforme cada máquina virtual é ativada, ele executa o script ConfigureCloudService.ps1 e instala as
dependências. Por padrão, esse script instala uma versão recente do Python por meio do NuGet e os pacotes
especificados em um arquivo requirements.txt.
Por fim, as funções de trabalho executam LaunchWorker.ps1, que inicia a execução do script do Python. As
funções web inicializam o IIS e começam a manipular solicitações da Web.
Dependências
Para os Serviços de Nuvem, o script ConfigureCloudService.ps1 usa pip para instalar um conjunto de
dependências do Python. As dependências devem ser especificadas em um arquivo chamado requirements.txt
(personalizável com a modificação de ConfigureCloudService.ps1). O arquivo é executado com
pip install -r requirements.txt como parte da inicialização.
Observe que as instâncias do Serviço de Nuvem não incluem compiladores do C e, portanto, todas as
bibliotecas com extensões do C devem fornecer binários pré-compilados.
O PIP e suas dependências e os pacotes em requirements.txt, são baixados automaticamente e podem ser
contados como uso de largura de banda passível de cobrança. Confira Gerenciar os pacotes necessários para
obter detalhes sobre como gerenciar arquivos requirements.txt.
Se a função web ou a função de trabalho não funcionar corretamente após a implantação, verifique o seguinte:
O projeto Python inclui uma pasta bin\ com (no mínimo):
ConfigureCloudService.ps1
LaunchWorker.ps1 (para funções de trabalho)
ps.cmd
O projeto Python inclui um arquivo requirements.txt que lista todas as dependências (ou, como
alternativa, uma coleção de arquivos de roda).
Habilite a Área de Trabalho Remota no serviço de nuvem e investigue os arquivos de log.
Os logs ConfigureCloudService.ps1 e LaunchWorker.ps1 são armazenados na pasta
C:\Resources\Directory%RoleId%.DiagnosticStore\LogFiles no computador remoto.
As funções Web podem gravar logs adicionais para um caminho configurado em web.config, ou seja, o
caminho na appSetting WSGI_LOG . A maioria dos logs do IIS ou FastCGI normal do host também funciona.
Atualmente, o arquivo LaunchWorker.ps1.log é a única maneira de exibir a saída ou os erros exibidos pela
função de trabalho do Python.
Como criar e gerenciar ambientes Python no Visual
Studio
Um ambiente Python é um contexto no qual você executa o código Python e inclui ambientes globais, virtuais
e Conda. Um ambiente é composto por um interpretador, uma biblioteca (normalmente a Biblioteca Padrão do
Python) e um conjunto de pacotes instalados. Juntos, esses componentes determinam quais constructos de
linguagem e qual sintaxe são válidos, qual funcionalidade do sistema operacional pode ser acessada e quais
pacotes podem ser usados.
No Visual Studio no Windows, use a janela Ambientes do Python , conforme descrito neste artigo, para
gerenciar ambientes e selecionar um como o padrão para novos projetos. Outros aspectos dos ambientes são
encontrados nos seguintes artigos:
Para qualquer projeto, você pode selecionar um ambiente específico em vez de usar o padrão.
Para obter detalhes de como criar e usar ambientes virtuais para projetos Python, confira Usar ambientes
virtuais.
Se desejar instalar pacotes em um ambiente, confira a referência da guia Pacotes.
Para instalar outro interpretador do Python, confira Instalar interpretadores do Python. Em geral, se você
baixar e executar um instalador de uma distribuição principal do Python, o Visual Studio detectará que a
nova instalação e o ambiente aparecem na janela Ambientes do Python e podem ser selecionados para
projetos.
Se você está começando a usar o Python no Visual Studio, os artigos a seguir também fornecem informações
gerais:
Trabalhar com o Python no Visual Studio
Instalar o suporte de Python no Visual Studio
NOTE
Você não pode gerenciar ambientes para código Python que é aberto somente como uma pasta usando o comando File
> Open > Folder . Em vez disso, Crie um projeto em Python com o código existente para aproveitar os recursos do
ambiente do Visual Studio.
NOTE
Você pode gerenciar ambientes de código Python que são abertos como uma pasta usando o comando File > Open >
Folder . A barra de ferramentas do Python permite alternar entre todos os ambientes detectados e também adicionar um
novo ambiente. As informações de ambiente são armazenadas no arquivo PythonSettings.json na pasta Workspace. vs.
A janela Ambientes do Python

Os ambientes conhecidos pelo Visual Studio são exibidos na janela Ambientes Python . Para abrir a janela, use
um dos seguintes métodos:
Selecione o comando de menu Exibir > outros > ambientes Python do Windows.
Clique com o botão direito do mouse no nó ambientes Python para um projeto no Gerenciador de
soluções e selecione Exibir todos os ambientes de python :
Em ambos os casos, a janela Ambientes do Python é exibida junto com o Gerenciador de Soluções :
O Visual Studio procura por ambientes globais instalados usando o Registro (seguindo o PEP 514), junto com os
ambientes virtuais e os ambientes do Conda (confira Tipos de ambientes). Se um ambiente esperado na lista
não for exibido, confira Manually identify an existing environment (Identificar manualmente um ambiente
existente).
Quando você seleciona um ambiente na lista, o Visual Studio exibe várias propriedades e comandos para esse
ambiente na guia visão geral . Por exemplo, você pode ver na imagem acima que o local do intérprete é
C:\Python36-32. Os quatro comandos na parte inferior da guia Visão Geral abrem um prompt de comando
com o interpretador em execução. Para obter mais informações, confira Referência de guias da janela Ambientes
do Python – Visão Geral.
Use a lista suspensa embaixo da lista de ambientes para alternar para diferentes guias como Pacotes e
IntelliSense . Essas guias também são descritas na Referência de guias da janela Ambientes do Python.
A seleção de um ambiente não altera sua relação com nenhum projeto. O ambiente padrão, mostrado em
negrito na lista, é aquele que o Visual Studio usa para os novos projetos. Para usar um ambiente diferente com
os novos projetos, use o comando Tornar este ambiente o padrão para novos projetos . Dentro do
contexto de um projeto sempre é possível selecionar um ambiente específico. Para obter mais informações,
confira Selecionar um ambiente para um projeto.
À direita de cada ambiente listado está um controle que abre uma janela interativa para esse ambiente. (No
Visual Studio 2017 15.5 e anterior, é exibido outro controle que atualiza o banco de dados do IntelliSense para
esse ambiente. Consulte referência da guia da janela ambientes para obter detalhes sobre o banco de dados.)
TIP
Ao expandir a janela Ambientes do Python até o tamanho suficiente, você obtém uma exibição mais completa de seus
ambientes que pode ser mais conveniente para trabalhar.
TIP
Ao expandir a janela Ambientes do Python até o tamanho suficiente, você obtém uma exibição mais completa de seus
ambientes que pode ser mais conveniente para trabalhar.
NOTE
Embora o Visual Studio respeite a opção de pacotes de site do sistema, ele não fornece uma maneira de alterá-lo no
próprio Visual Studio.
E se nenhum ambiente aparecer?
Se nenhum ambiente aparecer, isso significa que o Visual Studio não conseguiu detectar as instalações de
Python nos locais padrão. Por exemplo, você pode ter instalado o Visual Studio 2017 ou posterior, mas limpou
todas as opções de interpretador nas opções do instalador para a carga de trabalho do Python. Da mesma
forma, você pode ter instalado o Visual Studio 2015 ou anterior, mas não instalou um interpretador
manualmente (confira Instalar interpretadores do Python).
Se você souber que tem um intérprete do Python em seu computador, mas o Visual Studio (qualquer versão)
não o detectou, use o comando + personalizado para especificar seu local manualmente. Consulte a próxima
seção, Identificar manualmente um ambiente existente.
TIP
O Visual Studio detecta atualizações em um intérprete existente, como a atualização do Python 2.7.11 para o 2.7.14
usando os instaladores do python.org. Durante o processo de instalação, o ambiente mais antigo desaparece da lista de
ambientes Python antes que a atualização seja exibida em seu lugar.
No entanto, se você mover manualmente um interpretador e seu ambiente usando o sistema de arquivos, o Visual Studio
não saberá o novo local. Para obter mais informações, confira Mover um interpretador.
Tipos de ambientes
O Visual Studio pode trabalhar com ambientes globais, virtuais e do Conda.
Ambientes globais
Cada instalação do Python (por exemplo, Python 2,7, Python 3,6, Python 3,7, Anaconda 4.4.0, etc., consulte
instalar intérpretes do Python) mantém seu próprio ambiente global. Cada ambiente é composto pelo
interpretador do Python específico e sua biblioteca padrão, por um conjunto de pacotes pré-instalados e por
todos os pacotes adicionais instalados durante a ativação desse ambiente. A instalação de um pacote em um
ambiente global o torna disponível para todos os projetos que usam esse ambiente. Se o ambiente estiver em
uma área protegida do sistema de arquivos (em c:\Arquivos de Programas, por exemplo), a instalação de
pacotes exigirá privilégios de administrador.
Os ambientes globais estão disponíveis para todos os projetos no computador. No Visual Studio, selecione um
ambiente global como o padrão, que é usado para todos os projetos, a menos que você escolha especificamente
um diferente para um projeto. Para obter mais informações, confira Selecionar um ambiente para um projeto.
Ambientes virtuais
Embora trabalhar em um ambiente global seja uma maneira fácil de começar, ao longo do tempo, esse ambiente
ficará desorganizado, com muitos pacotes diferentes que você terá instalado para diferentes projetos. Essa
desorganização dificultará o teste completo de um aplicativo em relação a um conjunto específico de pacotes
com as versões conhecidas, que é exatamente o tipo de ambiente que você configuraria em um servidor Web ou
em um servidor de build. Também poderão ocorrer conflitos quando dois projetos exigirem pacotes
incompatíveis ou versões diferentes do mesmo pacote.
Por esse motivo, os desenvolvedores geralmente criam um ambiente virtual para um projeto. Um ambiente
virtual é uma subpasta em um projeto que contém uma cópia de um interpretador específico. Quando você
ativa o ambiente virtual, todos os pacotes passam a ser instalados somente na subpasta desse ambiente. Ao
executar um programa em Python nesse ambiente, você sabe que ele será executado somente em relação a
esses pacotes específicos.
O Visual Studio dá suporte direto para a criação de um ambiente virtual para um projeto. Por exemplo, se você
abrir um projeto que contenha um requirements.txt ou criar um projeto usando um modelo que inclua esse
arquivo, o Visual Studio solicitará que você crie automaticamente um ambiente virtual e instale essas
dependências.
A qualquer momento dentro de um projeto aberto, você pode criar um ambiente virtual. No Gerenciador de
Soluções , expanda o nó do projeto, clique com o botão direito do mouse no nó Ambientes do Python e
selecione “Adicionar Ambiente Virtual”. Para obter mais informações, confira Criar um ambiente virtual.
O Visual Studio também fornece um comando para gerar um arquivo requirements.txt de um ambiente virtual,
facilitando a recriação do ambiente em outros computadores. Para obter mais informações, confira Usar
ambientes virtuais.
Ambientes do Conda
Um ambiente do conda é aquele criado usando a ferramenta conda , ou com o gerenciamento do conda
integrado no Visual Studio 2017 versão 15.7 e superior. (Exige o Anaconda ou Miniconda, que estão disponíveis
por meio do Instalador do Visual Studio. Para informações, consulte Instalação.)
1. Selecione + Criar ambiente do conda na janela Ambientes do Python , que abre uma guia Criar
novo ambiente do conda :
2. Insira um nome para o ambiente no campo Nome , selecione um interpretador base do Python no campo
Python e selecione Criar .
3. A janela Saída mostra o progresso do novo ambiente, com algumas instruções da CLI após a conclusão
da criação:
4. No Visual Studio, você pode ativar um ambiente do Conda para um projeto da mesma forma como faria
com qualquer outro ambiente, conforme descrito em Selecionar um ambiente para um projeto.
5. Para instalar pacotes no ambiente, use a guia Pacotes.
1. Selecione + Adicionar Ambiente na janela Ambientes Python (ou na barra de ferramentas Python),
que abre a caixa de diálogo Adicionar ambiente . Na caixa de diálogo, selecione a guia Ambiente do
Conda :
2. Configure os seguintes campos:
CAMPO DESC RIÇ Ã O
Project O projeto no qual criar o ambiente (se você tiver vários

projetos na mesma solução do Visual Studio).
Nome O nome para o ambiente do conda.
Adicionar pacotes de Escolha Arquivo do ambiente caso tenha um arquivo

environment.yml descrevendo suas dependências, ou
escolha Um ou mais nomes de pacotes Anaconda e
liste pelo menos um pacote Python ou uma versão
Python no campo abaixo. A lista de pacotes instrui o
conda a criar um ambiente de Python. Para instalar a
versão mais recente do Python, use python ; para
instalar uma versão específica, use
python=,major>.<minor> como no python=3.7 . Você
também pode usar o botão de pacote para selecionar as
versões do Python e pacotes comuns de uma série de
menus.
Definir como ambiente atual Depois que o ambiente for criado, ativa o novo ambiente
no projeto selecionado.
Definir como ambiente padrão para novos projetos Define e ativa o ambiente do conda automaticamente
em todos os novos projetos criados no Visual Studio.
Essa opção é o mesmo que usar Tornar este o
ambiente padrão para novos projetos na janela
Ambientes do Python .
Exibir na janela de ambientes do Python Especifica se deve mostrar a janela Ambientes do

Python depois de criar o ambiente.
IMPORTANT
Ao criar um ambiente do conda, certifique-se de especificar pelo menos uma versão do Python ou um pacote do
Python usando environments.yml ou a lista de pacotes, que garante que o ambiente contém um runtime do
Python. Caso contrário, o Visual Studio ignora o ambiente: o ambiente não aparece na janela Ambientes do
Python , não é definido como o ambiente atual para um projeto e não está disponível como um ambiente global.
Se você criar um ambiente de conda sem uma versão do Python, use o comando conda info para ver os locais
das pastas de ambiente do conda, em seguida, remova manualmente a subpasta do ambiente do local.
3. Selecione Criar e observe o progresso na janela Saída . A saída inclui algumas instruções da CLI após a
conclusão da criação:
4. No Visual Studio, você pode ativar um ambiente do Conda para um projeto da mesma forma como faria
com qualquer outro ambiente, conforme descrito em Selecionar um ambiente para um projeto.
5. Para instalar pacotes adicionais no ambiente, use a guia Pacotes.
NOTE
Para obter melhores resultados com ambientes do conda, use o conda 4.4.8 ou posterior (as versões do conda são
diferentes das versões do Anaconda). Você pode instalar versões adequadas do Miniconda (Visual Studio 2019) e
Anaconda (Visual Studio 2017) pelo instalador do Visual Studio.
Para ver a versão do conda, na qual os ambientes do conda são armazenados, bem como outras informações,
execute conda info em um prompt de comando do Anaconda (ou seja, um prompt de comando no qual o
Anaconda está no caminho):
conda info
As pastas de ambiente do conda são exibidas da seguinte maneira:
envs directories : C:\Users\user\.conda\envs

c:\anaconda3\envs
C:\Users\user\AppData\Local\conda\conda\envs
Como os ambientes do conda não são armazenados com um projeto, eles atuam da mesma forma para
ambientes globais. Por exemplo, a instalação de um novo pacote em um ambiente do conda torna esse pacote
disponível para todos os projetos que usam esse ambiente.
Para o Visual Studio 2017 versão 15.6 e anterior, você pode usar ambientes do conda apontando-os
manualmente, conforme descrito em Identificar manualmente um ambiente existente.
O Visual Studio 2017 versão 15.7 e posterior detecta ambientes do conda automaticamente e exibe-os na janela
Ambientes do Python , conforme descrito na próxima seção.
Identificar manualmente um ambiente existente

Use as seguintes etapas para identificar um ambiente instalado em um local não padrão (incluindo ambientes
do conda no Visual Studio 2017 versão 15.6 e posterior):
1. Selecione + personalizado na janela ambientes Python , que abre a guia Configurar :
2. Insira um nome para o ambiente no campo Descrição .

3. Insira ou procure (usando ...) no caminho do intérprete no campo caminho do prefixo .
4. Se o Visual Studio detectar um interpretador Python nessa localização (como o caminho mostrado abaixo
para um ambiente de conda), ele habilitará o comando Detecção Automática . A seleção da detecção
automática conclui os campos restantes. Você também pode preencher esses campos manualmente.
5. Quando os campos contiverem os valores desejados, selecione Aplicar para salvar a configuração.
Agora, você pode usar o ambiente como qualquer outro no Visual Studio.
6. Se você precisar remover um ambiente identificado manualmente, selecione o comando remover na
guia Configurar . os ambientes detectados automaticamente não fornecem essa opção. Para saber mais,
confira Guia Configurar.
1. Selecione + Adicionar Ambiente na janela Ambientes Python (ou na barra de ferramentas Python),
que abre a caixa de diálogo Adicionar ambiente . Na caixa de diálogo, selecione a guia Ambiente
existente :
2. Selecione a lista suspensa Ambiente , em seguida selecione Personalizado :

3. Nos campos fornecidos na caixa de diálogo, insira ou procure (usando ...) o caminho do interpretador em
Caminho do prefixo , que preenche a maioria dos outros campos. Depois de revisar esses valores e
modificar conforme necessário, selecione Adicionar .
4. Os detalhes do ambiente podem ser examinados e modificados a qualquer momento na janela

Ambientes do Python . Nessa janela, selecione o ambiente e, em seguida, selecione a guia Configurar .
Depois de fazer alterações, selecione o comando aplicar . Você também pode remover o ambiente
usando o comando Remover (não disponível para ambientes detectados automaticamente). Para saber
mais, confira Guia Configurar.
Corrigir ou excluir ambientes inválidos

Se o Visual Studio encontrar entradas de registro para um ambiente, mas o caminho para o intérprete for
inválido, a janela ambientes Python mostrará o nome com uma fonte riscada:
Para corrigir um ambiente que você deseja manter, primeiro tente usar o processo Reparar do instalador dele.
Os instaladores para o Python 3.x padrão, por exemplo, incluem essa opção.
Para corrigir um ambiente que não tem uma opção de reparo, ou para remover um ambiente inválido, use as
etapas a seguir para modificar o Registro diretamente. O Visual Studio atualiza automaticamente a janela de
ambientes Python quando você faz alterações no registro.
1. Execute regedit.exe.
2. Navegue até HKEY_LOCAL_MACHINE\SOFTWARE\Python . Para o IronPython, procure IronPython .
3. Expanda o nó que corresponde à distribuição, como PythonCore para o CPython ou
ContinuumAnalytics para o Anaconda. Para o IronPython, expanda o nó de número de versão.
4. Inspecione os valores no nó InstallPath :
Se o ambiente ainda existir no computador, altere o valor de ExecutablePath para o local correto.
Corrija também os valores (Padrão) e WindowedExecutablePath , conforme necessário.
Se o ambiente não existir mais no computador e você desejar removê-lo da janela Ambientes do
Python , exclua o nó pai de InstallPath , como 3.6 na imagem acima.
Confira também
Como selecionar um ambiente do Python para um
projeto
Todo o código em um projeto Python é executado dentro do contexto de um ambiente específico, como um
ambiente do Python global, um ambiente do Anaconda, um ambiente virtual ou um ambiente do Conda. O
Visual Studio também usa esse ambiente para depuração, importação e conclusões de membro, verificação de
sintaxe e outras tarefas que exigem serviços de linguagem específicos da versão do Python e um conjunto de
pacotes instalados.
Todos os novos projetos do Python no Visual Studio são inicialmente configurados para usar o ambiente
global padrão, que aparece sob o nó ambientes Python em Gerenciador de soluções :
Para alterar o ambiente de um projeto, clique com o botão direito do mouse no nó ambientes Python e
selecione Adicionar/remover ambientes Python . Na lista exibida, que inclui ambientes global, virtual e
conda, selecione todos os que devem aparecer no nó Ambientes do Python :
Depois de marcar OK , todos os ambientes escolhidos são exibidos no nó Ambientes de Python . O ambiente
ativado no momento aparece em negrito:
Para ativar rapidamente outro ambiente, clique com o botão direito do mouse no nome desse ambiente e
selecione Ativar ambiente . Sua escolha é salva com o projeto e esse ambiente é ativado sempre que você
abrir o projeto futuramente. Se você desmarcar todas as opções na caixa de diálogo **Adicionar/Remover
Ambientes de Python **, o Visual Studio ativa o ambiente padrão global.
O menu de contexto no nó Ambientes do Python também fornece comandos adicionais:
C O M A N DO DESC RIÇ Ã O
Adicionar ambiente vir tual Inicia o processo de criação de um novo ambiente virtual
no projeto. Confira Criar um ambiente virtual.
Adicionar um ambiente vir tual existente Solicita que você selecione uma pasta que contém um
ambiente virtual e o adiciona à lista em Ambientes do
Python , mas não o ativa. Confira Ativar um ambiente
virtual existente.
Criar ambiente do Conda Alterna para a Python Environments janela de

ambientes do Python na qual você insere um nome para o
ambiente e especifica seu interpretador base. Confira
Ambientes do Conda.
Para alterar o ambiente para um projeto, clique com botão direito no nó Ambientes do Python e selecione
Adicionar Ambiente , ou selecione Adicionar Ambiente na lista suspensa do ambiente na barra de
ferramentas do Python.
Na caixa de diálogo Adicionar Ambiente , selecione a guia Ambiente existente e selecione um novo
ambiente na lista suspensa Ambiente :
Se você já adicionou um ambiente diferente do padrão global a um projeto, talvez seja necessário ativar um
ambiente recém-adicionado. Clique com o botão direito do mouse nesse ambiente sob o nó Ambientes do
Python e selecione Ativar Ambiente . Para remover um ambiente do projeto, selecione Remover .
Usar ambientes virtuais

Um ambiente virtual é uma combinação exclusiva de um intérprete Python específico e um conjunto
específico de bibliotecas diferente de outros ambientes conda e globais. Um ambiente virtual é específico a
um projeto e é mantido em uma pasta do projeto. Essa pasta contém as bibliotecas instaladas do ambiente e
um arquivo pyvenv.cfg que especifica o caminho do interpretador de base do ambiente em outro lugar no
sistema de arquivos. Ou seja, um ambiente virtual não contém uma cópia do interpretador, apenas um link
para ele.
Um benefício de usar um ambiente virtual é que, à medida que você desenvolve um projeto ao longo do
tempo, o ambiente virtual sempre reflete as dependências exatas do projeto. (Um ambiente global
compartilhado, por outro lado, contém qualquer número de bibliotecas, independentemente de você usá-las
em seu projeto ou não). Você pode criar facilmente um arquivo de requirements.txt do ambiente virtual, que é
usado para reinstalar essas dependências em outro computador de desenvolvimento ou de produção. Para
saber mais, confira Gerenciar pacotes necessários com requirements.txt.
Quando você abre um projeto no Visual Studio que contém um arquivo requirements.txt, o Visual Studio
oferece automaticamente a opção de recriar o ambiente virtual. Em computadores em que o Visual Studio não
está instalado, você pode usar pip install -r requirements.txt para restaurar os pacotes.
Como um ambiente virtual contém um caminho embutido em código para o interpretador de base e é
possível recriar o ambiente usando requirements.txt, normalmente você omite a pasta de todo o ambiente
virtual no controle do código-fonte.
As seções a seguir explicam como ativar um ambiente virtual existente em um projeto e como criar um novo
ambiente virtual.
No Visual Studio, um ambiente virtual pode ser ativado para um projeto como qualquer outro por meio do nó
Ambientes do Python no Gerenciador de Soluções .
Assim que um ambiente virtual for adicionado ao projeto, ele será exibido na janela Ambientes do Python .
Você pode ativá-lo como qualquer outro ambiente e gerenciar seus pacotes.
Criar um ambiente virtual
Você pode criar um novo ambiente virtual diretamente no Visual Studio da seguinte maneira:
1. Clique com o botão direito do mouse em ambientes Python no Gerenciador de soluções e
selecione Adicionar ambiente vir tual , que abre a seguinte caixa de diálogo:
2. No local do ambiente vir tual , especifique um caminho para o ambiente virtual. Se você especificar
apenas um nome, o ambiente virtual será criado dentro do projeto atual em uma subpasta com o
mesmo nome.
3. Selecione um ambiente como o interpretador base e selecione Criar . O Visual Studio exibe uma barra
de progresso enquanto configura o ambiente, e baixa todos os pacotes necessários. Após a conclusão,
o ambiente virtual aparecerá na janela Ambientes de Python para o projeto que o contém.
4. O ambiente virtual não está ativado por padrão. Para ativá-lo para o projeto, clique com o botão direito
e selecione Ativar Ambiente .
NOTE
Se o caminho do local identificar um ambiente virtual existente, o Visual Studio detectará automaticamente o
interpretador base (usando o arquivo orig-prefix.txt no diretório lib do ambiente) e alterará o botão Criar para
Adicionar .
Se existir um arquivo requirements.txt ao adicionar um ambiente virtual, a caixa de diálogo Adicionar Ambiente
Vir tual exibirá uma opção para instalar os pacotes automaticamente, facilitando a recriação de um ambiente em outra
máquina:
De qualquer forma, o resultado é o mesmo que se você tivesse usado o comando Adicionar ambiente vir tual
existente .
Ativar um ambiente virtual existente

Se você já tiver criado um ambiente virtual em outro lugar, você poderá ativá-lo para um projeto da seguinte
maneira:
1. Clique com o botão direito do mouse em ambientes Python no Gerenciador de soluções e
selecione Adicionar ambiente vir tual existente .
2. Na caixa de diálogo de procura exibida, navegue até e selecione a pasta que contém o ambiente
virtual e selecione OK . Se o Visual Studio detectar um arquivo requirements.txt nesse ambiente, ele
perguntará se deve instalar esses pacotes.
3. Após alguns instantes, o ambiente virtual aparece sob o nó ambientes Python em Gerenciador de
soluções . O ambiente virtual não está ativado por padrão, então clique duas vezes e selecione Ativar
Ambiente .
Criar um ambiente virtual
Você pode criar um novo ambiente virtual diretamente no Visual Studio da seguinte maneira:
1. Clique com o botão direito do mouse em Ambientes do Python no Gerenciador de Soluções e
selecione Adicionar Ambiente ou selecione Adicionar Ambientes na lista suspensa de ambientes
na barra de ferramentas do Python. Na caixa de diálogo Adicionar Ambiente que aparece, selecione a
guia Ambiente Vir tual :
2. Especifique um nome para o ambiente virtual, selecione um interpretador de base e verifique seu local.
Sob Instalar pacotes do arquivo , forneça o caminho para um arquivo Requirements.txt, se desejar.
3. Examine as outras opções na caixa de diálogo:
Definir como ambiente atual Depois que o ambiente for criado, ativa o novo
ambiente no projeto selecionado.
Definir como ambiente padrão para novos projetos Define e ativa o ambiente virtual automaticamente em
todos os novos projetos criados no Visual Studio. Ao
usar essa opção, o ambiente virtual deve ser colocado
em um local fora de um projeto específico.
Exibir na janela de ambientes do Python Especifica se deve abrir a janela Ambientes do

Python depois de criar o ambiente.
Tornar esse ambiente disponível globalmente Especifica se o ambiente virtual também atua como um
ambiente global. Ao usar essa opção, o ambiente virtual
deve ser colocado em um local fora de um projeto
específico.
4. Selecione Criar para finalizar o ambiente virtual. O Visual Studio exibe uma barra de progresso
enquanto configura o ambiente, e baixa todos os pacotes necessários. Após a conclusão, o ambiente
virtual é ativado e aparece no nó Ambientes do Python no Gerenciador de Soluções , e na janela
Ambientes do Python para o projeto que o contém.
Ativar um ambiente virtual existente
Se você já tiver criado um ambiente virtual em outro lugar, você poderá ativá-lo para um projeto da seguinte
maneira:
1. Clique com o botão direito do mouse em Ambientes de Python no Gerenciador de Soluções e
escolha Adicionar Ambiente .
2. Na caixa de diálogo de procura exibida, navegue até e selecione a pasta que contém o ambiente
virtual e selecione OK . Se o Visual Studio detectar um arquivo requirements.txt nesse ambiente, ele
perguntará se deve instalar esses pacotes.
3. Após alguns instantes, o ambiente virtual aparece sob o nó ambientes Python em Gerenciador de
soluções . O ambiente virtual não está ativado por padrão, então clique duas vezes e selecione Ativar
Ambiente .
Remover um ambiente virtual
1. Em Gerenciador de soluções , clique com o botão direito do mouse no ambiente virtual e selecione
remover .
2. O Visual Studio pergunta se você quer remover ou excluir o ambiente virtual. Selecionar Remover o
torna indisponível ao projeto, mas o deixa no sistema de arquivos. Selecionar Excluir remove o
ambiente do projeto e o exclui do sistema de arquivos. O interpretador de base não é afetado.
Exibir os pacotes instalados

No Gerenciador de Soluções, expanda qualquer nó de um ambiente específico para exibir rapidamente os
pacotes instalados nesse ambiente (ou seja, você não pode importar e usar esses pacotes em seu código
quando o ambiente estiver ativo):
Para instalar novos pacotes, clique com o botão direito do mouse no ambiente e escolha Instalar Pacote do
Python para alternar para a guia Pacotes apropriada na janela Ambientes de Python . Insira uma termo de
pesquisa (geralmente o nome do pacote) e o Visual Studio exibirá os pacotes correspondentes.
Para instalar novos pacotes, clique com o botão direito no ambiente e escolha Gerenciar Pacotes do
Python (ou use o botão de pacote na barra de ferramentas do Python) para alternar para a guia Pacotes
apropriada na janela Ambientes de Python . Na guia Pacotes , insira um termo de pesquisa (geralmente o
nome do pacote) e o Visual Studio exibirá os pacotes correspondentes.
No Visual Studio, os pacotes (e as dependências) para a maioria dos ambientes são baixados do PyPI (Índice
do Pacote do Python), no qual você também pode pesquisar os pacotes disponíveis. A barra de status e a
janela de saída do Visual Studio mostram informações sobre a instalação. Para desinstalar um pacote, clique
com o botão direito do mouse nele e escolha Remover .
O gerenciador de pacotes conda geralmente usa https://repo.continuum.io/pkgs/ como padrão de canal, mas
há outros canais disponíveis. Saiba mais em Gerenciar Canais (docs.conda.io).
Saiba que as entradas exibidas podem não ser precisas e a instalação e desinstalação podem não ser
confiáveis nem estar disponíveis. O Visual Studio usa o gerenciador de pacotes do PIP, se disponível, e o baixa
e o instala quando necessário. O Visual Studio também pode usar o gerenciador de pacotes easy_install. Os
pacotes instalados usando pip ou easy_install por meio da linha de comando também são exibidos.
Observe também que o Visual Studio não oferece suporte no momento ao uso de conda para instalar os
pacotes em um ambiente conda. Use conda na linha de comando.
TIP
Uma situação comum em que o Pip não consegue instalar um pacote é quando o pacote inclui o código-fonte para
componentes nativos em arquivos * * . PYD* . Sem a versão necessária do Visual Studio instalada, o PIP não pode
compilar esses componentes. A mensagem de erro exibida nessa situação é erro: Não foi possível localizar
vcvarsall.bat . easy_install geralmente é capaz de baixar binários pré-compilados, e você pode baixar um
compilador adequado para versões mais antigas do Python do https://www.microsoft.com/download/details.aspx?
id=44266 . Para obter mais detalhes, consulte Como lidar com o problema “Não é possível localizar vcvarsallbat” no
blog da equipe das Ferramentas Python.
Confira também
Gerenciar ambientes do Python no Visual Studio
Gerenciar os pacotes necessários com
requirements.txt
Se você compartilha um projeto com outras pessoas, usa um sistema de build ou planeja copiar o projeto para
qualquer outra localização em que precise restaurar um ambiente, você precisa especificar os pacotes externos
exigidos pelo projeto. A abordagem recomendada é usar um arquivo requirements.txt (readthedocs.org) que
contém uma lista de comandos do PIP que instala as versões necessárias dos pacotes dependentes. O comando
mais comum é pip freeze > requirements.txt , que registra a lista atual de pacotes de um ambiente no
requirements.txt.
Tecnicamente, qualquer nome de arquivo pode ser usado para acompanhar os requisitos (usando
-r <full path to file> durante a instalação de um pacote), mas o Visual Studio fornece suporte específico para
requirements.txt:
Se você carregou um projeto que contém requirements.txt e deseja instalar todos os pacotes listados
nesse arquivo, expanda o nó Ambientes de Python no Gerenciador de Soluções e clique com o
botão direito do mouse em um nó de ambiente e selecione Instalar de requirements.txt :
Se desejar instalar as dependências em um ambiente virtual, primeiro crie e ative esse ambiente e use o
comando Install from requirements.txt . Saiba mais sobre como criar um ambiente virtual em Usar
ambientes virtuais.
Se você já tiver todos os pacotes necessários instalados em um ambiente, poderá clicar com o botão
direito do mouse nesse ambiente em Gerenciador de soluções e selecionar gerar requirements.txt
para criar o arquivo necessário. Se o arquivo já existir, será exibido um prompt para como atualizá-lo:
Substituir todo o arquivo remove todos os itens, comentários e opções existentes.
Atualizar as entradas existentes detecta os requisitos do pacote e atualiza os especificadores de
versão para que eles correspondam à versão instalada.
Atualizar e adicionar entradas atualiza todos os requisitos encontrados e adiciona todos os outros
pacotes ao final do arquivo.
Como os arquivos requirements.txt se destinam a congelar os requisitos do ambiente, todos os pacotes
instalados são escritos com versões precisas. Usar versões precisas garante que você possa reproduzir
facilmente seu ambiente em outra máquina. Os pacotes serão incluídos, mesmo se eles foram instalados com
um intervalo de versão, como uma dependência de outro pacote ou com um instalador que não seja o PIP.
Se um pacote não puder ser instalado pelo PIP e for exibido em um arquivo requirements.txt, toda a instalação
falhará. Nesse caso, edite manualmente o arquivo para excluir esse pacote ou use as opções do PIP para se
referir a uma versão instalável do pacote. Por exemplo, você pode preferir usar pip wheel para compilar uma
dependência e adicionar a --find-links <path> opção à sua 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...
Consulte também
Como o Visual Studio usa caminhos de pesquisa de
Python
Com o uso típico do Python, a variável de ambiente PYTHONPATH (ou IRONPYTHONPATH , etc.) fornece o caminho de
pesquisa padrão para arquivos de módulo. Ou seja, quando você usa uma instrução from <name> import... ou
import <name> , o Python pesquisa os seguintes locais, nessa ordem, por um nome correspondente:
1. Módulos internos do Python.

2. A pasta que contém o código do Python que você está executando.
3. O "caminho de pesquisa do módulo", conforme definido pela variável de ambiente aplicável. (Consulte O
caminho de pesquisa do módulo e Variáveis de ambiente na documentação básica do Python.)
No entanto, o Visual Studio ignora a variável de ambiente do caminho de pesquisa, mesmo quando ela tiver sido
configurada para todo o sistema. Ele é ignorado, de fato, precisamente porque está definido para todo o sistema
e, portanto, gera determinadas perguntas que não podem ser respondidas automaticamente: os módulos
referenciados destinam-se ao Python 2,7 ou Python 3.6 +? Eles substituirão os módulos da biblioteca padrão? O
desenvolvedor está ciente desse comportamento ou essa é uma tentativa de sequestro mal-intencionada?
Dessa forma, o Visual Studio fornece um meio para especificar caminhos de pesquisa diretamente nos projetos e
ambientes. O código que você executa ou depura no Visual Studio recebe os caminhos de pesquisa no valor de
PYTHONPATH (e outras variáveis equivalentes). Ao adicionar caminhos de pesquisa, o Visual Studio inspeciona as
bibliotecas nessas localizações e compila bancos de dados do IntelliSense para elas quando necessário (Visual
Studio 2017 versão 15.5 e anterior; a criação do banco de dados pode demorar algum tempo, dependendo do
número de bibliotecas).
Para adicionar um caminho de pesquisa, acesse Gerenciador de Soluções , expanda o nó do projeto, clique
com o botão direito do mouse em Caminhos de Pesquisa , selecione Adicionar Pasta ao Caminho de
Pesquisa :
Esse comando exibe um navegador no qual você pode selecionar a pasta a ser incluída.
Se a variável de ambiente PYTHONPATH já incluir as pastas que você deseja, use Adicionar PYTHONPATH aos
Caminhos de Pesquisa como um atalho conveniente.
Depois que as pastas forem adicionadas aos caminhos de pesquisa, o Visual Studio usará esses caminhos para
qualquer ambiente associado ao projeto. (Você poderá ver erros se o ambiente tiver base no Python 3, e você
tentar adicionar um caminho de pesquisa aos módulos do Python 2.7.)
Os arquivos com uma extensão .zip ou .egg também podem ser adicionados como caminhos de pesquisa
selecionando Adicionar Arquivo Mor to Zip ao Caminho de Pesquisa . Assim como ocorre com pastas, o
conteúdo desses arquivos é examinado e disponibilizado para o IntelliSense.
Confira também
Referência as guias da janela Ambientes do Python
Para abrir a janela Ambientes de Python :

Selecione o comando de menu Exibir > outros > ambientes Python do Windows.
Clique com o botão direito do mouse no nó Ambientes do Python de um projeto no Gerenciador de
Soluções e escolha Exibir Todos os Ambientes do Python .
Se você expandir a janela de ambientes Python horizontalmente, essas opções serão mostradas como guias,
com as quais você pode achar mais conveniente trabalhar. Para maior clareza, as guias neste artigo são
mostradas na exibição expandida.
Guia Visão Geral
Fornece informações básicas e comandos para o ambiente:
Tornar este ambiente padrão para novos projetos Definir o ambiente ativo, o que pode fazer com que o Visual
Studio (2017 versão 15.5 e anteriores) pare de responder
brevemente enquanto carrega o banco de dados do
IntelliSense. Ambientes com muitos pacotes podem parar de
responder por um período maior.
Visitar o site do distribuidor Abre um navegador para a URL fornecida para a distribuição
de Python. Python 3. x, por exemplo, vai para python.org.
Abrir a janela interativa Abre a janela interativa (REPL) para esse ambiente dentro do
Visual Studio, aplicando quaisquer scripts de inicialização
(veja abaixo).
Explorar scripts interativos Veja os scripts de inicialização.

Usar o modo interativo do IPython Quando definido, abre a janela interativa com ipython por
padrão. Isso habilita os gráficos embutidos e a sintaxe
estendida do IPython como name? para exibir a ajuda e
!command para comandos shell. Essa opção é recomendada
quando estiver usando uma distribuição Anaconda, pois ela
requer pacotes extras. Para obter mais informações, confira
Usar o IPython na Janela Interativa.
Abrir no PowerShell Inicia o interpretador em uma janela de comando do

PowerShell.
(Links de pasta e do programa) Forneça acesso rápido à pasta de instalação do ambiente, ao

interpretador de python.exe e ao interpretador de
pythonw.exe . O primeiro abre no Windows Explorer, os dois
últimos abrem uma janela do console.
Scripts de inicialização
Como você janelas interativas no fluxo de trabalho diário, provavelmente desenvolverá funções auxiliares que
você usa regularmente. Por exemplo, você pode criar uma função que abre um dataframe no Excel e, em
seguida, salvar esse código como um script de inicialização para que ele esteja sempre disponível na janela
interativa .
Os scripts de inicialização contêm código que a janela interativa carrega e executa automaticamente, incluindo
importações, definições de função e, literalmente, qualquer outra coisa. Esses scripts são referenciados de duas
maneiras:
1. Quando você instala um ambiente, o Visual Studio cria uma pasta Documentos\Visual Studio <version>
\Python \ <environment> scripts em que < > a versão é a versão do Visual Studio (como 2017 ou 2019)
e < o ambiente > corresponde ao nome do ambiente. Você pode navegar facilmente para a pasta
específica do ambiente com o comando Explorar scripts interativos . Quando você inicia a janela
Interativa para esse ambiente, ela carrega e executa qualquer arquivo .py que for encontrado aqui em
ordem alfabética.
2. O controle Scripts na guia Ferramentas > Opções > Python > Janelas Interativas (confira Opções
de janelas Interativas) destina-se a especificar uma pasta adicional para os scripts de inicialização que
estão carregados e são executados em todos os ambientes. No entanto, esse recurso não funciona no
momento.
Guia Configurar
Se estiver disponível, a guia Configurar conterá detalhes, conforme descrito na tabela abaixo. Se essa guia não
estiver presente, isso significa que o Visual Studio está gerenciando todos os detalhes automaticamente.
Descrição O nome a ser fornecido para o ambiente.
Caminho do prefixo A localização da pasta base do interpretador. Ao preencher

esse valor e clicar em Detecção Automática , o Visual
Studio tenta preencher os outros campos para você.
Caminho do interpretador O caminho para o executável do interpretador,

normalmente, o caminho do prefixo seguido por
python.exe
Interpretador em janelas O caminho para o executável que não é de console,

geralmente, é o caminho do prefixo seguido por
pythonw.exe .
Caminho da biblioteca Especifica a raiz da biblioteca padrão, mas esse valor poderá
(se estiver disponível) ser ignorado se o Visual Studio conseguir solicitar um
caminho mais preciso do interpretador.
Versão da linguagem Selecionada no menu suspenso.
Arquitetura Normalmente detectado e preenchido automaticamente,

caso contrário especifica 32 bits ou 64 bits .
Variável de ambiente do caminho A variável de ambiente que o interpretador usa para

encontrar caminhos de pesquisa. O Visual Studio altera o
valor da variável ao iniciar o Python, para que ela contenha
os caminhos de pesquisa do projeto. Normalmente, essa
propriedade deve ser definida como PYTHONPATH , mas
alguns interpretadores usam outro valor.
Guia Pacotes
Também chamada de "pip" em versões anteriores.
Gerencia os pacotes instalados no ambiente usando pip (a guia Pacotes (PyPI) ) ou o conda (a guia Pacotes
(Conda) , para ambientes do conda no Visual Studio 2017 versão 15.7 e posteriores). Nessa guia, você também
pode procurar e instalar novos pacotes, incluindo as dependências dele.
Os pacotes que já estão instalados são exibidos com controles para atualizar (uma seta para cima) e desinstalar
(X em um círculo) o pacote:
Inserir um termo de pesquisa filtra a lista de pacotes instalados, bem como os pacotes que podem ser
instalados do PyPI.
Como você pode ver na imagem acima, os resultados da pesquisa mostram um número de pacotes que
correspondem ao termo de pesquisa; no entanto, a primeira entrada da lista é um comando para executar a
instalação <name> do Pip diretamente. Se você estiver na guia pacotes (Conda) , em vez disso, consulte
**Conda <name> install **:
Em ambos os casos, você pode personalizar a instalação pela adição de argumentos na caixa de pesquisa após o
nome do pacote. Quando você inclui argumentos, os resultados da pesquisa mostram pip install ou conda
install seguido do conteúdo da caixa de pesquisa:
Instalar um pacote cria subpastas dentro da pasta Lib do ambiente no sistema de arquivos. Por exemplo, se você
tiver Python 3.6 instalado em c:\Python36, os pacotes são instalados em c:\Python36\Lib, se você tiver o
Anaconda3 instalado em c:\Program Files\Anaconda3, os pacotes serão instalados em c:\Program
Files\Anaconda3\Lib. Nos ambientes do conda, os pacotes são instalados na pasta do ambiente.
Conceder privilégios de administrador à instalação do pacote
Ao instalar os pacotes em um ambiente que está localizado em uma área protegida do sistema de arquivos,
como c:\Program Files\Anaconda3\Lib, o Visual Studio deve executar pip install com privilégios elevados
para permitir que ele crie subpastas do pacote. Quando a elevação é necessária, o Visual Studio exibe o prompt,
os privilégios de administrador podem ser necessários para instalar, atualizar ou remover pacotes
para este ambiente :
Elevar agora concede privilégios administrativos para executar o PIP para uma única operação, sujeita
também a qualquer prompt de permissão do sistema operacional. A seleção de continuar sem privilégios
de administrador tenta instalar o pacote, mas a Pip falha ao tentar criar pastas com saída, como erro: não
foi possível criar ' C:\Program Files\Anaconda3\Lib\site-packages\png.py ': permissão negada.
Selecionar Sempre elevar ao instalar o u remover pacotes impede que a caixa de diálogo apareça para o
ambiente em questão. Para que a caixa de diálogo apareça novamente, vá para ferramentas > Opções >
Python > geral e selecione o botão redefinir todas as caixas de diálogo ocultas permanentemente .
Nessa mesma guia de Opções , você também pode selecionar sempre executar Pip como administrador
para suprimir a caixa de diálogo para todos os ambientes. Consulte Opções – guia Geral.
Restrições de segurança com versões mais antigas do Python
Ao usar o Python 2.6, 3.1 e 3.2, o Visual Studio mostra o aviso Devido a restrições de segurança, a
instalação por meio da Internet pode não funcionar nesta versão do Python :
O motivo do aviso é que com essas versões anteriores do Python, pip install o não contém suporte para a
camada de segurança de transporte (TLS) 1,2, que é necessária para baixar pacotes da origem do pacote,
PyPI.org. Compilações personalizadas do Python podem dar suporte a TLS 1,2, caso em que isso pip install
pode funcionar.
É possível baixar o get-pip.py apropriado para um pacote em bootstrap.pypa.io, fazer o download manual de
um pacote em pypi.org e, em seguida, instalar o pacote dessa cópia local.
No entanto, a recomendação é apenas atualizar para o Python 2.7 ou 3.3+; nesse caso, o aviso não é exibido.
Guia IntelliSense
Mostra o status atual do banco de dados de preenchimento do IntelliSense:
No Visual Studio 2017 versão 15.5 e anteriores, as conclusões do IntelliSense dependem de um banco de
dados que é compilado para essa biblioteca. A criação do banco de dados é feita em segundo plano quando
uma biblioteca é instalada, mas pode levar algum tempo e não pode ser concluída quando você começa a
escrever código.
O Visual Studio 2017 versão 15.6 e versões posteriores usam um método mais rápido para fornecer
conclusões que não dependem do banco de dados por padrão. Por esse motivo, a guia é rotulada
IntelliSense [banco de dados desabilitado] . Você pode habilitar o banco de dados desmarcando a
opção ferramentas > Opções > Python > experimental > usar novo estilo IntelliSense para
ambientes .
Quando o Visual Studio detecta um novo ambiente (ou você adiciona um), ele começa a compilar o banco de
dados automaticamente, analisando os arquivos de origem da biblioteca. Esse processo pode levar de um
minuto a uma hora ou mais, dependendo do que está instalado. (Anaconda, por exemplo, vem com muitas
bibliotecas e demora algum tempo para compilar o banco de dados.) Depois de concluído, você obtém o
IntelliSense detalhado e não precisa atualizar o banco de dados novamente (com o botão Atualizar BD ) até
instalar mais bibliotecas.
As bibliotecas para as quais os dados não foram compilados serão marcadas com um ! ; se o banco de dados de
um ambiente não estiver concluído, um ! também é exibido ao lado da lista do ambiente principal.
Consulte também
Configurar aplicativos Web do Python para o IIS
Ao usar IIS (Serviços de Informações da Internet) como um servidor Web em um computador Windows (incluindo
máquinas virtuais do Windows no Azure, os aplicativos do Python devem incluir configurações específicas nos
arquivos web.config, de forma que o IIS possa processar corretamente o código do Python. O próprio computador
também deve ter o Python instalado, juntamente com quaisquer pacotes que o aplicativo Web exija.
NOTE
Este artigo continha anteriormente diretrizes para configurar o Python no Serviço de Aplicativo do Azure no Windows. As
extensões do Python e os hosts de Windows usados nesse cenário foram preteridos em favor do Serviço de Aplicativo do
Azure no Linux. Para saber mais, confira Publicar aplicativos do Python no Serviço de Aplicativo do Azure (Linux). No
entanto, o artigo anterior ainda está disponível em Gerenciar o Serviço de Aplicativo no Windows com as extensões do
Python.
Instalar o Python no Windows

Para executar um aplicativo Web, primeiro instale a versão necessária do Python diretamente no computador host
do Windows, conforme descrito em Instalar interpretadores do Python.
Registre o local do interpretador do python.exe para etapas posteriores. Para sua conveniência, você pode
adicionar esse local à variável de ambiente PATH.
Instalar Pacotes
Ao usar um host dedicado, você pode usar o ambiente global do Python para executar o aplicativo, em vez de um
ambiente virtual. Da mesma forma, você pode instalar todos os requisitos do aplicativo no ambiente global
simplesmente executando pip install -r requirements.txt em um prompt de comando.
Configurar o web.config para apontar para o interpretador do Python

O arquivo web.config do aplicativo instrui o servidor Web do IIS (7 ou posterior) em execução no Windows sobre
como ele deve tratar as solicitações do Python por meio de HttpPlatform (recomendado) ou FastCGI. As versões
do Visual Studio 2015 e anterior fazem essas modificações automaticamente. Ao usar o Visual Studio 2017 e
posterior, você deve modificar web.config manualmente.
Configurar o manipulador HttpPlatform
O módulo HttpPlatform passa conexões de soquete diretamente para um processo de Python autônomo. Essa
passagem permite que você execute qualquer servidor Web que desejar, mas requer um script de inicialização que
executa um servidor Web local. Você especifica o script no <httpPlatform> elemento do web.config, em que o
atributo processPath aponta para o interpretador do Python da extensão de site e o atributo arguments aponta
para seu script e os argumentos que você quiser fornecer:
<?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>
A variável de ambiente HTTP_PLATFORM_PORT mostrada aqui contém a porta que o servidor local deve escutar para
as conexões do localhost. Este exemplo também mostra como criar outra variável de ambiente, se desejado, nesse
caso SERVER_PORT .
Configurar o manipulador do FastCGI
O FastCGI é uma interface que funciona no nível da solicitação. O IIS recebe conexões de entrada e encaminha
cada solicitação para um aplicativo WSGI em execução em um ou mais processos Python persistentes.
Para usá-lo, primeiro instale e configure o pacote wfastcgi, conforme descrito em pypi.org/project/wfastcgi/.
Em seguida, modifique o arquivo web.config do aplicativo para incluir os caminhos completos para python.exe e
wfastcgi.py na chave PythonHandler . As etapas a seguir pressupõem que o Python esteja instalado em
c:\python36-32 e que o código do aplicativo esteja em c:\home\site\wwwroot. Faça ajustes de maneira adequada
para seus caminhos:
1. Modifique a entrada PythonHandler em web.config para que o caminho corresponda à localização de
instalação do Python (confira Referência de configuração do IIS (iis.net) para obter detalhes exatos).
<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. Na <appSettings> seção de web.config, adicione chaves para WSGI_HANDLER , WSGI_LOG (opcional) e

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>
Esses valores <appSettings> estão disponíveis para seu aplicativo como variáveis de ambiente:
O valor de PYTHONPATH pode ser estendido livremente, mas deve incluir a raiz do seu aplicativo.
WSGI_HANDLER deve apontar para um aplicativo WSGI importável do seu aplicativo.
WSGI_LOG é opcional, mas recomendado para depuração do seu aplicativo.
3. Defina a entrada WSGI_HANDLER em web.config de acordo com a estrutura que você está usando:
Bottle : verifique se há parênteses depois de app.wsgi_app , conforme mostrado abaixo. Isso é
necessário porque esse objeto é uma função (consulte app.py) em vez de uma variável:


<add key="WSGI_HANDLER" value="app.wsgi_app()"/>
Flask : altere o valor de WSGI_HANDLER para <project_name>.app , em que <project_name>

corresponde ao nome do seu projeto. Você pode localizar o identificador exato examinando a
instrução from <project_name> import app no runserver.py. Por exemplo, se o projeto fosse
denominado "FlaskAzurePublishExample", a entrada seria semelhante ao seguinte:

<add key="WSGI_HANDLER" value="flask_iis_example.app"/>
Django : duas alterações são necessárias no web.config para projetos Django. Primeiro, altere o
valor de WSGI_HANDLER para django.core.wsgi.get_wsgi_application() (o objeto está no arquivo
wsgi.py):


<add key="WSGI_HANDLER" value="django.core.wsgi.get_wsgi_application()"/>
Em seguida, adicione a seguinte entrada abaixo da do WSGI_HANDLER , substituindo

DjangoAzurePublishExample pelo nome do seu projeto:
<add key="DJANGO_SETTINGS_MODULE" value="django_iis_example.settings" />
4. Somente aplicativos do Django : no arquivo settings.py do projeto do Django, adicione o domínio de

URL do site ou o endereço IP para ALLOWED_HOSTS , conforme mostrado abaixo, substituindo '1.2.3.4' por
endereço IP ou URL, claro:
# Change the URL or IP address to your specific site

ALLOWED_HOSTS = ['1.2.3.4']
A falha ao adicionar a URL à matriz resulta no erro DisallowedHost/cabeçalho de HTTP_HOST

inválido: ' <site URL> '. Talvez seja necessário adicionar ' <site URL> ' a ALLOWED_HOSTS.
Observe que, quando a matriz estiver vazia, o Django permitirá automaticamente 'localhost' e '127.0.0.1',
mas adicionar sua URL de produção removerá essas funcionalidades. Por esse motivo, talvez você queira
manter cópias do settings.py de desenvolvimento e de produção separadas ou usar variáveis de ambiente
para controlar os valores de tempo de execução.
Implantar em IIS ou em uma VM do Windows

Com o arquivo web.config correto no projeto, você pode publicar no computador que executa o IIS usando o
comando Publish no menu de contexto do projeto no Gerenciador de Soluções e selecionando a opção IIS,
FTP etc.. Nesse caso, o Visual Studio simplesmente copia os arquivos do projeto para o servidor. Você é
responsável por toda a configuração do lado do servidor.
Como você passa muito tempo dedicado ao desenvolvimento no editor de códigos, o Suporte para Python no
Visual Studio fornece funcionalidade para ajudá-lo a ser mais produtivo. Os recursos incluem o realce de sintaxe
do IntelliSense, o preenchimento automático, a ajuda da assinatura, as substituições de método, a pesquisa e a
navegação.
O editor também é integrado com a janela Interativa no Visual Studio, facilitando a troca de código entre os dois.
Confira Etapa 3 do tutorial: Usar a janela do REPL Interativo e Usar a janela Interativa – comando Enviar para
Interativa para obter detalhes.
Para obter uma documentação geral sobre edição do código no Visual Studio, confira Recursos do editor de
código. Confira também Estrutura de tópicos, que ajuda você a manter o foco em seções específicas do código.
Use também o Pesquisador de Objetos do Visual Studio (Exibir > Outras Janelas > Pesquisador de
Objetos ou Ctrl +W > J ) para inspecionar as classes Python definidas em cada módulo e as funções definidas
nessas classes.
IntelliSense
O IntelliSense fornece preenchimentos, ajuda da assinatura, informações rápidas e coloração de código. O Visual
Studio 2017 versão 15.7 e posteriores também dão suporte a dicas de tipo.
Para melhorar o desempenho, o IntelliSense no Visual Studio 2017 versão 15.5 e anteriores depende do banco de
dados de preenchimento que é gerado para cada ambiente do Python no projeto. Os bancos de dados podem
precisar de atualização se você adicionar, remover ou atualizar os pacotes. O status do banco de dados é
mostrado na janela Ambientes Python (um irmão do Solution Explorer) na guia IntelliSense (ver referência
de janelas ambientes).
O Visual Studio 2017 versão 15.6 e posterior usa um modo diferente para fornecer as conclusões de IntelliSense
que não são dependentes do banco de dados.
Preenchimentos
Preenchimentos aparecem como instruções, identificadores e outras palavras que podem ser inseridas
adequadamente na localização atual no editor. O que é mostrado na lista baseia-se no contexto e é filtrado para
omitir opções incorretas ou que desviam a atenção. As conclusões são frequentemente desencadeadas digitando
diferentes instruções import (como ) e operadores (incluindo um período), mas você pode fazê-las aparecer a
qualquer momento digitando Ctrl +J > Space .
Quando uma lista de preenchimento é aberta, é possível pesquisar o preenchimento que você deseja usando as
teclas de direção, o mouse ou continuando a digitação. Conforme você digita mais letras, a lista é filtrada ainda
mais para mostrar os prováveis preenchimentos. Você também pode usar atalhos, como:
Digitar letras que não estão no início do nome, como “parse” para encontrar “argparse”
Digitar apenas letras que estão no início de palavras, como “abc” para encontrar “AbstractBaseClass” ou “air”
para encontrar “as_integer_ratio”
Ignorar letras, como “b64” para encontrar “base64”
Alguns exemplos:
Os preenchimentos de membro aparecem automaticamente quando você digita um ponto final depois de uma
variável ou um valor, juntamente com os métodos e os atributos dos tipos possíveis. Se uma variável puder ser de
mais de um tipo, a lista incluirá todas as possibilidades de todos os tipos, com informações extras para indicar
quais tipos dão suporte a cada preenchimento. Quando um preenchimento tem o suporte de todos os tipos
possíveis, ele é mostrado sem anotação.
Por padrão, os membros “dunder” (membros que começam e terminam com um sublinhado duplo) não são
mostrados. Em geral, esses membros não devem ser acessados diretamente. Se você precisar de um, no entanto,
digitar o sublinhado duplo à esquerda adiciona esses preenchimentos à lista:
As instruções import e from ... import exibem uma lista de módulos que podem ser importados. Com
from ... import , a lista inclui os membros que podem ser importados do módulo especificado.
As instruções raise e except exibem listas de classes que provavelmente são tipos de erros. A lista pode não
incluir todas as exceções definidas pelo usuário, mas ajuda você a encontrar as exceções internas adequadas
rapidamente:
Digitar @ inicia um decorador e mostra os decoradores possíveis. Muitos desses itens não podem ser usados
como decoradores, verifique a documentação da biblioteca para determinar qual deles usar.
TIP
Você pode configurar o comportamento de conclusões através do Tools > Options > Text Editor > Python >
Advanced . Entre elas, a lista Filter com base na seqüência de pesquisa aplica a filtragem de sugestões de conclusão
conforme você digita (padrão é verificado) e a conclusão do membro exibe a interseção de membros mostra apenas
conclusões suportadas por todos os tipos possíveis (o padrão não é verificado). Consulte Opções – Resultados de
Conclusão.
Dicas de tipo
Visual Studio 2017 versão 15.7 e posterior.
As "dicas de tipo" no Python 3.5+ (PEP 484) (python.org) são uma sintaxe de anotação para funções e classes que
indicam os tipos de argumentos, valores de retorno e atributos de classe. O IntelliSense exibe dicas de tipo
quando você focaliza argumentos, variáveis e chamadas de função que contêm essas anotações.
No exemplo a seguir, a classe Vector é declarada como List[float] e a função scale contém dicas de tipo para
seus argumentos e o valor retornado. Passar o mouse sobre uma chamada da função mostra as dicas de tipo:
No exemplo a seguir, você pode ver como os atributos anotados da classe Employee aparecem no pop-up de
conclusão de IntelliSense para um atributo:
Também é útil validar as dicas de tipo em todo o seu projeto, pois erros normalmente não aparecerão até o
tempo de execução. Para isso, o Visual Studio integra a ferramenta MyPy padrão da indústria através do comando
de menu de contexto Python > Run Mypy in Solution Explorer :
A execução do comando solicitará que você instale o pacote do MyPy, se necessário. Em seguida, o Visual Studio
executará o MyPy para validar as dicas de tipo em todos os arquivos Python do projeto. Os erros aparecem na
janela Lista de Erros do Visual Studio. Selecionar um item na janela navega para a linha apropriada no seu
código.
Como um exemplo simples, a definição de função a seguir contém uma dica de tipo que indica que o argumento
input é do tipo str , enquanto a chamada para essa função tenta passar um número inteiro:
def commas_to_colons(input: str):
items = input.split(',')
items = [x.strip() for x in items]
return ':'.join(items)
commas_to_colons(1)
Usar o comando Execute Mypy neste código gera o seguinte erro:
TIP
Para as versões do Python anteriores à 3.5, o Visual Studio também exibe dicas de tipo fornecidas por meio de arquivos
stub do Typeshed (.pyi). Você pode usar arquivos stub sempre que não quiser incluir dicas de tipo diretamente no código,
ou quando quiser criar dicas de tipo para uma biblioteca que não as usa diretamente. Para obter mais informações, consulte
Criar stubs para módulos Python na wiki do projeto mypy.
No momento, o Visual Studio não dá suporte a dicas de tipo nos comentários.
TIP
Para as versões do Python anteriores à 3.5, o Visual Studio também exibe dicas de tipo fornecidas por meio de arquivos
stub do Typeshed (.pyi). Você pode usar arquivos stub sempre que não quiser incluir dicas de tipo diretamente no código,
ou quando quiser criar dicas de tipo para uma biblioteca que não as usa diretamente. Para obter mais informações, consulte
Criar stubs para módulos Python na wiki do projeto mypy.
O Visual Studio inclui um conjunto de pacotes de arquivos Typeshed para Python 2 e 3, para que os downloads adicionais
não sejam necessários. No entanto, se você quiser usar um conjunto diferente de arquivos, você pode especificar o caminho
nas opções de ser vidor > Python > de idioma pythonopções de ferramentas. > Confira Opções – Servidor de
linguagem.
No momento, o Visual Studio não dá suporte a dicas de tipo nos comentários.
Ajuda da assinatura
Ao escrever o código que chama uma função, a ajuda da assinatura é exibida quando você digita o ( de abertura
e exibe as informações de parâmetro e documentação disponíveis. Você também pode fazê-lo aparecer com
Ctrl +Shift +Space dentro de uma chamada de função. As informações exibidas dependem das cadeias de
caracteres de documentação no código-fonte da função, mas incluem os valores padrão.
TIP
Para desativar a ajuda de assinatura, vá para OEditor > de opções de > ferramentas > Python > General e limpe as
informações do parâmetro de conclusão > da declaração .
Informações rápidas
Focalizar o ponteiro do mouse em um identificador exibe uma dica de ferramenta Informações Rápidas.
Dependendo do identificador, as Informações Rápidas poderão exibir os possíveis valores ou tipos, toda a
documentação disponível, os tipos de retorno e os locais de definição:
Coloração de código
A coloração de código usa informações da análise de código para colorir variáveis, instruções e outras partes do
código. Por exemplo, as variáveis que se referem a módulos ou classes podem ser exibidas em uma cor diferente
da de funções ou outros valores e os nomes de parâmetro são exibidos em uma cor diferente da que variáveis
locais ou globais. (Por padrão, as funções não são exibidas em negrito):
Para personalizar as cores, vá para Fontes e Coresdo Ambiente > de Opções > de Ferramentas > e
modifique asentradas Python na lista de itens de exibição:
TIP
Para desativar a coloração de código, vá para OEditor > de Opções de > Ferramentas > Python > Avançado e limpe
nomes de cores de opções > diversascom base no tipo . Ver Opções - Opções diversas.
Snippets de código
Snippets de código são fragmentos de código que podem ser inseridos nos arquivos digitando um atalho e
pressionando Tab ou usando os comandos Editar > IntelliSense > Inserir Snippet de Código e Envolver
Com , selecionando Python e, em seguida, selecionando o snippet desejado.
Por exemplo, class é um atalho para um snippet de código que insere uma definição de classe. Você vê o
snippet aparecer na lista de conclusão automática ao digitar class :
Pressionar Tab gera o resto da classe. Em seguida, digite a lista de nomes e bases, movendo-se entre os campos
destacados com Tab e pressione Enter para começar a digitar o corpo.
Comandos de menu
Quando você usa o comando Editar > o menu Editarintesteja > código snippet, primeiro selecione Python e
selecione um trecho:
O comando Editar > IntelliSense > SurroundCom o comando, da mesma forma, coloca a seleção atual no
editor de texto dentro de um elemento estrutural escolhido. Por exemplo, suponha que você tivesse um trecho de
código semelhante ao seguinte:
sum = 0
for x in range(1, 100):
sum = sum + x
Selecionar esse código e escolher o comando Envolver com exibe uma lista de snippets de código disponíveis. A
escolha de def na lista coloca o código selecionado em uma definição de função, e você pode usar a tecla Tab
para navegar entre os argumentos e o nome de função realçados:
Examinar snippets disponíveis

Veja os snippets de código disponíveis no Gerenciador de Snippets de Código , abertos usando o comando
de menu Ferramentas > Gerenciador de Snippets de Código e selecionando Python como a linguagem:
Para criar seus próprios snippets de código, confira Passo a passo: Criar um snippet de código.
Se você escrever um ótimo snippet de código que gostaria de compartilhar, fique à vontade para postá-lo em
linhas gerais e contar para nós. Talvez possamos incluí-lo em uma versão futura do Visual Studio.
Navegar pelo seu código
O suporte ao Python no Visual Studio fornece vários meios para navegar rapidamente dentro do seu código,
incluindo bibliotecas para as quais o código-fonte está disponível: a barra de navegação, Vá para definição,
navegue para e encontre todas as referências. Você também pode usar o Visual Studio Object Browser .
Barra de navegação
A barra de navegação é exibida na parte superior de cada janela do editor e inclui uma lista de dois níveis de
definições. A lista suspensa à esquerda contém definições de nível superior de classe e função no arquivo atual; a
lista suspensa à direita exibe uma lista de definições dentro do escopo mostrado à esquerda. Conforme você usa
o editor, as listas são atualizadas para mostrar o contexto atual e você também pode selecionar uma entrada
dessas listas para ir diretamente para ela.
TIP
Para ocultar a barra de navegação, vá para OEditor > de opções de > ferramentas > Python > General e limpe a
barrade navegação de configurações > .
Ir para definição
O comando Ir Para Definição vai rapidamente do uso de um identificador (como um nome de função, classe ou
variável) para o código-fonte em que ele está definido. Você o invoca clicando com o botão direito do mouse em
um identificador e selecionando Ir para definição ou, colocando o caret no identificador e pressionando F12 .
Ele funciona em todo o código e nas bibliotecas externas, desde que o código-fonte esteja disponível. Se o
código-fonte da biblioteca não estiver disponível, o comando Ir para definição irá para a instrução import
relevante de uma referência de módulo ou exibirá um erro.
Navegar para
O comando Editar > navegar para (Ctrl +,) exibe uma caixa de pesquisa no editor onde você pode digitar
qualquer string e ver possíveis correspondências em seu código que define uma função, classe ou variável que
contenha essa seqüência. Esse recurso fornece uma funcionalidade semelhante a Ir Para Definição , mas sem a
necessidade de localizar um uso de um identificador.
Clicar duas vezes em qualquer nome, ou selecionar com teclas de seta e Enter, navega para a definição desse
identificador.
Localizar Todas as Referências

O comando Localizar Todas as Referências é uma maneira útil de descobrir o local em que um identificador
específico é definido e usado, incluindo importações e atribuições. Você o invoca clicando com o botão direito do
mouse em um identificador e selecionando Encontrar todas as referências, ou colocando o caret no
identificador e pressionando Shift +F12 . Clicar duas vezes em um item da lista navegará para sua localização.
Confira também
Formatação
Refatoração
Usar um linter
Formatar o código do Python
O Visual Studio permite que você reformate rapidamente o código para que ele corresponda às opções de
formatação pré-configuradas.
Para formatar uma seleção: selecione Editar > seleção de formato avançado > ou pressione Ctrl +E > F .
Para formatar todo o arquivo: selecione Editar > documento de formato avançado > ou pressione
Ctrl +E > D .
As opções são definidas através do Editor deopções de > Text Editor > ferramentas > Python > Formatação
e suas guias aninhadas. Você precisa selecionar Mostrar todas as configurações para essas opções serem
exibidas:
As opções de formatação por padrão são definidas para corresponder a um subconjunto do guia de estilo PEP 8. A
guia Geral determina quando a formatação é aplicada, as configurações para as outras três guias são descritas
neste artigo.
O suporte do Python no Visual Studio também adiciona o comando útil Preencher Parágrafo de Comentário
ao menu Editar > Avançado , conforme descrito em uma seção posterior.
Espaçamento
O espaçamento controla o local em que espaços são inseridos ou removidos em vários constructos de
linguagem. Cada opção tem três valores possíveis:
Marcado: garante que o espaçamento é aplicado.
Desmarcado: remove o espaçamento.
Indeterminado: deixa a formatação original em vigor.
Exemplos para as várias opções são fornecidos nas tabelas a seguir:
O P Ç Ã O DE DEF IN IÇ Õ ES DE C L A SSE VERIF IC A DO DESM A RC A DA
Inserir espaço entre o nome de class X (object): pass class X(object): pass
uma declaração da classe e a lista
de bases
Inserir espaço dentro dos class X( object ): pass class X(object): pass
parênteses da lista de bases
Inserir espaço dentro dos class X( ): pass class X(): pass

parênteses da lista de bases vazia
O P Ç Ã O DE DEF IN IÇ Õ ES DE F UN Ç Ã O VERIF IC A DO DESM A RC A DA
Inserir espaço entre o nome de def X (): pass def X(): pass
uma declaração da função e a lista
de parâmetros
Inserir espaço dentro dos def X( a, b ): pass def X(a, b): pass
parênteses da lista de parâmetros
Inserir espaço dentro dos def X( ): pass def X(): pass

parênteses da lista de parâmetros
vazia
Inserir espaços em torno de “=” includes X(a = 42): pass includes X(a=42): pass
em valores de parâmetro padrão
Inserir espaço antes e depois de includes X() -> 42: pass includes X()->42: pass
operadores de anotação de
retorno
O P Ç Ã O O P ERA DO RES VERIF IC A DO DESM A RC A DA
Inserir espaços em torno de a + b a+b

operadores binários
Inserir espaços em torno de a = b a=b

atribuições
O P Ç Ã O DE ESPA Ç A M EN TO DE
EXP RESSÃ O VERIF IC A DO DESM A RC A DA
Inserir espaço entre o nome de X () X()

uma chamada de função e a lista
de argumentos
Inserir espaço dentro dos X( ) X()

parênteses da lista de argumentos
vazia
O P Ç Ã O DE ESPA Ç A M EN TO DE
EXP RESSÃ O VERIF IC A DO DESM A RC A DA
Inserir espaço dentro dos X( a, b ) X(a, b)

parênteses da lista de argumentos
Inserir espaço dentro dos ( a ) (a)

parênteses da expressão
Inserir espaço dentro dos ( ) ()

parênteses da tupla vazia
Inserir espaço dentro dos ( a, b ) (a, b)

parênteses da tupla
Inserir espaço dentro de colchetes [ ] []

vazios
Inserir espaços dentro dos [ a, b ] [a, b]

colchetes das listas
Inserir espaço antes do colchete x [i] x[i]

de aber tura
Inserir espaços dentro de x[ i ] x[i]

colchetes
Instruções
As opções de Instruções controlam a reescrita automática de várias instruções em formatos mais apropriados
para o Python.
OPÇ ÃO A N T ES DA F O RM ATA Ç Ã O A P Ó S A F O RM ATA Ç Ã O
Colocar os módulos impor tados import sys, pickle import sys

em uma nova linha import pickle
Remover pontos-e-vírgulas x = 42; x = 42

desnecessários
Colocar várias instruções em x = 42; y = 100 x = 42

novas linhas y = 100
Disposição
O Encapsulamento permite que você defina a Largura máxima do comentário (o padrão é 80). Se a opção
Encapsular comentários que são muito largos for definida, o Visual Studio reformatará os comentários para
não excederem essa largura máxima.
# 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 Preencher Parágrafo de Comentário

Editar > Parágrafo de comentário de preenchimento avançado > (Ctrl +E > P) reflui e formata texto de
comentário, combinando linhas curtas e quebrando longas.
Por exemplo:
# foo
# bar
# baz
é alterado para:
# 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
é alterado para:
# This is a very long long long long long long long long long long long long
# long long long long long long long comment
Refatorar o código do Python
O Visual Studio fornece vários comandos para transformar e limpar o código-fonte do Python automaticamente:
Renomear renomeia uma classe, um método ou um nome de variável selecionado
Extrair método cria um novo método do código selecionado
Adicionar importação fornece uma marcação inteligente para adicionar uma importação ausente
Remover importações não utilizadas remove importações não utilizadas
Renomear
1. Clique com o botão direito do mouse no identificador que você deseja renomear e escolha Renomear ou
coloque o cursor no identificador e escolha o comando de menu Editar > Refatorar > Renomear (F2 ).
2. Na caixa de diálogo Renomear exibida, insira o novo nome do identificador e selecione OK :
3. Na próxima caixa de diálogo, selecione os arquivos e as instâncias no código aos quais a renomeação será
aplicada; selecione uma instância individual para visualizar a alteração específica:
4. Selecione Aplicar para fazer as alterações nos arquivos de código-fonte. (Não é possível desfazer esta
ação.)
Extrair método
1. Selecione as linhas de código ou a expressão a ser extraída para um método separado.
2. Selecione o Edit > comando de menu Editar método de extração derefatoração > Extract method ou
digite Ctrl + R > M .
3. Na caixa de diálogo exibida, insira um novo nome de método, indique o local em que ele deverá ser
extraído e selecione as variáveis de fechamento. As variáveis não selecionadas para fechamento são
transformadas em argumentos de método:
4. Selecione OK e o código será modificado de acordo:
Adicionar importação
Ao colocar o cursor em um identificador que não tem informações de tipo, o Visual Studio fornece uma marcação
inteligente (o ícone de lâmpada à esquerda do código) cujos comandos adicionam a instrução import ou
from ... import necessária:
O Visual Studio oferece conclusões import para módulos e pacotes de nível superior no projeto atual e na
biblioteca padrão. O Visual Studio também oferece conclusões from ... import para submódulos e subpacotes,
bem como membros do módulo. As conclusões incluem funções, classes e dados exportados. A seleção de uma
dessas opções adiciona a instrução na parte superior do arquivo após outras importações ou em uma instrução
from ... import existente se o mesmo módulo já foi importado.
O Visual Studio tenta filtrar os membros que não estão realmente definidos em um módulo, como módulos que
são importados para outro, mas que não são filhos do módulo que está realizando a importação. Por exemplo,
muitos módulos usam import sys em vez de from xyz import sys , portanto você não vê a conclusão da
importação sys de outros módulos, mesmo se eles não tiverem um membro __all__ que exclui sys .
Da mesma forma, o Visual Studio filtra funções importadas de outros módulos ou do namespace interno. Por
exemplo, se um módulo importa a função settrace do módulo sys , em teoria, é possível importá-lo desse
módulo. Porém, é melhor usar import settrace from sys diretamente, assim, o Visual Studio oferecerá essa
instrução especificamente.
Por fim, se algo normalmente precisar ser excluído devido às regras acima, mas tiver outros valores que serão
incluídos (devido ao fato de o nome ter recebido um valor no módulo, por exemplo), o Visual Studio ainda
excluirá a importação. Esse comportamento pressupõe que o valor não deverá ser exportado, pois ele é definido
em outro módulo e, portanto, a atribuição adicional provavelmente será um valor fictício que também não é
exportado.
Remover importações não utilizadas

Ao escrever o código, é fácil acabar com instruções import para módulos que não estão sendo usados. Como o
Visual Studio analisa o código, ele pode determinar automaticamente se uma instrução import é necessária,
observando se o nome importado é usado dentro do escopo abaixo, no qual a instrução ocorre.
Clique com o botão direito do mouse em qualquer lugar do editor e selecione Remover Impor tações , que
oferece opções para remover de Todos os Escopos ou apenas do Escopo Atual :
Em seguida, o Visual Studio fará as alterações apropriadas no código:

Observe que o Visual Studio não leva em conta o fluxo de controle, o uso de um nome antes de uma instrução
import é tratado como se o nome fosse, na verdade, usado. O Visual Studio também ignora todas as
importações from __future__ , as importações que são executadas dentro de uma definição de classe, bem como
de instruções from ... import * .
Usar o PyLint para verificar o código do Python
O PyLint, uma ferramenta amplamente usada que verifica se há erros no código do Python e incentiva bons
padrões de codificação do Python, é integrado ao Visual Studio para projetos do Python.
Executar PyLint
Basta clicar com o botão direito do mouse em um projeto Python no Gerenciador de Soluções e escolher
Python > Executar PyLint :
Usando esses prompts de comando você instala o PyLint no ambiente ativo se ele ainda não estiver presente.
Os avisos e os erros do PyLint aparecem na janela de lista de erros :
Clicar duas vezes em um erro leva você diretamente para o código-fonte que gerou o problema.
TIP
Consulte a referência de recursos do PyLint para obter uma lista detalhada de todas as mensagens de saída do PyLint.
Configurar opções de linha de comando do PyLint

A seção opções de linha de comando da documentação do PyLint descreve como controlar o comportamento do
PyLint por meio de um arquivo de configuração .pylintrc. Um arquivo desse tipo pode ser colocado na raiz de um
projeto do Python no Visual Studio ou em outro lugar, dependendo da abrangência desejada da aplicação das
configurações (consulte a opções de linha de comando para ver mais detalhes).
Por exemplo, para suprimir os avisos “docstring ausente” mostrados na imagem anterior com um arquivo .pylintrc
em um projeto, execute as etapas:
1. Na linha de comando, navegue até a raiz do projeto (que contém o arquivo .pyproj) e execute o seguinte
comando para gerar um arquivo de configuração comentado:
pylint --generate-rcfile > .pylintrc
2. No Visual Studio Gerenciador de soluções, clique com o botão direito do mouse em seu projeto, selecione
Adicionar > Item existente , navegue até o novo arquivo . pylintrc , selecione-o e selecione Adicionar .
3. Abra o arquivo para edição, que contém várias configurações com as quais você pode trabalhar. Para
desabilitar um aviso, localize a seção [MESSAGES CONTROL] e, em seguida, localize a configuração disable
nessa seção. Há uma longa cadeia de mensagens específicas, à qual é possível acrescentar os avisos
desejados. Neste exemplo, acrescente ,missing-docstring (incluindo a vírgula delimitadora).
4. Salve o arquivo .pylintrc e execute o PyLint novamente para ver se agora os avisos estão suprimidos.
TIP
Para usar um arquivo .pylintrc de um compartilhamento de rede, crie uma variável de ambiente denominada PYLINTRC
com o valor do nome de arquivo no compartilhamento de rede usando um caminho UNC ou uma letra da unidade
mapeada. Por exemplo, PYLINTRC=\\myshare\python\.pylintrc .
Definir comandos personalizados para projetos do
Python
Enquanto você trabalha com os projetos Python, é provável que você precise alternar para uma janela Comando
para executar scripts ou módulos específicos, executar comandos do Pip ou executar outra ferramenta qualquer.
Para melhorar o fluxo de trabalho, você pode adicionar comandos personalizados ao submenu Python no menu
de contexto do projeto Python. Esses comandos podem ser executados em uma janela de console ou na janela
Saída do Visual Studio. Você também pode usar expressões regulares para instruir o Visual Studio como analisar
os erros e avisos da saída do comando.
Por padrão, esse menu contém apenas o único comando Executar PyLint :
Os comandos personalizados aparecem nesse mesmo menu de contexto. Os comandos personalizados são
adicionados diretamente a um arquivo de projeto, aplicando-se a esse projeto individual. Defina também
comandos personalizados em um arquivo .targets que pode ser importado com facilidade para vários arquivos de
projeto.
Alguns modelos de projeto do Python no Visual Studio já adicionam seus próprios comandos personalizados
usando arquivos .targets. Por exemplo, os modelos Projeto Bottle Web e Projeto Flask Web adicionam dois
comandos, Iniciar ser vidor e iniciar ser vidor de depuração . O modelo Projeto Django Web adiciona esses
mesmos comandos além de alguns outros:
Cada comando personalizado pode se referir a um arquivo Python, um módulo Python, um código Python
embutido, um executável qualquer ou um comando de pip. Você também pode especificar como e onde o
comando é executado.
TIP
Sempre que você fizer alterações em um arquivo de projeto em um editor de texto, será necessário recarregar o projeto no
Visual Studio para aplicar essas alterações. Por exemplo, você precisará recarregar o projeto depois de adicionar definições de
comando personalizadas para que esses comandos sejam exibidos no menu de contexto do projeto.
Como você deve saber, o Visual Studio fornece um meio para editar o arquivo de projeto diretamente. Primeiro, clique com o
botão direito do mouse no arquivo de projeto e selecione descarregar projeto , clique com o botão direito do mouse
novamente e selecione **Editar <project-name> ** para abrir o projeto no editor do Visual Studio. Em seguida, faça edições e
salve-as, clique com botão direito do mouse no projeto mais uma vez e selecione Recarregar projeto , que também solicita
que você confirme o fechamento do arquivo de projeto no editor.
No entanto, ao desenvolver um comando personalizado, pode ser entendiante realizar todos esses cliques. Para obter um
fluxo de trabalho mais eficiente, carregue o projeto no Visual Studio e abra também o arquivo .pyproj em um editor
completamente separado (como outra instância do Visual Studio, o Visual Studio Code, o Bloco de notas, etc.). Quando você
salva as alterações no editor e alterna para o Visual Studio, o Visual Studio detecta alterações e pergunta se o projeto deve
ser recarregado (o projeto foi <name> modificado fora do ambiente ). Selecione Recarregar e as alterações serão
aplicadas imediatamente em apenas uma etapa.
Passo a passo: Adicionar um comando a um arquivo de projeto

Para se familiarizar com comandos personalizados, esta seção apresenta um exemplo simples que executa
diretamente um arquivo de inicialização do projeto usando python.exe. (Esse comando é efetivamente o mesmo
que usar debug > Iniciar sem depuração .)
1. Crie um projeto chamado "Python-CustomCommands" usando o modelo Aplicativo do Python . (Confira
Início rápido: criar um projeto do Python com base em um modelo no Visual Studio para obter instruções, se
você ainda não estiver familiarizado com o processo.)
2. Em Python_CustomCommands.py, adicione o código print("Hello custom commands") .
3. Clique com botão direito do mouse no projeto em Gerenciador de Soluções , selecione Python e observe
que o único comando que aparece no submenu é Executar PyLint . Seus comandos personalizados
aparecem neste mesmo submenu.
4. Conforme sugerido na introdução, abra Python-CustomCommands.pyproj em um editor de texto separado.
Em seguida, adicione as seguintes linhas ao final do arquivo, dentro do </Project> de fechamento e salve o
arquivo.
<PropertyGroup>
<PythonCommands>
$(PythonCommands);
</PythonCommands>
</PropertyGroup>
5. Retorne ao Visual Studio e selecione Recarregar quando ele perguntar sobre a alteração no arquivo. Em
seguida, verifique o menu do Python novamente para ver se Executar PyLint ainda é o único item
mostrado, porque as linhas que você adicionou somente replicam o grupo de propriedades padrão do
<PythonCommands> que contém o comando PyLint.
6. Alterne para o editor com o arquivo de projeto e adicione a seguinte definição de <Target> após o
<PropertyGroup> . Conforme será explicado mais adiante neste artigo, este elemento Target define um
comando personalizado para executar o arquivo de inicialização (identificado pela propriedade "StartupFile")
usando python.exe em uma janela de console. O atributo ExecuteIn="consolepause" usa um console que
espera até que você pressione uma tecla antes de ser fechado.
<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. Adicione o valor do atributo Name do destino ao grupo de propriedades <PythonCommands> adicionado

anteriormente, para que o elemento fique semelhante ao do código abaixo. Adicionar o nome do destino
nessa lista é o que o adiciona ao menu Python .
<PythonCommands>
$(PythonCommands);
Example_RunStartupFile
</PythonCommands>
Se você quiser que o comando apareça antes daqueles que já estão definidos em $(PythonCommands) ,
coloque-os antes desse token.
8. Salve o arquivo de projeto, alterne para o Visual Studio e recarregue o projeto quando solicitado. Em
seguida, clique com o botão direito do mouse no projeto Python-CustomCommands e selecione Python .
Um item Executar arquivo de inicialização deverá ser exibido no menu. Se o item de menu não for
exibido, verifique se você adicionou o nome ao elemento <PythonCommands> . Confira também a Solução de
problemas posteriormente neste artigo.
9. Selecione o comando Executar arquivo de inicialização e uma janela Comando deverá ser exibida com o
texto Olá, comandos personalizados seguida de Pressione qualquer tecla para continuar . Pressione
uma tecla para fechar a janela.
10. Retorne ao editor com o arquivo de projeto e altere o valor do atributo ExecuteIn para output . Salve o
arquivo, alterne para o Visual Studio, recarregue o projeto e invoque o comando novamente. Neste
momento, você verá que a saída do programa aparece na janela Saída do Visual Studio:
11. Para adicionar mais comandos, defina um elemento <Target> adequado para cada comando, adicione o
nome do destino no grupo de propriedades <PythonCommands> e recarregue o projeto no Visual Studio.
TIP
Se você invocar um comando que use propriedades do projeto, como ($StartupFile) , e o comando falhar porque o token
está indefinido, o Visual Studio desabilitará o comando até que você recarregue o projeto. No entanto, fazer alterações no
projeto que definem a propriedade não atualiza o estado desses comandos, portanto, você ainda precisa recarregar o projeto
nesses casos.
Estrutura de destino do comando

O formato geral do elemento <Target> é mostrado no pseudocódigo a seguir:
<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 referenciar propriedades do projeto ou variáveis de ambiente em valores de atributo, use o nome dentro de
um token $() , como $(StartupFile) e $(MSBuildProjectDirectory) . Para obter mais informações, confira
Propriedades do MSBuild.
Atributos de destino
AT RIB UTO O B RIGATÓ RIO DESC RIÇ Ã O
Name Sim O identificador do comando dentro do

projeto do Visual Studio. Esse nome
deve ser adicionado ao grupo de
propriedades <PythonCommands> para
que o comando seja exibido no
submenu Python.
Rotular Sim O nome de exibição da interface do

usuário que é exibido no submenu
Python.
Retornos Sim Deve conter @(Commands) , que

identifica o destino como um comando.
Atributos de CreatePythonCommandItem
Todos os valores de atributo não diferenciam maiúsculas de minúsculas.

TargetType Sim Especifica o que atributo de destino

contém e como ele é usado junto com o
atributo de argumentos:
executable : executar o
executável nomeado em Target,
acrescentando o valor em
Arguments, como se fosse
inserido diretamente na linha de
comando. O valor deve conter
apenas um nome de programa
sem argumentos.
script : execute python.exe com
o nome de arquivo em Target,
seguido pelo valor em
Arguments.
module : executar python -m
seguido pelo nome do módulo
em Target, seguido pelo valor
em Arguments.
code : executar o código
embutido contido em Target. O
valor de Arguments é ignorado.
pip : executar pip com o
comando em Target, seguido por
Arguments; é ExecuteIn é
definido como "output", no
entanto, o pip assume o
comando install e usa o
Target como o nome do pacote.
Destino Sim O nome de arquivo, o nome do

módulo, o código ou comando pip a ser
usado, dependendo do TargetType.
Argumentos Opcional Especifica uma cadeia de caracteres de

argumentos (se houver) a ser fornecida
ao destino. Observe que, quando o
TargetType é script , os argumentos
são fornecidos para o programa Python,
não para python.exe. Ignorado para o
TargetType code .
ExecuteIn Sim Especifica o ambiente no qual o

comando deve ser executado:
console : (padrão) executa o
Target e os argumentos como se
eles fossem inseridos
diretamente na linha de
comando. Uma janela de
comando aparece quando o
Target está em execução, em
seguida, ela é fechada
automaticamente.
consolepause : o mesmo que
um console, mas aguarda um
pressionamento de tecla antes
de fechar a janela.
output : executa o Target e exibe
seus resultados na janela de
Saída do Visual Studio. Se o
TargetType for "pip", o Visual
Studio usará o Target como o
nome do pacote e acrescentará
Arguments.
repl: executa o Target na janela
Interativa do Python; o nome de
exibição opcional é usado para o
título da janela.
none : comporta-se como o
console.
WorkingDirectory Opcional A pasta na qual o comando deve ser

executado.
ErrorRegex Opcional Usado somente quando ExecuteIn é

WarningRegEx output . Ambos os valores especificam
uma expressão regular com a qual o
Visual Studio analisa a saída do
comando para mostrar erros e avisos na
janela Lista de Erros . Se não for
especificado, o comando não afetará a
janela Lista de Erros . Para obter mais
informações sobre o que o Visual Studio
espera, confira Grupos de captura
nomeados.
RequiredPackages Opcional Uma lista dos requisitos de pacote para

o comando usando o mesmo formato
de requirements.txt (pip.readthedocs.io).
O comando Executar PyLint , por
exemplo, especifica pylint>=1.0.0 .
Antes de executar o comando, o Visual
Studio verifica se todos os pacotes na
lista estão instalados. O Visual Studio
usa o pip para instalar todos os pacotes
ausentes.
Ambiente Opcional Uma cadeia de caracteres de variáveis

de ambiente a ser definida antes da
execução do comando. Cada variável
usa o formulário <NAME> = <VALUE>
com várias variáveis separadas por
ponto e vírgula. Uma variável com
vários valores precisa estar entre aspas
simples ou duplas, como
'NAME=VALUE1;VALUE2'.
Grupos de captura nomeados para expressões regulares

Durante a análise de erros e avisos de uma saída de comando, o Visual Studio espera que as expressões regulares
nos valores ErrorRegex e WarningRegex usem os seguintes grupos nomeados:
(?<message>...) : texto do erro
(?<code>...) : código do erro
(?<filename>...) : nome do arquivo para o qual o erro foi relatado
(?<line>...) : número de linha do local no arquivo em que o erro foi relatado.
(?<column>...) : número da coluna do local no arquivo em que o erro foi relatado.
Por exemplo, PyLint gera avisos da seguinte forma:
************* Module hello

C: 1, 0: Missing module docstring (missing-docstring)
Para permitir que o Visual Studio extraia as informações corretas desses avisos e mostre-as na janela Lista de
Erros , o valor de WarningRegex para o comando Executar Pylint deve ser o seguinte:
^(?<filename>.+?)$(?<line>\d+),(?<column>\d+)$: warning (?<msg_id>.+?): (?<message>.+?)$]]
(Observe que msg_id no valor deve ser realmente code , confira o Problema 3680.)
Criar um arquivo .targets com comandos personalizados

A definição de comandos personalizados em um arquivo de projeto disponibiliza esses comandos apenas para esse
arquivo de projeto. Para usar os comandos em vários arquivos de projeto, defina o grupo de propriedades
<PythonCommands> e todos os elementos <Target> em um arquivo .targets. Em seguida, importe esse arquivo nos
arquivos de projeto individuais.
O arquivo .targets é formatado da seguinte maneira:
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<PythonCommands>
$(PythonCommands);

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


</Target>


</Project>
Para carregar um arquivo .targets em um projeto, coloque um elemento <Import Project="(path)"> em qualquer
lugar dentro do elemento <Project> . Por exemplo, se você tiver um arquivo chamado CustomCommands.targets
em uma subpasta targets no projeto, use o seguinte código:
<Import Project="targets/CustomCommands.targets"/>
NOTE
Sempre que você alterar o arquivo .targets, precisará recarregar a solução que contém o projeto, não recarregar apenas o
projeto.
Comandos de exemplo
Executar PyLint (destino do módulo )
O seguinte código é exibido no arquivo 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>
Executar a instalação de pip com um pacote específico (destino de pip)

O comando a seguir executa pip install my-package na janela de Saída . Você pode usar esse comando ao
desenvolver um pacote e testar sua instalação. Observe que Target contém o nome do pacote em vez do comando
install , que é considerado ao 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 pacotes de pip desatualizados (destino de 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>
Executar um executável com consolepause

O comando a seguir simplesmente executa where para mostrar os arquivos Python sendo iniciados na pasta do
projeto:
<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 para executar o servidor e executar o servidor de depuração

Para explorar como os comandos Iniciar ser vidor e Iniciar ser vidor de depuração para projetos Web são
definidos, examine o Microsoft.PythonTools.Web.targets (GitHub).
Instalar o pacote para desenvolvimento
<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 com a permissão.

Gerar o Windows Installer
<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>

Gerar pacote 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>
Mensagem: "Não foi possível carregar o arquivo de projeto"
Indica que há erros de sintaxe no arquivo de projeto. A mensagem inclui o erro específico com um número de linha
e a posição do caractere.
A janela do console é fechada imediatamente após a execução do comando
Use ExecuteIn="consolepause" em vez de ExecuteIn="console" .
O comando não aparece no menu
Verifique se o comando está incluído no grupo de propriedades <PythonCommands> e se o nome na lista de
comandos corresponde ao nome especificado no elemento <Target> .
Por exemplo, nos elementos a seguir, o nome "Example" no grupo de propriedades não corresponde ao nome
"ExampleCommand" no destino. O Visual Studio não encontra um comando chamado "Example", portanto, não
aparece nenhum comando. Use "ExampleCommand" na lista de comandos ou altere o nome do destino para
apenas "Example".
<PropertyGroup>
<PythonCommands>$(PythonCommands);Example</PythonCommands>
</PropertyGroup>
<Target Name="ExampleCommand" Label="Example Command" Returns="@(Commands)">

</Target>
Mensagem: "ocorreu um erro durante a execução <command name> . Falha ao obter comando <target-name>
do projeto. "
Indica que o conteúdo dos elementos <Target> ou <CreatePythonCommandItem> estão incorretos. Os motivos
possíveis incluem:
O atributo Targetobrigatório está vazio.
O atributo TargetType obrigatório está vazio ou contém um valor não reconhecido.
O atributo ExecuteIn obrigatório está vazio ou contém um valor não reconhecido.
ErrorRegex ou WarningRegex está especificado sem a configuração de ExecuteIn="output" .
Atributos não reconhecidos existem no elemento. Por exemplo, você pode ter usado Argumnets (escrito de
forma incorreta) em vez de Arguments .
Os valores de atributo poderão ficar vazios se você fizer referência a uma propriedade que não esteja definida. Por
exemplo, se você usar o token $(StartupFile) , mas nenhum arquivo de inicialização tiver sido definido no projeto,
o token será resolvido como uma cadeia de caracteres vazia. Nesses casos, é interessante definir um valor padrão.
Por exemplo, os comandos Executar ser vidor e Executar ser vidor de depuração definidos nos modelos de
projeto do Bottle, do Flask e do Django usarão como padrão manage.py se você não especificar um arquivo de
inicialização do servidor nas propriedades do projeto.
O Visual Studio trava e falha ao executar o comando
Provavelmente você está tentando executar um comando do console com ExecuteIn="output" e, nesse caso, o
Visual Studio pode falhar ao tentar analisar a saída. Use ExecuteIn="console" em vez disso. (Confira o Problema
3682.)
O comando executável "não é reconhecido como um comando interno ou externo, programa operável ou
arquivo em lotes"
Ao usar TargetType="executable" , o valor em Target precisa ser somente o nome do programa sem argumentos,
como somente python ou python.exe. Mover argumentos para o atributo Arguments .
Trabalhar com a janela Interativa do Python
O Visual Studio fornece uma janela interativa REPL (leitura-avaliação-impressão-loop) para cada um dos
ambientes do Python, que é uma melhoria do REPL obtido com python.exe na linha de comando. A janela
Interativa (aberta com os comandos de menu Exibir > Outras Janelas Interativas > <do ambiente> )
permite que você insira o código Python arbitrário e veja resultados imediatos. Esse modo de codificação ajuda
a você aprender e experimentar com APIs e bibliotecas e a desenvolver de forma interativa o código funcional
para incluir em seus projetos.
O Visual Studio tem diversos modos REPL do Python à sua disposição:
REP L DESC RIÇ Ã O EDIÇ Ã O DEP URA Ç Ã O IM A GEN S
Standard REPL padrão, que se Edição padrão (várias Sim, por meio de Não
comunica com o linhas etc.). $attach
Python diretamente
Depurar REPL padrão, que se Edição padrão Somente depuração Não

comunica com o
processo depurado
do Python
IPython O REPL se comunica Comandos do Não Sim, embutido no

com o back-end do IPython, REPL
IPython funcionalidades do
Pylab
IPython sem Pylab O REPL se comunica IPython padrão Não Sim, em uma janela
com o back-end do separada
IPython
Este artigo descreve os modos REPL Padrão e Depuração . Para obter detalhes sobre os modos do IPython,
confira Usar o REPL do IPython.
Para obter instruções detalhadas com exemplos, incluindo as interações com o editor, como Ctrl + Enter ,
consulte a etapa 3 do tutorial: usar a janela interativo repl.
Abrir uma janela Interativa

Há várias maneiras de abrir a janela Interativa de um ambiente.
Primeiro, alterne para a janela de ambientes do Python (exiba > outros > ambientes Python do Windows ou
Ctrl + K > Ctrl + ` ) e selecione o botão ou o comando Abrir janela interativa para um ambiente escolhido.
Em segundo lugar, perto da parte inferior do menu Exibir > outro Windows , há um comando de janela
interativa do Python para seu ambiente padrão, bem como um comando para alternar para a janela de
ambientes :
Terceiro, você pode abrir uma janela interativa no arquivo de inicialização em seu projeto, ou para um arquivo
autônomo, selecionando o comando debug > Execute <Project | File> in Python Interactive menu (Shift
+ ALT + F5 ):
Por fim, é possível marcar o código no arquivo e usar o comando Enviar código para Interativa descrito
abaixo.
Opções da janela interativa

Você pode controlar vários aspectos da janela Interativa por meio de Ferramentas > Opções > Python >
Janelas Interativas (confira Opções):
Usar a Janela Interativa
Quando a janela interativa estiver aberta, você poderá começar a inserir o código linha por linha no >>>
prompt. A janela interativa executa cada linha à medida que você a insere, o que inclui a importação de
módulos, a definição de variáveis e assim por diante:
A exceção é quando as linhas de código adicionais são necessárias para fazer uma instrução completa, como
quando uma instrução for termina em dois pontos como mostrado acima. Nesses casos, o prompt de linha
muda para ..., indicando que é necessário inserir linhas adicionais no bloco, conforme mostrado na quarta e
quinta linhas do gráfico acima. Ao pressionar Enter em uma linha em branco, a janela Interativa fecha o bloco
e o executa no interpretador.
TIP
A janela interativa aprimora a experiência de repl de linha de comando do Python usual, recuando automaticamente as
instruções que pertencem a um escopo ao redor. Seu histórico (recuperado com a seta para cima) também fornece itens
de várias linhas, enquanto o REPL de linha de comando fornece somente linhas individuais.
A janela Interativa também dá suporte a vários metacomandos. Todos os metacomandos começam com $ e
é possível digitar $help para obter uma lista dos metacomandos e $help <command> para obter detalhes de uso
de um comando específico.
M ETA C O M A N DO DESC RIÇ Ã O
$$ Insere um comentário, que é útil para comentar o código ao

longo da sessão.
$attach Anexa o depurador do Visual Studio ao processo da janela

REPL para habilitar a depuração.
$cls , $clear Limpa o conteúdo da janela do editor, deixando intactos o

histórico e o contexto de execução.
$help Exibe uma lista de comandos ou a ajuda sobre um comando

específico.
$load Carrega comandos do arquivo e os executa até a conclusão.
$mod Muda o escopo atual para o nome de módulo especificado.
$reset Redefine o ambiente de execução com o estado inicial, mas

mantém o histórico.
$wait Aguarda, pelo menos, o número especificado de

milissegundos.
Os comandos também são extensíveis pelas extensões do Visual Studio implementando e exportando
IInteractiveWindowCommand (exemplo).
Mudar escopos
Por padrão, a janelaInterativa de um projeto tem como escopo o arquivo de inicialização do projeto, como se
ele fosse executado no prompt de comando. Para um arquivo independente, ele tem esse arquivo como escopo.
No entanto, a qualquer momento durante a sessão de REPL, o menu suspenso na parte superior da janela
Interativa permite alterar o escopo:
Ao importar um módulo, como digitando import importlib , você verá opções na lista suspensa para mudar
para qualquer escopo nesse módulo. Uma mensagem na janela Interativa também indica o novo escopo,
portanto, é possível acompanhar como você chegou a um determinado estado durante sua sessão.
A inserção de dir() em um escopo exibe os identificadores válidos no escopo, incluindo nomes de função,
classes e variáveis. Por exemplo, o uso de import importlib seguido por dir() mostra o seguinte:
Comando Enviar para Interativa
Além de trabalhar na janela interativa diretamente, você pode selecionar o código no editor, clicar com o botão
direito do mouse e escolher Enviar para interativo ou pressionar Ctrl + Enter .
Esse comando é útil para o desenvolvimento de código iterativo ou evolucionário, incluindo o teste do código
durante o desenvolvimento. Por exemplo, depois de enviar um trecho de código para a janela interativa e ver
sua saída, você pode pressionar a seta para cima para mostrar o código novamente, modificá-lo e testá-lo
rapidamente pressionando Ctrl + Enter . (Pressionar Enter no final da entrada a executa, mas pressionar Enter
no meio da entrada insere uma nova linha.) Depois de ter o código desejado, você poderá copiá-lo facilmente
de volta para o arquivo de projeto.
TIP
Por padrão, o Visual Studio remove >>> e ... O REPL solicita ao colar o código da janela interativa no editor. Você pode
alterar esse comportamento na guia ferramentas > Opções > Editor de texto > doPython > avançado usando a
opção colar remove solicitações repl . Consulte Opções – opções diversas.
Trabalhar com células de código

As células de código podem ser usadas na análise de dados e são compatíveis com diversos editores de texto.
Por exemplo, ao usar um arquivo de código como um bloco de rascunho, geralmente você tem um pequeno
bloco de código que você deseja enviar de uma só vez. Para agrupar códigos, marque o código como uma
célula de código adicionando um comentário começando com #%% ao início da célula, que termina a anterior.
As células de código podem ser recolhidas e expandidas e o uso de Ctrl + Enter dentro de uma célula de
código envia a célula inteira para a janela interativa e move para a próxima.
O Visual Studio também detecta células de código começando com comentários como # In[1]: , que é o
formato que você obtém ao exportar um bloco de anotações do Jupyter como um arquivo do Python. Essa
detecção facilita a execução de um bloco de anotações do Azure notebooks baixando como um arquivo Python,
abrindo no Visual Studio e usando Ctrl + Enter para executar cada célula.
Comportamento do IntelliSense
A janela Interativa inclui o IntelliSense baseado nos objetos dinâmicos, ao contrário do editor de código, no
qual o IntelliSense é baseado apenas na análise de código-fonte. Essas sugestões estão mais corretas na janela
interativa , especialmente com código gerado dinamicamente. A desvantagem é que as funções com efeitos
colaterais (como mensagens de log) podem afetar sua experiência de desenvolvimento.
Se esse comportamento for um problema, altere as configurações em ferramentas > Opções > Python >
Interactive Windows no grupo modo de conclusão , conforme descrito em opções – opções interativas do
Windows.
Usar o IPython na janela Interativa
A janela Interativa do Visual Studio no modo do IPython é um ambiente avançado de desenvolvimento

interativo, porém amigável, que contém funcionalidades de Computação Paralela Interativa. Este artigo descreve
o uso do IPython na janela Interativa do Visual Studio, na qual todas as funcionalidades normais da janela
Interativa também estão disponíveis.
Para esse passo a passo, você deve ter o ambiente Anaconda instalado, que inclui o IPython e as bibliotecas
necessárias.
NOTE
O IronPython não dá suporte ao IPython, apesar do fato de ser possível selecioná-lo no formulário Opções Interativas .
Para obter mais informações, confira a solicitação de recurso.
1. Abra o Visual Studio, alterne para a janela Ambientes do Python (Exibir > Outras Janelas >
Ambientes do Python ) e selecione um ambiente do Anaconda.
2. Examine a guia Pacotes (Conda) (que pode ser exibida como pip ou Pacotes ) nesse ambiente para
verificar se ipython e matplotlib estão listados. Caso contrário, instale-os nessa localização. (Confira
Janelas dos Ambientes do Python – guia Pacotes.)
3. Selecione a guia visão geral e selecione usar o modo interativo do ipython . (No Visual Studio 2015,
selecione Configurar opções interativas para abrir a caixa de diálogo Opções e, em seguida, defina
modo interativo como ipython e selecione OK ).
4. Selecione Abrir janela interativa para exibir a janela interativa no modo ipython. Talvez seja necessário
redefinir a janela se você acabou de mudar para o modo interativo. Talvez também seja necessário
pressionar Enter se apenas um prompt >>> for exibido, para obter um prompt como Em [2] .
5. Insira o seguinte 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. Depois de inserir a última linha, você deverá ver um grafo embutido (que pode ser redimensionado
arrastando o canto inferior direito, se desejado).
7. Em vez de digitar o repl, você pode escrever código no editor, selecioná-lo, clicar com o botão direito do
mouse e selecionar o comando Enviar para interativo (ou pressionar Ctrl + Enter ). Tente colar o código
abaixo em um novo arquivo no editor, selecioná-lo com Ctrl + a e, em seguida, enviar para a janela
interativa . (O visual Studio envia o código como uma unidade para evitar a necessidade de gráficos
intermediários ou parciais. E se você não tiver um projeto Python aberto com um ambiente diferente
selecionado, o Visual Studio abrirá uma janela interativa para qualquer ambiente selecionado como
padrão na janela ambientes 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 os grafos fora da janela Interativa , execute o código em vez de usar o comando Depurar >
Iniciar sem Depuração .
O IPython tem muitos outros recursos úteis, como saída para o Shell do sistema, substituição de variáveis, saída
de captura, etc. Consulte a documentação do ipython para obter mais informações.
Consulte também
Para usar o Jupyter facilmente e sem instalação, experimente o serviço hospedado dos Notebooks do
Azure que permitem que você mantenha e compartilhe seus blocos de anotações com outras pessoas.
A Máquina Virtual de Ciência de Dados do Azure também é pré-configurada para executar Jupyter
notebooks, juntamente com uma ampla variedade de outras ferramentas de ciência de dados.
Depurar o código do Python
O Visual Studio fornece uma experiência de depuração abrangente para Python, incluindo anexar a processos
em execução, avaliar expressões na inspeção e janelas imediatas , inspecionar variáveis locais, pontos de
interrupção, instruções Step in/out/over, definir a próxima instrução e muito mais.
Veja também os seguintes artigos sobre depuração específicos ao cenário:
Depuração remota do Linux
Depuração de modo misto do Python/C++
Símbolos para a depuração de modo misto
TIP
O Python no Visual Studio dá suporte à depuração sem um projeto. Com um arquivo Python autônomo aberto, clique
com o botão direito do mouse no editor, selecione Iniciar com depuração e o Visual Studio iniciará o script com o
ambiente padrão global (consulte ambientes Python) e nenhum argumento. Mas daí em diante, você tem suporte
completo à depuração.
Para controlar o ambiente e os argumentos, crie um projeto para o código, que é facilmente feito com o modelo de
projeto de código Python existente .
Depuração básica
O fluxo de trabalho básico de depuração envolve a definição de pontos de interrupção, a execução do código
em etapas, a inspeção de valores e o tratamento de exceções, conforme descrito nas próximas seções.
Uma sessão de depuração começa com o comando depurar > Iniciar Depuração , o botão Iniciar na barra
de ferramentas ou a tecla F5 . Essas ações iniciam o arquivo de inicialização do projeto (mostrado em negrito
no Gerenciador de soluções ) com o ambiente ativo do projeto e quaisquer argumentos de linha de
comando ou caminhos de pesquisa que foram especificados nas Propriedades do projeto (consulte Opções
de depuração do projeto). O Visual Studio 2017 versão 15.6 e posterior alerta se você não tiver um arquivo de
inicialização definido; as versões anteriores podem abrir uma janela de saída com o interpretador do Python
em execução ou a janela de saída brevemente aparece e desaparece. De qualquer forma, clique com o botão
direito do mouse no arquivo apropriado e selecione Definir como Arquivo de Inicialização .
NOTE
O depurador sempre é iniciado com o ambiente ativo do Python para o projeto. Para alterar o ambiente, torne outro
ambiente ativo, conforme descrito em Selecionar um ambiente do Python para um projeto.
Pontos de interrupção
Os pontos de interrupção interrompem a execução de código em um ponto marcado, para que você possa
inspecionar o estado do programa. Defina pontos de interrupção clicando na margem esquerda do editor de
código ou clicando com o botão direito do mouse em uma linha de código e selecionando ponto de
interrupção > Inserir ponto de interrupção. Um ponto vermelho é exibido em cada linha com um ponto de
interrupção.
Clicar no ponto vermelho ou clicar com o botão direito do mouse na linha de código e selecionar ponto de
interrupção > excluir ponto de quebra remove o ponto de interrupção. Você também pode desabilitá-lo sem
removê-lo usando o comando de ponto de > interrupção Disable Breakpoint .
NOTE
Alguns pontos de interrupção no Python podem ser surpreendentes para desenvolvedores que trabalharam com outras
linguagens de programação. No Python, todo o arquivo é um código executável, para que o Python execute o arquivo
quando ele é carregado para processar as definições de classe ou de função de nível superior. Se um ponto de
interrupção tiver sido definido, você poderá descobrir que o depurador está interrompendo uma declaração de classe
parcialmente. Esse comportamento é correto, mesmo que às vezes seja surpreendente.
É possível personalizar as condições nas quais um ponto de interrupção é disparado, como a interrupção
somente quando uma variável é configurada para um determinado valor ou intervalo de valores. Para definir
condições, clique com o botão direito do mouse no ponto vermelho do ponto de interrupção, selecione
Condição e, em seguida, crie expressões usando o código do Python. Para obter detalhes completos sobre
esse recurso no Visual Studio, consulte condições de ponto de interrupção.
Ao configurar condições, também é possível definir Ação e criar uma mensagem a ser registrada na janela de
saída, opcionalmente, continuando a execução automaticamente. Registrar uma mensagem cria o que é
chamado de tracepoint sem adicionar código de log ao aplicativo diretamente:
Percorrer o código
Depois de interromper em um ponto de interrupção, você tem várias maneiras para executar o código em
etapas ou executar blocos de código antes de interromper novamente. Esses comandos estão disponíveis em
vários locais, incluindo a barra de ferramentas de depuração na parte superior, o menu Depuração , o menu de
contexto acionado ao clicar com o botão direito do mouse no editor de códigos e por meio de atalhos de
teclado (embora nem todos os comandos estejam em todos os locais):
REC URSO T EC L A S DESC RIÇ Ã O
Continuar F5 Executa o código até chegar ao

próximo ponto de interrupção.
Depuração Completa F11 Executa a próxima instrução e para. Se

a próxima instrução for uma chamada
a uma função, o depurador parará na
primeira linha da função que está
sendo chamada.
Depuração Parcial F10 Executa a próxima instrução, incluindo

fazer uma chamada a uma função
(executando todo o código) e aplicar
qualquer valor retornado. A depuração
parcial permite ignorar facilmente as
funções que não precisam ser
depuradas.
Sair Shift + F11 Executa o código até o final da função

atual e, em seguida, executa em
etapas até a instrução de chamada.
Esse comando é útil quando não é
necessário depurar o restante da
função atual.
Executar até o cursor Ctrl + F10 Executa o código até a localização do

cursor no editor. Esse comando
permite ignorar facilmente um
segmento de código que não precisa
ser depurado.
Definir Próxima Instrução Ctrl + Shift + F10 Altera o ponto de execução atual no
código para a localização atual do
cursor. Esse comando permite omitir a
execução de um segmento de código,
como nos casos em que você sabe
que o código tem uma falha ou
produz um efeito colateral indesejado.
Mostrar Próxima Instrução ALT + Núm * Retorna à próxima instrução a ser

executada. Esse comando é muito útil
se você está procurando em várias
partes do código e não se lembra em
qual parte o depurador foi
interrompido.
Inspecionar e modificar valores

Quando estiver parado no depurador, é possível inspecionar e modificar os valores das variáveis. Use também
a janela Inspeção para monitorar variáveis individuais, bem como expressões personalizadas. (Confira
Inspecionar variáveis para obter detalhes gerais.)
Para exibir um valor usando DataTips , basta passar o mouse sobre qualquer variável no editor. É possível clicar
no valor para alterá-lo:
A janela Automáticos (Depurar > Janelas > Automáticos ) contém variáveis e expressões que estão
próximas à instrução atual. Clique duas vezes na coluna de valor ou selecione e pressione F2 para editar o
valor:
A janela Locais (Depurar > Janelas > Locais ) exibe todas as variáveis que estão no escopo atual, que podem
ser editadas novamente:
Para obter mais informações sobre como usar Automáticos e Locais , confira Inspecionar variáveis nas janelas
Automáticos e Locais.
A janela Inspeção (Depurar > Janelas > Inspeção > Inspecionar 1-4 ) permite inserir expressões
arbitrárias do Python e exibir os resultados. As expressões são reavaliadas para cada etapa:
Para obter mais informações sobre como usar a janela Inspeção , confira Definir uma inspeção em variáveis
usando as janelas Inspeção e QuickWatch.
Ao inspecionar um valor de cadeia de caracteres ( str , unicode , bytes e bytearray são considerados cadeias
de caracteres para essa finalidade), um ícone de lupa é exibido no lado direito do valor. Se você clicar no ícone,
o valor de cadeia de caracteres sem aspas será exibido em uma caixa de diálogo pop-up, com encapsulamento
e rolagem, o que é útil para cadeias de caracteres longas. Além disso, selecionar a seta suspensa no ícone
permite que você selecione visualizações de texto sem formatação, HTML, XML e JSON:
As visualizações de HTML, XML e JSON são exibidas em janelas pop-up separadas com modos de exibição de
árvore e realce de sintaxe.
Exceções
Se ocorrer um erro no programa durante a depuração, mas você não tiver um manipulador de exceção para
ele, o depurador interromperá no ponto da exceção:
Neste ponto, é possível inspecionar o estado do programa, incluindo a pilha de chamadas. No entanto, se você
tentar executar o código em etapas, a exceção continuará sendo gerada até que ela seja tratada ou o programa
seja encerrado.
O Debug > comando de menu Depurar configurações de exceção doWindows > exibe uma janela na qual
você pode expandiras exceções do Python :
A caixa de seleção de cada exceção controla se o depurador sempre interrompe quando é acionado. Marque
essa caixa quando desejar interromper com mais frequência para uma exceção específica.
Por padrão, a maioria das exceções interromperá quando um manipulador de exceção não puder ser
encontrado no código-fonte. Para alterar esse comportamento, clique com o botão direito do mouse em
qualquer exceção e modifique a opção Continuar Quando Não For Tratada no Código do Usuário .
Desmarque essa caixa quando desejar interromper com menos frequência para uma exceção.
Para configurar uma exceção que não aparece nessa lista, clique no botão Adicionar para adicioná-la. O nome
deve corresponder ao nome completo da exceção.
Opções de depuração de projeto

Por padrão, o depurador inicia o programa com o inicializador padrão do Python, sem argumentos de linha de
comando e sem nenhum outro caminho ou condição especial. As opções de inicialização são alteradas por
meio das propriedades de depuração do projeto acessadas clicando com o botão direito do mouse em seu
projeto no Gerenciador de soluções , selecionando Propriedades e selecionando a guia depurar .
Opções de modo de inicialização

Inicializador padrão do Python Usa o código de depuração escrito no Python portátil que é
compatível com o CPython, IronPython e variantes como o
Stackless Python. Fornece a melhor experiência de
depuração de código puro do Python. Quando você o anexa
a um processo python.exe em execução, esse inicializador é
usado. Esse iniciador também fornece a depuração de modo
misto para o CPython, permitindo a execução em etapas
direta entre o código do C/C++ e o código do Python.
Inicializador da Web Inicia o navegador padrão na inicialização e habilita a

depuração de modelos. Consulte a seção Depuração de
modelos da Web para obter mais informações.
Inicializador da Web do Django Idêntico ao inicializador da Web e mostrado apenas para

compatibilidade com versões anteriores.
Inicializador do IronPython (.NET) Usa o depurador do .NET, que funciona somente com o
IronPython, mas que permite a execução em etapas entre
qualquer projeto de linguagem .NET, incluindo C# e VB. Esse
inicializador é usado se você se anexa a um processo em
execução do .NET que hospeda o IronPython.
Opções de execução (caminhos de pesquisa, argumentos de inicialização e variáveis de ambiente )

Caminhos de pesquisa Esses valores correspondem ao que é mostrado no nó de

caminhos de pesquisa do projeto no Gerenciador de
soluções . Você pode modificar esse valor aqui, mas é mais
fácil usar Gerenciador de soluções que permite procurar
pastas e converte automaticamente os caminhos para o
formulário relativo.
Argumentos de script Esses argumentos são adicionados ao comando usado para

iniciar o script, aparecendo após o nome de arquivo do
script. O primeiro item aqui está disponível para o script
como sys.argv[1] , o segundo como sys.argv[2] e
assim por diante.
Argumentos do interpretador Esses argumentos são adicionados à linha de comando do

inicializador antes do nome do script. Os argumentos
comuns aqui são -W ... para controlar avisos, -O para
otimizar o programa ligeiramente e -u para usar o E/S não
armazenado em buffer. Provavelmente, os usuários do
IronPython usarão esse campo para passar opções -X ,
como -X:Frames ou -X:MTA .
Caminho do intérprete Substitui o caminho associado ao ambiente atual. O valor

pode ser útil para iniciar o script com um interpretador não
padrão.
Variáveis de ambiente Nessa caixa de texto de várias linhas, adicione entradas do

formulário <NAME> = <VALUE> . Como essa configuração
é aplicada por último, na parte superior de qualquer variável
de ambiente global existente e, após PYTHONPATH ser
definida de acordo com a configuração de caminhos de
pesquisa , ela pode ser usada para substituir manualmente
qualquer uma dessas outras variáveis.
Janelas imediatas e interativas

Há duas janelas interativas que você pode usar durante uma sessão de depuração: a janela imediata do Visual
Studio padrão e a janela interativa de depuração do Python .
A janela Imediata (Depurar > Janelas > Imediata ) é usada para avaliação rápida de expressões do Python e
para inspeção ou atribuição de variáveis no programa em execução. Consulte o artigo da janela geral imediata
para obter detalhes.
A janela Interativa de Depuração do Python (Depurar > Janelas > Interativa de Depuração do
Python ) é mais avançada, pois disponibiliza toda a experiência de REPL Interativo durante a depuração,
incluindo a escrita e a execução de código. Ele se conecta automaticamente a qualquer processo iniciado no
depurador usando o iniciador do Python padrão (incluindo os Debug processos anexados por meio de >
anexação de depuração ao processo ). No entanto, ela não está disponível ao usar a depuração de modo
misto do C/C++.
A janela interativa de depuração dá suporte a metadados especiais, além dos comandos repl padrão:
C O M A N DO A RGUM EN TO S DESC RIÇ Ã O
$continue , $cont , $c Inicia a execução do programa da

instrução atual.
$down , $d Move o quadro atual um nível para

baixo no rastreamento de pilha.
$frame Exibe a ID de quadro atual.
$frame ID de quadro Muda a ID de quadro atual para a ID

de quadro especificada.
$load Carrega comandos do arquivo e os

executa até a conclusão
$proc Exibe a ID de processo atual.
$proc ID de processo Muda a ID de processo atual para a ID

de processo especificada.
C O M A N DO A RGUM EN TO S DESC RIÇ Ã O
$procs Lista os processos que estão sendo

depurados no momento.
$stepin , $step , $s Intervém na próxima chamada de

função, se possível.
$stepout , $return , $r Encaminha-se para fora da função

atual.
$stepover , $until , $unt Depura parcialmente a próxima

chamada de função.
$thread Exibe a ID de thread atual.
$thread ID de thread Muda a ID de thread atual para a ID

de thread especificada.
$threads Lista os threads que estão sendo

depurados no momento.
$up , $u Move o quadro atual um nível para

cima no rastreamento de pilha.
$where , $w , $bt Lista os quadros do thread atual.
Observe que as janelas do depurador padrão, como processos , threads e pilha de chamadas , não são
sincronizadas com a janela interativa de depuração . Alterar o processo, thread ou quadro ativo na janela
interativa de depuração não afeta as outras janelas do depurador. Da mesma forma, alterar o processo,
thread ou quadro ativo em outras janelas do depurador não afeta a janela interativa de depuração .
Usar o depurador herdado

O Visual Studio 2017 versões 15.8 e posteriores usam um depurador com base no ptvsd versão 4.1 ou
superior. O Visual Studio 2019 versões 16,5 e posteriores usam um depurador baseado em debugpy. Essas
versões do depurador são compatíveis com Python 2,7 e Python 3.5 +. Se você estiver usando o Python 2.6, 3.1
a 3.4 ou o IronPython, o Visual Studio mostrará o erro O depurador não dá supor te a este ambiente do
Python :
Nesses casos, você precisa usar o depurador mais antigo (o que é o padrão no Visual Studio 2017 versões 15.7
e anteriores). Selecione o Tools > comando de menuOpções de ferramentas, Python navegue até >
depuração do Python e selecione a opção usar depurador herdado .
Se você tiver instalado uma versão mais antiga do ptvsd no ambiente atual (como uma versão 4.0.x anterior ou
uma versão 3.x necessária para a depuração remota), o Visual Studio poderá mostrar um erro ou aviso.
O erro Não foi possível carregar o pacote do depurador será exibido se você tiver instalado o ptvsd 3.x:
Nesse caso, selecione Usar o depurador herdado para definir a opção Usar depurador herdado e reinicie
o depurador.
O aviso O pacote do depurador está desatualizado será exibido se você tiver instalado uma versão 4.x
anterior do ptvsd:
IMPORTANT
Embora você possa optar por ignorar o aviso em algumas versões do ptvsd, o Visual Studio poderá não funcionar
corretamente.
Para gerenciar a instalação do ptvsd:

1. Navegue até a guia Pacotes na janela Ambientes do Python .
2. Insira "ptvsd" na caixa de pesquisa e examine a versão do ptvsd instalada:
3. Se a versão for inferior à 4.1.1a9 (a versão empacotada com o Visual Studio), selecione o X à direita do
pacote para desinstalar a versão mais antiga. Assim, o Visual Studio passará a usar a versão empacotada.
(Você também pode desinstalar com o PowerShell usando pip uninstall ptvsd .)
4. Como alternativa, você pode atualizar o pacote ptvsd para a última versão seguindo as instruções da
seção Solução de problemas.
Para o Visual Studio 2019 (versão 16,4 e anterior) atualizar ptvsd
Se você tiver problemas com o depurador, primeiro atualize sua versão do depurador da seguinte maneira:
1. Navegue até a guia Pacotes na janela Ambientes do Python .
2. Insira ptvsd --upgrade na caixa de pesquisa, em seguida, selecione Executar o comando: pip install
ptvsd --upgrade . (Você também pode usar o mesmo comando no PowerShell).
Se o problema persistir, registre um problema no Repositório GitHub do PTVS.
NOTE
Para o Visual Studio 2019 versão 16,5 e posterior, o debugpy faz parte da carga de trabalho do Python do Visual
Studio e é atualizado junto com o Visual Studio.
Habilitar registro em log do depurador

Ao investigar um problema do depurador, a Microsoft pode solicitar que você habilite e colete logs de
depurador para ajudar no diagnóstico.
As seguintes etapas habilitam a depuração na sessão atual do Visual Studio:
1. Abra uma janela de comando no Visual Studio usando o comando de menu Exibir > outra > janela de
comando do Windows.
2. Insira o seguinte comando:
DebugAdapterHost.Logging /On /OutputWindow
3. Inicie a depuração e percorra todas as etapas são necessárias para reproduzir o problema. Durante esse
tempo, os logs de depuração aparecem na janela Saída em Log de Host do Adaptador de
Depuração . Em seguida, você poderá copiar os logs dessa janela e colá-los em um problema do
GitHub, em um email etc.
4. Se o Visual Studio parar de funcionar ou se não for possível acessar a janela Saída , reinicie o Visual
Studio, abra uma janela de comando e digite o seguinte comando:
DebugAdapterHost.Logging /On
5. Inicie a depuração e reproduza o problema novamente. Os logs de depurador podem ser encontrados
em %temp%\DebugAdapterHostLog.txt .
Confira também
Para obter detalhes completos sobre o depurador do Visual Studio, consulte Depuração no Visual Studio.
Depurar o código do Python remotamente no Linux
O Visual Studio pode iniciar e depurar aplicativos Python localmente e remotamente em um computador
Windows (consulte depuração remota). Ela também pode depurar remotamente em um dispositivo ou sistema
operacional diferente ou em uma implementação Python que não seja o CPython usando a biblioteca ptvsd.
Ao usar a ptvsd, o código do Python que está sendo depurado hospeda o servidor de depuração ao qual o Visual
Studio pode se anexar. Essa hospedagem exige uma pequena modificação no código para importar e habilitar o
servidor e pode exigir configurações de rede ou de firewall no computador remoto para permitir conexões TCP.
Para obter uma introdução à depuração remota, consulte

aprofundamento: depuração remota de plataforma cruzada
(YouTube.com, 6m22s), que se aplica ao Visual Studio 2015 e
2017.
Configurar um computador Linux

Os itens a seguir são necessários para acompanhar esse passo a passo:
Um computador remoto que execute o Python em um sistema operacional como o Mac OSX ou Linux.
A porta 5678 (entrada) aberta no firewall desse computador, que é o padrão para a depuração remota.
Crie com facilidade uma máquina virtual do Linux no Azure e acesse-a usando a Área de Trabalho Remota no
Windows. Ter o Ubuntu para a VM é conveniente, pois o Python é instalado por padrão. Caso contrário, veja a lista
em Instalar um interpretador do Python de sua escolha para obter mais locais de download do Python.
Para obter detalhes sobre como criar uma regra de firewall para uma VM do Azure, confira Abrir portas para uma
VM no Azure usando o portal do Azure.
Preparar o script para depuração

1. No computador remoto, crie um arquivo do Python chamado guessing-game.py com o seguinte código:
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 o pacote ptvsd no ambiente usando pip3 install ptvsd .
NOTE
É uma boa ideia registrar a versão do ptvsd instalada caso ela seja necessária para solução de problemas; a listagem
ptvsd também mostra as versões disponíveis.
3. Habilite a depuração remota adicionando o código abaixo ao primeiro ponto possível de guessing-game.py,
antes de outros códigos. (Embora esse não seja um requisito estrito, é impossível depurar os threads em
segundo plano gerados antes que a função enable_attach seja chamada.)
import ptvsd
ptvsd.enable_attach()
4. Salve o arquivo e execute python3 guessing-game.py . A chamada para enable_attach é executada em

segundo plano e aguarda as conexões de entrada enquanto você interage com o programa de outra
maneira. Se desejado, a função wait_for_attach pode ser chamada após enable_attach para bloquear o
programa até que o depurador seja anexado.
TIP
Além de enable_attach e wait_for_attach , o ptvsd também fornece uma função auxiliar break_into_debugger , que
serve como um ponto de interrupção programático, caso o depurador seja anexado. Também há uma função is_attached
que retorna True se o depurador é anexado (observe que não há necessidade de verificar esse resultado antes de chamar
outras funções ptvsd ).
Anexar remotamente por meio das Ferramentas Python

Nestas etapas, definiremos um ponto de interrupção simples para interromper o processo remoto.
1. Crie uma cópia do arquivo remoto no computador local e abra-a no Visual Studio. Não importa a
localização do arquivo, mas o nome deve corresponder ao nome do script no computador remoto.
2. (Opcional) Para ter o IntelliSense para ptvsd no computador local, instale o pacote de ptvsd em seu
ambiente de Python.
3. Selecione depuração > anexar ao processo .
4. No diálogo Anexar ao Processo que será exibido, configure o Tipo de Conexão como Python remoto
(ptvsd) . (Em versões anteriores do Visual Studio, esses comandos são denominados Transpor te e
Depuração remota do Python .)
5. No campo Destino da Conexão (Qualificador em versões anteriores), insira tcp://<ip_address>:5678 ,
em que <ip_address> é o do computador remoto (que pode ser um endereço explícito ou um nome como
myvm.cloudapp.net) e :5678 é o número da porta de depuração remota.
6. Pressione Enter para preencher a lista de processos de ptvsd disponíveis nesse computador:
Se outro programa for iniciado no computador remoto após a lista ser populada, selecione o botão
Atualizar .
7. Selecione o processo a ser depurado e, em seguida, Anexar ou clique duas vezes no processo.
8. Então, o Visual Studio alternará para o modo de depuração enquanto o script continuará a ser executado no
computador remoto, fornecendo todos os recursos normais de depuração. Por exemplo, defina um ponto
de interrupção na linha if guess < number: e, em seguida, mude para o computador remoto e insira outra
tentativa. Após fazer isso, o Visual Studio do seu computador local parará no ponto de interrupção,
mostrará variáveis locais e assim por diante:
9. Ao interromper a depuração, o Visual Studio se desanexa do programa, que continua a ser executado no
computador remoto. O ptvsd também continua a escuta para anexar depuradores, assim, é possível anexá-
los novamente ao processo a qualquer momento.
Solução de problemas de conexão
1. Verifique se você selecionou Python remoto (ptvsd) para o Tipo de Conexão (Depuração remota do
Python de Transpor te em versões anteriores).
2. Verifique se o segredo no Destino de Conexão (ou Qualificador ) corresponde exatamente ao segredo
no código remoto.
3. Verifique se o endereço IP no Destino de Conexão (ou Qualificador ) corresponde ao do computador
remoto.
4. Verifique se a porta de depuração remota foi aberta no computador remoto e se o sufixo da porta foi
incluído no destino de conexão, como :5678 .
Se for necessário usar uma porta diferente, será possível especificá-la na chamada enable_attach
usando o argumento address , como em ptvsd.enable_attach(address = ('0.0.0.0', 8080)) . Nesse caso,
abra a porta específica no firewall.
5. Verifique na tabela a seguir se a versão do ptvsd instalada no computador remoto conforme retornado por
pip3 list corresponde àquela utilizada pela versão das ferramentas do Python usadas no Visual Studio. Se
necessário, atualize o ptvsd no computador remoto.
VERSÃ O DO VISUA L ST UDIO VERSÃ O DA S F ERRA M EN TA S DO P Y T H O N / P T VSD
2017 15.8 4.1.1a9 (depurador herdado: 3.2.1.0)
2017 15.7 4.1.1a1 (depurador herdado: 3.2.1.0)
2017 15.4, 15.5, 15.6 3.2.1.0

VERSÃ O DO VISUA L ST UDIO VERSÃ O DA S F ERRA M EN TA S DO 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
Usar ptvsd 3.x

As informações a seguir aplicam-se apenas à depuração remota com o ptvsd 3.x, que contém alguns recursos que
foram removidos do ptvsd 4.x.
1. Com o ptvsd 3.x, a função enable_attach exigia que você passasse um "segredo" como o primeiro
argumento que restringe o acesso para o script em execução. Você insere o segredo ao anexar o depurador
remoto. Embora não seja recomendado, é possível permitir que qualquer pessoa se conecte, use
enable_attach(secret=None) .
2. A URL de destino de conexão é tcp://<secret>@<ip_address>:5678 , em que <secret> é a cadeia de

caracteres passada, enable_attach , no código do Python.
Por padrão, a conexão com o servidor de depuração remota ptvsd 3.x é protegida somente pelo segredo e todos
os dados são passados em texto sem formatação. Para obter uma conexão mais segura, o ptvsd 3.x dá suporte ao
uso do SSL com o protocolo tcsp , que você configura da seguinte maneira:
1. No computador remoto, gere certificados autoassinados separados e arquivos de chave usando o openssl:
openssl req -new -x509 -days 365 -nodes -out cert.cer -keyout cert.key
Quando solicitado, use o nome do host ou endereço IP (o que você usa para se conectar) no Nome
Comum quando solicitado pelo openssl.
(Consulte Certificados autoassinados nos documentos de módulo ssl do Python para obter mais detalhes.
Observe que o comando nesses documentos gera apenas um único arquivo combinado.)
2. No código, modifique a chamada para enable_attach a fim de incluir os argumentos certfile e keyfile
usando os nomes de arquivo como valores (esses argumentos têm o mesmo significado que a função
padrão ssl.wrap_socket do Python):
ptvsd.enable_attach(secret='my_secret', certfile='cert.cer', keyfile='cert.key')
Também é possível fazer essa mesma alteração no arquivo de código no computador local, porém, como
esse código não é executado, isso não é realmente necessário.
3. Reinicie o programa de Python no computador remoto, deixando-o pronto para depuração.
4. Proteja o canal adicionando o certificado à AC Raiz Confiável no computador Windows com o Visual Studio:
a. Copie o arquivo de certificado do computador remoto para o computador local.
b. Abra o Painel de Controle e navegue para Ferramentas Administrativas > Gerenciar
cer tificados de computador .
c. Na janela exibida, expanda Autoridades de Cer tificação Confiáveis no lado esquerdo, clique com o
botão direito do mouse em Cer tificados e selecione Todas as Tarefas > Impor tar .
d. Navegue para o arquivo .cer copiado do computador remoto, selecione-o e, em seguida, clique nas
caixas de diálogo para concluir a importação.
5. Agora, repita o processo de anexação no Visual Studio, conforme descrito anteriormente, usando tcps://
como protocolo para o Destino de Conexão (ou Qualificador ).
6. O Visual Studio o avisará sobre possíveis problemas de certificado ao se conectar via SSL. É possível
ignorar os avisos e continuar, porém, embora o canal ainda esteja criptografado contra interceptação, ele
pode estar aberto a ataques man-in-the-middle.
a. Se você vir o cer tificado remoto não é um aviso de confiança abaixo, isso significa que você não
adicionou corretamente o certificado à autoridade de certificação raiz confiável. Verifique essas
etapas e tente novamente.
b. Se você vir o nome do cer tificado remoto não corresponder ao aviso de hostname abaixo, isso
significa que você não usou o nome de host ou endereço IP adequado como o common name ao
criar o certificado.
O Visual Studio pode iniciar e depurar aplicativos Python localmente e remotamente em um computador
Windows (consulte depuração remota). Ele também pode depurar remotamente em uma implementação de
sistema operacional, dispositivo ou Python diferente de CPython usando a biblioteca debugpy.
Ao usar debugpy, o código Python que está sendo depurado hospeda o servidor de depuração ao qual o Visual
Studio pode ser anexado. Essa hospedagem exige uma pequena modificação no código para importar e habilitar o
servidor e pode exigir configurações de rede ou de firewall no computador remoto para permitir conexões TCP.
NOTE
Para o Visual Studio 2019 versão 16,4 e anterior, a biblioteca ptvsd foi usada. A biblioteca debugpy substituiu o ptvsd 4 no
Visual Studio 2019 versão 16,5.
Configurar um computador Linux

Os itens a seguir são necessários para acompanhar esse passo a passo:
Um computador remoto que execute o Python em um sistema operacional como o Mac OSX ou Linux.
A porta 5678 (entrada) aberta no firewall desse computador, que é o padrão para a depuração remota.
NOTE
Este tutorial é baseado no Visual Studio 2019 versão 16,6.
Crie com facilidade uma máquina virtual do Linux no Azure e acesse-a usando a Área de Trabalho Remota no
Windows. Ter o Ubuntu para a VM é conveniente, pois o Python é instalado por padrão. Caso contrário, veja a lista
em Instalar um interpretador do Python de sua escolha para obter mais locais de download do Python.
Para obter detalhes sobre como criar uma regra de firewall para uma VM do Azure, confira Abrir portas para uma
VM no Azure usando o portal do Azure.
Preparar o script para depuração

1. No computador remoto, crie um arquivo do Python chamado guessing-game.py com o seguinte código:
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 o pacote debugpy no ambiente usando pip3 install debugpy .
NOTE
É uma boa ideia registrar a versão do debugpy que está instalada caso você precise dela para solução de problemas;
a listagem debugpy também mostra as versões disponíveis.
3. Habilite a depuração remota adicionando o código abaixo ao primeiro ponto possível de guessing-game.py,
antes de outros códigos. (Embora esse não seja um requisito estrito, é impossível depurar os threads em
segundo plano gerados antes que a função listen seja chamada.)
import debugpy
debugpy.listen(5678)
4. Salve o arquivo e execute python3 guessing-game.py . A chamada para listen é executada em segundo
plano e aguarda as conexões de entrada enquanto você interage com o programa de outra maneira. Se
desejado, a função wait_for_client pode ser chamada após listen para bloquear o programa até que o
depurador seja anexado.
TIP
Além de listen e wait_for_client , o debugpy também fornece uma função auxiliar breakpoint , que serve como
um ponto de interrupção programático se o depurador estiver anexado. Também há uma função is_client_connected
que retorna True se o depurador é anexado (observe que não há necessidade de verificar esse resultado antes de chamar
outras funções debugpy ).
Anexar remotamente por meio das Ferramentas Python

Nestas etapas, definiremos um ponto de interrupção simples para interromper o processo remoto.
1. Crie uma cópia do arquivo remoto no computador local e abra-a no Visual Studio. Não importa a
localização do arquivo, mas o nome deve corresponder ao nome do script no computador remoto.
2. Adicional Para ter o IntelliSense para debugpy em seu computador local, instale o pacote debugpy em seu
ambiente do Python.
3. Selecione depuração > anexar ao processo .
4. Na caixa de diálogo anexar ao processo que aparece, defina tipo de conexão como Python Remote
(debugpy) .
5. No campo destino da conexão , insira tcp://<ip_address>:5678 onde <ip_address> é o do computador
remoto (que pode ser um endereço explícito ou um nome como MyVM.cloudapp.net) e :5678 é o número
da porta de depuração remota.
6. Pressione Enter para preencher a lista de processos de debugpy disponíveis nesse computador:
Se outro programa for iniciado no computador remoto após a lista ser populada, selecione o botão
Atualizar .
7. Selecione o processo a ser depurado e, em seguida, Anexar ou clique duas vezes no processo.
8. Então, o Visual Studio alternará para o modo de depuração enquanto o script continuará a ser executado no
computador remoto, fornecendo todos os recursos normais de depuração. Por exemplo, defina um ponto
de interrupção na linha if guess < number: e, em seguida, mude para o computador remoto e insira outra
tentativa. Após fazer isso, o Visual Studio do seu computador local parará no ponto de interrupção,
mostrará variáveis locais e assim por diante:
9. Ao interromper a depuração, o Visual Studio se desanexa do programa, que continua a ser executado no
computador remoto. o debugpy também continua ouvindo os depuradores, para que você possa reanexá-
lo ao processo novamente a qualquer momento.
Solução de problemas de conexão
1. Verifique se você selecionou o Python Remote (debugpy) para o tipo de conexão
2. Verifique se o segredo no destino da conexão corresponde exatamente ao segredo no código remoto.
3. Verifique se o endereço IP no destino de conexão corresponde ao do computador remoto.
4. Verifique se você abriu a porta de depuração remota no computador remoto e se você incluiu o sufixo de
porta no destino de conexão, como :5678 .
Se você precisar usar uma porta diferente, poderá especificá-la no listen , como em
debugpy.listen((host, port)) . Nesse caso, abra a porta específica no firewall.
5. Verifique se a versão do debugpy está instalada no computador remoto conforme retornado por
pip3 list correspondências usadas pela versão das ferramentas Python que você está usando no Visual
Studio na tabela a seguir. Se necessário, atualize debugpy no computador remoto.
VERSÃ O DO VISUA L ST UDIO F ERRA M EN TA S P Y T H O N / VERSÃ O DEB UGP Y
2019 16,6 1.0.0 B5
2019 16,5 1.0.0 B1

NOTE
O Visual Studio 2019 versão 16.0-16.4 utilizou ptvsd, não debugpy. O processo neste passo a passos para essas versões é
semelhante, mas os nomes de função são diferentes. O Visual Studio 2019 versão 16,5 usa debugpy, mas os nomes de
função eram os mesmos que os em ptvsd. Em vez de listen , você usaria enable_attach . Em vez de
wait_for_client , você usaria wait_for_attach . Em vez de breakpoint , você usaria break_into_debugger .
Usando ptvsd 3. x para depuração herdada

O Visual Studio 2017 versões 15.8 e posteriores usam um depurador com base no ptvsd versão 4.1 ou superior. O
Visual Studio 2019 versões 16,5 e posteriores usam um depurador baseado em debugpy. Essas versões do
depurador são compatíveis com Python 2,7 e Python 3.5 +. Se você estiver usando o Python 2,6, 3,1 a 3,4 ou
IronPython, o Visual Studio mostrará o erro, o depurador não oferece supor te a esse ambiente do Python .
As informações a seguir se aplicam somente à depuração remota com ptvsd 3. x.
1. Com o ptvsd 3.x, a função enable_attach exigia que você passasse um "segredo" como o primeiro
argumento que restringe o acesso para o script em execução. Você insere o segredo ao anexar o depurador
remoto. Embora não seja recomendado, é possível permitir que qualquer pessoa se conecte, use
enable_attach(secret=None) .
2. A URL de destino de conexão é tcp://<secret>@<ip_address>:5678 , em que <secret> é a cadeia de

caracteres passada, enable_attach , no código do Python.
Por padrão, a conexão com o servidor de depuração remota ptvsd 3.x é protegida somente pelo segredo e todos
os dados são passados em texto sem formatação. Para obter uma conexão mais segura, o ptvsd 3.x dá suporte ao
uso do SSL com o protocolo tcsp , que você configura da seguinte maneira:
1. No computador remoto, gere certificados autoassinados separados e arquivos de chave usando o openssl:
openssl req -new -x509 -days 365 -nodes -out cert.cer -keyout cert.key
Quando solicitado, use o nome do host ou endereço IP (o que você usa para se conectar) no Nome
Comum quando solicitado pelo openssl.
(Consulte Certificados autoassinados nos documentos de módulo ssl do Python para obter mais detalhes.
Observe que o comando nesses documentos gera apenas um único arquivo combinado.)
2. No código, modifique a chamada para enable_attach a fim de incluir os argumentos certfile e keyfile
usando os nomes de arquivo como valores (esses argumentos têm o mesmo significado que a função
padrão ssl.wrap_socket do Python):
ptvsd.enable_attach(secret='my_secret', certfile='cert.cer', keyfile='cert.key')
Também é possível fazer essa mesma alteração no arquivo de código no computador local, porém, como
esse código não é executado, isso não é realmente necessário.
3. Reinicie o programa de Python no computador remoto, deixando-o pronto para depuração.
4. Proteja o canal adicionando o certificado à AC Raiz Confiável no computador Windows com o Visual Studio:
a. Copie o arquivo de certificado do computador remoto para o computador local.
b. Abra o Painel de Controle e navegue para Ferramentas Administrativas > Gerenciar
cer tificados de computador .
c. Na janela exibida, expanda Autoridades de Cer tificação Confiáveis no lado esquerdo, clique com o
botão direito do mouse em Cer tificados e selecione Todas as Tarefas > Impor tar .
d. Navegue para o arquivo .cer copiado do computador remoto, selecione-o e, em seguida, clique nas
caixas de diálogo para concluir a importação.
5. Agora, repita o processo de anexação no Visual Studio, conforme descrito anteriormente, usando tcps://
como protocolo para o Destino de Conexão (ou Qualificador ).
6. O Visual Studio o avisará sobre possíveis problemas de certificado ao se conectar via SSL. É possível
ignorar os avisos e continuar, porém, embora o canal ainda esteja criptografado contra interceptação, ele
pode estar aberto a ataques man-in-the-middle.
a. Se você vir o cer tificado remoto não é um aviso de confiança abaixo, isso significa que você não
adicionou corretamente o certificado à autoridade de certificação raiz confiável. Verifique essas
etapas e tente novamente.
b. Se você vir o nome do cer tificado remoto não corresponder ao aviso de hostname abaixo, isso
significa que você não usou o nome de host ou endereço IP adequado como o common name ao
criar o certificado.
No momento, o Python tem suporte no Serviço de Aplicativo do Azure para Linux. Você pode publicar
aplicativos usando Git deploy e contêineres, conforme descrito neste artigo.
NOTE
O suporte do Python no Serviço de Aplicativo do Azure para Windows foi oficialmente preterido. Como resultado, o
comando Publicar do Visual Studio oficialmente tem suporte somente para um destino IIS. A depuração remota no
Serviço de Aplicativo do Azure não tem mais suporte oficial.
No entanto, os recursos para Publicar no Serviço de Aplicativo no Windows ainda funcionam por enquanto, pois as
extensões do Python para o Serviço de Aplicativo no Windows permaneçam disponíveis, mas não terão manutenção
nem atualizações.
Publicar no Serviço de Aplicativo no Linux usando Git deploy

Git deploy conecta um Serviço de Aplicativo no Linux a uma ramificação específica de um repositório Git. A
confirmação do código para essa ramificação implanta automaticamente o no Serviço de Aplicativo. O Serviço
de Aplicativo instala automaticamente quaisquer dependências listadas em requirements.txt. Nesse caso, o
Serviço de Aplicativo no Linux executa o código em uma imagem de contêiner pré-configurada que usa o
servidor Web Gunicorn. No momento, esse serviço está em Versão prévia e não tem suporte para uso em
produção.
Para saber mais, confira os seguintes artigos na documentação do Azure:
Início rápido: Criar um aplicativo Web do Python no Serviço de Aplicativo fornece um breve passo a passo
sobre o processo de Git deploy usando um aplicativo simples do Flask e a implantação de um repositório
Git local.
Como configurar o Python descreve as características do Serviço de Aplicativo no contêiner do Linux e
como personalizar o comando de inicialização do Gunicorn para seu aplicativo.
Publicar no Serviço de Aplicativo no Linux usando contêineres

Em vez de depender do contêiner criado previamente com o Serviço de Aplicativo no Linux, você pode fornecer
seu próprio contêiner. Essa opção permite que você escolha quais servidores Web usará e personalize o
comportamento do contêiner.
Há duas opções para criar, gerenciar e enviar contêineres por push:
Use o Visual Studio Code e a extensão do Docker, conforme descrito em Implantar o Python usando
contêineres do Docker. Mesmo que você não use o Visual Studio Code, o artigo fornece detalhes úteis
para a criação de imagens de contêiner para aplicativos do Flask e do Django usando os servidores Web
prontos para produção uwsgi e nginx. Depois, você pode implantar esse mesmo contêiner usando a CLI
do Azure.
Use a linha de comando e a CLI do Azure, conforme descrito em Usar uma imagem personalizada do
Docker na documentação do Azure. No entanto, o guia é genérico e não é específico do Python.
Publicar no IIS
No Visual Studio, você pode publicar em uma máquina virtual do Windows ou em outro computador
compatível com o IIS com o comando Publicar . Ao usar o IIS, crie ou modifique um arquivo web.config no
aplicativo que informe ao IIS onde localizar o interpretador do Python. Para saber mais, confira Configurar
aplicativos Web do IIS.
Criar uma extensão do C++ para o Python
Os módulos escritos em C++ (ou em C) são geralmente usados para estender as funcionalidades de um
interpretador do Python, bem como para permitir o acesso a funcionalidades de baixo nível do sistema
operacional. Há três tipos de módulos principais:
Módulos de acelerador: como o Python é uma linguagem interpretada, algumas partes do código podem ser
escritas em C++ para um desempenho mais alto.
Módulos de wrapper: expõem interfaces C/C++ existentes para o código Python ou expõem uma API mais
"Pythonic" fácil de usar do Python.
Módulos de acesso de baixo nível do sistema: criados para acessar os recursos de baixo nível do runtime
CPython, do sistema operacional ou do hardware subjacente.
Este artigo explica como criar um módulo de extensão C++ para CPython que calcula uma tangente hiperbólica
e faz uma chamada a ela do código Python. A rotina é implementada primeiro em Python para demonstrar o
ganho de desempenho relativo da implementação da mesma rotina em C++.
Este artigo também demonstra duas maneiras de disponibilizar o C++ para Python:
As extensões padrão de CPython, conforme descrito na Documentação do Python
PyBind11, que é recomendado para C++ 11 devido à sua simplicidade.
Há uma comparação entre esses e outros meios em abordagens alternativas no final deste artigo.
O exemplo completo deste passo a passo pode ser encontrado em python-samples-vs-cpp-extension (GitHub).
Pré-requisitos
Visual Studio 2017 ou posterior com as cargas de trabalho Desenvolvimento para Desktop com
C++ e Desenvolvimento do Python instaladas com as opções padrão.
Na carga de trabalho Desenvolvimento Python , marque também a caixa à direita para Ferramentas
de desenvolvimento nativo em Python . Essa opção define a maior parte da configuração descrita
neste artigo. (Essa opção também inclui a carga de trabalho do C++ automaticamente.)
TIP
A instalação da carga de trabalho Aplicativos de ciência de dados e análise também inclui o Python e a
opção Ferramentas nativas de desenvolvimento em Python por padrão.
Para obter mais informações, confira Instalar o suporte para Python para Visual Studio, incluindo o uso de
outras versões do Visual Studio. Se você instalar o Python separadamente, lembre-se de selecionar Baixar
símbolos de depuração e Baixar binários de depuração em Opções Avançadas no instalador. Essa
opção garante que você terá as bibliotecas de depuração necessárias disponíveis se optar por fazer um build de
depuração.
Criar o aplicativo do Python

1. Crie um novo projeto Python no Visual Studio selecionando arquivo > novo > projeto . Pesquise
"Python", selecione o modelo Aplicativo Python , atribua a ele um nome e um local adequados e
selecione OK .
2. O trabalho com C++ exige o uso de um interpretador de Python de 32 bits (Python 3.6 ou superior
recomendado). Na janela Gerenciador de Soluções do Visual Studio, expanda o nó do projeto, depois o
nó Ambientes do Python . Se você não encontrar um ambiente de 32 bits como o padrão (em negrito
ou rotulado com padrão global ), siga as instruções em Escolher um ambiente de Python para um
projeto. Se você não encontrar um interpretador de 32 bits instalado, confira Instalar interpretadores do
Python.
3. No arquivo .py do projeto, cole o código a seguir que submeterá a benchmark o cálculo de uma tangente
hiperbólica (implementada sem o uso da biblioteca de matemática para facilitar a comparação). Fique à
vontade para inserir o código manualmente para experimentar alguns recursos de edição do Python.
from itertools import islice

from random import random
from time import perf_counter
COUNT = 500000 # Change this value depending on the speed of your computer
DATA = list(islice(iter(lambda: (random() - 0.5) * 3.0, None), 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)')
4. Execute o programa usando depurar > Iniciar sem depuração (Ctrl + F5 ) para ver os resultados. Você
pode ajustar a variável COUNT para alterar o tempo que os parâmetros de comparação levam para serem
executados. Para a finalidade deste passo a passo, defina a contagem de forma que cada parâmetro de
comparação leve cerca de dois segundos.
TIP
Ao executar parâmetros de comparação, sempre use debug > Star t sem Debugging para evitar a sobrecarga incorrida
ao executar o código no depurador do Visual Studio.
Criar os projetos principais de C++

Siga as instruções nesta seção para criar dois projetos de C++ idênticos chamados "superfastcode" e
"superfastcode2". Posteriormente, você usará em cada projeto formas diferentes de expor o código C++ para
Python.
1. Verifique se a variável de ambiente PYTHONHOME está definida para o interpretador do Python que você
deseja usar. Os projetos do C++ no Visual Studio dependem dessa variável para localizar os arquivos,
como python.h, que são usados ao criar uma extensão do Python.
2. Clique com o botão direito do mouse na solução em Gerenciador de Soluções e escolha Adicionar >
Novo Projeto . Uma solução do Visual Studio pode conter os projetos Python e C++ juntos (essa é uma
das vantagens de usar o Visual Studio para Python).
3. Pesquise por "C++", selecione Projeto vazio , especifique o nome "superfastcode" ("superfastcode2" para
o segundo projeto) e selecione OK .
TIP
Com as ferramentas de desenvolvimento nativo do Python instaladas no Visual Studio, você poderá
começar em vez disso com o modelo Módulo de Extensão do Python , que tem grande parte do que está
descrito abaixo já implementado. No entanto, para este passo a passo, começar com um projeto vazio demonstra
o build do módulo de extensão passo a passo. Depois de entender o processo, o modelo faz com que você
economize tempo ao escrever suas próprias extensões.
4. Crie um arquivo do C++ no novo projeto clicando com o botão direito do mouse no nó Arquivos de
Origem , escolha Adicionar > Novo Item , escolha Arquivo do C++ , forneça a ele o nome module.cpp
e marque OK .
IMPORTANT
Um arquivo com a extensão .cpp é necessário para ativar as páginas de propriedade C++ nas etapas a seguir.
5. No Gerenciador de Soluções , clique com o botão direito do mouse no projeto C++ e escolha
Propriedades .
6. Na parte superior da caixa de diálogo Páginas de Propriedades exibida, defina Configuração para
Todas as Configurações e Plataforma para Win32 .
7. Defina as propriedades específicas, conforme descrito na tabela a seguir e, em seguida, selecione OK .
TA B P RO P RIEDA DE VA LO R
TA B P RO P RIEDA DE VA LO R
Geral Geral > Nome do destino Especifique o nome do módulo ao

qual você deseja se referir do
Python nas instruções
from...import . Você pode usar
esse mesmo nome em C++ ao
definir o módulo para Python. Se
você quiser usar o nome do projeto
como o nome do módulo, deixe o
valor padrão de $(ProjectName) .
Geral > Extensão de destino .pyd
Padrões > do projeto Tipo de Biblioteca Dinâmica (.dll)

configuração
C/C++ > Geral Diretórios de Inclusão Adicione a pasta include do Python

Adicionais conforme apropriado para sua
instalação, por exemplo,
c:\Python36\include .
C/C++ > Pré-processador Definições do Pré-processador Apenas CPython : adicione

Py_LIMITED_API; no início da
cadeia de caracteres (inclusive o
ponto e vírgula). Essa definição
restringe algumas das funções que
podem ser chamadas do Python e
torna o código mais portável entre
diferentes versões do Python. Se
você estiver trabalhando com
PyBind11, não adicione essa
definição, caso contrário, verá erros
de build.
C/C++ > Geração de código **Biblioteca de Runtime ** DLL com multi-thread (/MD)
(confira Aviso abaixo)
Vinculador > Geral Diretórios de Biblioteca Adicione a pasta libs do Python que
Adicionais contém arquivos .lib conforme
apropriado para sua instalação, por
exemplo, c:\Python36\libs .
(Lembre-se de apontar para a pasta
libs que contém arquivos .lib e não
para a pasta Lib que contém
arquivos .py.)
TIP
Se a guia C/C++ não for exibida nas propriedades do projeto, isso indicará que o projeto não contém nenhum
arquivo que ele identifica como arquivos de origem do C/C++. Essa condição poderá ocorrer se você criar um
arquivo de origem sem uma extensão .c ou .cpp. Por exemplo, se você acidentalmente inseriu module.coo em vez
de module.cpp na caixa de diálogo novo item anteriormente, o Visual Studio criará o arquivo, mas não definirá o
tipo de arquivo como "C/c + Code", que é o que ativa a guia de propriedades C/C++. Essa identificação indesejada
permanece o caso, mesmo se você renomear o arquivo com .cpp . Para configurar o tipo de arquivo
corretamente, clique com o botão direito do mouse no arquivo no Gerenciador de Soluções , escolha
Propriedades e, em seguida, defina Tipo de Arquivo como Código C/C++ .
WARNING
Sempre defina a opção de biblioteca de tempo de execução de código do C/C++ > Code Generation >
Runtime Librar y como /MD (DLL de vários threads) , mesmo para uma configuração de depuração, porque
essa configuração é a qual os binários do Python sem depuração são compilados. Com o CPython, se você definir
a opção /MDD (DLL de depuração multi-threaded) , a criação de uma configuração de depuração
produzirá o erro C1189: Py_LIMITED_API é incompatível com Py_DEBUG, Py_TRACE_REFS e
Py_REF_DEBUG . Além disso, se você remover Py_LIMITED_API (que é necessário com CPython, mas não em
PyBind11) para evitar o erro de build, o Python falhará ao tentar importar o módulo. (A falha ocorre na chamada
da DLL a PyModule_Create , conforme descrito adiante, com a mensagem de saída Erro fatal do Python:
PyThreadState_Get: nenhum thread atual.)
A opção/MDd é usada para criar os binários de depuração do Python (como python_d.exe), mas selecioná-lo para
uma DLL de extensão ainda causa o erro de compilação com Py_LIMITED_API .
8. Clique com o botão direito do mouse no projeto C++ e selecione Compilar para testar suas
configurações ( depuração e versão ). Os arquivos .pyd estão localizados na pasta solução em Depurar
e Versão , não na própria pasta do projeto do C++.
9. Adicione o seguinte código ao arquivo module.cpp do projeto do 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);
}
10. Compile o projeto do C++ novamente para confirmar se o código está correto.
11. Se ainda não tiver feito isso, repita as etapas acima para criar um segundo projeto denominado
"superfastcode2" com conteúdo idêntico.
Converter os projetos de C++ em uma extensão para Python

Para transformar a DLL C++ em uma extensão para Python, primeiro você precisa modificar os métodos
exportados para interagir com tipos Python. Em seguida, será necessário adicionar uma função que exporte o
módulo, juntamente com as definições dos métodos do módulo.
As seções a seguir explicam como executar essas etapas usando o PyBind11 e as extensões de CPython.
Extensões de CPython
Para obter informações sobre o que é mostrado nesta seção para Python 3.x, consulte o Manual de Referência de
API do Python/C e especialmente os Objetos de Módulo em python.org (Lembre-se de selecionar a versão do
Python do controle suspenso no canto superior direito para exibir a documentação correta).
Se você estiver trabalhando com o Python 2.7, consulte em vez disso Extending Python 2.7 with C or C++
(Estender o Python 2.7 com C ou C++) e Porting Extension Modules to Python 3 (Fazer a portabilidade de
módulos de extensão para Python 3) (python.org).
1. Na parte superior de module.cpp, inclua Python.h:
#include <Python.h>
2. Modifique o método tanh_impl para aceitar e retornar tipos Python (um PyOjbect* , que é):
PyObject* tanh_impl(PyObject *, PyObject* o) {

double x = PyFloat_AsDouble(o);
double tanh_x = sinh_impl(x) / cosh_impl(x);
return PyFloat_FromDouble(tanh_x);
}
3. Adicione uma estrutura que define como a função tanh_impl do C++ é apresentada ao Python:
static PyMethodDef superfastcode_methods[] = {

// The first property is the name exposed to Python, fast_tanh, the second is the C++
// function name that contains the implementation.
{ "fast_tanh", (PyCFunction)tanh_impl, METH_O, nullptr },
// Terminate the array with an object containing nulls.

{ nullptr, nullptr, 0, nullptr }
};
4. Adicionar uma estrutura que define o módulo da maneira como você deseja fazer referência a ele em seu
código Python, especificamente ao usar a instrução from...import . (Faça isso corresponde ao valor nas
propriedades do projeto em Propriedades > de configuração Geral > Nome de destino .) No exemplo
a seguir, o nome do módulo "superfastcode" significa que você pode usar
from superfastcode import fast_tanh no Python, porque fast_tanh está definido em
superfastcode_methods . (Os nomes de FileNames internos ao projeto C++, como Module. cpp, são
irrelevantes.)
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. Adicione um método que o Python chama quando carrega o módulo, que deve ser nomeado
PyInit_<module-name> , em que < nome do módulo > corresponde exatamente à propriedade de nome
de destino geral do projeto C++ > Target Name (ou seja, corresponde ao nome de arquivo do . PYD
compilado pelo projeto).
PyMODINIT_FUNC PyInit_superfastcode() {
return PyModule_Create(&superfastcode_module);
}
6. Defina a configuração de destino como liberar e compilar o projeto C++ novamente para verificar seu
código. Se encontrar erros, confira a seção Solução de problemas abaixo.
PyBind11
Se tiver concluído as etapas na seção anterior, você certamente observou que usou muito código com texto
clichê para criar as estruturas de módulo necessárias para o código C++. O PyBind11 simplifica o processo por
meio de macros em um arquivo de cabeçalho de C++ que alcançam o mesmo resultado com muito menos
código. Para obter informações de contexto sobre o que é mostrado nesta seção, confira PyBind11 basics
(Noções básicas de PyBind11) (github.com).
1. Instale o PyBind11 usando pip: pip install pybind11 ou py -m pip install pybind11 .
2. Na parte superior de module.cpp, inclua pybind11.h:
#include <pybind11/pybind11.h>
3. Na parte inferior de module.cpp, use a macro PYBIND11_MODULE para definir o ponto de entrada da função
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
}
4. Defina a configuração de destino como Versão e crie o projeto C++ para verificar o código. Se encontrar
erros, confira a seção de solução de problemas a seguir.
A compilação do módulo de C++ pode falhar pelos seguintes motivos:
Não é possível localizar Python.h (E1696: não é possível abrir o arquivo de software livre
"Python.h" e/ou C1083: não é possível abrir o arquivo de inclusão: "Python.h": o arquivo ou
diretório não existe ), verifique se o caminho em C/C++ > Geral > Diretórios de Inclusão
Adicionais nas propriedades do projeto aponta para a pasta include da instalação do Python. Veja a
etapa 6 em Criar o projeto principal do C++.
Não é possível localizar bibliotecas Python: Verifique se o caminho Linker em diretórios de > General >
biblioteca adicionais gerais do vinculador nas propriedades do projeto aponta para a pasta bibliotecas
da sua instalação do Python. Veja a etapa 6 em Criar o projeto principal do C++.
Erros do vinculador relacionadas à arquitetura de destino: altere a arquitetura do projeto de destino C++
para corresponder à instalação do Python. Por exemplo, se você tiver como alvo x64 com o projeto C++,
mas a instalação do Python for x86, altere o projeto C++ para ter como destino x86.
Testar o código e comparar os resultados

Agora que você tem as DLLs estruturadas como extensões de Python, é possível consultá-las por meio do
projeto do Python, importar o módulo e usar seus métodos.
Disponibilizar a DLL para o Python
Há duas maneiras de disponibilizar a DLL para o Python.
O primeiro método funcionará se o projeto Python e o projeto C++ estiverem na mesma solução. Vá para
Gerenciador de soluções , clique com o botão direito do mouse no nó referências em seu projeto Python e
selecione Adicionar referência . Na caixa de diálogo que é exibida, selecione a guia Projetos , selecione os
projetos superfastcode e superfastcode2 e, em seguida, selecione OK .
O método alternativo, descrito nas etapas a seguir, instala o módulo no ambiente Python global, tornando-o
disponível para outros projetos Python também. (Fazer isso normalmente requer que você atualize o banco de
dados de preenchimento do IntelliSense para esse ambiente no Visual Studio 2017 versão 15.5 e anterior. A
atualização também é necessária ao remover o módulo do ambiente.)
1. Se estiver usando o Visual Studio 2017 ou posterior, execute o instalador do Visual Studio, escolha
Modificar e escolha Componentes Individuais > Compiladores, ferramentas de build e
runtimes > conjunto de ferramentas do Visual C++ 2015.3 v140 . Essa etapa é necessária porque
o Python (para o Windows) foi criado com o Visual Studio 2015 (versão 14.0) e espera que essas
ferramentas estejam disponíveis durante o build de uma extensão por meio do método descrito aqui.
(Observe que talvez seja necessário instalar uma versão de 32 bits do Python e direcionar a DLL para o
Win32 e não para o x64).
2. Crie um arquivo chamado setup.py em seu projeto de C++ clicando com o botão direito do mouse no
projeto e selecionando Adicionar > Novo Item . Em seguida, escolha Arquivo do C++ (.cpp) , nomeie
o arquivo como setup.py e escolha OK (nomear o arquivo com a extensão .py faz com que o Visual
Studio o reconheça como Python, apesar do uso do modelo do C++). Quando o arquivo for exibido no
editor, cole o seguinte código nele conforme for adequado ao método de extensão:
Extensões de CPython (projeto superfastcode):
from distutils.core import setup, Extension, DEBUG
sfc_module = Extension('superfastcode', sources = ['module.cpp'])
setup(name = 'superfastcode', version = '1.0',

description = 'Python Package with superfastcode C++ extension',
ext_modules = [sfc_module]
)
Consulte criando Python.org (extensões C e C++ ) para obter a documentação sobre este script.
PyBind11 (projeto superfastcode2):
import os, sys
from distutils.core import setup, Extension

from distutils import sysconfig
cpp_args = ['-std=c++11', '-stdlib=libc++', '-mmacosx-version-min=10.7']
sfc_module = Extension(
'superfastcode2', sources = ['module.cpp'],
include_dirs=['pybind11/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. O código setup.py instrui o Python a compilar a extensão usando o conjunto de ferramentas do C++ no
Visual Studio 2015, quando usado na linha de comando. Abra um prompt de comandos com privilégios
elevados, navegue até a pasta que contém o projeto C++ (ou seja, a pasta que contém setup.py) e digite o
seguinte comando:
pip install .
ou:
py -m pip install .
Chamar a DLL no Python

Após disponibilizar a DLL para o Python conforme descrito na seção anterior, você poderá chamar as funções
superfastcode.fast_tanh e superfastcode2.fast_tanh2 do código Python e comparar seu desempenho com a
implementação do Python:
1. Adicione as seguintes linhas ao arquivo .py para chamar métodos exportados das DLLs e exibir suas
saídas:
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. Execute o programa Python (depuração > Iniciar sem depuração ou Ctrl + F5 ) e observe que as
rotinas do C++ são executadas aproximadamente cinco a vinte vezes mais rápido do que a
implementação do Python. A saída típica aparecerá como se segue:
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

Se o comando Iniciar sem depuração estiver desabilitado, clique com o botão direito do mouse no
projeto Python no Gerenciador de soluções e selecione definir como projeto de inicialização .
3. Tente aumentar a variável COUNT para que as diferenças sejam mais evidentes. Uma compilação de
depuração do módulo C++ também é executada mais lentamente do que uma compilação de versão
porque a compilação de depuração é menos otimizada e contém várias verificações de erro. Fique à
vontade para alternar entre essas configurações para comparação.
NOTE
Na saída, você pode ver que a extensão PyBind11 não é tão rápida quanto a extensão CPython, embora ainda seja
significativamente mais rápida que a implementação direta de Python. A diferença se deve a uma pequena quantidade de
sobrecarga por chamada que o PyBind11 introduz para tornar sua interface de C++ consideravelmente mais simples. Essa
diferença por chamada é bastante irrelevante: como o código de teste chama as funções de extensão 500.000 vezes, os
resultados que você vê aqui amplificam bastante essa sobrecarga! Normalmente, uma função de C++ faz muito mais
trabalho do que os métodos fast_tanh[2] triviais usados aqui e, nesse caso, a sobrecarga não é importante. No
entanto, se você estiver implementando métodos que podem ser chamados milhares de vezes por segundo, usar a
abordagem de CPython poderá resultar em um desempenho melhor do que no caso do PyBind11.
Depurar o código C++

O Visual Studio é compatível com a depuração de código de Python e C++ juntos. Esta seção explica o processo
usando o projeto superfastcode . As etapas são as mesmas para o projeto superfastcode2 .
1. Clique com o botão direito do mouse no projeto Python, no Gerenciador de Soluções , escolha
Propriedades , marque a guia Depuração e, em seguida, a opção Depurar > Habilitar depuração de
código nativo .
TIP
Quando você habilita a depuração de código nativo, a janela de saída do Python pode desaparecer imediatamente
quando o programa é concluído sem fornecer a você a tecla usual para continuar pausar. Para forçar uma
pausa, adicione a -i opção ao campo executar > argumentos do intérprete na guia depurar ao habilitar a
depuração de código nativo. Esse argumento coloca o interpretador do Python no modo interativo após a
conclusão do código e, nesse ponto, ele espera que você pressione Ctrl + Z > Enter para sair. (Como alternativa,
se você não se importar em modificar o código do Python, poderá adicionar as instruções import os e
os.system("pause") ao final do programa. Esse código duplicará o prompt de pausa original.)
2. Selecione arquivo > salvar para salvar as alterações de propriedade.

3. Defina a configuração de compilação a ser depurada na barra de ferramentas do Visual Studio.
4. Como o código geralmente demora mais para ser executado no depurador, talvez seja interessante alterar
a variável COUNT no seu arquivo .py para um valor que seja cerca de cinco vezes menor (por exemplo,
altere-o de 500000 para 100000 ).
5. No código do C++, defina um ponto de interrupção na primeira linha do método tanh_impl e, em
seguida, inicie o depurador (F5 ou Depurar > Iniciar Depuração ). O depurador para quando esse
código é chamado. Se o ponto de interrupção não for atingido, verifique se a configuração está definida
como depurar e se você salvou o projeto (o que não acontece automaticamente ao iniciar o depurador).
6. Neste ponto, você poderá executar o código C++ em etapas, examinar variáveis e assim por diante. Esses
recursos são detalhados em Depurar C++ e Python juntos.
Abordagens alternativas
Há uma variedade de meios para criar extensões Python, conforme descrito na tabela a seguir. As duas primeiras
entradas para CPython e PyBind11 já foram discutidas neste artigo.
USUÁ RIO S
A B O RDA GEM VIN TA GE REP RESEN TA N T ES VA N TA GEN S DESVA N TA GEN S
Módulos de extensão 1991 Biblioteca Padrão Tutoriais e Compilação,

do C/C++ para o documentação portabilidade,
CPython abrangente. Controle gerenciamento de
total. referências. Profundo
conhecimento sobre
o C.
PyBind11 2015 Biblioteca leve, Mais novo, menos

(recomendado para somente cabeçalho maduro. Uso
C++) para a criação de intensivo de recursos
associações de C++ 11. Lista curta
Python de código de compiladores
C++ existente. compatíveis (o Visual
Poucas dependências. Studio está incluído).
Compatibilidade de
PyPy.
Cython 2007 gevent, kivy Semelhante ao Compilação, nova

(recomendado para Python. Altamente sintaxe, nova cadeia
C) maduro. Alto de ferramentas.
desempenho.
Boost.Python 2002 Funciona com Pacote grande e

praticamente complexo de
qualquer compilador bibliotecas; contém
C++. várias soluções
alternativas para
compiladores antigos.
ctypes 2003 oscrypto Sem compilação, O acesso e a

ampla mutação de
disponibilidade. estruturas do C são
complicados e
sujeitos a erros.
SWIG 1996 crfsuite Gere associações Sobrecarga excessiva

para várias se o Python for o
linguagens de uma único destino.
só vez.
USUÁ RIO S
A B O RDA GEM VIN TA GE REP RESEN TA N T ES VA N TA GEN S DESVA N TA GEN S
cffi 2013 cryptography, pypy Facilidade de Mais novo, menos

integração, maduro.
compatibilidade com
o PyPy.
cppyy 2017 Semelhante ao cffi Mais recente, pode

usando C++. ter alguns problemas
com o VS 2017.
Confira também
O exemplo completo deste passo a passo pode ser encontrado em python-samples-vs-cpp-extension (GitHub).
Depurar o Python e o C++ juntos
A maioria dos depuradores regulares do Python dão suporte apenas à depuração de código do Python. No
entanto, na prática, o Python é usado em conjunto com C ou C++, em cenários que exigem alto desempenho ou
a capacidade de invocar diretamente as APIs da plataforma. (Confira Criar uma extensão do C++ para o Python
para obter um passo a passo.)
O Visual Studio fornece depuração integrada e simultânea de modo misto para Python e C/C++ nativo, desde
que você selecione a opção ferramentas de desenvolvimento nativo do Python para a carga de trabalho
de desenvolvimento do Python no instalador do Visual Studio.
NOTE
A depuração de modo misto não está disponível nas Ferramentas Python para Visual Studio 1.x no Visual Studio 2015 e
anteriores.
Os recursos de depuração de modo misto incluem o seguinte, conforme explicado neste artigo:
Pilhas de chamada combinadas
Etapa entre o Python e o código nativo
Pontos de interrupção nos dois tipos de código
Veja as representações de Python de objetos em quadros nativos e vice-versa
Depuração dentro do contexto do projeto do Python ou C++
Para obter uma introdução ao build, ao teste e à depuração
de módulos nativos do C com o Visual Studio, assista ao
vídeo Deep Dive: Creating Native Modules
(Aprofundamento: Criar módulos nativos) (youtube.com,
9min09s). O vídeo aplica-se para o Visual Studio 2015 e
2017.
Habilitar a depuração de modo misto em um projeto do Python

1. Clique com o botão direito do mouse no projeto Python no Gerenciador de soluções , selecione
Propriedades , selecione a guia depurar e, em seguida, selecione Habilitar depuração de código
nativo . Essa opção habilita o modo misto em todas as sessões de depuração.
TIP
Quando você habilita a depuração de código nativo, a janela de saída do Python pode desaparecer imediatamente
quando o programa é concluído sem fornecer a você a tecla usual para continuar pausar. Para forçar uma
pausa, adicione a -i opção ao campo executar > argumentos do intérprete na guia depurar ao habilitar a
depuração de código nativo. Esse argumento coloca o interpretador do Python no modo interativo após a
conclusão do código e, nesse ponto, ele espera que você pressione Ctrl + Z > Enter para sair.
2. Ao anexar o depurador de modo misto a um processo existente (depurar > anexar ao processo ), use o
botão selecionar para abrir a caixa de diálogo Selecionar tipo de código . Em seguida, defina a opção
Depurar esses tipos de código e selecione Nativo e Python na lista:
As configurações de tipo de código são persistentes, portanto, se você quiser desabilitar a depuração de
modo misto ao anexar a um processo diferente mais tarde, limpe o tipo de código Python .
É possível selecionar outros tipos de código além do Nativo ou em vez dele. Por exemplo, se um
aplicativo gerenciado hospeda CPython, que por sua vez usa módulos de extensão nativos, e você deseja
depurar todos os três, você pode verificar o Python , nativo e gerenciado em conjunto para uma
experiência de depuração unificada, incluindo pilhas de chamadas combinadas e percorrendo entre todos
os três tempos de execução.
3. Ao iniciar a depuração no modo misto pela primeira vez, você poderá ver uma caixa de diálogo Símbolos
Obrigatórios do Python (confira Símbolos para depuração de modo misto). Você precisa instalar
símbolos apenas uma vez para qualquer ambiente do Python. Os símbolos serão incluídos
automaticamente se você instalar o suporte do Python por meio do instalador do Visual Studio (Visual
Studio 2017 e posterior).
4. Para tornar o código-fonte do Python padrão em si disponível durante a depuração, visite
https://www.python.org/downloads/source/ , baixe o arquivo apropriado para sua versão e extraia-o para
uma pasta. Em seguida, aponte o Visual Studio para arquivos específicos nessa pasta em qualquer ponto
que for solicitado.
Habilitar a depuração de modo misto em um projeto do C/C++

O Visual Studio (2017 versão 15.5 e posterior) é compatível com a depuração de modo misto em um projeto do
C/C++ (por exemplo, ao inserir Python em outro aplicativo, conforme a descrição em python.org). Para habilitar
a depuração de modo misto, configure o projeto C/C++ para iniciar a Depuração do Python/Nativa :
1. Clique com o botão direito do mouse no projeto C/C++ em Gerenciador de soluções e selecione
Propriedades .
2. Selecione a guia Depuração , Depuração Nativa/do Python em Depurador a ser iniciado e OK .
NOTE
Se você não tiver a opção de selecionar a depuração do Python/Native , precisará primeiro instalar as ferramentas
de desenvolvimento nativo do Python usando o instalador do vs. Você pode encontrá-lo como uma opção na carga
de trabalho de desenvolvimento do Python. Para obter informações adicionais, consulte como instalar o suporte do
Python no Visual Studio no Windows.
Usando esse método, fique ciente de que você não pode depurar o próprio inicializador do py.exe, pois ele gera
um processo filho python.exe ao qual o depurador não será anexado. Caso deseje iniciar o python.exe
diretamente com argumentos, altere a opção Comando nas propriedades Depuração do Python/Nativa
(mostradas na imagem anterior) para especificar o caminho completo para python.exe e, em seguida,
especifique os argumentos em Argumentos do Comando .
Anexando o depurador de modo misto
Para todas as versões anteriores do Visual Studio, a depuração direta de modo misto é habilitada apenas ao
iniciar um projeto do Python no Visual Studio, pois os projetos do C/C++ usam somente o depurador nativo. No
entanto, você pode anexar o depurador separadamente:
1. Inicie o projeto C++ sem depuração (Debug > Iniciar Depuração sem depuração ou Ctrl + F5 ).
2. Selecione depuração > anexar ao processo . Na caixa de diálogo exibida, selecione o processo
apropriado e, em seguida, use o botão selecionar para abrir a caixa de diálogo Selecionar tipo de
código na qual você pode selecionar python :
3. Selecione OK para fechar essa caixa de diálogo, em seguida, Anexar para iniciar o depurador.
4. Talvez seja necessário introduzir uma pausa ou atraso adequado no aplicativo C++ para garantir que ele
não chame o código Python que você deseja depurar antes que você tenha a chance de anexar o
depurador.
Recursos específicos ao modo misto

Pilha de chamadas combinada
Exibição de valores PyObject no código nativo
Exibição de valores Nativos no código do Python
Pilha de chamadas combinada
A janela pilha de chamadas mostra os quadros de pilha nativos e Python intercalados, com transições
marcadas entre os dois:
As transições serão exibidas como [Código Externo] , sem especificar a direção da transição, se a opção
Ferramentas > Opções > Depuração > Geral > Habilitar Apenas Meu Código estiver definida.
Clicar duas vezes em um quadro de chamada o torna ativo e abre o código-fonte apropriado, se possível. Se o
código-fonte não estiver disponível, o quadro ainda ficará ativo e as variáveis locais poderão ser inspecionadas.
Ao usar os comandos Step Into (F11 ) ou Step Out (Shift + F11 ), o depurador de modo misto manipula
corretamente as alterações entre os tipos de código. Por exemplo, quando o Python chama um método de um
tipo implementado no C, a intervenção em uma chamada a esse método é interrompida no início da função
nativa que implementa o método. Da mesma forma, quando o código nativo chama uma função de API do
Python, isso resulta na invocação do código do Python. Por exemplo, a intervenção em um PyObject_CallObject
em um valor de função que foi originalmente definido no Python é interrompida no início da função do Python.
Também há suporte para a intervenção do Python para nativo em funções nativas invocadas do Python por
meio de ctypes.
Exibição de valores PyObject no código nativo
Quando um quadro nativo (C ou C++) estiver ativo, suas variáveis locais aparecerão na janela locais do
depurador. Nos módulos de extensão nativos do Python, muitas dessas variáveis são do tipo PyObject (que é
um typedef de _object ) ou alguns outros tipos fundamentais do Python (consulte a lista abaixo). Na depuração
de modo misto, esses valores apresentam um nó filho adicional rotulado [exibição do Python] . Quando
expandido, esse nó mostra a representação do Python da variável, idêntica a que você veria se uma variável local
referenciando o mesmo objeto estivesse presente em um quadro do Python. Os filhos desse nó são editáveis.
Para desabilitar esse recurso, clique com o botão direito do mouse em qualquer lugar da janela Locais e
ative/desative a opção de menu Python > Mostrar Nós de Exibição do Python :
Tipos C que mostram os nós [modo de exibição Python] (se habilitado):
PyObject
PyVarObject
PyTypeObject
PyByteArrayObject
PyBytesObject
PyTupleObject
PyListObject
PyDictObject
PySetObject
PyIntObject
PyLongObject
PyFloatObject
PyStringObject
PyUnicodeObject
[Exibição do Python] não aparece automaticamente para os tipos que você mesmo cria. Ao criar extensões
para Python 3. x, essa falta geralmente não é um problema porque qualquer objeto tem, por fim ob_base , um
campo de um dos tipos acima, o que faz com que [exibição do Python] apareça.
No entanto, para o Python 2.x, cada tipo de objeto normalmente declara seu cabeçalho como uma coleção de
campos embutidos e não há nenhuma associação entre os tipos criados personalizados e PyObject no nível do
sistema de tipos do código C/C++. Para habilitar nós da [exibição do Python] para esses tipos personalizados,
edite o arquivo PythonDkm.natvis no diretório de instalação das ferramentas Python e adicione outro elemento
ao XML do struct C ou da classe C++.
Uma opção alternativa (e melhor) é seguir o PEP 3123 e usar um campo PyObject ob_base; explícito em vez de
PyObject_HEAD , embora isso nem sempre seja possível por motivos de compatibilidade com versões anteriores.
Exibição de valores Nativos no código do Python

Semelhante à seção anterior, você pode habilitar um [modo de exibição C++] para valores nativos na janela
locais quando um quadro Python está ativo. Esse recurso não está habilitado por padrão; portanto, ative-o
clicando com o botão direito do mouse na janela Locais e ativando/desativando a opção de menu Python >
Mostrar Nós de Exibição do C++ .
O nó [modo de exibição c++] fornece uma representação da estrutura C/c++ subjacente para um valor,
idêntico ao que você veria em um quadro nativo. Por exemplo, ele mostra uma instância de _longobject (para a
qual PyLongObject é um typedef) de um inteiro longo do Python e tenta inferir tipos para as classes nativas
criadas por conta própria. Os filhos desse nó são editáveis.
Se um campo filho de um objeto for do tipo PyObject , ou um dos outros tipos com suporte, ele terá um nó de
representação [modo de exibição do Python] (se essas representações estiverem habilitadas), possibilitando
a navegação de gráficos de objeto em que os links não são expostos diretamente para o Python.
Ao contrário de nós [modo de exibição Python] , que usam metadados de objeto Python para determinar o
tipo do objeto, não há um mecanismo confiável semelhante para [modo de exibição C++] . Em termos gerais,
considerando um valor do Python (ou seja, uma referência PyObject ), não é possível determinar com confiança
qual estrutura do C/C++ está dando suporte a ele. O depurador de modo misto tenta adivinhar esse tipo,
observando vários campos do tipo de objeto (como o PyTypeObject referenciado por seu campo ob_type ) que
têm tipos de ponteiro de função. Se um desses ponteiros de função referenciar uma função que pode ser
resolvida e essa função tiver um parâmetro self com um tipo mais específico que PyObject* , esse tipo será
considerado como o tipo de suporte. Por exemplo, se ob_type->tp_init de um objeto especificado apontar para
a seguinte função:
static int FobObject_init(FobObject* self, PyObject* args, PyObject* kwds) {

return 0;
}
o depurador poderá deduzir corretamente que o tipo C do objeto é FobObject . Se não for possível determinar
um tipo mais preciso de tp_init , ele seguirá para outros campos. Se não for possível deduzir o tipo de
qualquer um desses campos, o nó [modo de exibição C++] apresentará o objeto como uma PyObject
instância.
Para obter sempre uma representação útil de tipos criados personalizados, é melhor registrar pelo menos uma
função especial ao registrar o tipo e usar um parâmetro self fortemente tipado. A maioria dos tipos atende a
esse requisito naturalmente; se não for o caso, geralmente, tp_init será a entrada mais conveniente a ser usada
para essa finalidade. Uma implementação fictícia de tp_init de um tipo que está presente exclusivamente para
habilitar a inferência de tipos do depurador pode apenas retornar zero imediatamente, como no exemplo de
código acima.
Diferenças da depuração padrão do Python

O depurador de modo misto é diferente do depurador padrão do Python, que introduz alguns recursos
adicionais, mas que não contém algumas funcionalidades relacionadas ao Python:
Recursos sem suporte: pontos de interrupção condicionais, janela interativa de depuração e depuração
remota de plataforma cruzada.
Janela imediata : está disponível, mas com um subconjunto limitado de sua funcionalidade, incluindo todas
as limitações listadas aqui.
Versões do Python com suporte: somente CPython 2.7 e 3.3+.
Shell do Visual Studio: ao usar o Python com o Shell do Visual Studio (por exemplo, se ele tiver sido instalado
por meio do instalador integrado), o Visual Studio não poderá abrir projetos do C++ e a experiência de
edição para arquivos do C++ será apenas a de um editor de texto básico. No entanto, há suporte completo
para a depuração do C/C++ e a depuração de modo misto no Shell com código-fonte, execução em etapas
em código nativo e avaliação de expressão do C++ nas janelas do depurador.
Exibindo e expandindo objetos: ao exibir objetos Python nas janelas de ferramentas locais e assistir ao
depurador, o depurador de modo misto mostra apenas a estrutura dos objetos. Ele não avalia propriedades
automaticamente nem mostra atributos computados. Para coleções, ele mostra apenas os elementos de tipos
de coleção interna ( tuple , list , dict , set ). Os tipos de coleção personalizada não são visualizados como
coleções, a menos que sejam herdados de algum tipo de coleção interna.
Avaliação de expressão: consulte abaixo.
Avaliação de expressão
O depurador padrão do Python permite a avaliação de expressões de Python arbitrárias em inspeção e janelas
imediatas quando o processo depurado é pausado em qualquer ponto do código, desde que ele não seja
bloqueado em uma operação de e/s ou outra chamada de sistema semelhante. Na depuração de modo misto, as
expressões arbitrárias podem ser avaliadas somente quando interrompidas no código do Python, depois de um
ponto de interrupção ou intervindo no código. As expressões podem ser avaliadas apenas no thread em que o
ponto de interrupção ou a operação de intervenção ocorreu.
Quando interrompida no código nativo ou no código do Python quando as condições acima não se aplicarem
(por exemplo, após uma operação de depuração circular ou em um thread diferente), a avaliação da expressão é
limitada ao acesso das variáveis locais e globais no escopo do quadro atualmente selecionado, ao acesso de seus
campos e à indexação de tipos de coleção interna com literais. Por exemplo, a seguinte expressão pode ser
avaliada em qualquer contexto (desde que todos os identificadores refiram-se a variáveis e a campos existentes
dos tipos apropriados):
foo.bar[0].baz['key']
O depurador de modo misto também resolve essas expressões de outra forma. Todas as operações de acesso a
membro pesquisam somente os campos que fazem parte diretamente do objeto (como uma entrada em seu
__dict__ ou __slots__ , ou um campo de um struct nativo que é exposto ao Python por meio de tp_members ) e
ignoram qualquer __getattr__ , __getattribute__ ou lógica do descritor. Da mesma forma, todas as operações
de indexação ignoram __getitem__ e acessam as estruturas de dados internas das coleções diretamente.
Para fins de consistência, esse esquema de resolução de nomes é usado para todas as expressões que
correspondem às restrições de avaliação de expressão limitada, independentemente se as expressões arbitrárias
são permitidas no ponto de interrupção atual. Para forçar a semântica correta do Python quando um avaliador
completo está disponível, coloque a expressão entre parênteses:
(foo.bar[0].baz['key'])
Instalar símbolos de depuração para interpretadores
do Python
Para fornecer uma experiência de depuração completa, o depurador de modo misto do Python no Visual Studio
precisa de símbolos de depuração para que o interpretador do Python sendo usado analise várias estruturas de
dados internas. Por python27.dll, por exemplo, o arquivo de símbolo correspondente é python27. pdb; por
python36.dll, o arquivo de símbolo é python36. pdb. Cada versão do interpretador também fornece arquivos de
símbolo para diversos módulos.
Com o Visual Studio 2017 e posterior, os interpretadores do Python 3 e do Anaconda 3 instalam automaticamente
seus respectivos símbolos e o Visual Studio encontra esses símbolos de forma automática. Para o Visual Studio
2015 e anterior, ou ao usar outros interpretadores, você precisa baixar símbolos separadamente e, em seguida,
apontar o Visual Studio para eles por meio da caixa de diálogo opções de ferramentas > Options na guia
símbolos de depuração > Symbols . Essas etapas são detalhadas nas seções a seguir.
É possível que o Visual Studio faça solicitações quando precisar de símbolos, normalmente ao iniciar uma sessão
de depuração de modo misto. Nesse caso, ele exibe uma caixa de diálogo com duas opções:
A caixa de diálogo Abrir configurações de símbolo abre a caixa de diálogo Opções na guia
Depuração > Símbolos .
Baixar símbolos para o interpretador abrirá esta página de documentação. Nesse caso, selecione,
Ferramentas > Opções e navegue para a guia Depuração > Símbolos para continuar.
Baixar símbolos
Python 3.5 e versões posteriores: adquira símbolos de depuração por meio do instalador do Python.
Selecione Instalação personalizada , selecione Avançar para ir para as Opções Avançadas e, em
seguida, marque as caixas para Baixar símbolos de depuração e Baixar binários de depuração :
Em seguida, os arquivos de símbolo (.pdb) são encontrados na pasta de instalação raiz (os arquivos de
símbolo para módulos individuais também estão na pasta DLLs). Por isso, o Visual Studio os localiza
automaticamente e nenhuma etapa adicional é necessária.
Python 3.4. x e anterior: os símbolos estão disponíveis como arquivos . zip que podem ser baixados das
distribuições oficiais ou Canopys. Após o download, extraia os arquivos para uma pasta local para continuar,
como uma pasta Symbols dentro da pasta do Python.
IMPORTANT
Os símbolos são diferentes entre builds secundárias do Python e entre compilações de 32 e 64 bits, assim, é
desejável que as versões sejam correspondentes. Para verificar o intérprete que está sendo usado, expanda o nó
ambientes Python em seu projeto no Gerenciador de soluções e observe o nome do ambiente. Em seguida,
mude para a janela Ambientes do Python e anote o local de instalação. Em seguida, abra uma janela Comando
nesse local e inicie python.exe, que exibirá a versão exata e se ela é de 32 ou 64 bits.
Para qualquer outra distribuição do Python de terceiros, como o ActiveState Python, será necessário entrar
em contato com os autores dessa distribuição e solicitar que eles forneçam símbolos. No entanto, o
WinPython incorpora o interpretador padrão do Python sem alterações; portanto, use símbolos da
distribuição oficial para o número de versão correspondente.
Apontar o Visual Studio para os símbolos

Se os símbolos tiverem sido baixados separadamente, siga as etapas abaixo para que o Visual Studio os
reconheça. Se os símbolos foram instalados por meio do Python 3.5 ou de um instalador posterior, o Visual Studio
os encontra automaticamente.
1. Selecione o Tools > menuOpções de ferramentas e navegue até símbolos de depuração > Symbols .
2. Selecione o botão Adicionar na barra de ferramentas (descrita abaixo), insira a pasta em que os símbolos
baixados foram expandidos (em que python.pdb está localizado, como c:\python34\Symbols, conforme
mostrado abaixo) e selecione OK .
3. Durante uma sessão de depuração, o Visual Studio também pode solicitar o local de um arquivo de origem
para o interpretador de Python. Se você baixou os arquivos de origem (de Python.org/downloads/, por
exemplo), é claro que você pode apontar para eles também.
NOTE
As funcionalidades de cache de símbolo mostradas no diálogo são usadas para criar um cache local de símbolos obtidos de
uma fonte online. Essas funcionalidades não serão necessárias com os símbolos do interpretador de Python, uma vez que os
símbolos já estão presentes localmente. Em qualquer caso, consulte especificar símbolos e arquivos de origem no depurador
do Visual Studio para obter detalhes.
Distribuições oficiais
VERSÃ O DO P Y T H O N DO W N LO A DS
3.5 e versões posteriores Instale símbolos por meio do instalador do 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

VERSÃ O DO P Y T H O N DO W N LO A DS
3.3.2 32 bits - 64 bits
3.3.1 32 bits - 64 bits
3.3.0 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
O Enthought Canopy fornece símbolos para seus binários a partir da versão 1.2. Eles são instalados
automaticamente juntamente com a distribuição, mas você ainda precisa adicionar manualmente a pasta que os
contém ao caminho do símbolo, conforme descrito anteriormente. Para uma instalação típica por usuário do
Canopy, os símbolos estão localizados em %UserProfile%\AppData\Local\Enthought\Canopy\User\Scripts para a
versão de 64 bits e em %UserProfile%\AppData\Local\Enthought\Canopy32\User\Scripts para a versão de 32 bits.
O Enthought Canopy 1.1 e anterior, bem como o EPD (Enthought Python Distribution), não fornecem símbolos de
interpretador e, portanto, não são compatíveis com a depuração de modo misto.
Criar perfil do código do Python
Você pode criar um perfil de um aplicativo Python ao usar interpretadores baseados em CPython. (Confira Matriz
de recursos – criação de perfil para saber a disponibilidade desse recurso para diferentes versões do Visual
Studio.)
Criação de perfil para interpretadores baseados em CPython

A criação de perfil é iniciada por meio do comando de menu analisar > Iniciar criação de perfil de python ,
que abre uma caixa de diálogo de configuração:
Quando você seleciona OK , o criador de perfil é executado e abre um relatório de desempenho por meio do qual é
possível explorar como o tempo é gasto no aplicativo:
NOTE
No momento, o Visual Studio oferece suporte somente a esse nível de criação de perfil de aplicativo completo, mas
certamente queremos ouvir seus comentários sobre recursos futuros. Use o botão Comentários sobre o produto no
final desta página.
Criação de perfil do IronPython

Como o IronPython não é um interpretador baseado em CPython, o recurso de criação de perfil não funciona.
Em vez disso, use o criador de perfil do .NET do Visual Studio iniciando ipy.exe diretamente como o aplicativo de
destino, usando os argumentos apropriados para iniciar o script de inicialização. Inclua -X:Debug na linha de
comando para garantir que todo o seu código Python possa ser depurado e seja passível à criação de perfil. Esse
argumento gera um relatório de desempenho, incluindo o tempo gasto no runtime do IronPython e no código. O
código é identificado usando nomes danificados.
Como alternativa, o IronPython tem alguns de seus próprios recursos de criação de perfis internos, mas
atualmente não há nenhum visualizador adequado para eles. Consulte An IronPython Profiler (Um criador de
perfil do IronPython) (blogs do MSDN) para ver o que está disponível.
Configurar o teste de unidade para o código do
Python
Testes de unidade são partes do código que testam outras unidades de código em um aplicativo, normalmente,
funções isoladas, classes e assim por diante. Quando um aplicativo é aprovado em todos os seus testes de
unidade, pelo menos, é possível confiar que sua funcionalidade de baixo nível está correta.
O Python usa testes de unidade extensivamente para validar cenários durante a criação de um programa. O
suporte do Python no Visual Studio inclui a descoberta, a execução e a depuração de testes de unidade no
contexto do processo de desenvolvimento, sem precisar executar os testes separadamente.
Este artigo fornece uma breve descrição das funcionalidades de teste de unidade no Visual Studio com o Python.
Para obter mais informações sobre testes de unidade em geral, consulte Executar um teste de unidade no código.
Descobrir e exibir testes

Por convenção, o Visual Studio identifica os testes como métodos cujos nomes começam com test . Para ver esse
comportamento, faça o seguinte:
1. Abra um projeto Python carregado no Visual Studio, clique com o botão direito do mouse no projeto,
escolha Adicionar > Novo Item e escolha Teste de Unidade do Python seguido por Adicionar .
2. Isso cria um arquivo test1.py com um código que importa o módulo unittest padrão, deriva uma classe
de teste de unittest.TestCase e invoca unittest.main() se o script é executado diretamente:
import unittest
class Test_test1(unittest.TestCase):
def test_A(self):
self.fail("Not implemented")
if __name__ == '__main__':
unittest.main()
3. Salve o arquivo se necessário e, em seguida, abra o Gerenciador de Testes com o comando de menu
Teste > Windows > ** Gerenciador de Testes**.
4. O Gerenciador de testes pesquisa o projeto em busca de testes e os exibe conforme mostrado abaixo. Se
você clicar duas vezes em um teste, seu arquivo de origem será aberto.
5. Conforme você adiciona mais testes ao seu projeto, pode organizar o modo de exibição no Gerenciador
de testes usando o menu Agrupar por na barra de ferramentas:
6. Você também pode inserir texto no campo de pesquisa para filtrar os testes por nome.
Para obter mais informações sobre o unittest módulo e escrever testes, consulte a documentação do Python 2,7
ou a documentação do Python 3,7 (Python.org).
Executar testes
No Gerenciador de testes , você pode executar testes de várias maneiras:
Executar Todos claramente executa todos os testes mostrados (sujeito a filtros).
O menu executar fornece comandos para execução de testes com falha, aprovação ou não execução como um
grupo.
É possível selecionar um ou mais testes, clicar com o botão direito do mouse e selecionar Executar Testes
Selecionados .
Testes executados em segundo plano e Test Explorer atualiza o status de cada teste à medida que ele é concluído:
Os testes aprovados mostram um tique verde e o tempo necessário para executar o teste:
Os testes com falha mostram uma cruz vermelha com um link Saída que mostra a saída do console e a
saída unittest da execução de teste:
Depurar testes
Como os testes de unidade são partes do código, eles estão sujeitos a bugs, assim como qualquer outro código e,
ocasionalmente, precisam ser executados em um depurador. No depurador é possível definir pontos de
interrupção, examinar variáveis e executar o código em etapas. O Visual Studio também fornece ferramentas de
diagnóstico para testes de unidade.
Para iniciar a depuração, defina um ponto de interrupção inicial em seu código, clique com o botão direito do
mouse no teste (ou uma seleção) no Gerenciador de testes e selecione depurar testes selecionados . O
Visual Studio inicia o depurador do Python como faria com o código do aplicativo.
Você também pode usar a cober tura de código de análise para testes selecionados . Para obter mais
informações, confira Usar a cobertura de código para determinar quanto do código está sendo testado.
Problemas conhecidos
Ao iniciar a depuração, o Visual Studio parece iniciar e interromper a depuração e, em seguida, iniciá-la
novamente. O comportamento é esperado.
Quando estiver depurando vários testes, cada um deles será executado de forma independente, o que
interromperá a sessão de depuração.
O Visual Studio falha intermitentemente ao iniciar um teste durante a depuração. Normalmente, a tentativa de
depurar o teste novamente tem êxito.
Durante a depuração, é possível executar a depuração circular de um teste na implementação unittest .
Normalmente, a próxima etapa é executada ao final do programa e interrompe a depuração.
Selecione a estrutura de teste para um projeto Python

O Visual Studio dá suporte a duas estruturas de teste para Python, UnitTest e pytest (disponível no Visual Studio
2019 a partir da versão 16,3). Por padrão, nenhuma estrutura é selecionada quando você cria um projeto Python.
Para especificar uma estrutura, clique com o botão direito do mouse no nome do projeto em Gerenciador de
Soluções e selecione a opção Propriedades . Isso abre o designer de projeto, que permite que você configure
testes por meio da guia teste . Nessa guia, você pode selecionar a estrutura de teste que deseja usar para seu
projeto.
Para a estrutura UnitTest , o diretório raiz do projeto é usado para a descoberta de teste. Esse local, bem como
o padrão de texto para identificar os testes, podem ser modificados na guia teste para valores especificados
pelo usuário.
Para a estrutura pytest , as opções de teste, como local de teste e padrões de nome de arquivo, são
especificadas usando o arquivo de configuração padrão pytest. ini. Consulte a documentação de referência do
pytest para obter mais detalhes.
Depois de salvar as configurações e a seleção da estrutura, a descoberta de testes será iniciada no Gerenciador de
testes. Se a janela Gerenciador de testes ainda não estiver aberta, navegue até a barra de ferramentas e selecione
testar > Gerenciador de testes .
Configurar testes para Python sem um projeto

O Visual Studio permite executar e testar o código Python existente sem um projeto, abrindo uma pasta com
código Python. Sob essas circunstâncias, você precisará usar um PythonSettings.jsno arquivo para configurar o
teste.
1. Abra o código Python existente usando a opção abrir uma pasta local .
2. Na janela Gerenciador de Soluções, clique no ícone Mostrar todos os arquivos para mostrar todos os
arquivos na pasta atual.
3. Navegue até o PythonSettings.jsno arquivo na pasta configurações locais . Se você não vir esse
arquivo na pasta configurações locais , crie-o manualmente.
4. Adicione o campo TestFrameWork ao arquivo de configurações e defina-o como pytest ou UnitTest
dependendo da estrutura de teste que você deseja usar.
{
"TestFramework": "unittest",
"UnitTestRootDirectory": "testing",
"UnitTestPattern": "test_*.py"
}
NOTE
Para a estrutura UnitTest , se os campos UnitTestRootDirector y e UnitTestPattern não forem especificados no
PythonSettings.jsno arquivo, eles serão adicionados e atribuídos valores padrão "." e "Test *. py", respectivamente.
5. Se sua pasta contiver um diretório src separado da pasta que contém seus testes, especifique o caminho
para a pasta src usando o campo SearchPaths em seu PythonSettings.jsno arquivo.
{
"TestFramework": "unittest",
"UnitTestRootDirectory": "testing",
"UnitTestPattern": "test_*.py",
"SearchPaths": [ ".\\src"]
}
6. Salve suas alterações no PythonSettings.jsno arquivo para iniciar a descoberta de teste para a estrutura
especificada.
NOTE
Se a janela Gerenciador de testes já estiver aberta Ctrl + R, uma também disparará A descoberta.
Descobrir e exibir testes

Por padrão, o Visual Studio identifica os testes UnitTest e pytest como métodos cujos nomes começam com
test . Para ver a descoberta de teste, faça o seguinte:
1. Abra um projeto do Python.

2. Depois que o projeto for carregado no Visual Studio, clique com o botão direito do mouse em seu projeto
no Gerenciador de Soluções e selecione a estrutura UnitTest ou Pytest na guia teste de propriedades.
NOTE
Se você usar a estrutura pytest, poderá especificar o local de teste e os padrões de nome de arquivo usando o
arquivo de configuração padrão pytest. ini. Por padrão, a pasta de trabalho/projeto é usada, com um padrão de
test_*py e *_test.py . Consulte a documentação de referência do pytest para obter mais detalhes.
3. Depois que a estrutura for selecionada, clique com o botão direito do mouse no projeto novamente e
selecione Adicionar > novo item , em seguida, selecione teste de unidade do Python seguido por
Adicionar .
4. Essa ação cria um arquivo test_1. py com código que importa o unittest módulo padrão, deriva uma
classe de teste de unittest.TestCase e invoca unittest.main() se você executa o script diretamente:
import unittest
class Test_test1(unittest.TestCase):
def test_A(self):
self.fail("Not implemented")
if __name__ == '__main__':
unittest.main()
5. Salve o arquivo, se necessário, abra o Gerenciador de testes com o comando de menu Test > Test
Explorer .
6. O Gerenciador de testes pesquisa o projeto em busca de testes e os exibe conforme mostrado abaixo. Se
você clicar duas vezes em um teste, seu arquivo de origem será aberto.
7. Conforme você adiciona mais testes ao seu projeto, pode organizar o modo de exibição no Gerenciador
de testes usando o menu Agrupar por na barra de ferramentas:
8. Você também pode inserir texto no campo de pesquisa para filtrar os testes por nome.
Para obter mais informações sobre o unittest módulo e escrever testes, consulte a documentação do Python 2,7
ou a documentação do Python 3,7 (Python.org).
Executar testes
No Gerenciador de testes , você pode executar testes de várias maneiras:
Executar Todos claramente executa todos os testes mostrados (sujeito a filtros).
O menu executar fornece comandos para execução de testes com falha, aprovação ou não execução como um
grupo.
É possível selecionar um ou mais testes, clicar com o botão direito do mouse e selecionar Executar Testes
Selecionados .
Testes executados em segundo plano e Test Explorer atualiza o status de cada teste à medida que ele é concluído:
Os testes aprovados mostram um tique verde e o tempo necessário para executar o teste:
Os testes com falha mostram uma cruz vermelha com um link Saída que mostra a saída do console e a
saída unittest da execução de teste:
Depurar testes
Como os testes de unidade são partes do código, eles estão sujeitos a bugs, assim como qualquer outro código e,
ocasionalmente, precisam ser executados em um depurador. No depurador é possível definir pontos de
interrupção, examinar variáveis e executar o código em etapas. O Visual Studio também fornece ferramentas de
diagnóstico para testes de unidade.
NOTE
Por padrão, a depuração de teste usa o depurador do ptvsd 4 para o Visual Studio 2017 (versões 15,8 e posteriores) e o
debugpy para Visual Studio 2019 (versões 16,5 e posteriores). Se você quiser usar o ptvsd 3, poderá selecionar a opção
usar depurador herdado em opções ferramentas > Options > Python > depuração do Python.
Para iniciar a depuração, defina um ponto de interrupção inicial em seu código, clique com o botão direito do
mouse no teste (ou uma seleção) no Gerenciador de testes e selecione depurar testes selecionados . O
Visual Studio inicia o depurador do Python como faria com o código do aplicativo.
Você também pode usar a cober tura de código de análise para testes selecionados . Para obter mais
informações, confira Usar a cobertura de código para determinar quanto do código está sendo testado.
Usar a extensão Cookiecutter
O Cookiecutter fornece uma interface gráfica do usuário para descobrir modelos e opções de modelo de entrada
e criar projetos e arquivos. Ele é incluído no Visual Studio 2017 e posterior e pode ser instalado separadamente
em versões anteriores do Visual Studio.
O Cookiecutter exige o Python 3.3 ou posterior (32 ou 64 bits) ou o Anaconda 3 4.2 ou posterior (32 ou 64 bits).
Se um interpretador do Python adequado não estiver disponível, o Visual Studio exibirá um aviso. Se você
instalar um interpretador do Python enquanto o Visual Studio estiver em execução, clique no botão página
inicial na barra de ferramentas CookieCutter para detectar o intérprete recentemente instalado. (Veja ambientes
Python para obter mais informações sobre ambientes em geral.)
Depois de instalado, selecione Exibir > CookieCutter Explorer para abrir sua janela:
Fluxo de trabalho do Cookiecutter

Trabalhar com o Cookiecutter é um processo que inclui procurar e selecionar um modelo, cloná-lo no
computador local, configurar opções e, em seguida, criar um código com base nesse modelo, conforme descrito
nas próximas seções.
Procurar modelos
A home page do Cookiecutter exibe uma lista de modelos a serem escolhidos, organizados nos seguintes grupos:
A GRUPA R DESC RIÇ Ã O
Instalado Modelos que foram instalados no computador local. Quando

um modelo online é usado, seu repositório é clonado
automaticamente em uma subpasta de ~/.cookiecutters. É
possível excluir um modelo instalado escolhido pressionando
Delete .
A GRUPA R DESC RIÇ Ã O
Recomendadas Modelos carregados do feed recomendado. O feed padrão é

coletado pela Microsoft. Consulte Opções do Cookiecutter
abaixo para obter detalhes sobre como personalizar o feed.
GitHub Resultados da pesquisa do GitHub para a palavra-chave

cookiecutter. Os resultados do GitHub retornam paginados e,
se houver mais resultados disponíveis, a opção Carregar
Mais será exibida ao final da lista.
Personalizado Quando uma localização personalizada é inserida na caixa de

pesquisa, ela é exibida nesse grupo. É possível digitar um
caminho completo para o repositório GitHub ou o caminho
completo para uma pasta no disco local.
Clonar
Ao selecionar um modelo seguido por Avançar , o Cookiecutter faz uma cópia local com a qual trabalhará.
Se você selecionar um modelo dos grupos Recomendados ou GitHub ou inserir uma URL personalizada na
caixa de pesquisa e selecionar esse modelo, ele será clonado e instalado no computador local. Se o modelo tiver
sido instalado em uma sessão anterior do Visual Studio, ele será excluído automaticamente e a última versão será
clonada.
Se você selecionar um modelo do grupo Instalados ou inserir um caminho de pasta personalizada na caixa de
pesquisa e selecionar esse modelo, o Visual Studio carregará o modelo sem cloná-lo.
IMPORTANT
Os modelos do Cookiecutter são clonados em uma única pasta ~/.cookiecutters. Cada subpasta é nomeada de acordo com
o nome do repositório Git, que não inclui o nome de usuário do GitHub. Poderão surgir conflitos se você clonar modelos
diferentes com o mesmo nome que são de autores diferentes. Nesse caso, o Cookiecutter impede que você substitua o
modelo existente por um modelo diferente com o mesmo nome. Para instalar o outro modelo, é necessário primeiro excluir
existente.
Configurar opções de modelo

Depois que o modelo for instalado localmente, o Cookiecutter exibirá uma página de opções na qual é possível
especificar a localização em que você deseja que o Cookiecutter gere arquivos, junto com outras opções:
Cada modelo do Cookiecutter define seu próprio conjunto de opções e especifica um valor padrão para cada um
(exibido como o texto sugerido em cada campo de entrada). Um valor padrão pode ser um snippet de código,
geralmente, quando ele é um valor dinâmico que usa outras opções.
É possível personalizar os valores padrão de opções específicas com um arquivo de configuração do usuário.
Quando a extensão Cookiecutter detecta um arquivo de configuração do usuário, ela substitui os valores padrão
do modelo pelos valores padrão da configuração do usuário. Esse comportamento é abordado na seção
Configuração do usuário da documentação do Cookiecutter.
Se o modelo especificar tarefas específicas do Visual Studio a serem executadas após a geração de código, uma
opção adicional Executar tarefas adicionais após a conclusão será exibida, que permite recusar essas
tarefas. O uso mais comum de tarefas é abrir um navegador da Web, abrir arquivos no editor, instalar
dependências e assim por diante.
Criar
Depois de configurar as opções, selecione Criar para gerar o código (um aviso será exibido se a pasta de saída
não estiver vazia). Se estiver familiarizado com a saída do modelo e não se incomodar em substituir arquivos,
ignore o aviso. Caso contrário, selecione Cancelar , especifique uma pasta vazia e, em seguida, copie
manualmente os arquivos criados para a pasta de saída não vazia.
Depois que os arquivos forem criados com êxito, o Cookiecutter fornecerá uma opção para abri-los no
Gerenciador de Soluções :
Opções do Cookiecutter
As opções de CookieCutter estão disponíveis por meio de ferramentas > Opções > CookieCutter :
URL de feed recomendada A localização do feed recomendado dos modelos. Pode ser
uma URL ou um caminho para um arquivo local. Deixe a URL
vazia para usar o feed padrão coletado pela Microsoft. O feed
fornece uma lista simples de localizações de modelos,
separadas por novas linhas. Para solicitar alterações ao feed
coletado, faça uma solicitação pull na fonte, no GitHub.
Mostrar Ajuda Controla a visibilidade da barra de informações de ajuda na

parte superior da janela do Cookiecutter.
Otimizar modelos do Cookiecutter para o Visual Studio

Para obter noções básicas sobre como criar um modelo do Cookiecutter, consulte a documentação do
Cookiecutter. A extensão Cookiecutter para o Visual Studio dá suporte aos modelos criados para o Cookiecutter
v1.4.
A renderização padrão de uma variável de modelo depende do tipo de dados (cadeia de caracteres ou lista):
Cadeia de caracteres: rótulo do nome da variável, caixa de texto para inserção do valor e uma marca-d'água
mostrando o valor padrão. A dica de ferramenta na caixa de texto mostra o valor padrão.
Lista: rótulo do nome da variável e caixa de combinação para seleção de um valor. A dica de ferramenta na
caixa de combinação mostra o valor padrão.
É possível melhorar essa renderização especificando metadados adicionais no arquivo cookiecutter.json que são
específicos ao Visual Studio (e ignorados pela CLI do Cookiecutter). Todas as propriedades são opcionais:
P RO P RIEDA DE DESC RIÇ Ã O
Rotular Especifica o que é exibido acima do editor para a variável, em

vez do nome da variável.
Descrição Especifica a dica de ferramenta que é exibida no controle de

edição, em vez do valor padrão dessa variável.
P RO P RIEDA DE DESC RIÇ Ã O
URL Altera o rótulo para um hiperlink, com uma dica de

ferramenta que mostra a URL. Se você clicar no hiperlink, o
navegador padrão do usuário será aberto nessa URL.
Seletor Permite a personalização do editor para uma variável.

Atualmente, há suporte para os seguintes seletores:
string : caixa de texto padrão, o padrão para cadeias
de caracteres.
list : caixa de combinação padrão, o padrão para
listas.
yesno : caixa de combinação para escolher entre y
e n , para cadeias de caracteres.
odbcConnection : Caixa de texto com um botão ...
que abre um diálogo de conexão de banco de dados.
Exemplo:
{
"site_name": "web-app",
"python_version": ["3.5.2", "2.7.12"],
"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"
}
}
}
Executar tarefas do Visual Studio

O Cookiecutter tem um recurso chamado Pós-gerar Ganchos, que permite a execução do código arbitrário do
Python após a geração dos arquivos. Embora seja flexível, ele não permite fácil acesso ao Visual Studio.
Por exemplo, talvez você deseje abrir um arquivo no editor do Visual Studio, em seu navegador da Web ou
disparar a interface do usuário do Visual Studio que solicita que o usuário crie um ambiente virtual e instale os
requisitos do pacote.
Para permitir esses cenários, o Visual Studio procura metadados estendidos em cookiecutter.json, que descreve os
comandos a serem executados depois que o usuário abrir os arquivos gerados no Gerenciador de Soluções
ou depois que os arquivos forem adicionados a um projeto existente. (Novamente, o usuário pode recusar a
execução das tarefas desmarcando Executar tarefas adicionais após a conclusão nas opções de modelo.)
Exemplo:
"_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"
}
]
Os comandos são especificados pelo nome e devem usar o nome não localizado (em inglês) para funcionar em
instalações localizadas do Visual Studio. Você pode testar e descobrir os nomes de comando na janela de
comando do Visual Studio.
Se desejar passar um único argumento, especifique-o como uma cadeia de caracteres, como no exemplo anterior.
Se não precisar passar um argumento, deixe-o como uma cadeia de caracteres vazia ou omita-o do JSON:
{
"name": "View.WebBrowser"
}
]
Use uma matriz para vários argumentos. Para opções, divida a opção e seu valor em argumentos separados e use
a delimitação correta. Por exemplo:
{
"name": "File.OpenFile",
"args": [
"{{cookiecutter._output_folder_path}}\\read me.txt",
"/e:",
"Source Code (text) Editor"
]
}
]
Os argumentos podem se referir a outras variáveis do Cookiecutter. Nos exemplos acima, a variável
_output_folder_path interna é usada para formar um caminho absoluto para os arquivos gerados.
Observe que o comando Python.InstallProjectRequirements apenas funciona ao adicionar arquivos a um projeto

existente. Essa limitação existe porque o comando é processado pelo projeto Python no Gerenciador de
Soluções e não há nenhum projeto para receber a mensagem no Gerenciador de Soluções - Exibição de
Pasta . Esperamos remover a limitação de uma versão futura (e fornecer um melhor suporte à exibição de
pasta em geral).
Erro ao carregar o modelo
Alguns modelos podem estar usando tipos de dados inválidos, como booliano, em seu cookiecutter.json. Reporte
essas instâncias para o autor do modelo selecionando o link Problemas no painel de informações do modelo.
Script de gancho com falha
Alguns modelos podem usar scripts pós-geração que não são compatíveis com a interface do usuário do
Cookiecutter. Por exemplo, os scripts que consultam a entrada do usuário falha devido a não ter um console de
terminal.
Script de gancho sem suporte no Windows
Se o pós-script for .sh, ele poderá não ser associado a um aplicativo no computador Windows. Você poderá ver
uma caixa de diálogo do Windows solicitando que você encontre um aplicativo compatível na Windows Store.
Modelos com problemas conhecidos
Falhas de clone:
wildfish/cookiecutter-django-crud (caractere inválido | no nome da subpasta)
cookiecutter-pyvanguard (caractere inválido | no nome da subpasta)
Falhas de carregamento:
chrisdev/wagtail-CookieCutter-Foundation (usa um tipo booliano em cookiecutter.jsem)
quintoandar/cookiecutter-android (nenhuma pasta de modelos)
Falhas de execução:
iknite/cookiecutter-ansible-role (pós-script de gancho exige entrada do console)
benregn/cookiecutter-django-ansible (Erro Jinja)
Usa bash (não fatal):
openstack-dev/cookiecutter
Modelos de item do Python
Os modelos de item estão disponíveis em projetos do Python Project por meio do > comando de
menuAdicionar novo item do projeto ou do comando Adicionar > novo item no menu de contexto no
Gerenciador de soluções .
Se você usar o nome fornecido para o item, o modelo geralmente criará um ou mais arquivos e pastas dentro da
pasta que está atualmente marcada no projeto (ao clicar duas vezes com o botão direito do mouse em uma
pasta para exibir o menu de contexto, essa pasta será automaticamente marcada). Se você adicionar um item, ele
será incluído no projeto do Visual Studio e será exibido no Gerenciador de Soluções .
A tabela a seguir explica brevemente o efeito de cada modelo de item em um projeto do Python:
M O DELO O Q UE O M O DELO C RIA
Arquivo vazio do Python Um arquivo vazio com a extensão .py.
Classe Python Um arquivo .py que contém uma única definição de classe
vazia do Python.
Pacote do Python Uma pasta que contém um arquivo * _ _ init _ _ . py* .
Teste de Unidade do Python Um arquivo .py com um único teste de unidade baseado na
estrutura unittest , juntamente com uma chamada a
unittest.main() para executar os testes no arquivo.
Página HTML Um arquivo .html com uma estrutura de página simples que
consiste em um <head> e um elemento <body> .
JavaScript Um arquivo .js vazio.
Folha de estilos Um arquivo .css que contém um estilo vazio para body .
Arquivo de texto Um arquivo .txt vazio.
Aplicativo Django 1.9 Uma pasta com o nome do aplicativo que contém os
Aplicativo Django 1.4 arquivos principais de um aplicativo do Django conforme
explicado em Aprender Django no Visual Studio, Etapa 2 de
2 para o Django 1.9. No caso do Django 1.4, a pasta
migrations, o arquivo admin.py e o arquivo apps.py não
estão incluídos.
Janela WPF do IronPython Uma janela WPF consiste em dois arquivos lado a lado: um
arquivo .xaml que define um <Window> com um elemento
<Grid> vazio e um arquivo .py associado que carrega o
arquivo XAML usando a biblioteca do wpf . Normalmente
usado em um projeto criado usando um dos modelos de
projeto do IronPython. Confira Gerenciar projetos Python –
Modelos de projetos.
Arquivos de Supor te de Função da Web Uma pasta bin na raiz do projeto (independentemente da
pasta escolhida no projeto). A pasta contém um script de
implantação padrão e um arquivo web.config para funções
da web do Serviço de Nuvem do Azure. O modelo também
inclui um arquivo readme.html que explica os detalhes.
Arquivos de supor te à função de trabalho Uma pasta bin na raiz do projeto (independentemente da
pasta escolhida no projeto). A pasta contém o script de
implantação e lançamento padrão, além de um arquivo
web.config, para funções de trabalho do Serviço de Nuvem
do Azure. O modelo também inclui um arquivo readme.html
que explica os detalhes.
web.config do Azure (FastCGI) Um arquivo web.config que contém entradas para aplicativos
que usam um objeto WSGI para tratar das conexões de
entrada. Normalmente, esse arquivo é implantado na raiz de
um servidor Web que executa o IIS. Para saber mais, confira
Configurar um aplicativo para IIS.
web.config do Azure (HttpPlatformHandler) Um arquivo web.config que contém entradas para aplicativos
que escutam conexões de entrada com um soquete.
Normalmente, esse arquivo é implantado na raiz de um
servidor Web que executa o IIS, como o Serviço de Aplicativo
do Azure. Para saber mais, confira Configurar um aplicativo
para IIS.
Arquivos estáticos web.config do Azure Um arquivo web.config normalmente adicionado a uma

pasta static (ou outra pasta que contém itens estáticos) para
desabilitar o processamento do Python para essa pasta. Esse
arquivo de configuração funciona em conjunto com um dos
arquivos de configuração FastCGI ou HttpPlatformHandler
acima. Para saber mais, confira Configurar um aplicativo para
IIS.
Depuração remota de web.config do Azure Preterido (foi usado para depuração remota no Serviço de
Aplicativo do Azure para Windows, que não é mais
suportado).
Confira também
Gerenciar projetos Python – Modelos de projetos
Modelos de projeto Web do Python
Opções para o Python no Visual Studio
Para exibir as opções python, use o comandoDesmenu Opções de ferramentas, > certifique-se de mostrar que
todas as configurações estão selecionadas e, em seguida, navegue até Python :
Há também opções adicionais específicas do Python na guia 'Editor de > textoPython > Advanced' e na guia
Condições > do AmbienteFontes e Cores dentro do grupo Editor de texto.
NOTE
O grupo Experimental contém opções para recursos que ainda estão em desenvolvimento e não estão documentados
aqui. Geralmente eles são discutidos em postagens no blog Python engineering at Microsoft (Engenharia Python na
Microsoft).
Opções gerais
(Guia > Python de opções > de ferramentas.)
OPÇ ÃO PA DRÃ O DESC RIÇ Ã O
Mostrar a Janela de Saída ao criar Por Desmarque essa opção para impedir
ambientes vir tuais que a janela Saída seja exibida.
Mostrar a Janela de Saída ao Por Desmarque essa opção para impedir

instalar ou remover pacotes que a janela Saída seja exibida.
Mostrar barra de notificações para Por Somente Visual Studio 2019. Quando
criar ambientes essa opção é configurada e o usuário
abre um projeto que contém um
arquivo requirements.txt ou
environment.yml, o Visual Studio exibe
uma barra de informações com
sugestões para criar um ambiente
virtual ou ambiente conda,
respectivamente, em vez de usar o
ambiente global padrão.
Mostrar barra de notificações para Por Somente Visual Studio 2019. Quando
instalar pacotes essa opção é configurada e o usuário
abre um projeto que contém um
arquivo requirements.txt (e não está
usando o ambiente global padrão), o
Visual Studio compara esses requisitos
com pacotes instalados no ambiente
atual. Se houver pacotes ausentes, o
Visual Studio exibirá um prompt para
instalar essas dependências.
Sempre executar gerenciadores de Desativado Sempre eleva pip install e

pacotes como administrador operações semelhantes de gerenciador
de pacote para todos os ambientes. Ao
instalar pacotes, o Visual Studio
solicitará privilégios de administrador se
o ambiente estiver localizado em uma
área protegida do sistema de arquivos
como c:\Program Files. Nesse prompt,
você pode optar por sempre elevar o
comando de instalação apenas para
esse ambiente específico. Consulte a
guia Pacotes .
Gerar automaticamente o BD de Por Aplica-se ao Visual Studio 2017 versão

conclusão no primeiro uso 15.5 e anteriores e a versões
posteriores ao usar um banco de dados
do IntelliSense. Prioriza a conclusão do
banco de dados para uma biblioteca
quando você escreve código que a usa.
Confira mais informações na guia
IntelliSense.
Ignorar variáveis PYTHONPATH de Por PYTHONPATH é ignorado por padrão

todo o sistema porque o Visual Studio fornece um meio
mais direto para especificar caminhos
de pesquisa em projetos e ambientes.
Confira Caminhos de pesquisa para
obter detalhes.
Atualizar os caminhos de pesquisa Por Quando definido, adicionar um arquivo

ao adicionar arquivos vinculados vinculado a um projeto atualiza os
caminhos de pesquisa para que o
IntelliSense possa incluir o conteúdo da
pasta do arquivo vinculado em seu
banco de dados de conclusão.
Desmarque esta opção para excluir o
conteúdo do banco de dados de
conclusão.
Avisar quando o módulo Por Desmarque esta opção para suprimir

impor tado não puder ser avisos quando você sabe que um
encontrado módulo importado não está disponível
no momento, mas não afeta a operação
do código de outra forma.
Relatar recuo divergente como Avisos Como o interpretador do Python

depende muito do recuo adequado
para determinar o escopo, o Visual
Studio por padrão emite avisos quando
detecta recuos inconsistentes que
podem indicar erros de codificação.
Definir como Erros para ser ainda mais
estrito, o que faz com que o programa
saia nesses casos. Para desabilitar esse
comportamento completamente,
selecione Não .
Verificar se há pesquisa/notícias Uma vez por semana Visual Studio 2017 e anterior. Define a
frequência com que você permite que o
Visual Studio abra uma janela contendo
uma página da Web com itens de
notícias e pesquisas relacionados ao
Python, se disponível. As opções são
Nunca , Uma vez por dia , Uma vez
por semana e Uma vez por mês .
Botão Redefinir todas as caixas de n/d Caixas de diálogo diferentes fornecem

diálogo permanentemente ocultas opções como Não mostrar
novamente . Use esse botão para
limpar essas opções e fazer com que as
caixas de diálogo sejam exibidas
novamente.
Opções do Conda
(Guia Ferramentas > Opções > Python > Conda .)

Caminho do executável do Conda (blank) Especifica um caminho exato para o

arquivo executável conda.exe, em vez
de contar com a instalação do
Miniconda padrão incluído com a carga
de trabalho do Python. Se outro
caminho for fornecido aqui, ele terá
precedência sobre a instalação padrão e
outros executáveis conda.exe
especificados no registro. Essa
configuração poderá ser alterada se
você instalar manualmente uma versão
mais recente do Anaconda ou do
Miniconda ou se desejar usar uma
distribuição de 32 bits em vez da
distribuição padrão de 64 bits.
Opções de depuração
(Opçõesde > ferramentas > Guia > de depuração python.)
Perguntar antes de executar Por Quando definido, solicita que você

quando houver erros confirme que deseja executar o código
que contém erros. Desmarque esta
opção para desabilitar o aviso.
Aguardar pela entrada quando o Ativo (para os dois) Um programa de Python iniciado no
processo for encerrado de forma Visual Studio é executado em sua
anormal própria janela de console. Por padrão, a
janela espera que você pressione uma
Aguardar pela entrada quando o tecla antes de fechá-la,
processo for encerrado independentemente de como o
normalmente programa é encerrado. Para remover
este prompt e fechar a janela
automaticamente, desmarque uma ou
ambas as opções.
A saída do programa para Por Exibe a saída do programa em uma

Depurar a janela de Saída janela separada do console e na janela
de Saída do Visual Studio. Desmarque
esta opção para mostrar a saída
somente na janela do console separado.
Interromper a exceção SystemExit Desativado Se definido, interrompe o depurador

com código de saída zero nessa exceção. Quando desmarcado, o
depurador sai sem interromper.
Habilitar a depuração da Desativado Torna possível intervir no código-fonte

biblioteca padrão do Python da biblioteca padrão durante a
depuração, mas aumenta o tempo
necessário para iniciar o depurador.
Mostrar o valor retornado da Por Somente Visual Studio 2019. Exibe os

função valores retornados de função na janela
Locals , em seguida, passa uma
chamada de função no depurador (F10)
Usar depurador herdado Desativado Somente Visual Studio 2019. Instrui o

Visual Studio a usar o depurador
herdado por padrão. Confira mais
informações em Depuração – Usar o
depurador herdado.
Opções de diagnóstico
(Opçõesde > ferramentas > guia Python > Diagnostics.)
Inclui logs de análise Por Inclui logs detalhados relacionados à

análise de ambientes do Python
instalados ao salvar o diagnóstico em
um arquivo ou copiá-los na área de
transferência usando os botões. Essa
opção pode aumentar
significativamente o tamanho do
arquivo gerado, mas costuma ser
necessária para diagnosticar problemas
do IntelliSense.
Salvar diagnósticos para o botão de n/d Solicita um nome de arquivo e salva o

arquivo log em um arquivo de texto.
Copiar diagnósticos para o botão n/d Coloca a totalidade do log na área de

da área de transferência transferência; essa operação pode levar
algum tempo, dependendo do tamanho
do log.
Opções da Janela Interativa
(Opçõesde ferramentas > Options > Python > InteractiveWindows tab.)
Scripts n/d Especifica uma pasta geral para scripts

de inicialização que serão aplicados às
janelas Interativas de todos os
ambientes. Veja os scripts de
inicialização. No entanto, observe que
esse recurso não funciona no momento.
As setas para cima e para baixo Por Usa as teclas de direção para navegar
navegam o histórico no histórico na janela Interativa .
Desmarque essa configuração para usar
as teclas de direção para navegar na
saída da janela Interativa .
Modo de Conclusão Avaliar somente expressões sem O processo de determinar os membros

chamadas de função disponíveis em uma expressão na janela
Interativa pode exigir a avaliação da
expressão incompleta atual, que pode
resultar em efeitos colaterais ou funções
sendo chamadas várias vezes. A
configuração padrão Avaliar somente
expressões sem função chamadas
exclui expressões que aparecem para
chamar uma função, mas avaliada
outras expressões. Por exemplo, ele
avalia a.b , mas não a().b . Nunca
avaliar expressões impede todos os
efeitos colaterais, usando apenas o
mecanismo IntelliSense normal para
obter sugestões. Avaliar todas as
expressões avalia a expressão
completa para obter sugestões,
independentemente de efeitos
colaterais.
Ocultar sugestões de análise Desativado Quando definido, exibe apenas

estática sugestões que são obtidas avaliando a
expressão. Se combinado com o valor
do Modo de Conclusão****Nunca
avaliar expressões , nenhuma
conclusão útil será exibida na janela
Interativa .
Opções de servidor de linguagem

(Guia Ferramentas > Opções > Python > Ser vidor de linguagem .)
Desabilitar conclusões do Desativado O Visual Studio IntelliSense

Typeshed normalmente usa uma versão agrupada
do Typeshed (um conjunto de arquivos
.pyi) para encontrar dicas de tipo de
biblioteca padrão e bibliotecas de
terceiros para o Python 2 e o Python 3.
Essa opção desabilita o comportamento
do TypeShed agrupado.
Caminho de Typeshed (blank) Se definido, o Visual Studio usa os

personalizado arquivos de Typeshed nesse caminho,
em vez de sua versão agrupada. Ignore
caso a opção Desabilitar conclusões
do Typeshed esteja definida.
Opções avançadas de editor de Python
Python > (Opções de > ferramentas > Guia PythonAdvanced do Editor > de texto.)
Resultados de Conclusão
A conclusão de membros exibe a Desativado Quando definido, mostra apenas

interseção de membros conclusões que têm suporte por todos
os tipos possíveis.
Lista de filtro com base na cadeia Por Aplica a filtragem de sugestões de

de pesquisa preenchimento conforme você digita (o
padrão é marcado).
Mostrar automaticamente Por Desmarque esta opção para desabilitar

conclusões para todos os as conclusões no editor e nas janelas
identificadores Interativas .
Seleção em listas de conclusão

Confirmado pela digitação dos {}[]().:;;+-*/%&|^~=<> #@\ Esses caracteres normalmente seguem
seguintes caracteres um identificador que pode ser
selecionado em uma lista de conclusão,
portanto, é conveniente confirmar a
conclusão digitando um caractere. Você
pode remover ou adicionar caracteres
específicos à lista conforme desejado.
Inserir a conclusão atual de Por Quando definido, a tecla Enter escolhe

confirmação e aplica a conclusão escolhida no
momento, assim como acontece com os
caracteres acima (mas obviamente, não
há um caractere para Enter portanto,
ele não pode entrar diretamente para
essa lista!).
Adicionar uma nova linha ao Desativado Por padrão, se você digitar a palavra
pressionar Enter após o fim da inteira que aparece no pop-up de
palavra totalmente digitada conclusão e pressionar Enter , você
confirmará a conclusão. Ao definir essa
opção, você realmente confirma as
conclusões quando termina de digitar o
identificador, de modo que Enter insere
uma nova linha.
Opções diversas
Entrar no modo de estrutura de Por Ative automaticamente o recurso de

tópicos quando os arquivos forem estrutura de tópicos do Visual Studio no
aber tos editor ao abrir o arquivo de código do
Python.
Colar prompts REPL removidos Por Remove >>> e ... do texto colado,
permitindo fácil transferência de código
da janela Interativa para o editor.
Desmarque essa opção se você precisar
manter esses caracteres ao colar de
outras fontes.
Nomes de cores com base em Por Habilita as cores de sintaxe no código

tipos do Python.
Opções de Fontes e Cores
( GuiaFontes e cores doambiente > dentro do grupo Editor de texto.)
Os nomes das opções do Python são prefixadas com Python e são autoexplicativas. A fonte padrão para todos os
temas de cores do Visual Studio é 10pt Consolas regular (não está em negrito). As cores padrão variam de acordo
com o tema. Normalmente, você altera uma fonte ou a cor se tiver dificuldade para ler texto com as configurações
padrão.

Python Visual Studio

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Python Visual Studio

Загружено:

Авторское право:

Доступные форматы

Contents

Python no Visual Studio

Suporte para vários interpretadores

Edição avançada, IntelliSense e compreensão do código

Sistema de projeto e modelos de projeto e de item

Ferramentas de criação de perfil com relatórios abrangentes

Para mais informações:

Para mais informações:

SDK do Azure para Python

2013 2013 2013 2012 2010 SP 1

2013 2013 2013 2012 2010 SP 1

2013 2013 2013 2012 2010 SP 1

DEP URA Ç 2013 2013 2013 2012 2010 SP 1

C RIA Ç Ã O 2013 2013 2013 2012 2010 SP 1

2013 2013 2013 2012 2010 SP 1

Recursos de produtividade populares

Rabiscos e Ações Rápidas

Acessar e Escolher Definição

Funcionalidades avançadas do Python

Interagindo com o C++

Integração ao SQL Server

Para mais informações:

SDKs e serviços adicionais

Visual Studio 2019 e Visual Studio de 2017

OPÇ ÃO DESC RIÇ Ã O

Distribuições do Python Escolha qualquer combinação de opções disponíveis,

Supor te do modelo Cookiecutter Instala a interface gráfica do usuário Cookiecutter para

Supor te Web do Python Instala as ferramentas para desenvolvimento para a

Supor te ao Python IoT Compatível com o desenvolvimento do Windows IoT

Ferramentas de desenvolvimento nativo do Instala o compilador do C++ e outros componentes

OPÇ ÃO DESC RIÇ Ã O

Distribuições do Python Escolha qualquer combinação de opções disponíveis,

Supor te do modelo Cookiecutter Instala a interface gráfica do usuário Cookiecutter para

Supor te Web do Python Instala as ferramentas para desenvolvimento para a

Ferramentas de desenvolvimento nativo do Instala o compilador do C++ e outros componentes

Visual Studio 2015

Visual Studio 2013 e anterior

IN T ERP RETA DO R DESC RIÇ Ã O

CPython O interpretador “nativo” e mais usado, disponível em versões

IronPython Uma implementação do .NET do Python, disponível em

Anaconda Uma plataforma aberta de ciência de dados do Python, além

PyPy Uma implementação JIT de rastreamento de alto

Jython Uma implementação do Python na JVM (Máquina Virtual

1. Abra o Visual Studio 2019.

Instalar a biblioteca Flask

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

8. A saída do programa aparece em uma janela de comando separada:

Definir um diretório de trabalho

1. Inicie o Visual Studio e selecione File > New > Project .

Instale a extensão do GitHub para o Visual Studio

Trabalhe com o GitHub no Visual Studio

self.assertTrue(True) # This should be True

4. Escolha o modelo Microsoft/python-sklearn-classifier-cookiecutter e escolha Avançar . (O processo

Etapa 1: criar um novo projeto do Python

Aprofunde-se um pouco mais

Etapa anterior : Criar um novo projeto do Python

4. Preencha a instrução para que ela corresponda ao seguinte:

print("Hello, Visual Studio")

9. Preencha a linha digitando ou selecionando sys .

Aprofunde-se um pouco mais

init.py O arquivo que identifica o aplicativo como um pacote.