Advanced Visual Studio Code for Python Developers

Using the Keyboard Shortcuts Editor

Open the Keyboard Shortcuts editor by going to File → Preferences → Keyboard Shortcuts or Code → Preferences → Keyboard Shortcuts on macOS:

In this editor, you can see a list of all the existing shortcuts along with their details:

• Command: The command or action to be run
• Keybinding: The sequence of keys to press to trigger this command, with a blank indicating that there’s no mapping
• When: Conditions that need to be met for this keybinding to work, with a minus sign (-) indicating that there are no requirements
• Source: Where this binding was configured, either defined by Default, User, or Extension, the last one indicating that you provided it by installing a keymap extension

To override an existing binding, right-click on the existing action and click Change Keybinding. To assign a keybinding to a command that has no binding, double-click on it. If the key sequence you press is already assigned to something else, VS Code will warn you with a link to see which commands are mapped to this keybinding.

As an example, type python create terminal in the search box at the top. If no results come up, make sure you have the Python extension installed. Press Enter to assign a keybinding, like Ctrl+Alt+T, and then hit Enter again.

To assign that shortcut to only work when you’re editing Python code, right-click on the shortcut and select Change When Expression. Enter the expression editorLangId == 'python':

There are more conditional operators to choose from if you need something more specific. Here are some examples to get you started:

• Use resourceFilename == '__init__.py' when the file you’re editing is __init__.py
• Use editorLangId == 'python' when working with Python. If needed, you can also replace 'python' with another language identifier.
• Use editorHasSelection for when you’re inside the editor.

Once you’ve configured this extension, open up a Python file in the editor to try it out by pressing your newly assigned keyboard shortcut Ctrl+Alt+T to open up a Python terminal.

Setting Up Keyboard Shortcuts for Commands From the Command Palette

You’ll refer to the Command Palette many times in this tutorial. Most of the functionality in VS Code is accessible through the UI from context menus, but you won’t find everything there. Anything that can be done in the core editor or via an extension is available in the Command Palette. You can get to the Command Palette by pressing one of these keyboard shortcuts:

• macOS: F1 or Cmd+Shift+P
• Windows or Linux: F1 or Ctrl+Shift+P

To run a command, type its descriptive name, like Python: Run All Tests. Once the Command Palette is up and the command you want is at the top of the menu, click the cog on the right to assign a keyboard shortcut:

Once you’ve started using the Command Palette regularly, you may find that there are five to ten commands you run really often. Assign some shortcuts to those commands to save yourself a few extra keystrokes.

Installing Keyboard Mappings From Other Editors

If you’ve been working in another editor or IDE for some time, you may have your usual keyboard shortcuts committed to muscle memory.

You’ll find helpful keyboard mappings in extensions for Vim, IntelliJ and PyCharm, Sublime Text, Notepad++, Emacs, and Atom.

If your previous editor isn’t on this list, you may find that someone else has created a mapping extension for you. Keymaps is a helpful category on the VS Code extension marketplace.

Once you’ve installed a keymap extension, you may also find additional options to customize it beyond the defaults. For example, you can use the Vim keymap extension to configure Vim features such as whether to start in insert mode.

Using Split Screens

Python’s style guide, PEP 8, leans toward short line lengths. For wide screens, this leaves a lot of unused screen space.

When you find yourself needing to switch between two or more files, use the split panel functionality to show many editor regions at once. You can access this functionality through the Command Palette with the command View: Split Editor.

Alternatively, you can use the associated keyboard shortcut:

• macOS: Cmd+\
• Windows or Linux: Ctrl+\

You can also open the split editor functionality by going to View → Editor Layout or by right-clicking on a file’s tab:

This setup is really useful when writing unit tests with your test code on the left and the module you’re testing on the right.

Some file types, like Markdown, have a preview region that you can use instead. Use the Markdown: Open Preview to the Side command to open the preview editor.

Using Zen Mode for Focused Work

If you need your absolute focus on a single file or task in VS Code, then use Zen Mode by going to View → Appearance → Zen Mode to show a full-screen window with just the editor:

This feature is especially useful for blocking out noisy distractions and notifications so that you can just focus on getting your current task done.

Theming

VS Code has a huge library of themes in the VS Code Marketplace. Some of the most popular themes out there are Material Theme, Winter is Coming, Dracula, Noctis, and Monokai Pro.

Let’s focus on the Material Theme as it comes with a broad set of color schemes to suit many tastes. You can install the extension from the Extensions view. Once installed, you can select a color theme by running Preferences: Color Theme in the Command Palette.

The Material Theme looks best with a custom icon theme. Icon themes are separate extensions from the color themes, so you have to install a second extension. Search for pkief.material-icon-theme in the Extensions view to find the most popular Material icon pack for the theme. After installing this, VS Code will prompt you to switch your icon pack.

This is the Material Theme with the Palenight color theme and the Material icon pack:

You can change the icon theme at any time from the Command Palette by using the command Preferences: File Icon Theme and then selecting one of the icon themes from the list.

Installing a Better Programming Font

Programming fonts are a special group of typefaces, typically with fixed-width characters called monospace. There’s a long list of available fonts to browse at ProgrammingFonts.org:

Once you’ve selected a font, go to Nerd Fonts to download it and install the font on your operating system. The downloads at Nerd Fonts are copies of the monospace fonts with support for glyphs, otherwise known as icons, which you can use inside the terminal prompt.

After installing your selected font, you need to change the editor.fontFamily setting to the name of the new font. You can do that by navigating to Code → Preferences → Settings and then selecting Text Editor → Font in the navigation dropdown. You can change the font your editor will use by adding the name of your new font in the first field of the Font Family setting.

Changing the Default Shell Provider

You can reconfigure the terminal window to have multiple profiles. These profiles form the dropdown list when you spawn a new terminal.

VS Code allows you to configure multiple terminal profiles. You can’t edit terminal profiles in the settings UI, so you need to use the Preferences: Open Settings (JSON) command in the Command Palette to open the settings.json file. You’ll notice that key-value pairs make up the settings file. Each key represents the configuration setting for VS Code or one of its extensions.

There are three terminal profile settings, which have the following names:

Once you type in the name, the editor autocompletes the default profiles into the JSON file.

Note that there’s no Python REPL profile in the default settings. You can add a profile with the key "python3-repl" to the integrated profiles JSON file so that VS Code makes it available as a profile option and drops you straight onto the REPL prompt:

"python3-repl": {
    "path": "python3",
    "args": ["-q"]
}

The -q flag is a Python command-line flag to stop the version header from showing. You can add any extra Python command-line flags to "args".

Once configured, your profiles should look something like this, depending on your OS:

"terminal.integrated.profiles.osx": {
    "bash": {
        "path": "bash",
        "icon": "terminal-bash",
    },
    "zsh": {
        "path": "zsh"
    },
    "pwsh": {
        "path": "pwsh",
        "icon": "terminal-powershell",
    },
    "python3-repl": {
        "path": "python3",
        "args": ["-q"]
    }
},

VS Code has two launch modes for terminals: integrated and external. Once you’ve configured the profiles, you can set the default profile for your integrated terminal by setting the value for "terminal.integrated.defaultProfile.osx":

"terminal.integrated.defaultProfile.osx": "zsh",

If something gets launched in an external terminal, it will use the default shell of your operating system. If you prefer a different terminal app, like iTerm 2 for macOS or Windows Terminal for Windows, you can change the default external terminal as well:

"terminal.external.osxExec": "iTerm.app",

With this setting for macOS, for example, you’re saying that VS Code should bring up the iTerm app every time it launches an external terminal window.

There are even more settings you can change in regards to terminals in VS Code. For example, you can make VS Code activate your virtual environment automatically when you bring up a new terminal window, and you can customize the look and feel of your terminal by adding custom prompts. You’ll explore how to do both in this tutorial.

Virtual Environment Activation in the Terminal

Virtual environments are very important for managing multiple dependencies across Python projects. Visual Studio Code will activate any Python virtual environment once the interpreter is selected. If you already have a virtual environment, run Python: Select Interpreter from the Command Palette to select the Python interpreter virtual environment.

If you don’t have one, then create one inside the terminal. VS Code can automatically pick it up if the virtual environment path is named .venv/, env/, or venv/.

After you set the interpreter, you’ll automatically activate the virtual environment when you start a new terminal window inside VS Code:

If you already had a terminal open, you can destroy it by clicking the garbage can icon.

Any commands you run inside the terminal, such as python -m pip install, will be for the activated virtual environment.

In the above screenshot, you can see a custom command prompt that uses the Oh My Posh prompt toolkit. In the next section, you’ll install and configure Oh My Posh. Oh My Posh is optional, especially if you already have a custom command prompt installed.

Installing Oh My Posh

Oh My Posh is one of many libraries for customizing the command prompt of your terminal. It works across Linux, macOS, and Windows. It also works with all shells like Bash, Zsh, Fish, and PowerShell. You can install Oh My Posh to spice up your terminal.

If you’re on macOS and using Bash, run the following commands to install Oh My Posh:

$ brew tap jandedobbeleer/oh-my-posh
$ brew install oh-my-posh
$ curl https://github.com/JanDeDobbeleer/oh-my-posh/raw/main/themes/tonybaloney.omp.json -sLo ~/.mytheme.omp.json
$ echo "eval \"\$(oh-my-posh --init --shell bash --config ~/.mytheme.omp.json)\"" >> ~/.profile
$ . ~/.profile

If you’re on macOS and using Zsh, run the following commands to install Oh My Posh:

$ brew tap jandedobbeleer/oh-my-posh
$ brew install oh-my-posh
$ curl https://github.com/JanDeDobbeleer/oh-my-posh/raw/main/themes/tonybaloney.omp.json -sLo ~/.mytheme.omp.json
$ echo "eval \"\$(oh-my-posh --init --shell zsh --config ~/.mytheme.omp.json)\"" >> ~/.zprofile
$ . ~/.zprofile

If you’re on Windows and using PowerShell, run the following commands to install Oh My Posh:

PS C:\> Install-Module oh-my-posh -Scope CurrentUser
PS C:\> Add-Content $PROFILE "`nSet-PoshPrompt -Theme tonybaloney"

Finally, if you’re on Linux and using Bash, run the following commands to install Oh My Posh:

$ sudo wget https://github.com/JanDeDobbeleer/oh-my-posh/releases/latest/download/posh-linux-amd64 -O /usr/local/bin/oh-my-posh
$ sudo chmod +x /usr/local/bin/oh-my-posh
$ curl https://github.com/JanDeDobbeleer/oh-my-posh/raw/main/themes/tonybaloney.omp.json -sLo ~/.mytheme.omp.json
$ echo "eval \"\$(oh-my-posh --init --shell bash --config ~/.mytheme.omp.json)\"" >> ~/.bashrc
$ . ~/.bashrc

When you open up a new terminal in VS Code, you’ll get this prompt:

The components on the terminal are the folder, Git branch, and Python version. Check out the list of themes for some other options.

By default, the terminal will use the same font face that you configured for the editor, editor.fontFamily. You can override this by defining a different font family for the terminal.integrated.fontFamily identifier. You’ll also need to update any external terminal applications you use.

Global User Settings for Python

By default, the Python extension for Visual Studio Code has a very basic configuration. Many features like linting, formatting, and security checks are disabled because you need to install third-party tools like Black, Pylint, and Bandit to use them.

You can install these tools and make them available to every virtual environment by using either pipx or pip install --user. pipx is preferable over pip install --user because it’ll create and maintain a virtual environment for that package, keeping your global site packages smaller and reducing the risk of packaging conflicts.

Once you’ve installed pipx, you can install the common tools:

$ pipx install pylint && \
  pipx install black && \
  pipx install poetry && \
  pipx install pipenv && \
  pipx install bandit && \
  pipx install mypy && \
  pipx install flake8

Alternatively, use python3 -m pip install --user to install the common tools:

$ python3 -m pip install --user pylint black poetry pipenv bandit mypy flake8

Once you’ve installed the base tools, open the user settings from the Command Palette with Preferences: Open Settings (JSON). Add settings for the preferences you want to apply to all projects:

 1"python.pipenvPath": "${env:HOME}/.local/bin/pipenv",
 2"python.poetryPath": "${env:HOME}/.local/bin/poetry",
 3"python.condaPath": "${env:HOME}/.local/bin/conda",
 4"python.linting.enabled": true,
 5"python.linting.banditPath": "${env:HOME}/.local/bin/bandit",
 6"python.linting.banditEnabled": true,
 7"python.linting.pylintPath": "${env:HOME}/.local/bin/pylint",
 8"python.linting.mypyPath": "${env:HOME}/.local/bin/mypy",
 9"python.linting.flake8Path": "${env:HOME}/.local/bin/flake8",
10"python.formatting.blackPath": "${env:HOME}/.local/bin/black",

With these settings, you’ve managed to accomplish a couple of things that’ll be useful for your development workflow across many projects:

1. Lines 1 to 3 enable package discovery for projects enabled with pipenv, poetry, and conda.
2. Line 4 enables Python linting.
3. Lines 5 to 6 enable and set the path to bandit.
4. Lines 7 to 10 enable Python formatting and set the path to a globally-installed instance of pylint, mypy, flake8, and black.

In each absolute path, you can automatically substitute your home folder by using the macro ${env:HOME}.

Workspace Settings

Outside of the user settings, you can use the .vscode/ directory inside the workspace to configure some project-specific settings:

• Which commands to run to execute the project
• How to test and debug the project
• Which linter and formatter to use and any project-specific parameters

The following files hold the VS Code preferences:

Most of VS Code’s settings, as well as the settings for your extensions, are in these three files.

In the workspace preferences, the following predefined variables are supported:

Using these variables will keep the project settings agnostic to the environment, so you can commit them into Git.

As an example of working with these settings, if you want to use Black as the default code formatter for this project, you can create the file .vscode/settings.json with this configuration:

{
    "python.formatting.provider": "black",
}

Anyone who checks out this project will now automatically use Black as the formatter for Python files. You’ll see how this setting influences the autoformatting options in the section about setting format and lint on save.

Using the Settings Sync Extension

If you use VS Code across multiple computers, you can enable the automatic synchronization of Settings, Keyboard Shortcuts, User Snippets, Extensions, and UI State. If you haven’t used Settings Sync before, you’ll need to enable it:

1. Run Settings Sync: Turn On in your Command Palette.
2. Follow the setup steps as prompted by VS Code. You can authenticate with GitHub.
3. Once the setup is done, run Settings Sync: Configure from the Command Palette.
4. Select what you want to sync.

Once Settings Sync is configured on all the computers you have VS Code installed on, you can see the state for each synced setting by running Settings Sync: Show Synced Data from the Command Palette, where they’ll show up under Synced Machines:

This view shows you the last synced time for each of the settings and which machines are in sync.