As discussed in my guide Visual Studio Code for Software Development, one of the advantages of Visual Studio Code is the power and flexibility enabled by extensions. You can find extensions either from inside the editor or by going to the Visual Studio Code Marketplace. .NET (or C#) is one of the most popular extensions. At the time of this publication, Python is the top extension for Visual Studio Code, enjoying more than twice the number of installs of the C# extension.
This guide will discuss how to install Visual Studio Code along with the Python extension and how to use the two together as a powerful development tool.
While you could develop Python apps using the default installation of Visual Studio Code, the Python extension will make it much easier. Open the Extensions pane with Ctrl-Shift-X / Cmd-Shift-X on macOS, or click the fifth icon down in the sidebar.
At the top of the pane, search for
Python in the list of extensions.
The one you want is from Microsoft. It will have more downloads than all the others because it is currently the most popular extension for Visual Studio Code. Click the green install button and the extension will be installed.
The Python extension adds many features, such as
This guide is not going to be able to cover all of these features but will take a look a some of them.
The example in this guide assumes that you have Python installed and know something about the language. This guide will not go into specifics about Python basics or virtual environments. But if you have a virtual environment in the directory that is open in the Explorer, Visual Studio Code can detect it and associate it within the editor. Open the Command Palette and search for
Python: Select Interpreter.
This will bring up a list of detected virtual environments.
In this screenshot, there are a lot of environments on the system. But you will select the one that you created in the current directory. After that, when you open a new terminal window, the activation script for the virtual environment will run. It even detects the shell and selects the appropriate script!
When opening a Python file for the first time in a directory, Visual Studio Code will prompt you to install a linter.
Click Install and Visual Studio Code will open another terminal, activate the virtual environment, and
pip install a linter. The linter will be used to detect errors in your code that will be displayed inside of the editor window.
Visual Studio Code provides tab completion and code hints for Python code. Notice it will detect built-in modules from the Python Standard Library:
As well as third party modules installed with
pip, such as
flask (there is also snippet support!):
And user-defined code too! It also handles indentation which you can configure to PEP-8 or your own style:
The Python extension also supports debugging inside of Visual Studio Code. Before debugging, you'll need to create a launch.json file to configure Visual Studio Code. This is done via the Command Palette with the
Debug: Open launch.json command. Select the
Python File to debug the currently open file.
This will create a
launch.json file in the
.vscode directory in the root of the project. Set a breakpoint in a Python file by clicking to the left of the line numbers. A red dot will appear. Now switch to the Debug panel with the shortcut Ctrl-Shift-D / Cmd-Shift-D on macOS. Make sure that the configuration Python: Current File is selected in the dropdown box at the top and press the green Run button.
The interpreter will execute the current file and stop on the line with the breakpoint. You can inspect the current values in scope in the Variables pane in the sidebar. You can set expressions in the Watch pane as well. Notice the at the top of the editor are the familiar controls for Continue, Step Over and other debugging tasks.
If you are developing web apps with Flask or Django, you can debug those in Visual Studio Code as well. In the Debug Pane select Add Configuration.
launch.json file will open and prompt you for the type of configuration to add. Select
This will bring up the configuration selection list in the Command Palette. Select
You will be prompted for the path to the app. In this example, the app is in a file named
two.py, select the Python: Flask option in the Debug panel, and a breakpoint inside of the code.
Press the Run button. Go to
http://127.0.0.1:5000 and the code will break on line 10. Notice the variables in scope can be inspected.
The extension can also detect and run Python tests using
nose. This example uses
unittest as it's part of the Python Standard Library. Here is a simple method to run a test on:
1import random 2import string 3 4 5def generate_password(min_length = 8): 6 password = '' 7 for _ in range(min_length): 8 next = random.choice(string.ascii_letters + string.digits) 9 password += next 10 return password
Then include a test file:
1# filename password_test.py 2import password 3import unittest 4 5class PasswordTests(unittest.TestCase):def test_password_length_16(self): 6 self.assertEqual(len(password.generate_password(16)), 16) 7 8if __name__ == '__main__': 9 unittest.main()
This simple test merely checks that the length of the generated password is the same as the value passed to the
generate_password function. Open the Command Palette and search for
Python: Configure Tests. You'll be asked to select a test framework,
unittest in this case (no pun intended).
Next, select the location of tests. For this simple example the root of the project will suffice.
Finally, select a pattern that will identify files with tests. The test file for this example ends with
_test.py so select the option for
By installing the Test Explorer UI extension by Holger Benl, you can run the detected tests inside of the editor. Open up the Test pane (the beaker icon) to see a list of the detected tests. Click Run All Tests or open the Command Palette and search for
Python: Run All Tests. The results will be shown in the Test pane and the
unittest output shown at the bottom of the window.
15 for the expected value in
test_password_length will make the test fail.
The Python extension provides support for Jupyter notebook. This is a very popular tool with data scientists. To create a new notebook file, open the Command Palette and search for
Python: Create New Blank Jupyter Notebook. You may be prompted to install the
ipykernel library which is required for Juypter support.
Visual Studio Code will start a Jupyter notebook session and show the notebook in the editor.
Enter code into the cells and click the green Run button to execute the cell, or press Shift-Enter.
Cells can also contain markdown text by pressing the Markdown button. If you are working with a package like
matplotlib, you can even display visualizations inline.
You can also export and import notebook files from other Jupyter notebook implementations such as Google Colab and Azure Notebooks.
Finally, right click in any Python file and select Run Current File in Python Interactive Window to open an interactive Python console.
The file will be executed and any members available at the prompt in the bottom of the interactive console.
You can also execute just the current line or selection in the file by pressing Ctrl-Enter.