Documentation
Topics Overview Overview Linux macOS Windows VS Code for the Web Raspberry Pi Network Additional Components Uninstall VS Code Tutorial Copilot Quickstart User Interface Personalize VS Code Install Extensions Tips and Tricks Intro Videos Overview Setup Quickstart Overview Language Models Context Tools Agents Customization Trust & Safety Overview Agents Tutorial Agents Window Planning Memory Tools Subagents Local Agents Copilot CLI Cloud Agents Third-Party Agents Overview Chat Sessions Add Context Inline Chat Review Edits Checkpoints Artifacts Panel Debug Chat Interactions Prompt Examples Overview Instructions Prompt Files Custom Agents Agent Skills Language Models MCP Hooks Plugins Context Engineering Customize AI Test-Driven Development Edit Notebooks with AI Test with AI Test Web Apps with Browser Tools Debug with AI MCP Dev Guide OpenTelemetry Monitoring Inline Suggestions Smart Actions Best Practices Security Troubleshooting FAQ Cheat Sheet Settings Reference MCP Configuration Workspace Context Display Language Layout Keyboard Shortcuts Settings Settings Sync Extension Marketplace Extension Runtime Security Themes Profiles Overview Voice Interactions Command Line Interface Telemetry Basic Editing IntelliSense Code Navigation Refactoring Snippets Overview Multi-Root Workspaces Workspace Trust Tasks Debugging Debug Configuration Testing Port Forwarding Integrated Browser Overview Quickstart Staging & Committing Branches & Worktrees Repositories & Remotes Merge Conflicts Collaborate on GitHub Troubleshooting FAQ Getting Started Tutorial Terminal Basics Terminal Profiles Shell Integration Appearance Advanced Overview Enterprise Policies AI Settings Extensions Telemetry Updates Overview JavaScript JSON HTML Emmet CSS, SCSS and Less TypeScript Markdown PowerShell C++ Java PHP Python Julia R Ruby Rust Go T-SQL C# .NET Swift Working with JavaScript Node.js Tutorial Node.js Debugging Deploy Node.js Apps Browser Debugging Angular Tutorial React Tutorial Vue Tutorial Debugging Recipes Performance Profiling Extensions Tutorial Transpiling Editing Refactoring Debugging Quick Start Tutorial Run Python Code Editing Linting Formatting Debugging Environments Testing Python Interactive Django Tutorial FastAPI Tutorial Flask Tutorial Create Containers Deploy Python Apps Python in the Web Settings Reference Getting Started Navigate and Edit Refactoring Formatting and Linting Project Management Build Tools Run and Debug Testing Spring Boot Modernizing Java Apps Application Servers Deploy Java Apps GUI Applications Extensions FAQ Intro Videos GCC on Linux GCC on Windows GCC on Windows Subsystem for Linux Clang on macOS Microsoft C++ on Windows Build with CMake CMake Tools on Linux CMake Quick Start C++ Dev Tools for Copilot Editing and Navigating Debugging Configure Debugging Refactoring Settings Reference Configure IntelliSense Configure IntelliSense for Cross-Compiling FAQ Intro Videos Get Started Navigate and Edit IntelliCode Refactoring Formatting and Linting Project Management Build Tools Package Management Run and Debug Testing FAQ Overview Node.js Python ASP.NET Core Debug Docker Compose Registries Deploy to Azure Choose a Dev Environment Customize Develop with Kubernetes Tips and Tricks Overview Jupyter Notebooks Data Science Tutorial Python Interactive Data Wrangler Quick Start Data Wrangler PyTorch Support Azure Machine Learning Manage Jupyter Kernels Jupyter Notebooks on the Web Data Science in Microsoft Fabric Foundry Toolkit Overview Foundry Toolkit Copilot Tools Create Agents Models Playground Agent Builder Agent Inspector Evaluation Tool Catalog Fine-Tuning (Automated Setup) Fine-Tuning (Project Template) Model Conversion Tracing Profiling (Windows ML) FAQ File Structure Manual Model Conversion Manual Model Conversion on GPU Setup Environment Without Foundry Toolkit Template Project Migrating from Visualizer to Agent Inspector Overview Getting Started Resources View Deployment VS Code for the Web - Azure Containers Azure Kubernetes Service Kubernetes MongoDB Remote Debugging for Node.js Overview SSH Dev Containers Windows Subsystem for Linux GitHub Codespaces VS Code Server Tunnels SSH Tutorial WSL Tutorial Tips and Tricks FAQ Overview Tutorial Attach to Container Create Dev Container Advanced Containers devcontainer.json Dev Container CLI Tips and Tricks FAQ Default Keyboard Shortcuts Default Settings Substitution Variables Tasks Schema
Copy as Markdown
On this page there are 8 sections
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.
General Python settings
| condaPath | "conda" | Path to the conda executable. |
| defaultInterpreterPath | "python" | 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 ${workspaceFolder} and ${workspaceFolder}/.venv. Using a path to a folder allows anyone working with a project to create an environment in the .venv folder as appropriate to their operating system, rather than having to specify an exact platform-dependent path. The settings.json file can then be included in a source code repository. 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. |
| envFile | "${workspaceFolder}/.env" | Absolute path to a file containing environment variable definitions. See .env file support. |
| experiments.enabled | true | Enables A/B experiments in the Python extension. If enabled, you may be provided with proposed enhancements and/or features. |
| globalModuleInstallation | false | Specifies whether to install packages for the current user only using the --user command-line argument (the default), or to install for all users in the global environment (when set to true). Ignored when using a virtual environment. For more information on the --user argument, see pip - User Installs. |
| interpreter.infoVisibility | "onPythonRelated" | 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 "always" if you'd like it to always show on the status bar, or "never" to hide it entirely. |
| pipenvPath | "pipenv" | Path to the pipenv executable to use for activation. |
| poetryPath | "poetry" | Specifies the location of the Poetry dependency manager executable, if installed. The default value "poetry" assumes the executable is in the current path. The Python extension uses this setting to install packages when Poetry is available and there's a poetry.lock file in the workspace folder. |
| REPL.enableREPLSmartSend | true | Specifies whether Shift+Enter leverage Smart Send. Smart Send looks at the code where the cursor is placed, sends the smallest runnable chunk of code to the Python REPL, and then places your cursor at the next line of code. |
| terminal.activateEnvInCurrentTerminal | false | Specifies whether to activate the currently open terminal when the Python extension is activated, using the virtual environment selected. |
| terminal.activateEnvironment | true | 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 true and you select a virtual environment, the extension automatically runs the environment's activate command when creating a new terminal (source env/bin/activate on macOS/Linux; env\scripts\activate on Windows). Note: This setting is superseded by python-envs.terminal.autoActivationType when that setting is configured. |
| terminal.executeInFileDir | false | Indicates whether to run a file in the file's directory instead of the current folder. |
| terminal.focusAfterLaunch | false | Whether to switch the cursor focus to the terminal when launching a Python terminal. |
| 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 launchArgs list, each item is a top-level command-line element that's separated by a space (quoted values that contain spaces are a single top-level element and are thus one item in the list). For example, for the arguments --a --b --c {"value1" : 1, "value2" : 2}, the list items should be ["--a", "--b", "--c", "{\"value1\" : 1, \"value2\" : 2}\""]. Note that VS Code ignores this setting when debugging because it instead uses arguments from your selected debugging configuration in launch.json. |
| terminal.useEnvFile | false | Controls whether environment variables from env files and python.envFile setting are injected into terminals. |
| venvFolders | [] | Paths to folders where virtual environments are created. Depending on the virtualization tool used, it can be the project itself: ${workspaceFolder}, or separate folders for all virtual environments located side by side: .\envs, ~/.virtualenvs, and so on. Note: This setting is automatically merged with python-envs.globalSearchPaths. Consider migrating to the new setting for additional features. |
Python Environments extension settings
The Python Environments extension provides environment and package management within the VS Code UI. These settings control environment discovery, creation, and terminal activation.
For more information about environment management, see Python environments.
Environment management settings
| defaultEnvManager | "ms-python.python:venv" | The default environment manager for creating and managing environments. |
| defaultPackageManager | "ms-python.python:pip" | The default package manager for installing packages in environments. |
| pythonProjects | [] | The list of Python projects. Each item is an object with properties: path (string), envManager (string), packageManager (string). Use this to configure per-folder environments in multi-root workspaces. |
| workspaceSearchPaths | ["./**/.venv"] | Glob patterns to search for environments in this workspace. By default, searches for any folder named .venv anywhere in your workspace. Note: This setting must be configured at the workspace or folder level, not user level. |
| globalSearchPaths | [] | Absolute paths to search for Python environments across all workspaces. Use for shared environment folders like ~/envs. Note: Legacy settings python.venvPath and python.venvFolders are automatically merged with this setting. |
| alwaysUseUv | true | When set to true, uv will be used to manage all virtual environments if available. When set to false, uv will only manage virtual environments explicitly created by uv. |
Terminal settings
| autoActivationType | "command" | Specifies how the extension activates an environment in a terminal. Available values: command (activation by executing a command in terminal), shellStartup (activation using shell integration or by modifying terminal shell startup script, supported for zsh, fish, pwsh, bash, cmd), off (no automatic activation). Note: This setting takes precedence over python.terminal.activateEnvironment. |
| showActivateButton | false | (Experimental) Whether to show the 'Activate' button in the terminal menu. |
Legacy settings migration
If you're migrating from older Python extension settings, the following table shows the mapping to new settings:
| python.venvPath | python-envs.globalSearchPaths or python-envs.workspaceSearchPaths | Legacy setting still works and is merged automatically. Consider migrating to use glob patterns. |
| python.venvFolders | python-envs.globalSearchPaths or python-envs.workspaceSearchPaths | Legacy setting still works and is merged automatically. |
| python.terminal.activateEnvironment | python-envs.terminal.autoActivationType | Set to "off" to disable auto-activation. The new setting takes precedence when configured. |
Debugger Settings
General debugging
| debugJustMyCode | true | Specifies whether the debugger should only step through user-written code. Disabling allows you to step through library code as well. | Debugging |
Testing settings
General testing
| autoTestDiscoverOnSaveEnabled | true | Specifies whether to enable or disable auto run test discovery when saving a test file. | Testing |
| cwd | null | Specifies an optional working directory for tests. | Testing |
| debugPort | 3000 | Port number used for debugging of unittest tests. | Testing |
| promptToConfigure | true | Specifies whether VS Code prompts to configure a test framework if potential tests are discovered. | Testing |
unittest framework
| unittestArgs | ["-v", "-s", ".", "-p", "*test*.py"] | Arguments to pass to unittest, where each top-level element that's separated by a space is a separate item in the list. | Testing |
| unittestEnabled | false | Specifies whether unittest is enabled for testing. | Testing |
pytest framework
| 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 --no-cov in these arguments. | Testing |
| pytestEnabled | false | Specifies whether pytest is enabled for testing. | Testing |
| pytestPath | "pytest" | Path to pytest. Use a full path if pytest is located outside the current environment. | Testing |
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.
| 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.
| aiCodeActions | true | Whether to enable specific AI-assisted code actions. Requires the GitHub Copilot Chat extension to be enabled. Accepted value is an object with a code action as key and a boolean as value. Available code actions: implementAbstractClasses (enables code action to implement methods of classes inherited from an abstract class, using AI suggestions from GitHub Copilot to populate the method body). Usage example: {"implementAbstractClasses": true} |
| autoFormatStrings | false | When typing "{" inside a string, whether to automatically prefix it with an "f". |
| autoImportCompletions | false | Controls the offering of auto imports in completions. Available values are true and false. |
| autoIndent | true | Whether to automatically adjust indentation based on language semantics when typing Python code. Accepted values are true or false. |
| autoSearchPaths | true | Indicates whether to automatically add search paths based on some predefined names (like src). Available values are true and false. |
| completeFunctionParens | false | Adds parentheses to function completions. Accepted values are true and false. |
| diagnosticMode | openFilesOnly | Specifies what code files the language server analyzes for problems. Available values are workspace and openFilesOnly. |
| diagnosticSeverityOverrides | {} | Allows a user to override the severity levels for individual diagnostics. For each rule, the available severity levels are error (red squiggle), warning (yellow squiggle), information (blue squiggle), and none (rule disabled). For information about the keys to use for the diagnostic severity rules, see the Diagnostic severity rules section below. |
| enableEditableInstalls | false | Enables improved IntelliSense support by resolving import paths for packages installed in editable mode (pip install -e .) as defined by PEP 660. |
| exclude | [] | Paths of directories or files that should not be included in analysis. These override the directories listed under the python.analysis.include setting, allowing specific subdirectories to be excluded. Note that files listed in this exclude setting may still be included in the analysis if they are referenced/imported by source files that are not in the excluded list. Paths may contain wildcard characters such as ** (a directory or multiple levels of directories), * (a sequence of zero or more characters), or ? (a single character). If no exclude paths are specified, Pylance automatically excludes the following: **/node_modules, **/__pycache__, .git and any virtual environment directories. |
| extraPaths | [] | Specifies extra search paths for import resolution. Accepts paths specified as strings and separated by commas if there are multiple paths. For example: ["path 1","path 2"]. |
| importFormat | absolute | Defines the default format when auto importing modules. Accepted values are absolute or relative. |
| 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 ** (a directory or multiple levels of directories), * (a sequence of zero or more characters), or ? (a single character). |
| fixAll | [] | A list of code actions to run when running the Fix All command or the source.fixAll code action. Accepted values: source.unusedImports (removes all unused imports in the open file), source.convertImportFormat (converts the imports according to the python.analysis.importFormat setting). |
| includeAliasesFromUserFiles | false | Whether to include alias symbols from user files in auto-import suggestions and in the add import Quick Fix. When disabled, Pylance will offer the import suggestion from where the symbol is defined. When enabled, it'll also offer import suggestions from files where the symbol is imported (i.e. aliased). Available values are true and false. |
| 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 ** (a directory or multiple levels of directories), * (a sequence of zero or more characters), or ? (a single character). If no value is provided, the value of python.linting.ignorePatterns (if set) will be used. |
| 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 true or false. When set to true, by default Pylance indexes top-level symbols of installed packages (i.e., symbols in __all__ under package/__init__.py), as well as all symbols from up to 2000 user files. When set to false, Pylance will only display symbols already referenced or used in files that were previously opened in or loaded by the editor. |
| inlayHints.callArgumentNames | off | Controls the display of inlay hints for call argument names. Available values are off, partial, and all. When set to off, no inlay hints are shown. When set to partial, hints are disabled for positional-only and keyword-only parameters. When set to all, hints are shown for all parameters. |
| inlayHints.functionReturnTypes | false | Whether to display inlay hints for function return types. Accepted values are true or false. |
| inlayHints.pytestParameters | false | Whether to display inlay hints for pytest fixture argument types. Accepted values are true or false. |
| inlayHints.variableTypes | false | Whether to display inlay hints for variable types. Accepted values are true or false. |
| languageServerMode | default | Offers predefined configurations to optimize Pylance's performance based on the development needs. Available values are default and light. When set to default, the language server delivers sufficient functionality for most machines without overloading the system. When set to light, it enables a lightweight, memory-efficient setup. This mode disables various features to make Pylance function more like a streamlined text editor, and it's ideal for those who do not require the full breadth of IntelliSense capabilities and prefer Pylance to be as resource-friendly as possible. In light mode, the following settings are overridden: python.analysis.exclude is set to ["**"], python.analysis.useLibraryCodeForTypes is set to false, python.analysis.enablePytestSupport is set to false, and python.analysis.indexing is set to false. |
| logLevel | Error | Specifies the level of logging to be performed by the language server. The possible levels of logging, in increasing level of information provided, are Error, Warning, Information, and Trace. |
| nodeArguments | "--max-old-space-size=8192" | Specifies custom arguments directly the custom Node.js executable defined by python.analysis.nodeExecutable. This can be used to allocate more memory or configure Node.js behavior. Accepts a list of arguments supported by Node.js. Each "arg=value" should be separated by commas in the list. Usage example: "python.analysis.nodeArguments": ["--max-old-space-size=8192"] |
| nodeExecutable | "" | Specifies the Node.js executable to use, which allows Pylance to allocate more memory. Accepted values are strings with executable paths, an empty string or "auto". When set to an empty string, Pylance will use VS Code's node executable. When set to "auto", it will automatically download Node.js. |
| 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 {"name": "package name (str)", "depth": "depth to scan (int)", "includeAllSymbols": "whether to include all symbols (bool)"}. If includeAllSymbols is set to false, only symbols in each package's __all__ are included. When it's set to true, Pylance will index every module/top level symbol declarations in the file. Usage example: [{"name": "sklearn", "depth": 2, "includeAllSymbols": true}, {"name": "matplotlib", "depth": 3, "includeAllSymbols": false}] |
| 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. |
| typeCheckingMode | off | Specifies the level of type checking analysis to perform. Available values are off, basic, and strict. When set to off no type checking analysis is conducted; unresolved imports/variables diagnostics are produced. When set to basic non-type checking-related rules (all rules in off), as well as basic type checking rules are used. When set to strict all type checking rules at the highest severity of error (including all rules in off and basic categories) are used. |
| useLibraryCodeForTypes | true | Parses the source code for a package when a type stub is not found. Available values are true and false. |
| 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. |
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.