Setting Up Pylance

Pylance is an extension that works alongside Python in Visual Studio Code to provide deeper language support and introspection of Python code. Pylance will provide auto-completions, automated module imports, better code navigation, type checking, and tons more .

To get Pylance, go to the Extensions menu on the side bar and search Pylance ( ms-python.vscode-pylance ).

Note: Pylance is now bundled with the Python extension, so you might already have it installed.

Once you have Pylance installed, there are two default configuration settings you may want to change in your user settings to get the most out of the extension.

The first setting to change is the type checking mode, which you can use to specify the level of type checking analysis performed:

By default, the type checking mode is set to "off" .

The other options are "basic" or "strict" . With "basic" , rules unrelated to type checking and rules for basic type checking are run. If the mode is set to "strict" , it will run all type checking rules at the highest severity of error. Set this to "basic" for a balance between strict and disabled.

The other default setting is python.analysis.diagnosticMode . By default, Pylance will inspect currently open files only. Changing this setting to workspace will inspect all Python files in the workspace, giving you a list of errors and warnings inside the Explorer view:

You should only set python.analysis.diagnosticMode to "workspace" if you have some RAM to spare as it will consume more resources.

Pylance is most effective when it has information about the types used as the arguments to methods and functions as well as the return types.

For external libraries, Pylance will use typeshed to infer the return types and argument types. Pylance also comes with type stubs and intelligence for some of the most popular data-science libraries, like pandas, Matplotlib, scikit-learn, and NumPy. If you’re working with pandas, Pylance will give you information and examples for common functions and patterns:

For libraries that don’t have type stubs on typeshed, Pylance will do its best to guess what the types are. Otherwise, you can add your own type stubs .

Setting Format and Lint on Save

Configuring Test Integration

If you have more complex settings for pytest, put those in pytest.ini instead of the VS Code settings. That way, you’ll keep the configuration consistent with any automated testing or CI/CD tooling.

Executing Tests

Using Tasks to Compile Wheels

If you have a setup.py file to build a package for distribution on PyPI, you can use the tasks system to automate building the source (Python) and binary (compiled Python) distribution packages.

Tasks are defined in a .vscode/tasks.json file. To try it out, create .vscode/tasks.json and copy this configuration:

There are a few things to note in this example, so you’ll look at the most important configurations line by line:

To execute the default build task, you can run Tasks: Run Build Task from the Command Palette or use the built-in keyboard shortcut, Cmd + F9 or Ctrl + F9 . Under the Terminal tab, you can find the output of the build command called whatever you specified in "label" :

You’re not limited to build scripts. The task system is a great solution to Django and Flask’s management commands.

Using Tasks for Django

Chaining Tasks

Expanding on the setup.py example , if you want to first build a source distribution of your package, you can add the following task to tasks.json :

Within the default build task, you can then add a property dependsOn along with a list of the task labels that need to run first:

Using Tasks to Run Tox

Now you’ll explore tox , which is a tool that aims to automate and standardize testing in Python. The Python extension for Visual Studio Code doesn’t come with tox integration. Instead, you can use the tasks system to set tox as the default test task.

Tip: If you want to get started quickly with tox, then install tox with pip and run the tox-quickstart command:

This will prompt you through the steps of creating a tox configuration file .

To automate running tox with your tox configuration, add the following task to tasks.json :

You can run this task using Tasks: Run Test Task from the Command Palette, and the task will execute tox with the output within the Terminal tab:

If you have a few tasks and need to run them often, it’s time to explore a great extension that adds some shortcuts in the UI for running configured tasks.

Using the Task Explorer Extension

The Task Explorer extension ( spmeesseman.vscode-taskexplorer ) adds simple UI controls to run your pre-configured tasks. Once installed, Task Explorer will be a panel within the Explorer view. It scans your project to auto-discover tasks for npm , make , gulp , and many other build tools. You can find your tasks under the vscode group:

Click the arrow next to any task to execute it, and click the refresh icon at the top if you change your task’s configuration.

Setting Watches

Configuring a Launch File

Note: To see the expected result of the upcoming configuration, you need to have a working FastAPI project set up and the async web server uvicorn installed in the Python environment you’re using.

For an example of working with launch profiles in VS Code, you’ll explore how to use the ASGI server uvicorn to start a FastAPI application. Normally, you might just use the command line:

Here, you set "type" in the configuration to "python" , which tells VS Code to use the Python debugger. You also set "module" to specify the Python module to run, which in this case is "uvicorn" . You can provide any number of arguments under "args" . If your application requires environment variables, you can also set those using the env parameter.

Once you’ve added this configuration, you should find your new launch configuration ready to start under the Run and Debug panel:

Whatever you configured as the first launch configuration will run when you press F5 or select Run → Start Debugging from the top menu.

If VS Code doesn’t automatically select the right Python environment for you, then you can also declare an explicit path to the appropriate Python interpreter as an option in your .vscode/launch.json file:

You can add the path to your Python interpreter as a new entry with the name "python" . In this example, the interpreter is located in a Python virtual environment named venv that you created at the root of your workspace folder. If there’s a different Python interpreter you’d like to use, you can define the path to it by editing the path shown in line 6 to fit your setup.

Remote Development With Containers

You need to install the Docker runtime on your machine to use remote debugging for containers. If you don’t already have Docker installed, you can download it from the Docker website .

Once Docker is running, go to the Remote Explorer tab on the left navigation menu. Change the Remote Explorer dropdown to Containers , and you’ll see a view with panels:

These panels aren’t populated if you have a fresh Docker install.

If you already have Docker images installed and running, the three panels might be populated:

For example, if you installed the Try Out Development Container: Python by following the steps outlined in VS Code’s containers tutorial , your VS Code Remote Explorer tab will show the name of the running container across the panels mentioned earlier:

Use these panels as a quick way of managing any Docker containers that your project depends on.

In general, there are three primary ways of running the Remote Containers extension:

Creating a .devcontainer/devcontainer.json file has significant benefits over simply opening a container:

If you’re planning on working within containers and VS Code a lot, spending the extra time to create a development container will pay off.

Note: You can learn how to create a development container in more detail by reading through the official VS Code documentation.

A quick way to get started using a dev container is by creating it from your current workspace:

VS Code will then port your existing workspace and create a .devcontainer/devcontainer.json configuration based upon a generic Dockerfile for Python.

Dev containers have two required files:

In the default setup, Dockerfile is inside the .devcontainer/ directory. If your project already has a Dockerfile , you can reuse that by changing the path in .devcontainer/devcontainer.json .

You’ll use the defaults inside .devcontainer/devcontainer.json to specify:

If your application requires additional packages from PyPI, change .devcontainer/devcontainer.json and uncomment the line specifying "postCreateCommand" :

You can also add options for port forwarding if you’re developing an application that provides network services, like a web app. For the full list of options, you can go through the devcontainer.json reference .

After making changes to either the Dockerfile or the devcontainer specification, rebuild the container from the Remote Explorer by right-clicking the running container and selecting Rebuild Container :

By doing this, you’ll rebuild the Docker container with any changes to the configuration and Dockerfile .

Beyond the functionality of the Remote Development extension pack’s extension for remote debugging, there’s a Docker extension for VS Code. You’ll cover this extension at the end of the tutorial and find even more features.

Remote Development With SSH

By running Remote-SSH: Open SSH Configuration File in the Command Palette, you can open up the local SSH configuration file. This is a standard SSH config file for you to list hosts, ports, and paths to private keys. The IdentityFile option defaults to ~/.ssh/id_rsa , so the best way to authenticate is a private and public key pair.

Here’s an example configuration of two hosts:

Once you save the configuration file, the Remote Explorer tab will list those SSH hosts under the SSH Targets dropdown option:

To connect to that server, click on Connect to Host in New Window , which is the icon to the right of any host. This will open a new VS Code window with the remote host.

Once connected, click Open Folder under the Explorer view. VS Code will show you a special folder navigation menu that displays the available folders on the remote host. Navigate to the folder where your code is located, and you can start a new workspace under that directory:

In this remote workspace, you can edit and save any files live on the remote server. The Terminal tab is automatically set as the SSH terminal for the remote host if you need to run any additional commands.

Remote Development With WSL

Windows Subsystem for Linux , or WSL , is a component for Microsoft Windows that enables users to run any number of Linux distros on their Windows OS without the need for a separate hypervisor.

VS Code supports WSL as a remote target, so you can run VS Code for Windows and develop for Linux under WSL.

Using WSL with VS Code first requires that WSL is installed. Once WSL is installed, you need to have at least one distro available.

The easiest way to install WSL on the latest version of Windows 10 is to open a command prompt and run:

The --install command performs the following actions:

Once you’ve successfully set up WSL on your computer, you also need to install the Remote - WSL ( ms-vscode-remote.remote-wsl ) extension for VS Code. After that, you’re ready to use WSL in Visual Studio Code.

If you already have code in WSL, run Remote-WSL: Open Folder in WSL from the Command Palette in VS Code. Select the target directory for your code in the Linux subsystem.

If your code was checked out in Windows, run Remote-WSL: Reopen Folder in WSL from the Command Palette.

The Remote Explorer will remember your configured WSL targets and let you reopen them quickly from the WSL Targets dropdown in the Remote Explorer view:

If you want a reproducible environment, consider creating a Dockerfile instead of working directly on the WSL host.

Installing the Jupyter Notebook Extension

To get started with Jupyter Notebooks on VS Code, you’ll need the Jupyter Extension ( ms-toolsai.jupyter ) .

Note: Jupyter Notebooks support is now bundled with the Python extension, so don’t be surprised if you already have it installed.

Jupyter Notebooks supports pip as the package manager, as well as conda from the Anaconda distribution .

Data science libraries for Python often require compiled modules written in C and C++. You should use conda as the package manager if you’re using a lot of third-party packages because the Anaconda distribution has resolved the build dependencies on your behalf, making it easier to install packages.

Getting Started With Jupyter Notebooks in VS Code

For this example, you’ll open a series of Jupyter Notebooks on wave transformations . Download the repo’s .zip/ folder and unzip it, or clone the GitHub repo and open it with VS Code. The steps described further down will also work with any other workspace containing .ipynb notebook files.

Note: The rest of this section uses the conda package manager. You’ll need to have Anaconda installed if you want to use the commands shown in this section.

In VS Code, you can use any existing conda environment. Instead of installing packages into the base environment, you can create a conda environment specifically for VS Code from your terminal:

After you’ve created the conda environment named vscode , you can install some common dependencies into it:

Once you’ve installed the dependencies, run the Python: Select Interpreter command from the VS Code Command Palette and search for vscode to select the new conda environment:

This selection will set your VS Code to use the Python interpreter from your conda environment, vscode .

Note: If the conda environment is not available in the list, you may need to reload the window by running the Developer: Reload Window command from the Command Palette.

Once selected, open a notebook in VS Code and click the Select Kernel button on the right or run the Notebook: Select Notebook Kernel command from the Command Palette. Type vscode to select the newly created conda environment with the dependencies installed:

Selecting your new conda environment as the kernel for your notebook will give your notebook access to all the dependencies that you installed in that environment. It’s necessary for executing the code cells.

Once the kernel is selected, you can run any or all of the cells and see the output of the operations displayed right inside VS Code:

Once the notebook has executed, the Jupyter Extension will make any of the intermediate variables such as lists, NumPy arrays, and pandas DataFrames available in the Jupyter: Variables view:

You can bring this view into focus by clicking the Variables button at the top of the notebook or by running the Jupyter: Focus on Variables View command.

For the more complex variables, choose the icon to open the data in the data viewer.

Using the Data Viewer

The data viewer supports inline filtering and paging for large data sets. If you’re plotting large data sets in Matplotlib, the Jupyter Extension supports Matplotlib widgets instead of SVG rendering.

Using the Rainbow CSV Extension

If you work with CSV or TSV input data, there’s a useful extension called Rainbow CSV ( mechatroner.rainbow-csv ) that enables you to open and visualize CSV files in VS Code:

Each column is colorized, giving you a quick way to spot missing commas. You can also align all columns by running the Rainbow CSV: Align CSV Columns command from the Command Palette.

Note: If you’re looking for an example CSV file to try this extension, you can pick a CSV file for download from the official statistics page of the New Zealand government.

The Rainbow CSV extension also comes with a Rainbow Query Language (RBQL) query tool that lets you write RBQL queries on the CSV data to create filtered data sets:

You can access the RBQL console by running Rainbow CSV: RBQL in the Command Palette. After executing a query, you’ll see the results in a new tab as a temporary CSV file that you can save and use for further data analysis work.

Throughout this tutorial, you’ve installed a couple of useful extensions for VS Code. There are a lot of useful extensions available. In the final section of this tutorial, you’ll learn about some extra extensions you haven’t covered so far that you might also want to try out.

Code Spell Checker

Code Spell Checker ( streetsidesoftware.code-spell-checker ) is a spell checker that inspects variable names, text inside strings, and Python docstrings:

The Code Spell Checker extension will highlight any suspected misspellings. You can either correct the spelling from the dictionary or add the word to a user or workspace dictionary.

The workspace dictionary will live inside the workspace folder, so you can check it into Git. The user dictionary is persisted across all your projects. If there are lots of keywords and phrases you use often, you can add them to the user dictionary.

Docker

The Docker extension ( ms-azuretools.vscode-docker ) makes it easy to create, manage, and debug containerized applications:

The Docker extension goes beyond the Remote - Containers extension that you covered earlier. It gives you a UI to manage images, networks, container registries, volumes, and containers.

Thunder Client

Thunder Client ( rangav.vscode-thunder-client ) is an HTTP client and UI for VS Code designed to aid testing of REST APIs. If you’re developing and testing APIs in frameworks like Flask , FastAPI , or Django Rest Framework , you may already use a tool like Postman or curl to test your application.

Inside Thunder Client, you can create HTTP requests and send them to your API, manipulate headers, and set payloads of text, XML, and JSON:

Thunder Client is a great alternative to Postman or curl, and since you can use it right inside of VS Code, you can avoid switching between applications when testing and developing your REST APIs.

VS Code Pets

VS Code Pets ( tonybaloney.vscode-pets ) is a fun extension that puts one or many small pets in your VS Code window:

You can customize the pets, customize their environments, and play games with them.

Note: As the author of this tutorial, I’ll say that this is a great extension—but I may be biased because I created it.

This is just a snapshot of the extensions on the marketplace. There are thousands more to discover for additional language support, UI improvements, or even Spotify Integration .