Usando VS Code

O VS Code éuma IDE de programação e pode ser instalado à partir de:

Site oficial do Visual Studio Code;
VS Code for Windows.
Downloads do VS Code (mutiplataforma: Windows, Linux, macOS).

Recomenda-se também a instalação de extensões para aumentar as funcoinalidades do mesmo.

Extensões Recomendadas

Elas podem ser baixadas à partir do Visual Studio Marketplace:

Extensão	Autor	Recomendado?	Função
Python	Microsoft	⭐⭐⭐⭐⭐	Python, Conda, execução, debugging
Pylance	Microsoft	⭐⭐⭐⭐⭐	IntelliSense, análise de código Python, autocomplete, documentação, análise estática, auto-importa, etc.
Python Debugger	Microsoft	⭐⭐⭐⭐⭐	Debugger Python
Jupyter	Microsoft	⭐⭐⭐⭐	Permite interagir com`.ipynb` (células `# %%` dentro do código Python) (Opcional)
Markdown Preview Enhanced	Yiyi Wang	⭐⭐⭐⭐⭐	Extensão super completa (talvez até demais) para Markdown, equações LaTeX, TOC, Mermaid, etc. Instruções em Português
Markdown+Math	Goessner	⭐⭐⭐⭐	Renderização matemática: LaTeX/KaTeX em Markdown.
Markdown Preview Mermaid Support	Matt Bierner	⭐⭐⭐⭐	Mermaid no Markdown.
C/C++	Microsoft	⭐⭐⭐⭐⭐	C/C++, IntelliSense e debugging. Obs.: Esta extensão não instala compilador C/C++.
PlatformIO IDE	PlatformIO	⭐⭐⭐⭐⭐	Trabalhos com ESP32/Arduino e outros microcontroladores

Observações:

A extensão Python da Microsoft já instala/integra Pylance como dependência opcional, portanto você não precisa ficar procurando configurações alternativas de language server. (Visual Studio Marketplace)
A extensão Markdown Preview Enhanced: permite trabalhar com Markdown + MathJax/KaTeX, Mermaid, PlantUML, Pandoc, PDF etc. Apesar de ser uma extensão ppoderosa e conhecida, ela tenta resolver muita coisa sozinha (pode ficar "instável" no VS Code). Instruções em Português. Atenção: não instalar junto com "Markdown+Math" + "Markdown Preview Mermaid Support" (gera conflitos; comandos como TOC não corretamente interpretados).
Existe a extensão Arduino Community Edition, é um fork comunitário da antiga extensão da Microsoft, mas não se recomenda sua intalação conjunta com a extensão PlatformIO.
Evite instalar muitas extensões: muitas extensões → mais processos → mais consumo → mais possibilidade de conflito → eventualmente alguma deixa de funcionar (exigindo o re-inicio de todo o VS Code).
Para minimizar a execução simultânea de várias extensões, você pode criar perfis no VS Code. Por exemplo: poderiam ser criados 3 perfis: Python, Embedded e Markdown/Documentação. Você pode ter PlatformIO habilitado no perfil Embedded, mas não necessariamente carregado quando estiver trabalhando em Python/Markdown.

VS Code

A documentação oficial atual mantém uma referência específica para macOS. (Visual Studio Code)

🎹 Atalhos de teclado mais importantes:

Obs.: ⌘ == CMD (macOS) ➔ Ctrl (Windows/Linux); ⌥ == Option ➔ Alt (Windows/Linux); ⇧ == Shift:

Ação	Atalho/Teclas
Abrir Command Palette	⇧⌘P
Abrir arquivo rapidamente	⌘P
Salvar	⌘S
Salvar tudo	⌥⌘S
Fechar arquivo	⌘W
Novo arquivo (New)	⌘N
Procurar no arquivo	⌘F
Substituir	⌥⌘F
Procurar em todos os arquivos	⇧⌘F
Ir para linha	⌃G
Ir para definição	F12
Quick Fix	⌘.
Formatar documento	⇧⌥F
Comentar/descomentar linha	⌘/
Desfazer	⌘Z
Refazer	⇧⌘Z

A Command Palette (⇧⌘P) é especialmente importante. Você pode simplesmente pressioná-la e começar a digitar:


Python

ou:


Terminal

ou:


Jupyter

ou:


Format Document

e o VS Code mostra os comandos disponíveis. (Visual Studio Code)

Navegação entre arquivos e painéis

Ação	Atalho/Teclas
Quick Open / abrir arquivo	⌘P
Próximo editor	⌃Tab
Editor anterior	⌃⇧Tab
Fechar editor	⌘W
Dividir editor	⌘
Alternar entre grupos	⌘1, ⌘2, ...
Explorer	⇧⌘E
Search / Pesquisa	⇧⌘F
Source Control / Git	⌃⇧G
Run/Debug	⇧⌘D
Extensions	⇧⌘X

Obs.: ⌘ == CMD (macOS) ➔ Ctrl (Windows/Linux); ⌥ == Option ➔ Alt (Windows/Linux); ⇧ == Shift:

Terminal dentro do VS Code

Essa parte é particularmente interessante para o que você estava querendo fazer.

Ação	Atalho/Teclas
Abrir/fechar terminal	⌃`
Novo terminal	⌃⇧`
Focar terminal	⌃`
Command Palette	⇧⌘P

Obs.: ⌘ == CMD (macOS) ➔ Ctrl (Windows/Linux); ⌥ == Option ➔ Alt (Windows/Linux); ⇧ == Shift:

Assim você pode ter:


┌──────────────────────────────────────────────┐
│                 VS Code                      │
│                                              │
│  controle_pid.py                             │
│                                              │
│  import numpy as np                          │
│  import matplotlib.pyplot as plt             │
│                                              │
│  ...                                         │
│                                              │
├──────────────────────────────────────────────┤
│ Terminal                                     │
│ $ conda activate controle                    │
│ $ python controle_pid.py                     │
└──────────────────────────────────────────────┘

Ou simplesmente abrir o terminal do sistema e fazer:


conda activate controle
code .

O VS Code abre a pasta inteira como um projeto. O comando code também pode ser instalado no PATH pelo próprio VS Code no macOS. (Visual Studio Code)

Executar progressivamente scripts Python

Você pode usar o .py normal, mas colocar:


# %%

para separar blocos.

Por exemplo:


# %%
import numpy as np
import matplotlib.pyplot as plt

# %%
R = 10e3
C = 100e-6
tau = R*C

# %%
t = np.linspace(0, 5, 500)
vc = 1 - np.exp(-t/tau)

plt.plot(t, vc)
plt.grid()
plt.show()

O VS Code passa a mostrar Run Cell em cada bloco # %%.

Ou seja, você consegue fazer:


xxxxxxxxxx
        arquivo .py normal
               │
               ├── executar tudo
               │
               ├── executar apenas # %%
               │
               ├── depurar
               │
               ├── usar terminal
               │
               └── visualizar gráficos

sem ncessidade de usar Jupyter/Notebook organizando os comandos dentro de células num arquivo .ipynb.

Transformar .py → .ipynb

Vantagem adicional: se você quiser, pode posteriormente transformar um coódigo Python .py com linhas # %% em um notebook .ipynb, mas para tanto é necessário ter a extensão Jupyter instalada.

Neste caso, no exemplo do programa acima, usar:

Command Palette (⇧⌘P) → Jupyter: Export Current Python File as Jupyter Notebook

e o VS Code cria o .ipynb.

Assim você obtêm:


xxxxxxxxxx
controle_rc.py
controle_rc.ipynb

com cada bloco delimitado por # %% transformado em uma célula.

Transformar .ipynb → .py

Um .ipynb aberto no VS Code pode ser exportado para:


xxxxxxxxxx
.py

Pode-se trabalhar assim:


xxxxxxxxxx
                 ┌──────────────┐
                 │  programa.py │
                 │   # %%       │
                 └──────┬───────┘
                        │
                     exportar
                        |
                        ↓
                 ┌────────────────┐
                 │ programa.ipynb │
                 └────────────────┘

Eventualmente para:

desenvolver inicialmente tudo em .py;
usar # %% para dividir blocos de programação;
executar células individualmente quando estiver explorando;
manter o código sob controle de versão;
quando quiser entregar uma demonstração (notebook), exportar para .ipynb;
acrescentar textos explicativos em Markdown no notebook.

Perfis/Profiles no VS Code

Para minimizar a execução simultânea de várias extensões, você pode criar perfis no VS Code. Por exemplo: poderiam ser criados 3 perfis: Python, Embedded e Markdown/Documentação. Algo como:

Perfil	Extensões principais	Uso
🐍 Python & Jupyter	Python, Pylance, Python Debugger, Jupyter	Python, Conda, NumPy, SciPy, Controle, DSP
📝 Markdown & Docs	Markdown Preview Enhanced ou: Markdown+Math, Mermaid	Documentação, notas
🔌 ESP32 & Arduino	C/C++, PlatformIO	ESP32, Arduino, C/C++

Deixaria Git, terminal, editor, Explorer etc. como recursos comuns do VS Code.

A idéia é evitar instalar tudo no Default Profile e deixar o VS Code algo pesado e instável (em relação às extensões), seguindo recomendação da prípria Microsoft.

Para criar os Perfis

Code → Settings → Profiles → Profiles

ou usar:

⇧⌘P

e procurar:


xxxxxxxxxx
Profiles: Create Profile

A versão atual do VS Code possui um Profiles Editor específico para criar, modificar, importar/exportar e administrar os perfis.

Outra maneira é clicar no ícone de Manage (engrenagem) na barra lateral e escolher o gerenciamento de Profiles.

Criando Perfil Python

Recomendado começar com um perfil vazio.

Escolha:

Create Profile → Empty Profile

Nome:


xxxxxxxxxx
Python & Jupyter

Escolha um ícone qualquer — por exemplo 🐍, se disponível.

O ponto importante é não copiar seu Default Profile inteiro, porque queremos justamente reduzir a quantidade de extensões ativas.

O VS Code permite criar um Empty Profile que começa sem suas extensões, configurações, snippets etc.

Instale somente:


xxxxxxxxxx
ms-python.python
ms-python.vscode-pylance
ms-python.debugpy
ms-toolsai.jupyter

Ou, pela interface:

⇧⌘X → Extensions

procure:


xxxxxxxxxx
Python
Pylance
Python Debugger
Jupyter

Essas quatro são suficientes para trabalhos com Python.

Configurando o Conda

Por exemplo, suponha 2 ambientes/environments Python:


xxxxxxxxxx
controle


xxxxxxxxxx
robotica

Você pode abrir um projeto e usar:

⇧⌘P → Python: Select Interpreter

e selecionar:


xxxxxxxxxx
Python (controle)

ou:


xxxxxxxxxx
Python (robotica)

O importante é que o environment Conda não precisa ser um Profile diferente.

Distinção que vale muito a pena manter:


xxxxxxxxxx
PROFILE
   ↓
define ferramentas do VS Code


CONDA ENVIRONMENT
   ↓
define bibliotecas/runtime Python

Portanto:


xxxxxxxxxx
Python & Jupyter
       │
       ├── Conda: controle
       ├── Conda: DSP
       ├── Conda: robotica
       └── Conda: ML

Você não precisa criar um Profile para cada environment.

Obs.: um perfil não contém seus environments Conda, por exemplo.

Portanto:


xxxxxxxxxx
Python-Jupyter.code-profile
       ↓
extensões + configurações do VS Code


controle.yml
       ↓
bibliotecas do Conda

São coisas diferentes.

Isso pode faciliar exportar environments Conda.

Você poderia ter, por exemplo:


xxxxxxxxxx
MeuAmbiente/
│
├── vscode/
│   └── Python-Jupyter.code-profile
│
├── conda/
│   └── controle.yml
│
└── projetos/
    └── ...

e transportar separadamente a configuração do editor e o ambiente Python.

Perfil Markdown & Docs

Crie novamente:

⇧⌘P → Profiles: Create Profile

Escolha:


xxxxxxxxxx
Empty Profile

Nome:


xxxxxxxxxx
Markdown & Docs

Instalsar somente:


xxxxxxxxxx
Markdown+Math
Markdown Preview Mermaid Support

A visualização Markdown nativa do VS Code já existe; essas extensões apenas acrescentam as duas coisas que nos interessam:


xxxxxxxxxx
Markdown
   │
   ├── texto
   ├── LaTeX/KaTeX
   └── Mermaid

Assim você poderá escrever, por exemplo:


xxxxxxxxxx
# Circuito RC


A função de transferência é:


$$
H(s)=\frac{1}{RCs+1}
$$


```mermaid
graph LR
    A[Entrada] --> B[RC]
    B --> C[Saída]
```

e visualizar tudo no Preview.

Atalhos usados

Abra o .md e:

⇧⌘V

para abrir o Markdown Preview.

Ou:

⌘K V

para abrir o preview ao lado.

Perfil ESP32 & Arduino

Fazer agora:

⇧⌘P → Profiles: Create Profile → Empty Profile

Nome:


xxxxxxxxxx
ESP32 & Arduino

Instalar:


xxxxxxxxxx
C/C++
PlatformIO IDE

Ou seja:


xxxxxxxxxx
ms-vscode.cpptools
platformio.platformio-ide

Não instalaria Python nem Jupyter neste perfil. A idéia é deixar o VS Code mais leve.

Detalhe do PlatformIO

O PlatformIO traz uma quantidade razoável de funcionalidade própria:

CMake;
Makefile Tools;
Arduino;
ESP-IDF;
vários debuggers;
extensões para cada placa.

Resultado final

A idéia é ter algo assim:


xxxxxxxxxx
VS Code
│
├── 🐍 Python & Jupyter
│      ├── Python
│      ├── Pylance
│      ├── Python Debugger
│      └── Jupyter
│
├── 📝 Markdown & Docs
│      ├── Markdown+Math
│      └── Mermaid
│
└── 🔌 ESP32 & Arduino
       ├── C/C++
       └── PlatformIO

Cada Profile mantém seu próprio conjunto de extensões e configurações.

Associar Profiles à Pastas

Aqui está uma característica do VS Code que permite tentar organizar diferentes ações.

Imagine que você tenha:


xxxxxxxxxx
~/Projetos/
│
├── Python/
│   ├── Controle/
│   ├── DSP/
│   └── Robotica/
│
├── Apostilas/
│   ├── Controle/
│   └── DSP/
│
└── Embedded/
    ├── ESP32/
    └── Arduino/

Se for aberto:


xxxxxxxxxx
~/Projetos/Python/Controle

e selecionado o perfil:


xxxxxxxxxx
Python & Jupyter

O VS Code pode associar aquele workspace/pasta ao Profile. Assim, quando você abrir novamente aquela pasta, o Profile associado será ativado.

Trocar Profiles manualmente

No VS Code:

⇧⌘P

→


xxxxxxxxxx
Profiles: Switch Profile

e escolher:


xxxxxxxxxx
Python & Jupyter
Markdown & Docs
ESP32 & Arduino

Também é possível abrir uma nova janela já com determinado Profile, sem modificar a janela atual. O VS Code oferece inclusive File → New Window with Profile.

Isso permite, por exemplo:


xxxxxxxxxx
┌─────────────────────────────┐
│ VS Code                     │
│ Python & Jupyter            │
│                             │
│ controle_pid.py             │
└─────────────────────────────┘

┌─────────────────────────────┐
│ VS Code                     │
│ ESP32 & Arduino             │
│                             │
│ motor_pid.cpp               │
└─────────────────────────────┘

Cada janela com seu ambiente de extensões.

Exportanto Perfis

Depois que você montar os três perfis e verificar que estão funcionando, exportaria cada um deles.

Fazer:

⇧⌘P → Profiles: Export Profile

o VS Code gera um arquivo como:


xxxxxxxxxx
Python-Jupyter.code-profile

Esse é o arquivo que você pode guardar como backup ou levar para outro computador.

E não, não é XML.

É um arquivo de configuração baseado em JSON.

O VS Code permite exportar um Profile para um arquivo .code-profile e depois importá-lo em outra máquina. Mas para tanto, recomenda-se cirar uma pasta própria para os mesmos, por exemplo:


xxxxxxxxxx
~/Documents/VSCode-Profiles/

e colocar lá dentro os diferentes perfis:


xxxxxxxxxx
~/Documents/VSCode-Profiles/
├── Python-Jupyter.code-profile
├── Markdown-Docs.code-profile
└── ESP32-Arduino.code-profile

Isso é particularmente interessante porque você pode posteriormente configurar o mesmo ambiente num Ubuntu ou outro PC.

E existe ainda uma opção bastante prática: pela linha de comando do VS Code você pode abrir uma pasta já especificando o Profile:


xxxxxxxxxx
code ~/Projetos/Python/Controle --profile "Python & Jupyter"

O CLI oficial suporta tanto --profile quanto instalação/listagem de extensões por Profile.

Mas não confuda profiles com arquivos de um projeto. Se recomenda deixa-los separados:


xxxxxxxxxx
~/Projetos/
    Python/
    DSP/
    Controle/
    ESP32/


xxxxxxxxxx
~/Documents/VSCode-Profiles/
    Python-Jupyter.code-profile
    Markdown-Docs.code-profile
    ESP32-Arduino.code-profile

Ou seja:


xxxxxxxxxx
PROJETO
   ↓
código, dados, notebooks etc.


PROFILE
   ↓
como o VS Code deve se comportar

Isso torna uma migração muito mais limpa.

Importando um Perfil

Se você tiver, por exemplo:


xxxxxxxxxx
Python-Jupyter.code-profile

Faça:

Pela interface do VS Code

Abra o VS Code.
Pressione ⇧⌘P para abrir a Command Palette.
Digite:


xxxxxxxxxx
Profiles: Import Profile

Selecione Profiles: Import Profile.
Escolha o arquivo:


xxxxxxxxxx
Python-Jupyter.code-profile

O VS Code mostrará o conteúdo do Profile — extensões, configurações etc.
Escolha Create a new profile para criar um Profile separado.

Depois ele aparecerá na lista de Profiles.

Também se pode acessar:

Code → Settings → Profiles

e procurar a opção de Import Profile.

Verificando Perfis já existentes

Você pode conferir as extensões:

No Profile Python & Jupyter, abra:

⇧⌘X

e veja se aparecem:


xxxxxxxxxx
Python
Pylance
Python Debugger
Jupyter

O .code-profile pode incluir a lista de extensões, mas as extensões precisam ser instaladas na nova máquina; o importador cuida desse processo conforme o conteúdo do Profile.

No caso de uma migração Mac → Ubuntu, se faria:


xxxxxxxxxx
Mac
 │
 ├── Python-Jupyter.code-profile ──────┐
 ├── Markdown-Docs.code-profile        │
 └── ESP32-Arduino.code-profile        │
                                       ↓
                                    Ubuntu
                                       │
                                importar Profiles

e, separadamente, se migraria os environments Conda com os arquivos .yml. Assim você reproduz praticamente todo o seu ambiente de desenvolvimento sem carregar lixo ou configurações específicas do macOS.

Fernando Passold, 20/08/2026.

Usando VS Code

Extensões Recomendadas

VS Code

🎹 Atalhos de teclado mais importantes:

Navegação entre arquivos e painéis

Terminal dentro do VS Code

Executar progressivamente scripts Python

Transformar .py → .ipynb

Transformar .ipynb → .py

Perfis/Profiles no VS Code

Para criar os Perfis

Criando Perfil Python

Configurando o Conda

Perfil Markdown & Docs

Atalhos usados

Perfil ESP32 & Arduino

Detalhe do PlatformIO

Resultado final

Associar Profiles à Pastas

Trocar Profiles manualmente

Exportanto Perfis

Importando um Perfil

Pela interface do VS Code

Pelo menu

Verificando Perfis já existentes