Chuyển tới nội dung
Home » Visual Studio Code Python Interpreter | Code Actions

Visual Studio Code Python Interpreter | Code Actions

How to Select Python Interpreter in Visual Studio Code (vscode)

Next steps

  • Python environments – Control which Python interpreter is used for editing and debugging.
  • Editing code – Learn about autocomplete, IntelliSense, formatting, and refactoring for Python.
  • Linting – Enable, configure, and apply a variety of Python linters.
  • Debugging – Learn to debug Python both locally and remotely.
  • Testing – Configure test environments and discover, run, and debug tests.

Install Python interpreters

There are several options for installing Python interpreters to work with Visual Studio. You can install an interpreter when you install the Python workload, or you can install an interpreter after a workload is present. Interpreters can also be installed manually outside of the Visual Studio Installer.

When you install the Python development workload in Visual Studio 2017 and later, Python 3 (64-bit) also installs by default. As an option, you can choose to install the 32-bit or 64-bit version of Python 2 or Python 3, along with Miniconda (Visual Studio 2019) or Anaconda 2/Anaconda 3 (Visual Studio 2017). The steps for this type of installation are described in Install Python support in Visual Studio.

An alternate approach is to install standard Python interpreters by using the Add Environment feature in Visual Studio. This option is available in the Python Environments window and the Python toolbar.

Python interpreters can also be installed manually outside of the Visual Studio Installer. Suppose you install Anaconda 3 before you install Visual Studio. You don’t need to reinstall Anaconda through the Visual Studio Installer. You can also install a newer version of an interpreter if it isn’t yet listed in the Visual Studio Installer.

Types of Python environments

Global environments

By default, any Python interpreter installed runs in its own global environment. For example, if you just run

python

,

python3

, or

py

at a new terminal (depending on how you installed Python), you’re running in that interpreter’s global environment. Any packages that you install or uninstall affect the global environment and all programs that you run within it.

Tip: In Python, it is best practice to create a workspace-specific environment, for example, by using a local environment.

Local environments

There are two types of environments that you can create for your workspace: virtual and conda. These environments allow you to install packages without affecting other environments, isolating your workspace’s package installations.

Virtual environments

A virtual environment is a built-in way to create an environment. A virtual environment creates a folder that contains a copy (or symlink) to a specific interpreter. When you install packages into a virtual environment it will end up in this new folder, and thus isolated from other packages used by other workspaces.

Note: While it’s possible to open a virtual environment folder as a workspace, doing so is not recommended and might cause issues with using the Python extension.

Conda environments

A conda environment is a Python environment that’s managed using the

conda

package manager (see Getting started with conda).Choosing between conda and virtual environments depends on your packaging needs, team standards, etc.

Python environment tools

The following table lists the various tools involved with Python environments:

Tool Definition and Purpose
pip The Python package manager that installs and updates packages. It’s installed with Python 3.9+ by default (unless you are on a Debian-based OS; install
venv Allows you to manage separate package installations for different projects and is installed with Python 3 by default (unless you are on a Debian-based OS; install
conda Installed with Miniconda. It can be used to manage both packages and virtual environments. Generally used for data science projects.
How to Select Python Interpreter in Visual Studio Code (vscode)
How to Select Python Interpreter in Visual Studio Code (vscode)

Talk To The Interpreter

One benefit of the interpreter is that you can start an interactive session with the interpreter and type Python code right into it to see what it does. This is a great way to try out code ideas.

For example, what happens if you use with strings or with lists? Here is an interpreter session trying that way. The

>>>

is the prompt, the bold text is what you type, followed by the interpreter’s response on the next line.

>>> ‘hello’ + ‘!’ ‘hello!’ >>> [1, 2] + [3, 4] [1, 2, 3, 4] >>>

You could look up the formal description of , but just typing an experiment in the interpreter to see what it does is quick and satisfying.

Incidentally,

>>>

examples like the above are used throughout these pages to show phrases of Python code with their output. You can always start your own interpreter session to replicate and play with these experiments yourself.

Phản hồi

Gửi và xem ý kiến phản hồi dành cho

Enable Visual Studio Code to seamlessly identify the correct runtime for your project, letting you leverage the security and compliance features inherent in the ActiveState project within your integrated development environment (IDE).

Before using your ActiveState project’s Python interpreter in your VS Code environment, make sure the following conditions are met:


state update. If you have installed the State Tool after opening VS Code you will need to restart VS Code for the changes to take effect.

The following will help you integrate Visual Studio Code with your ActiveState project.

Begin by creating a Python file in your project, or opening an existing Python file. If this is a new file you may be prompted to select an interpreter, or if it is an existing file you can select a new interpreter using the VS Code Command Palette.

To access the “Select Interpreter” drop-down from the Command Palette

This will automatically generate a list of all of the interpreters currently available on your machine (including those provided by ActiveState). Click to select your preferred interpreter and begin working on your file.

After making your selection your new interpreter will be displayed at the bottom of the VS Code window (“andrewd-activestate/PythonWindows3’:ActiveState” shown above).

If your ActiveState Python interpreter is not immediately available in the “Select Interpreter” dropdown:


python.activeStateToolPathunder the “Settings” list.


$PATHor


%PATH%variable. To enter the absolute path to the State Tool’s executable go to File > Preferences> Settings and search for ”State Tool”. Enter the absolute path to the State Tool executable in the field shown.


state projects

How to Change the Python Interpreter in VS Code

The Python interpreter is a programming language which can be used in Visual Studio Code. It comes in different versions with different features and capabilities. The default version usually comes with Python when you install it on your computer. However, you can have multiple versions installed on your device, and you can choose between them if you need to change the interpreter.

In this article, we’ll explain how to change the Python interpreter in VS Code.

How to Add Python Interpreter in Visual Studio Code - Step By Step
How to Add Python Interpreter in Visual Studio Code – Step By Step

Configure and run the debugger

Let’s now try debugging our Python program. Debugging support is provided by the Python Debugger extension, which is automatically installed with the Python extension. To ensure it has been installed correctly, open the Extensions view (⇧⌘X (Windows, Linux Ctrl+Shift+X)) and search for

@installed python debugger

. You should see the Python Debugger extension listed in the results.

Next, set a breakpoint on line 2 of

hello.py

by placing the cursor on the

Next, to initialize the debugger, press F5. Since this is your first time debugging this file, a configuration menu will open from the Command Palette allowing you to select the type of debug configuration you would like for the opened file.

Note: VS Code uses JSON files for all of its various configurations;


launch.json

is the standard name for a file containing debugging configurations.

Select Python File, which is the configuration that runs the current file shown in the editor using the currently selected Python interpreter.

The debugger will start, and then stop at the first line of the file breakpoint. The current line is indicated with a yellow arrow in the left margin. If you examine the Local variables window at this point, you can see that the

msg

variable appears in the Local pane.

A debug toolbar appears along the top with the following commands from left to right: continue (F5), step over (F10), step into (F11), step out (⇧F11 (Windows, Linux Shift+F11)), restart (⇧⌘F5 (Windows, Linux Ctrl+Shift+F5)), and stop (⇧F5 (Windows, Linux Shift+F5)).

The Status Bar also changes color (orange in many themes) to indicate that you’re in debug mode. The Python Debug Console also appears automatically in the lower right panel to show the commands being run, along with the program output.

To continue running the program, select the continue command on the debug toolbar (F5). The debugger runs the program to the end.

Tip Debugging information can also be seen by hovering over code, such as variables. In the case of


msg

, hovering over the variable will display the string

Roll a dice!

in a box above the variable.

You can also work with variables in the Debug Console (If you don’t see it, select Debug Console in the lower right area of VS Code, or select it from the … menu.) Then try entering the following lines, one by one, at the > prompt at the bottom of the console:


msg msg.capitalize() msg.split()

Select the blue Continue button on the toolbar again (or press F5) to run the program to completion. “Roll a dice!” appears in the Python Debug Console if you switch back to it, and VS Code exits debugging mode once the program is complete.

If you restart the debugger, the debugger again stops on the first breakpoint.

To stop running a program before it’s complete, use the red square stop button on the debug toolbar (⇧F5 (Windows, Linux Shift+F5)), or use the Run > Stop debugging menu command.

For full details, see Debugging configurations, which includes notes on how to use a specific Python interpreter for debugging.

Tip: Use Logpoints instead of print statements: Developers often litter source code with

Run Python code

Click the Run Python File in Terminal play button in the top-right side of the editor.

The button opens a terminal panel in which your Python interpreter is automatically activated, then runs

python3 hello.py

(macOS/Linux) or

python hello.py

(Windows):

There are three other ways you can run Python code within VS Code:

  1. Right-click anywhere in the editor window and select Run > Python File in Terminal (which saves the file automatically):

  2. Select one or more lines, then press Shift+Enter or right-click and select Run Selection/Line in Python Terminal. This command is convenient for testing just a part of a file.

  3. From the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)), select the Python: Start REPL command to open a REPL terminal for the currently selected Python interpreter. In the REPL, you can then enter and run lines of code one at a time.

Congrats, you just ran your first Python code in Visual Studio Code!

select Python Interpreter Visual Studio Code
select Python Interpreter Visual Studio Code

Environment variables

Environment variable definitions file

An environment variable definitions file is a text file containing key-value pairs in the form of

environment_variable=value

, with used for comments. Multiline values aren’t supported, but references to previously defined environment variables are allowed. Environment variable definitions files can be used for scenarios such as debugging and tool execution (including linters, formatters, IntelliSense, and testing tools), but aren’t applied to the terminal.

Note: Environment variable definitions files are not necessarily cross-platform. For instance, while Unix uses

as a path separator in environment variables, Windows uses. There is no normalization of such operating system differences, and so you need to make sure any environment definitions file use values that are compatible with your operating system.

By default, the Python extension looks for and loads a file named

.env

in the current workspace folder, then applies those definitions. The file is identified by the default entry

"python.envFile": "${workspaceFolder}/.env"

in your user settings (see General Python settings). You can change the

python.envFile

setting at any time to use a different definitions file.

Note: Environment variable definitions files are not used in all situations where environment variables are available for use. Unless Visual Studio Code documentation states otherwise, these only affect certain scenarios as per their definition. For example, the extension doesn’t use environment variable definitions files when resolving setting values.

A debug configuration also contains an

envFile

property that also defaults to the

.env

file in the current workspace (see Debugging – Set configuration options). This property allows you to easily set variables for debugging purposes that replace variables specified in the default

.env

file.

For example, when developing a web application, you might want to easily switch between development and production servers. Instead of coding the different URLs and other settings into your application directly, you could use separate definitions files for each. For example:

dev.env file


# dev.env - development configuration # API endpoint MYPROJECT_APIENDPOINT=https://my.domain.com/api/dev/ # Variables for the database MYPROJECT_DBURL=https://my.domain.com/db/dev MYPROJECT_DBUSER=devadmin MYPROJECT_DBPASSWORD=!dfka**213=

prod.env file


# prod.env - production configuration # API endpoint MYPROJECT_APIENDPOINT=https://my.domain.com/api/ # Variables for the database MYPROJECT_DBURL=https://my.domain.com/db/ MYPROJECT_DBUSER=coreuser MYPROJECT_DBPASSWORD=kKKfa98*11@

You can then set the

python.envFile

setting to

${workspaceFolder}/prod.env

, then set the

envFile

property in the debug configuration to

${workspaceFolder}/dev.env

.

Note: When environment variables are specified using multiple methods, be aware that there is an order of precedence. All


env

variables defined in the

launch.json

file will override variables contained in the

.env

file, specified by the

python.envFile

setting (user or workspace). Similarly,

env

variables defined in the

launch.json

file will override the environment variables defined in the

envFile

that are specified in

launch.json

.

Use of the PYTHONPATH variable

The PYTHONPATH environment variable specifies additional locations where the Python interpreter should look for modules. In VS Code, PYTHONPATH can be set through the terminal settings (

terminal.integrated.env.*

) and/or within an

.env

file.

When the terminal settings are used, PYTHONPATH affects any tools that are run within the terminal by a user, as well as any action the extension performs for a user that is routed through the terminal such as debugging. However, in this case when the extension is performing an action that isn’t routed through the terminal, such as the use of a linter or formatter, then this setting won’t have an effect on module look-up.

Working with Python interpreters

Select and activate an environment

The Python extension tries to find and then select what it deems the best environment for the workspace. If you would prefer to select a specific environment, use the Python: Select Interpreter command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)).

Note: If the Python extension doesn’t find an interpreter, it issues a warning. On macOS 12.2 and older, the extension also issues a warning if you’re using the OS-installed Python interpreter as it is known to have compatibility issues. In either case, you can disable these warnings by setting


python.disableInstallationCheck

to

true

in your user settings.

The Python: Select Interpreter command displays a list of available global environments, conda environments, and virtual environments. (See the Where the extension looks for environments section for details, including the distinctions between these types of environments.) The following image, for example, shows several Anaconda and CPython installations along with a conda environment and a virtual environment (

env

) that’s located within the workspace folder:

Note: On Windows, it can take a little time for VS Code to detect available conda environments. During that process, you may see “(cached)” before the path to an environment. The label indicates that VS Code is presently working with cached information for that environment.

If you have a folder or a workspace open in VS Code and you select an interpreter from the list, the Python extension will store that information internally. This ensures that the same interpreter will be used when you reopen the workspace.

The selected environment is used by the Python extension for running Python code (using the Python: Run Python File in Terminal command), providing language services (auto-complete, syntax checking, linting, formatting, etc.) when you have a

.py

file open in the editor, and opening a terminal with the Terminal: Create New Terminal command. In the latter case, VS Code automatically activates the selected environment.

Tip: To prevent automatic activation of a selected environment, add


"python.terminal.activateEnvironment": false

to your

settings.json

file (it can be placed anywhere as a sibling to the existing settings).

Tip: If the activate command generates the message “Activate.ps1 is not digitally signed. You cannot run this script on the current system.”, then you need to temporarily change the PowerShell execution policy to allow scripts to run (see About Execution Policies in the PowerShell documentation):


Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process

Note: By default, VS Code uses the interpreter selected for your workspace when debugging code. You can override this behavior by specifying a different path in the


python

property of a debug configuration. See Choose a debugging environment.

The selected interpreter version will show on the right side of the Status Bar.

The Status Bar also reflects when no interpreter is selected.

In either case, clicking this area of the Status Bar is a convenient shortcut for the Python: Select Interpreter command.

Tip: If you have any problems with VS Code recognizing a virtual environment, please file an issue so we can help determine the cause.

Manually specify an interpreter

If VS Code doesn’t automatically locate an interpreter you want to use, you can browse for the interpreter on your file system or provide the path to it manually.

You can do so by running the Python: Select Interpreter command and select the Enter interpreter path… option that shows on the top of the interpreters list:

You can then either enter the full path of the Python interpreter directly in the text box (for example, “.venv/Scripts/python.exe”), or you can select the Find… button and browse your file system to find the python executable you wish to select.

If you want to manually specify a default interpreter that will be used when you first open your workspace, you can create or modify an entry for the

python.defaultInterpreterPath

setting.

Note: Changes to the


python.defaultInterpreterPath

setting are not picked up after an interpreter has already been selected for a workspace; any changes to the setting will be ignored once an initial interpreter is selected for the workspace.

Additionally, if you’d like to set up a default interpreter to all of your Python applications, you can add an entry for

python.defaultInterpreterPath

manually inside your User Settings. To do so, open the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) and enter Preferences: Open User Settings. Then set

python.defaultInterpreterPath

, which is in the Python extension section of User Settings, with the appropriate interpreter.

How the extension chooses an environment automatically

If an interpreter hasn’t been specified, then the Python extension automatically selects the interpreter with the highest version in the following priority order:

  1. Virtual environments located directly under the workspace folder.
  2. Virtual environments related to the workspace but stored globally. For example, Pipenv or Poetry environments that are located outside of the workspace folder.
  3. Globally installed interpreters. For example, the ones found in

    /usr/local/bin

    ,

    C:\\python38

    , etc.

Note: The interpreter selected may differ from what


python

refers to in your terminal.

If Visual Studio Code doesn’t locate your interpreter automatically, you can manually specify an interpreter.

Where the extension looks for environments

The extension automatically looks for interpreters in the following locations, in no particular order:

  • Standard install paths such as

    /usr/local/bin

    ,

    /usr/sbin

    ,

    /sbin

    ,

    c:\\python36

    , etc.
  • Virtual environments located directly under the workspace (project) folder.
  • Virtual environments located in the folder identified by the

    python.venvPath

    setting (see General Python settings), which can contain multiple virtual environments. The extension looks for virtual environments in the first-level subfolders of

    venvPath

    .
  • Virtual environments located in a

    ~/.virtualenvs

    folder for virtualenvwrapper.
  • Interpreters created by pyenv, Pipenv, and Poetry.
  • Virtual environments located in the path identified by

    WORKON_HOME

    (as used by virtualenvwrapper).
  • Conda environments found by

    conda env list

    . Conda environments which do not have an interpreter will have one installed for them upon selection.
  • Interpreters installed in a

    .direnv

    folder for direnv under the workspace folder.

Environments and Terminal windows

After using Python: Select Interpreter, that interpreter is applied when right-clicking a file and selecting Python: Run Python File in Terminal. The environment is also activated automatically when you use the Terminal: Create New Terminal command unless you change the

python.terminal.activateEnvironment

setting to

false

.

Please note that launching VS Code from a shell in which a specific Python environment is activated doesn’t automatically activate that environment in the default Integrated Terminal.

Note: conda environments cannot be automatically activated in the integrated terminal if PowerShell is set as the integrated shell. See Integrated terminal – Terminal profiles for how to change the shell.

Changing interpreters with the Python: Select Interpreter command doesn’t affect terminal panels that are already open. Thus, you can activate separate environments in a split terminal: select the first interpreter, create a terminal for it, select a different interpreter, then use the split button (⌘\ (Windows, Linux Ctrl+Shift+5)) in the terminal title bar.

Choose a debugging environment

By default, the debugger will use the Python interpreter chosen with the Python extension. However, if there is a

python

property specified in the debug configuration of

launch.json

, it takes precedence. If this property is not defined, it will fall back to using the Python interpreter path selected for the workspace.

For more details on debug configuration, see Debugging configurations.

My Python Development Environment Setup - Full Tutorial
My Python Development Environment Setup – Full Tutorial

Review Python interpreters

The following table lists Python interpreters that can be used with Visual Studio.

Interpreter Description Notes
CPython The “native” and most commonly used interpreter, available in 32-bit and 64-bit versions (32-bit recommended). Includes the latest language features, maximum Python package compatibility, full debugging support, and interop with IPython. Review the considerations in Should I use Python 2 or Python 3? to help determine which version of Python to install. Visual Studio 2015 and earlier don’t support Python 3.6 or later, and can return errors like Unsupported python version 3.6. For Visual Studio 2015 and earlier, use Python 3.5 or earlier.
IronPython A .NET implementation of Python, available in 32-bit and 64-bit versions. Provides C#/F#/Visual Basic interop, access to .NET APIs, standard Python debugging (but not C++ mixed-mode debugging), and mixed IronPython/C# debugging. IronPython doesn’t support virtual environments.
Anaconda An open data science platform powered by Python. Includes the latest version of CPython and most of the difficult-to-install packages. If you’re unable to decide on an interpreter, we recommend using Anaconda.
PyPy A high-performance tracing JIT implementation of Python. Good for long-running programs and situations where you identify performance issues but can’t find other resolutions. Works with Visual Studio but with limited support for advanced debugging features.
Jython An implementation of Python on the Java Virtual Machine (JVM). Similar to IronPython, code running in Jython can interact with Java classes and libraries. However, many of the libraries intended for CPython might not be accessible. Works with Visual Studio but with limited support for advanced debugging features.

Debugging

No more

For more specific information on debugging in Python, such as configuring your

launch.json

settings and implementing remote debugging, see Debugging. General VS Code debugging information is found in the debugging document.

Additionally, the Django and Flask tutorials provide examples of how to implement debugging in the context of web applications, including debugging Django templates.

How to CHANGE or ADD Python Interpreter on Visual Studio Code - VS Code Python Tutorial 2023
How to CHANGE or ADD Python Interpreter on Visual Studio Code – VS Code Python Tutorial 2023

Interpreter Hacks: dir help

What are all the functions that the

str

type has? You could look it up, but it’s also possible in the interpreter to pull the list of function names directly out of Python this (

str

is the name of the built-int string type):

>>> dir(str) [‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getnewargs__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__init_subclass__’, ‘__iter__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mod__’, ‘__mul__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__rmod__’, ‘__rmul__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘capitalize’, ‘casefold’, ‘center’, ‘count’, ‘encode’, ‘endswith’, ‘expandtabs’, ‘find’, ‘format’, ‘format_map’, ‘index’, ‘isalnum’, ‘isalpha’, ‘isascii’, ‘isdecimal’, ‘isdigit’, ‘isidentifier’, ‘islower’, ‘isnumeric’, ‘isprintable’, ‘isspace’, ‘istitle’, ‘isupper’, ‘join’, ‘ljust’, ‘lower’, ‘lstrip’, ‘maketrans’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’, ‘rjust’, ‘rpartition’, ‘rsplit’, ‘rstrip’, ‘split’, ‘splitlines’, ‘startswith’, ‘strip’, ‘swapcase’, ‘title’, ‘translate’, ‘upper’, ‘zfill’]

The above is not the most pretty form of the data, as we’re just dumping the names of Python’s internal structure. Names that begin with 2 underbars like

__add__

are special internal functions that code does not normally need to know about. You can see regular functions like

lower()

and ‘find()` in the list.

With the special help function, you can pull up the PyDoc for each function (the triple-quote comments for a function). To refer to a function within the

str

type use the form

str.find

. Note that the function name is not followed by parenthesis – this is the unusual case of referring to a function but not calling it.

>>> help(str.find) find(…) S.find(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.

Copyright 2020 Nick Parlante

Python in Visual Studio Code

Working with Python in Visual Studio Code, using the Microsoft Python extension, is simple, fun, and productive. The extension makes VS Code an excellent Python editor, and works on any operating system with a variety of Python interpreters. It leverages all of VS Code’s power to provide auto complete and IntelliSense, linting, debugging, and unit testing, along with the ability to easily switch between Python environments, including virtual and conda environments.

This article provides only an overview of the different capabilities of the Python extension for VS Code. For a walkthrough of editing, running, and debugging code, use the button below.

Run, debug, and test

Now that you are more familiar with Python in VS Code, let’s learn how to run, debug, and test your code.

Run

There are a few ways to run Python code in VS Code.

To run the Python script you have open on the editor, select the Run Python File in Terminal play button in the top-right of the editor.

There are also additional ways you can iteratively run snippets of your Python code within VS Code:

  • Select one or more lines, then press Shift+Enter or right-click and select Run Selection/Line in Python Terminal. This command is convenient for testing just a part of a file.
  • From the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)), select the Python: Start REPL command to open a REPL terminal for the currently selected Python interpreter. In the REPL, you can then enter and run lines of code one at a time.

Debug

The debugger is a helpful tool that allows you to inspect the flow of your code execution and more easily identify errors, as well as explore how your variables and data change as your program is run. You can start debugging by setting a breakpoint in your Python project by clicking in the gutter next to the line you wish to inspect.

To start debugging, initialize the debugger by pressing F5. Since this is your first time debugging this file, a configuration menu will open allowing you to select the type of application you want to debug. If it’s a Python script, you can select Python File.

Once your program reaches the breakpoint, it will stop and allow you to track data in the Python Debug console, and progress through your program using the debug toolbar.

For a deeper dive into Python debugging functionality, see Python debugging in VS Code.

Test

The Python extension provides robust testing support for Unittest and pytest.

You can configure Python tests through the Testing view on the Activity Bar by selecting Configure Python Tests and selecting your test framework of choice.

You can also create tests for your Python project, which the Python extension will attempt to discover once your framework of choice is configured. The Python extension also allows you to run and debug your tests in the Testing view and inspect the test run output in the Test Results panel.

For a comprehensive look at testing functionality, see Python testing in VS Code.

How to set up Python on Visual Studio Code
How to set up Python on Visual Studio Code

Next steps

To learn how to build web apps with popular Python web frameworks, see the following tutorials:

There is then much more to explore with Python in Visual Studio Code:

  • Python profile template – Create a new profile with a curated set of extensions, settings, and snippets
  • Editing code – Learn about autocomplete, IntelliSense, formatting, and refactoring for Python.
  • Linting – Enable, configure, and apply a variety of Python linters.
  • Debugging – Learn to debug Python both locally and remotely.
  • Testing – Configure test environments and discover, run, and debug tests.
  • Settings reference – Explore the full range of Python-related settings in VS Code.
  • Deploy Python to Azure App Service
  • Deploy Python to Container Apps

Quick Start Guide for Python in VS Code

The Python extension makes Visual Studio Code an excellent Python editor, works on any operating system, and is usable with a variety of Python interpreters.

Get started by installing:

  • VS Code
  • A Python Interpreter (any actively supported Python version)
  • Python extension from the VS Code Marketplace

To further customize VS Code for Python, you can leverage the Python profile template, automatically installing recommended extensions and settings. For Data Science projects, consider using the Data Science profile template.

How to Change the Python Interpreter in VS Code on Windows or Linux

Changing the Python interpreter in VS Code is a straightforward process that can be completed in just a few steps.

Here’s how it’s done:

  1. Press “Ctrl + Shift + P” to open the Command Palette. You can easily access VS Code commands and features through the Command Palette.
  2. Start typing “

    Python: Select Interpreter

    ” and press Enter. You’ll open a list on Python interpreters available on your device if you have multiple versions installed. If the Python extension doesn’t locate an interpreter, it displays a warning.
  3. Click on the Python Interpreter you want to use. VS Code will show the selected interpreter in the Status Bar at the bottom right part of the screen. It serves as a shortcut for the “

    Python: Select Interpreter

    ” command and shows when no interpreter is selected as well. You can also check if the correct version is being used by opening a Python file.
\
\”Select Python Interpreter\” Erorr Fix

General Python settings

Setting

(python.)

Default Description
condaPath Path to the
defaultInterpreterPath Path to the default Python interpreter to be used by the Python extension on the first time it loads for a workspace, or the path to a folder containing the Python interpreter.

Can use variables like

Using a path to a folder allows anyone working with a project to create an environment in the

Note: Changes to this setting made after an interpreter has been selected for a workspace will not be applied or considered by the Python extension. The Python extension doesn’t automatically add or change this setting.

interpreter.infoVisibility Controls when to display the selected interpreter information on the status bar.

By default, it only shows when there are Python related files open in the editor.

You can set it to

pipenvPath Path to the pipenv executable to use for activation.
venvFolders Paths to folders where virtual environments are created.

Depending on the virtualization tool used, it can be the project itself:

envFile Absolute path to a file containing environment variable definitions.

See Configuring Python environments – environment variable definitions file.

globalModuleInstallation Specifies whether to install packages for the current user only using the

For more information on the

poetryPath Specifies the location of the Poetry dependency manager executable, if installed. The default value

The Python extension uses this setting to install packages when Poetry is available and there’s a

terminal.launchArgs Launch arguments that are given to the Python interpreter when you run a file using commands such as Python: Run Python File in Terminal.

In the

For example, for the arguments

Note that VS Code ignores this setting when debugging because it instead uses arguments from your selected debugging configuration in

terminal.executeInFileDir Indicates whether to run a file in the file’s directory instead of the current folder.
terminal.activateEnvironment Indicates whether to automatically activate the environment you select using the Python: Select Interpreter command when a new terminal is created.

For example, when this setting is

terminal.activateEnvInCurrentTerminal Specifies whether to activate the currently open terminal when the Python extension is activated, using the virtual environment selected.
terminal.focusAfterLaunch Whether to switch the cursor focus to the terminal when launching a Python terminal.
logging.level Specifies the level of logging to be performed by the extension.

The possible levels of logging, in increasing level of information provided, are

When set to

At the

At the

experiments.enabled Enables A/B experiments in the Python extension. If enabled, you may be provided with proposed enhancements and/or features.

Environments

The Python extension automatically detects Python interpreters that are installed in standard locations. It also detects conda environments as well as virtual environments in the workspace folder. See Configuring Python environments.

The current environment is shown on the right side of the VS Code Status Bar:

The Status Bar also indicates if no interpreter is selected:

The selected environment is used for IntelliSense, auto-completions, linting, formatting, and any other language-related feature. It is also activated when you run or debug Python in a terminal, or when you create a new terminal with the Terminal: Create New Terminal command.

To change the current interpreter, which includes switching to conda or virtual environments, select the interpreter name on the Status Bar or use the Python: Select Interpreter command.

VS Code prompts you with a list of detected environments as well as any you’ve added manually to your user settings (see Configuring Python environments).

Como Configurar VSCode Para Python em 2024[RÁPIDO]
Como Configurar VSCode Para Python em 2024[RÁPIDO]

Python profile template

Profiles let you quickly switch your extensions, settings, and UI layout depending on your current project or task. To help you get started with Python development, you can use the Python profile template, which is a curated profile with useful extensions, settings, and snippets. You can use the profile template as is or use it as a starting point to customize further for you own workflows.

You select a profile template through the Profiles > Create Profile… dropdown:

Once you select a profile template, you can review the settings and extensions, and remove individual items if you don’t want to include them in your new Profile. After creating the new profile based on the template, changes made to settings, extensions, or UI are persisted in your profile.

Code Actions

Code Actions (also known as Quick Fixes) are provided to help fix issues when there are warnings in your code. These helpful hints are displayed in the editor left margin as a lightbulb (💡). Select the light bulb to display Code Action options. These Code Action can come from extensions such as Python, Pylance, or VS Code itself. For more information about Code Actions, see Python Quick Fixes.

VSCode Setting Python Interpreter
VSCode Setting Python Interpreter

How to create and open a Python project or file

If you have an existing Python project you wish to work on in VS Code, you can begin by opening your folder or file from the VS Code Welcome page or File Explorer view, or by selecting File > Open Folder (Ctrl+K Ctrl+O) or File > Open File (⌘O (Windows, Linux Ctrl+O)).

You can create a new Python file by selecting New File on the VS Code Welcome page and then selecting Python file, or by navigating to File > New File ().

Tip: If you already have a workspace folder open in VS Code, you can add new files or folders directly into your existing project. You can create new folders and files by using the corresponding New Folder or New File icons on the top level folder in the File Explorer view.

Testing

The Python extension supports testing with Python’s built-in unittest framework and pytest.

In order to run tests, you must enable one of the supported testing frameworks in the settings of your project. Each framework has its own specific settings, such as arguments for identifying the paths and patterns for test discovery.

Once the tests have been discovered, VS Code provides a variety of commands (on the Status Bar, the Command Palette, and elsewhere) to run and debug tests. These commands also allow you to run individual test files and methods

How to run Python in Visual Studio Code on Windows 10/11 [ 2024 Update ] Python Developers
How to run Python in Visual Studio Code on Windows 10/11 [ 2024 Update ] Python Developers

Install and use packages

Let’s build upon the previous example by using packages.

In Python, packages are how you obtain any number of useful code libraries, typically from PyPI, that provide additional functionality to your program. For this example, you use the

numpy

package to generate a random number.

Return to the Explorer view (the top-most icon on the left side, which shows files), open

hello.py

, and paste in the following source code:


import numpy as np msg = "Roll a dice" print(msg) print(np.random.randint(1,9))

Tip: If you enter the above code by hand, you may find that auto-completions change the names after the


as

keywords when you press Enter at the end of a line. To avoid this, type a space, then Enter.

Next, run the file in the debugger using the “Python: Current file” configuration as described in the last section.

You should see the message, “ModuleNotFoundError: No module named ‘numpy'”. This message indicates that the required package isn’t available in your interpreter. If you’re using an Anaconda distribution or have previously installed the

numpy

package you may not see this message.

To install the

numpy

package, stop the debugger and use the Command Palette to run Terminal: Create New Terminal (⌃⇧` (Windows, Linux Ctrl+Shift+`)). This command opens a command prompt for your selected interpreter.

To install the required packages in your virtual environment, enter the following commands as appropriate for your operating system:

  1. Install the packages


    # Don't use with Anaconda distributions because they include matplotlib already. # macOS python3 -m pip install numpy # Windows (may require elevation) py -m pip install numpy # Linux (Debian) apt-get install python3-tk python3 -m pip install numpy

  2. Now, rerun the program, with or without the debugger, to view the output!

Congrats on completing the Python tutorial! During the course of this tutorial, you learned how to create a Python project, create a virtual environment, run and debug your Python code, and install Python packages. Explore additional resources to learn how to get the most out of Python in Visual Studio Code!

Intro to CS at Harvey Mudd College

Professor Zachary Dodds is a Computer Science professor at Harvey Mudd College who teaches several introductory classes both for students new to Computer Science and students from a non-Computer Science background. He co-created the popular introduction to Computer Science class CS5, which attracts students from all backgrounds to develop programming and problem-solving skills and to build “a coherent, intellectually compelling picture of Computer Science”. The class is taught with Python and uses VS Code as the recommended editor.

Why Visual Studio Code?

Professor Dodds has been recommending and using Visual Studio Code in his classes since it debuted in 2015.

“Visual Studio Code is the best balance of authenticity and accessibility… Visual Studio Code doesn’t feel ‘fake’, it’s what real software developers use. Plus, Visual Studio Code works on every OS!”

VS Code runs on Windows, macOS, Linux, and even Chromebooks.

Classroom settings

Since VS Code is easy to customize, Professor Dodds is able to tailor the editor for his students, preferring to hide IntelliSense, or code completion suggestions, so they can learn from what they type and reinforce the conceptual models being built.

Here are the settings his students use:


"editor.quickSuggestions": false, "editor.acceptSuggestionOnCommitCharacter": false, "editor.suggest.filterGraceful": true, "editor.suggestOnTriggerCharacters": false, "editor.acceptSuggestionOnEnter": "on", "editor.suggest.showIcons": false, "editor.suggest.maxVisibleSuggestions": 7, "editor.hover.enabled": false, "editor.hover.sticky": false, "editor.suggest.snippetsPreventQuickSuggestions": false, "editor.parameterHints.enabled": false, "editor.wordBasedSuggestions": "matchingDocuments", "editor.tabCompletion": "on", "extensions.ignoreRecommendations": true, "files.autoSave": "afterDelay",

You can find the most up-to-date settings on his course website: CS5 – Python Tips.

Integrated Terminal

Professor Dodds also utilizes the built-in terminal heavily in his class as an introduction to running programs from the command line and navigating around their machine all within Visual Studio Code. He appreciates how “the built-in terminal panel does not try to automate too much (which, if it did, would deprive newcomers of the experience of the information-flow that’s going on).”

In the video below, the student does all of their command line and coding work in one place, such as installing Python libraries, while working on Lab 3 from the CS5 class:

Thank you, Professor Dodds, for sharing your story! If you’re interested in using VS Code to teach Python in your classes, you can get started with the Python Education Extension Pack below!

How To Create & Activate A Virtual Environment In Visual Studio Code (Python 3.12)
How To Create & Activate A Virtual Environment In Visual Studio Code (Python 3.12)

Enhance completions with AI

GitHub Copilot is an AI-powered code completion tool that helps you write code faster and smarter. You can use the GitHub Copilot extension in VS Code to generate code, or to learn from the code it generates.

GitHub Copilot provides suggestions for languages beyond Python and a wide variety of frameworks, including JavaScript, TypeScript, Ruby, Go, C# and C++.

You can learn more about how to get started with Copilot in the Copilot documentation.

Achieve More with the Right Python Interpreter

Learning how to change the Python interpreter will allow you to switch between your installed Python versions, use virtual environments to manage your Python dependencies, use a specific Python distribution, and more. Following the steps outlined in this article, you’ll learn how to easily switch between different Python interpreters to suit your needs.

Have you already tried changing Python Interpreter in VS Code? Did you use any of the tips outlined in this article? Tell us in the comments section below.

Disclaimer: Some pages on this site may include an affiliate link. This does not effect our editorial in any way.

How to create Virtual Environment for Python in Visual Studio Code (2023)
How to create Virtual Environment for Python in Visual Studio Code (2023)

How To Get An Interpreter

There are 2 easy ways to get the interpreter:

1. Open a command-line terminal. Mac: run the “Terminal” app in the Utilities folder. Windows: type “powershell” in the lower left, this opens the Windows command line terminal. In the terminal type the command “python3” (“python” on Windows, or sometimes “py”). This runs the interpreter program directly. On the Mac type ctrl-d to exit (on Windows ctrl-z).

2. If you have PyCharm installed, at the lower-left of any window, click the Python Console tab. Or use the Tools > Python Console menu item to open an interpreter window within PyCharm.

Testing settings

General testing

Setting

(python.testing.)

Default Description See also
cwd null Specifies an optional working directory for tests. Testing
promptToConfigure Specifies whether VS Code prompts to configure a test framework if potential tests are discovered. Testing
debugPort Port number used for debugging of unittest tests. Testing
autoTestDiscoverOnSaveEnabled Specifies whether to enable or disable auto run test discovery when saving a test file. Testing

unittest framework

Setting

(python.testing.)

Default Description See also
unittestEnabled Specifies whether unittest is enabled for testing. Testing
unittestArgs Arguments to pass to unittest, where each top-level element that’s separated by a space is a separate item in the list. Testing

pytest framework

Setting

(python.testing.)

Default Description See also
pytestEnabled Specifies whether pytest is enabled for testing. Testing
pytestPath Path to pytest. Use a full path if pytest is located outside the current environment. Testing
pytestArgs Arguments to pass to pytest, where each top-level element that’s separated by a space is a separate item in the list. When debugging tests with pytest-cov installed, include Testing
How To Debug Python Code In Visual Studio Code (VSCode)
How To Debug Python Code In Visual Studio Code (VSCode)

Prerequisites

  • Visual Studio supports Python version 3.7. While it’s possible to use an earlier version of Visual Studio to edit code written in earlier versions of Python, those versions of Python aren’t officially supported. Visual Studio features such as IntelliSense and debugging might not work with earlier versions of Python.

  • For Visual Studio 2015 and earlier, use Python 3.5 or earlier. You must manually install one of the Python interpreters.

Anaconda distributions

Although Visual Studio offers to install the Anaconda distribution, your use of the distribution and other packages from Anaconda Repository are bound by the Anaconda Terms of Service. These terms might require some organizations to pay Anaconda for a commercial license, or else configure the tools to access an alternate repository. For more information, see the Conda channels documentation.

Jupyter notebooks

To enable Python support for Jupyter notebook files (

.ipynb

) in VS Code, you can install the Jupyter extension. The Python and Jupyter extensions work together to give you a great Notebook experience in VS Code, providing you the ability to directly view and modify code cells with IntelliSense support, as well as run and debug them.

You can also convert and open the notebook as a Python code file through the Jupyter: Export to Python Script command. The notebook’s cells are delimited in the Python file with

#%%

comments, and the Jupyter extension shows Run Cell or Run Below CodeLens. Selecting either CodeLens starts the Jupyter server and runs the cell(s) in the Python interactive window:

You can also connect to a remote Jupyter server to run your notebooks. For more information, see Jupyter support.

What is the Python Interpreter? (How does Python Work?)
What is the Python Interpreter? (How does Python Work?)

Indent In Interpreter

It’s possible to write multi-line indented code in the interpreter. If a line is not finished, such as ending with “:”, typing the return key does not run the code right away. You can write further indented lines. When you enter a blank line, the interpreter runs the whole thing. (For throw-away code like this, I am willing to indent just 2 spaces).

>>> for i in range(10): … mult = i * 100 … print(i, mult) … 0 0 1 100 2 200 3 300 4 400 5 500 6 600 7 700 8 800 9 900

Working With The Interpreter

The interpreter prints a

>>>

prompt and waits for you to type some Python code. It reads what you type, evaluates it, and prints the result — the so called read-eval-print loop (here what the user types is shown in bold)

>>> 1 + 2 * 3 7 >>> ‘hello’ + ‘there’ ‘hellothere’ >>> max(1, 5, -2) 5 >>> ‘hello’ + 2 TypeError: can only concatenate str (not “int”) to str >>> ‘hello’ + str(2) ‘hello2’ >>>

This is an excellent way to experiment with Python features to see how they work. If you have some code you are thinking about, it can be quick and informative to fire up the interpreter, and type the code in to see what it does. When you have an expression that works in the interpreter, you can copy/paste it into your program as a first draft of that line.

When you write a Python program, you store your code in a file like

hello.py

, where you can write and revise a series of functions and comments and whatnot over many lines, like writing a paper. You would not want to write a whole program at the

>>>

prompt, which works best for little throw-away phrases.

How To Install OpenCV Python in Visual Studio Code (Windows 10)
How To Install OpenCV Python in Visual Studio Code (Windows 10)

Creating environments

Using the Create Environment command

To create local environments in VS Code using virtual environments or Anaconda, you can follow these steps: open the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)), search for the Python: Create Environment command, and select it.

The command presents a list of environment types: Venv or Conda.

If you are creating an environment using Venv, the command presents a list of interpreters that can be used as a base for the new virtual environment.

If you are creating an environment using Conda, the command presents a list of Python versions that can be used for your project.

After selecting the desired interpreter or Python version, a notification will show the progress of the environment creation and the environment folder will appear in your workspace.

Note: The command will also install necessary packages outlined in a requirements/dependencies file, such as


requirements.txt

,

pyproject.toml

, or

environment.yml

, located in the project folder. It will also add a

.gitignore

file to the virtual environment to help prevent you from accidentally committing the virtual environment to source control.

Create a virtual environment in the terminal

If you choose to create a virtual environment manually, use the following command (where “.venv” is the name of the environment folder):


# macOS/Linux # You may need to run `sudo apt-get install python3-venv` first on Debian-based OSs python3 -m venv .venv # Windows # You can also use `py -3 -m venv .venv` python -m venv .venv

Note: To learn more about the


venv

module, read Creation of virtual environments on Python.org.

When you create a new virtual environment, a prompt will be displayed in VS Code to allow you to select it for the workspace.

Tip: Make sure to update your source control settings to prevent accidentally committing your virtual environment (in for example


.gitignore

). Since virtual environments are not portable, it typically does not make sense to commit them for others to use.

Create a conda environment in the terminal

The Python extension automatically detects existing conda environments. We recommend you install a Python interpreter into your conda environment, otherwise one will be installed for you after you select the environment. For example, the following command creates a conda environment named

env-01

with a Python 3.9 interpreter and several libraries:


conda create -n env-01 python=3.9 scipy=0.15.0 numpy

Note: For more information on the conda command line, you can read Conda environments.

Additional notes:

  • If you create a new conda environment while VS Code is running, use the refresh icon on the top right of the Python: Select Interpreter window; otherwise you may not find the environment there.

  • To ensure the environment is properly set up from a shell perspective, use an Anaconda prompt and activate the desired environment. Then, you can launch VS Code by entering the


    code .

    command. Once VS Code is open, you can select the interpreter either by using the Command Palette or by clicking on the status bar.

  • Although the Python extension for VS Code doesn’t currently have direct integration with conda


    environment.yml

    files, VS Code itself is a great YAML editor.

  • Conda environments can’t be automatically activated in the VS Code Integrated Terminal if the default shell is set to PowerShell. To change the shell, see Integrated terminal – Terminal profiles.

  • You can manually specify the path to the


    conda

    executable to use for activation (version 4.4+). To do so, open the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) and run Preferences: Open User Settings. Then set

    python.condaPath

    , which is in the Python extension section of User Settings, with the appropriate path.

Install Python and the Python extension

The tutorial guides you through installing Python and using the extension. You must install a Python interpreter yourself separately from the extension. For a quick install, use Python from python.org and install the extension from the VS Code Marketplace.

Note: To help get you started with Python development, you can use the Python profile template that includes useful extensions, settings, and Python code snippets.

Once you have a version of Python installed, select it using the Python: Select Interpreter command. If VS Code doesn’t automatically locate the interpreter you’re looking for, refer to Environments – Manually specify an interpreter.

You can configure the Python extension through settings. Learn more in the Python Settings reference.

Windows Subsystem for Linux: If you are on Windows, WSL is a great way to do Python development. You can run Linux distributions on Windows and Python is often already installed. When coupled with the WSL extension, you get full VS Code editing and debugging support while running in the context of WSL. To learn more, go to Developing in WSL or try the Working in WSL tutorial.

Harvard CS50’s Introduction to Programming with Python – Full University Course
Harvard CS50’s Introduction to Programming with Python – Full University Course

Autocomplete and IntelliSense

The Python extension supports code completion and IntelliSense using the currently selected interpreter. IntelliSense is a general term for a number of features, including intelligent code completion (in-context method and variable suggestions) across all your files and for built-in and third-party modules.

IntelliSense quickly shows methods, class members, and documentation as you type. You can also trigger completions at any time with ⌃Space (Windows, Linux Ctrl+Space). Hovering over identifiers will show more information about them.

Create a virtual environment

A best practice among Python developers is to use a project-specific

virtual environment

. Once you activate that environment, any packages you then install are isolated from other environments, including the global interpreter environment, reducing many complications that can arise from conflicting package versions. You can create non-global environments in VS Code using Venv or Anaconda with Python: Create Environment.

Open the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)), start typing the Python: Create Environment command to search, and then select the command.

The command presents a list of environment types, Venv or Conda. For this example, select Venv.

The command then presents a list of interpreters that can be used for your project. Select the interpreter you installed at the beginning of the tutorial.

After selecting the interpreter, a notification will show the progress of the environment creation and the environment folder (

/.venv

) will appear in your workspace.

Ensure your new environment is selected by using the Python: Select Interpreter command from the Command Palette.

Note: For additional information about virtual environments, or if you run into an error in the environment creation process, see Environments.

Best Python IDE: Vim, Emacs, PyCharm, or Visual Studio Code? | Guido van Rossum and Lex Fridman
Best Python IDE: Vim, Emacs, PyCharm, or Visual Studio Code? | Guido van Rossum and Lex Fridman

Move an interpreter

If you move an existing interpreter to a new location by using the file system, Visual Studio doesn’t automatically detect the change.

  • If you originally specified the location of the interpreter through the Python Environments window, you can edit its environment by using the Configure tab in that window to identify the new location. For more information, see Manually identify an existing environment.

  • If you installed the interpreter by using an installer program, use the following steps to reinstall the interpreter in the new location:

    1. Restore the Python interpreter to its original location.
    2. Uninstall the interpreter by using its installer, which clears the registry entries.
    3. Reinstall the interpreter at the new location.
    4. Restart Visual Studio, which should autodetect the new location in place of the old location.

This process ensures that the registry entries that identify the interpreter’s location, which Visual Studio uses, are properly updated. Using an installer also handles any other side effects that might exist.

Run Python code

To experience Python, create a file (using the File Explorer) named

hello.py

and paste in the following code:


print("Hello World")

The Python extension then provides shortcuts to run Python code using the currently selected interpreter (Python: Select Interpreter in the Command Palette). To run the active Python file, click the Run Python File in Terminal play button in the top-right side of the editor.

You can also run individual lines or a selection of code with the Python: Run Selection/Line in Python Terminal command (Shift+Enter). If there isn’t a selection, the line with your cursor will be run in the Python Terminal. An identical Run Selection/Line in Python Terminal command is available on the context menu for a selection in the editor. The same terminal will be used every time you run a selection or a line in the terminal/REPL, until that terminal is closed. The same terminal is also used for Run Python File in Terminal. If that terminal is still running the REPL, you should exit the REPL (

exit()

) or switch to a different terminal before running a Python file.

The Python extension automatically removes indents based on the first non-empty line of the selection, shifting all other lines left as needed.

The command opens the Python Terminal if necessary; you can also open the interactive REPL environment directly using the Python: Start REPL command that activates a terminal with the currently selected interpreter and then runs the Python REPL.

For a more specific walkthrough and other ways of running code, see the run code tutorial.

Can you use ChatGPT in VS Code??
Can you use ChatGPT in VS Code??

Python Extension Pack

Unsure which extensions to recommend to your students? You can point your students to the Python Education Extension Pack that contains essential and helpful extensions for the classroom. You can download the extension pack from the VS Code Marketplace:

The extension pack contains:

  • Python for basic Python functionality like compiling, debugging support, linting, Jupyter Notebooks, unit tests, and more.
  • Live Share to enable real-time collaboration.
  • Remote – SSH to work on remote projects (for example, to access lab machines) through SSH with full VS Code functionality.
  • Markdown+Math for full LaTeX support in Markdown.
  • Python Test Explorer for Visual Studio Code to visualize and run Python tests in the side bar.
  • Code Runner to run snippets (selected code) and single files of any code with a single click.

Start VS Code in a workspace folder

By starting VS Code in a folder, that folder becomes your “workspace”.

Using a command prompt or terminal, create an empty folder called “hello”, navigate into it, and open VS Code (

code

) in that folder () by entering the following commands:


mkdir hello cd hello code .

Note: If you’re using an Anaconda distribution, be sure to use an Anaconda command prompt.

Alternately, you can create a folder through the operating system UI, then use VS Code’s File > Open Folder to open the project folder.

How to Run Python 3.12 in Visual Studio Code on Windows 10 [2023]| Run Sample Python Program
How to Run Python 3.12 in Visual Studio Code on Windows 10 [2023]| Run Sample Python Program

Free Python and Data Science lessons

NASA-inspired lessons

This learning path enables students to use Python to explore doing analyses and projects inspired from real-world problems faced by National Aeronautics and Space Administration (NASA) scientists. View full details of the lessons under NASA-inspired Lessons.

Learn Python with Over The Moon

These space-themed lessons were inspired by the Netflix film, Over the Moon, and will introduce students to data science, machine learning, and artificial intelligence using Python and Azure. View full details on Learn Python with Over The Moon.

Wonder Woman-inspired lessons

Give an introduction to Python with “Wonder Woman 1984”-inspired lessons that help students learn about the basics like conditionals and variables. Get full lesson details under Learn Python with Wonder Woman.

Python in Notebooks

Learn the basics of Python. View the full lesson at Write basic Python in Notebooks in Visual Studio Code.

Set up your Python beginner development environment

A step-by-step guide to installing and setting up your Python and VS Code environment. View the full lesson at Set up your Python beginner development environment with Visual Studio Code.

Python Interpreter

You write your Python code in a text file with a name like

hello.py

. How does that code Run? There is program installed on your computer named “python3” or “python”, and its job is looking at and running your Python code. This type of program is called an “interpreter”.

Next steps

To learn how to build web apps with popular Python web frameworks, see the following tutorials:

There is much more to explore with Python in Visual Studio Code:

  • Python profile template – Create a new profile with a curated set of extensions, settings, and snippets
  • Editing code – Learn about autocomplete, IntelliSense, formatting, and refactoring for Python.
  • Linting – Enable, configure, and apply a variety of Python linters.
  • Debugging – Learn to debug Python both locally and remotely.
  • Testing – Configure test environments and discover, run, and debug tests.
  • Settings reference – Explore the full range of Python-related settings in VS Code.

Python settings reference

The Python Extension for Visual Studio Code is highly configurable. This page describes the key settings you can work with.

For general information about working with settings in VS Code, refer to User and workspace settings, as well as the Variables reference for information about predefined variable support.

How to setup Python for VSCode in 2023 in 5mins! | Install Python and Setup VSCode for Windows 10
How to setup Python for VSCode in 2023 in 5mins! | Install Python and Setup VSCode for Windows 10

Predefined variables

The Python extension settings support predefined variables. Similar to the general VS Code settings, variables use the ${variableName} syntax. Specifically, the extension supports the following variables:

  • ${cwd} – the task runner’s current working directory on startup

  • ${workspaceFolder} – the path of the folder opened in VS Code

  • ${workspaceRootFolderName} – the name of the folder opened in VS Code without any slashes (/)

  • ${workspaceFolderBasename} – the name of the folder opened in VS Code without any slashes (/)

  • ${file} – the current opened file

  • ${relativeFile} – the current opened file relative to


    workspaceFolder

  • ${relativeFileDirname} – the current opened file’s dirname relative to


    workspaceFolder

  • ${fileBasename} – the current opened file’s basename

  • ${fileBasenameNoExtension} – the current opened file’s basename with no file extension

  • ${fileDirname} – the current opened file’s dirname

  • ${fileExtname} – the current opened file’s extension

  • ${lineNumber} – the current selected line number in the active file

  • ${selectedText} – the current selected text in the active file

  • ${execPath} – the path to the running VS Code executable

For additional information about predefined variables and example usages, see the Variables reference in the general VS Code docs.

More Python resources

  • Getting Started with Python in VS Code – Learn how to edit, run, and debug code in VS Code.
  • Virtual Environments and Packages (Python.org) – Learn more about virtual environments and packages.
  • Installing Python Modules (Python.org) – Learn how to install Python modules.
  • Python tutorial (Python.org) – Learn more about the Python language.

I am using VSCode with ArcGIS Pro 3.0 in a virtual environment. Until yesterday, everything worked just fine. After updating to Pro 3.0, I was still able to use open a script and then have it run in the terminal window.

Previously, I was able to select a line from the script, run it, and then it would open the correct interpreter. However, now I am unable to do so and cannot troubleshoot why this is happening. I have added the correct path to the ArcGIS Pro python executable in the interpreter path, but the terminal opens to another python executable. Any advice would be greatly appreciated as to how I can run specific python executable that I want to run.

UPDATE: I can open VSCode using code from my anaconda installation, but still am having trouble running python interactively in the terminal. Previously, I used to be able to do this (e.g. test indented code cells), but this doesn’t seem to be functioning anymore.

Python in Visual Studio Code

Visual Studio Code is a free source code editor that fully supports Python and useful features such as real-time collaboration. It’s highly customizable to support your classroom the way you like to teach.

“Visual Studio Code is the best balance of authenticity and accessibility… Visual Studio Code doesn’t feel ‘fake’, it’s what real software developers use. Plus, Visual Studio Code works on every OS!” – Professor Zachary Dodds from Harvey Mudd College

Read below for recommendations for extensions, settings, and links to free lessons that you can use in your classes.

Creating Web App With Python Streamlit - Lesson 1
Creating Web App With Python Streamlit – Lesson 1

Create a Python source code file

From the File Explorer toolbar, select the New File button on the

hello

folder:

Name the file

hello.py

, and VS Code will automatically open it in the editor:

By using the

.py

file extension, you tell VS Code to interpret this file as a Python program, so that it evaluates the contents with the Python extension and the selected interpreter.

Note: The File Explorer toolbar also allows you to create folders within your workspace to better organize your code. You can use the New folder button to quickly create a folder.

Now that you have a code file in your Workspace, enter the following source code in

hello.py

:


msg = "Roll a dice" print(msg)

When you start typing

IntelliSense and auto-completions work for standard Python modules as well as other packages you’ve installed into the environment of the selected Python interpreter. It also provides completions for methods available on object types. For example, because the

msg

variable contains a string, IntelliSense provides string methods when you type

msg.

:

Finally, save the file (⌘S (Windows, Linux Ctrl+S)). At this point, you’re ready to run your first Python file in VS Code.

For full details on editing, formatting, and refactoring, see Editing code. The Python extension also has full support for Linting.

Code analysis settings

IntelliSense engine settings

Note: If you have never changed your language server setting, your language server is set to Pylance via the “Default” setting value.

Setting

(python.)

Default Description
languageServer Default Defines type of the language server (Default, Pylance, Jedi, and None).

Python Language Server settings

Pylance Language Server

The language server settings apply when

python.languageServer

is

Pylance

or

Default

. If you have difficulties with the language server, see Troubleshooting in the language server repository.

Setting

(python.analysis.)

Default Description
typeCheckingMode off Specifies the level of type checking analysis to perform.

Available values are

When set to

When set to

When set to

diagnosticMode openFilesOnly Specifies what code files the language server analyzes for problems.

Available values are

include [] Paths of directories or files that should be included in analysis.

If no paths are specified, Pylance defaults to the directory that contains the workspace root.

Paths may contain wildcard characters such as

exclude [] Paths of directories or files that should not be included in analysis.

These override the directories listed under the

Note that files listed in this

Paths may contain wildcard characters such as

If no exclude paths are specified, Pylance automatically excludes the following:

ignore [] Paths of directories or files whose diagnostic output (errors and warnings) should be suppressed, even if they are an included file or within the transitive closure of an included file.

Paths may contain wildcard characters such as

If no value is provided, the value of

stubPath ./typings Specifies a path to a directory that contains custom type stubs. Each package’s type stub file(s) are expected to be in its own subdirectory.
autoSearchPaths true Indicates whether to automatically add search paths based on some predefined names (like
extraPaths [] Specifies extra search paths for import resolution.

Accepts paths specified as strings and separated by commas if there are multiple paths. For example:

indexing true Used to specify whether Pylance should index user files as well as installed third party libraries at start up, to provide a more complete set of symbols in features such as auto imports, Quick Fixes, auto completions, etc.

Accepted values are

When set to

When set to

packageIndexDepths [] Used to override how many levels under installed packages to index on a per package basis.

By default, only top-level modules are indexed (depth = 1).

To index submodules, increase depth by 1 for each level of submodule you want to index.

Accepted values are tuples of objects like

If

Usage example:

userFileIndexingLimit 2000 Sets the maximum number of user files for Pylance to index in the workspace. When set to -1, Pylance will index all files.

Note that indexing files is a performance-intensive task.

autoFormatStrings false When typing “{” inside a string, whether to automatically prefix it with an “f”.
completeFunctionParens false Adds parentheses to function completions. Accepted values are
useLibraryCodeForTypes true Parses the source code for a package when a type stub is not found. Available values are
autoImportCompletions false Controls the offering of auto imports in completions. Available values are
importFormat Defines the default format when auto importing modules. Accepted values are
inlayHints.variableTypes false Whether to display inlay hints for variable types. Accepted values are
inlayHints.functionReturnTypes false Whether to display inlay hints for function return types. Accepted values are
inlayHints.callArgumentNames false Whether to display inlay hints for call argument names. Accepted values are
inlayHints.pytestParameters false Whether to display inlay hints for pytest fixture argument types. Accepted values are
diagnosticSeverityOverrides {} Allows a user to override the severity levels for individual diagnostics.

For each rule, the available severity levels are

For information about the keys to use for the diagnostic severity rules, see the Diagnostic severity rules section below.

fixAll A list of code actions to run when running the Fix All command or the

Accepted values in this list:

logLevel Specifies the level of logging to be performed by the language server.

The possible levels of logging, in increasing level of information provided, are

Diagnostic severity rules

This section details all the available rules that can be customized using the

python.analysis.diagnosticSeverityOverrides

setting as shown in the following example.


{ "python.analysis.diagnosticSeverityOverrides": { "reportUnboundVariable": "information", "reportImplicitStringConcatenation": "warning" } }

Value Description
reportGeneralTypeIssues Diagnostics for general type inconsistencies, unsupported operations, argument/parameter mismatches, etc. This covers all of the basic type-checking rules not covered by other rules. It does not include syntax errors.
reportPropertyTypeMismatch Diagnostics for properties where the type of the value passed to the setter is not assignable to the value returned by the getter. Such mismatches violate the intended use of properties, which are meant to act like variables.
reportFunctionMemberAccess Diagnostics for member accesses on functions.
reportMissingImports Diagnostics for imports that have no corresponding imported python file or type stub file.
reportMissingModuleSource Diagnostics for imports that have no corresponding source file. This happens when a type stub is found, but the module source file was not found, indicating that the code may fail at runtime when using this execution environment. Type checking will be done using the type stub.
reportMissingTypeStubs Diagnostics for imports that have no corresponding type stub file (either a typeshed file or a custom type stub). The type checker requires type stubs to do its best job at analysis.
reportImportCycles Diagnostics for cyclical import chains. These are not errors in Python, but they do slow down type analysis and often hint at architectural layering issues. Generally, they should be avoided.
reportUnusedImport Diagnostics for an imported symbol that is not referenced within that file.
reportUnusedClass Diagnostics for a class with a private name (starting with an underscore) that is not accessed.
reportUnusedFunction Diagnostics for a function or method with a private name (starting with an underscore) that is not accessed.
reportUnusedVariable Diagnostics for a variable that is not accessed.
reportDuplicateImport Diagnostics for an imported symbol or module that is imported more than once.
reportWildcardImportFromLibrary Diagnostics for a wildcard import from an external library.
reportOptionalSubscript Diagnostics for an attempt to subscript (index) a variable with an Optional type.
reportOptionalMemberAccess Diagnostics for an attempt to access a member of a variable with an Optional type.
reportOptionalCall Diagnostics for an attempt to call a variable with an Optional type.
reportOptionalIterable Diagnostics for an attempt to use an Optional type as an iterable value (e.g. within a for statement).
reportOptionalContextManager Diagnostics for an attempt to use an Optional type as a context manager (as a parameter to a with statement).
reportOptionalOperand Diagnostics for an attempt to use an Optional type as an operand to a binary or unary operator (like ‘+’, ‘==’, ‘or’, ‘not’).
reportUntypedFunctionDecorator Diagnostics for function decorators that have no type annotations. These obscure the function type, defeating many type analysis features.
reportUntypedClassDecorator Diagnostics for class decorators that have no type annotations. These obscure the class type, defeating many type analysis features.
reportUntypedBaseClass Diagnostics for base classes whose type cannot be determined statically. These obscure the class type, defeating many type analysis features.
reportUntypedNamedTuple Diagnostics when “namedtuple” is used rather than “NamedTuple”. The former contains no type information, whereas the latter does.
reportPrivateUsage Diagnostics for incorrect usage of private or protected variables or functions. Protected class members begin with a single underscore
reportConstantRedefinition Diagnostics for attempts to redefine variables whose names are all-caps with underscores and numerals.
reportIncompatibleMethodOverride Diagnostics for methods that override a method of the same name in a base class in an incompatible manner (wrong number of parameters, incompatible parameter types, or incompatible return type).
reportIncompatibleVariableOverride Diagnostics for class variable declarations that override a symbol of the same name in a base class with a type that is incompatible with the base class symbol type.
reportInvalidStringEscapeSequence Diagnostics for invalid escape sequences used within string literals. The Python specification indicates that such sequences will generate a syntax error in future versions.
reportUnknownParameterType Diagnostics for input or return parameters for functions or methods that have an unknown type.
reportUnknownArgumentType Diagnostics for call arguments for functions or methods that have an unknown type.
reportUnknownLambdaType Diagnostics for input or return parameters for lambdas that have an unknown type.
reportUnknownVariableType Diagnostics for variables that have an unknown type.
reportUnknownMemberType Diagnostics for class or instance variables that have an unknown type.
reportMissingTypeArgument Diagnostics for when a generic class is used without providing explicit or implicit type arguments.
reportInvalidTypeVarUse Diagnostics for improper use of type variables in a function signature.
reportCallInDefaultInitializer Diagnostics for function calls within a default value initialization expression. Such calls can mask expensive operations that are performed at module initialization time.
reportUnnecessaryIsInstance Diagnostics for ‘isinstance’ or ‘issubclass’ calls where the result is statically determined to be always true or always false. Such calls are often indicative of a programming error.
reportUnnecessaryCast Diagnostics for ‘cast’ calls that are statically determined to be unnecessary. Such calls are sometimes indicative of a programming error.
reportAssertAlwaysTrue Diagnostics for ‘assert’ statement that will probably always assert. This can be indicative of a programming error.
reportSelfClsParameterName Diagnostics for a missing or misnamed “self” parameter in instance methods and “cls” parameter in class methods. Instance methods in metaclasses (classes that derive from “type”) are allowed to use “cls” for instance methods.
reportImplicitStringConcatenation Diagnostics for two or more string literals that follow each other, indicating an implicit concatenation. This is considered a bad practice and often masks bugs such as missing commas.
reportUndefinedVariable Diagnostics for undefined variables.
reportUnboundVariable Diagnostics for unbound and possibly unbound variables.
reportInvalidStubStatement Diagnostics for statements that should not appear within a stub file.
reportUnusedCallResult Diagnostics for call expressions whose results are not consumed and are not None.
reportUnsupportedDunderAll Diagnostics for unsupported operations performed on
reportUnusedCoroutine Diagnostics for call expressions that return a Coroutine and whose results are not consumed.
Python Interpreter selection in visual studio or vscode #visualstudio #vscode #seekers
Python Interpreter selection in visual studio or vscode #visualstudio #vscode #seekers

Detect your environment

Visual Studio shows all known environments in the Python Environments window. It automatically detects updates to existing interpreters.

If Visual Studio doesn’t detect an installed environment, see Manually identify an existing environment.

If you want to provide new forms of detection for Python environments, see PTVS Environment Detection (github.com).

Registry entries

Visual Studio (all versions) automatically detects each installed Python interpreter and its environment by checking the registry according to PEP 514 – Python registration in the Windows registry. Python installations are typically found under the HKEY_LOCAL_MACHINE\SOFTWARE\Python (32-bit) and HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Python (64-bit) key within nodes for the distribution, such as PythonCore (CPython) and ContinuumAnalytics (Anaconda).

Next steps

  • Python Hello World tutorial – Get started with Python in VS Code.
  • Editing Python – Learn about auto-completion, formatting, and refactoring for Python.
  • Basic Editing – Learn about the powerful VS Code editor.
  • Code Navigation – Move quickly through your source code.
  • Django tutorial
  • Flask tutorial

Getting Started with Python in VS Code

In this tutorial, you will learn how to use Python 3 in Visual Studio Code to create, run, and debug a Python “Roll a dice” application, work with virtual environments, use packages, and more! By using the Python extension, you turn VS Code into a great, lightweight Python editor.

If you are new to programming, check out the Visual Studio Code for Education – Introduction to Python course. This course offers a comprehensive introduction to Python, featuring structured modules in a ready-to-code browser-based development environment.

To gain a deeper understanding of the Python language, you can explore any of the programming tutorials listed on python.org within the context of VS Code.

For a Data Science focused tutorial with Python, check out our Data Science section.

Python and Visual Studio Code Installation
Python and Visual Studio Code Installation

Next steps

  • Editing code – Learn about autocomplete, IntelliSense, formatting, and refactoring for Python.
  • Debugging – Learn to debug Python both locally and remotely.
  • Testing – Configure test environments and discover, run, and debug tests.
  • Settings reference – Explore the full range of Python-related settings in VS Code.

Other popular Python extensions

The Microsoft Python extension provides all of the features described previously in this article. Additional Python language support can be added to VS Code by installing other popular Python extensions.

  1. Open the Extensions view (⇧⌘X (Windows, Linux Ctrl+Shift+X)).
  2. Filter the extension list by typing ‘python’.

The extensions shown above are dynamically queried. Click on an extension tile above to read the description and reviews to decide which extension is best for you. See more in the Marketplace.

How To Setup A Virtual Environment For Python In Visual Studio Code In 2023
How To Setup A Virtual Environment For Python In Visual Studio Code In 2023

Install a Python interpreter

Along with the Python extension, you need to install a Python interpreter. Which interpreter you use is dependent on your specific needs, but some guidance is provided below.

Windows

Install Python from python.org. Use the Download Python button that appears first on the page to download the latest version.

Note: If you don’t have admin access, an additional option for installing Python on Windows is to use the Microsoft Store. The Microsoft Store provides installs of supported Python versions.

For additional information about using Python on Windows, see Using Python on Windows at Python.org

macOS

The system install of Python on macOS is not supported. Instead, a package management system like Homebrew is recommended. To install Python using Homebrew on macOS use

brew install python3

at the Terminal prompt.

Note: On macOS, make sure the location of your VS Code installation is included in your PATH environment variable. See these setup instructions for more information.

Linux

The built-in Python 3 installation on Linux works well, but to install other Python packages you must install

pip

with get-pip.py.

Other options

  • Data Science: If your primary purpose for using Python is Data Science, then you might consider a download from Anaconda. Anaconda provides not just a Python interpreter, but many useful libraries and tools for data science.

  • Windows Subsystem for Linux: If you are working on Windows and want a Linux environment for working with Python, the Windows Subsystem for Linux (WSL) is an option for you. If you choose this option, you’ll also want to install the WSL extension. For more information about using WSL with VS Code, see VS Code Remote Development or try the Working in WSL tutorial, which will walk you through setting up WSL, installing Python, and creating a Hello World application running in WSL.

Note: To verify that you’ve installed Python successfully on your machine, run one of the following commands (depending on your operating system):

Linux/macOS: open a Terminal Window and type the following command:


python3 --version

Windows: open a command prompt and run the following command:


py -3 --version

If the installation was successful, the output window should show the version of Python that you installed. Alternatively, you can use the


py -0

command in the VS Code integrated terminal to view the versions of python installed on your machine. The default interpreter is identified by an asterisk (*).

How to Change the Python Interpreter in VS Code on macOS

Changing the Python interpreter in VS Code on macOS is similar to changing it on Windows or Linux as only one step is different.

Simply follow these steps:

  1. Press “Cmd + Shift + P” to open the Command Palette.
  2. Start typing “

    Python: Select Interpreter

    ” and press Enter. You’ll open a list on Python interpreters available on your device if you have multiple versions installed. If the Python extension doesn’t locate an interpreter, it displays a warning.
  3. Click on the Python Interpreter you want to use. VS Code will show the selected interpreter in the Status Bar at the bottom right part of the screen. It serves as a shortcut for the “

    Python: Select Interpreter

    ” command and it shows when no interpreter is selected as well. You can also check if the correct version is being used by opening a Python file.

If VS Code doesn’t locate your interpreter automatically, you can manually specify an interpreter by creating a path.

Here’s what you need to do:

  1. Press “Cmd + Shift + P” to open the Command Palette.
  2. Start typing “

    Python: Select Interpreter

    ” and press Enter.
  3. Select “Enter Interpreter Path…”.
  4. Enter full path on the Python interpreter of select “Find…” and browse your file system to find the Python you need.

If you don’t have the right Python extension inside your VS Code, you need to install it first.

  1. Go to “Extensions” on the left side of the screen. Once you type “Python,” it will reveal the list of VS Code extensions popular on the VS Code Marketplace.
  2. Select the extension from the search results and click the “Install” button.
  3. Click on “Code,” then “Preferences,” and “Setting.“
  4. Start typing “Environment.”
  5. Under “Extensions” locate “Python.”
  6. Make sure that the box saying “Activate Python Environment in Terminal created using the Extension” is unchecked.

If you don’t have VS Code installed on your device, you can download it from the official website.

How To Change Python Interpreter In VSCode (If It's Not Working)
How To Change Python Interpreter In VSCode (If It’s Not Working)

Keywords searched by users: visual studio code python interpreter

How To Add Python Interpreter In Visual Studio Code - Step By Step - Youtube
How To Add Python Interpreter In Visual Studio Code – Step By Step – Youtube
How To Change The Python Interpreter In Vs Code
How To Change The Python Interpreter In Vs Code
Setting Up Vscode For Python: A Complete Guide | Datacamp
Setting Up Vscode For Python: A Complete Guide | Datacamp
Setting Up Vscode For Python: A Complete Guide | Datacamp
Setting Up Vscode For Python: A Complete Guide | Datacamp
How To Select Python Interpreter In Visual Studio Code (Vscode) - Youtube
How To Select Python Interpreter In Visual Studio Code (Vscode) – Youtube
Python Debugging In Visual Studio Code - Development - 3D Slicer Community
Python Debugging In Visual Studio Code – Development – 3D Slicer Community
Python In Visual Studio Code – July 2022 Release - Python
Python In Visual Studio Code – July 2022 Release – Python
How To Change The Python Interpreter In Vs Code
How To Change The Python Interpreter In Vs Code
Python In Vscode: Running And Debugging • Python Land Tutorial
Python In Vscode: Running And Debugging • Python Land Tutorial
Remote Python Development In Visual Studio Code - Python
Remote Python Development In Visual Studio Code – Python
Selecting The Correct Python Interpreter In Vscode'S Python Extension -  Youtube
Selecting The Correct Python Interpreter In Vscode’S Python Extension – Youtube
How To Change The Python Interpreter In Vs Code
How To Change The Python Interpreter In Vs Code
Hướng Dẫn Lập Trình Python Với Visual Studio Code - Học Lập Trình Python -  Viettuts
Hướng Dẫn Lập Trình Python Với Visual Studio Code – Học Lập Trình Python – Viettuts
Python In Visual Studio Code – June 2022 Release - Python
Python In Visual Studio Code – June 2022 Release – Python

See more here: kientrucannam.vn

Trả lời

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *