Visual Studio Code: run Python file with arguments

Visual Studio Code only supports one launch.json file. However, it supports two or more configurations that appear in the debug pane's drop down list (instead of "No Configurations").

In the DEBUG pane, either click the Config button circled in red above or click the blue link "create launch.json file":

Click it and it creates a launch.json file with debugging configurations. Edit this file and add the args in this key-pair format AND add multiple for different args including Variable Substitution!

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File with my args",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "args": [
                "--username", "Jeremy",
                "--account", "Stackoverflow"
            ],
            "console": "integratedTerminal"
        },
        {
            "name": "Python: Current File with UserName arg",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "args": ["${env:USERNAME}"],
            "console": "integratedTerminal"
        }
    ]
}

Set your desired Config Option in the drop down and put a breakpoint in your Python script, for example on the first line under def main(...) and then press F5 or Run> Start Debugging.

You can run a Python file with arguments without a debugger by selecting a configuration in debug panel, then Ctrl F5 to run it without debugging.

Pro Tip: see the Variable Substitution reference its the perfect way to automate things for the whole team by not hardcoding individuals info or settings in the configs instead using things in Build Pipelines such as Environmental Variables from the get go!

Pro Tip:

1. Environmental Variables to override any setting.

2. A settings (aka appSettings.json) file to override the default/shared values.

3. Default/Shared settings (or hardcoded POCO constructor values).

   
   Later configuration providers overwrite the previous providers. Image courtesy Andrew Lock.

You can add a custom task to do this. This deals with the tasks.json. You can add a default tasks.json file for you project (project folder). Follow these steps. Keyboard press Ctrl + Shift + B. It will prompt the following popup

Click on the Configure Build Task If there is already a custom tasks.json file created in the following location .vscode/tasks.json editor will open it. If not, it will give a drop down of suggestions of already existing task runners.

Our intention is to create a custom tasks.json file for our project, so to create one we need to select the Others option from the drop down. Check the screenshot below.

Once you select the Others option, you could see a default tasks.json file will get created from the root directory of the project to the location .vscode/tasks.json. Below is an example of tasks.json.

Now edit the tasks.json file to support Python.

1. Change the Command property from "echo" to "Python"
2. Keep showOutput as "Always"
3. Change args (arguments) from ["Hello World"] to ["${file}"] (filename)
4. Delete the last property problemMatcher
5. Keep isShellCommand and version properties as unchanged
6. Save the changes made

You can now open your .py file and run it nicely with the shortcut Ctrl + Shift + B.

A workaround is to have your script ask for the command-line arguments (in the internal Visual Studio Code console).

This can be made much more usable by leaning on readline, which allows you to do things like press the Up arrow key to cycle through previous commands (command history), and more. An example:

import argparse, readline

def main():
  # Ask for additional command line arguments if needed (for VSCode)
  parser = argparse.ArgumentParser()
  parser.add_argument('--interactive', action='store_true', default=False)
  (args, rest) = parser.parse_known_args()
  if args.interactive:
    try: readline.read_history_file()
    except: pass
    rest += input("Arguments: ").split(" ")  # Get input args
    try: readline.write_history_file()
    except: pass

  # Your other script arguments go here
  parser.add_argument("-output-dir", default="/out")
  # ...
  args = parser.parse_args(rest)

  print(args)

if __name__ == "__main__":
  main()

Then just set up Visual Studio Code to always pass in the --interactive argument, and your script will always ask for arguments (with history!) even as you set breakpoints.

If you don’t have a task.json file in your project you can create a new one with press Ctrl + Shift + B. Then choose the first option showing to you then replace all of them with the below:

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Run Python with argument",
            "type": "shell",
            "command": "python PROGRAM_NAME.py ARG1 ARG2 ...",
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}

Otherwise add the above configuration in your existed tasks.json file.

Replace PROGRAM_NAME in the above configuration with your program name and ARG1 ARG2 ... indicate your specific arguments.

After all, you can execute your created task with Ctrl + Shift + B and choose the new "Run Python with argument" task.

With recent VS Code releases you can add the following configuration to your launch.json. When you debug using this configuration VS Code will provide an entry field for you to enter your command line arguments. These values will be passed into sys.argv.

NOTE: VS Code can generate this configuration for you, but it puts square brackets around "${command:pickArgs}". This results in multiple arguments being passed in as a single string, e.g. "one two three", instead of three separate arguments, "one", "two" and "three".

"version": "0.2.0",
    "configurations": [
        {
            "name": "Python Debugger: Current File with Arguments",
            "type": "debugpy",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal",
            "args": "${command:pickArgs}"
        },

Another option is you can run your python program from the commandline via

python3 -m debugpy --wait-for-client --listen localhost:5678 myprogram.py

Then you can use a Python: Remote Attach launch.json configuration to connect to the program. It means an extra step every time to you turn on your program: run the program on the CLI then attach debugger, but it does make specifying the arguments more fluid.

To make things even simpler, you could put the above in a bash script and pass through args from CLI to python:

start.sh "my arg that changes all the time"

Then attach via "Remote Attach".

If you've already known how to set args in launch.json, and debug. And your question is how to run python with arguments, just Run->Run without debugging.

An easy solution is to use the %run magic command.

For example:

%run demo.py arg1 arg2

You can run it in the input editor (prompt) of the interactive window.

1. Focus the input editor with Interactive Window: Focus Input Editor
2. Type the command and execute it with Shift Enter. If you already typed it once, you can recall it with the arrow up key.
3. As you can see on the picture, sys.args contains the arguments specified in the command.
4. You can bring the focus back to the program with View: Focus Previous Editor Group and you can reuse it next time you want to run again.

Another possibility is to run the command from a selection.

1. Create a comment with the command
2. Select it without the comment character
3. Execute the selection with Jupyter: Run Selection/Line in Interactive Window.
4. As you can see on the picture, sys.args contains the arguments specified in the command.

Note that the file must be saved. This is not the case when using the command Jupyter: Run Current File in Interactive Window.

With a block comment, it’s even simpler because you don’t need to select the command, you just need the cursor to be on the line of the command.

"""
%run demo.py arg1 arg2
"""

I have looked for a solution to the issue described here but don't think any of the answers are sufficient so I have created a debugpy-run utility to solve it.

If you have the VS Code Python extension installed then the full debugpy debugger is already bundled with it. The utility finds the path where debugpy is installed and then runs it for program and arguments you specify, in listen mode. Connect to it from within VS Code using the Python "Remote Attach" debug configuration (using the default host and port settings). You can just control+c and then re-run the command with changed arguments using your shell history and command line editing facilities, for each debug run.

In addition, to xdhmoore's answers, for those not too familiar with creating configurations in launch.json, it should look as follows:

"configurations": [
    ...,
    {
        "name": "Python: Remote Attach",
        "type": "python",
        "request": "attach",
        "host": "127.0.0.1",
        "port": 5678

    }
]

To start debugging, first issue the command line command in the terminal and then launch the (newly created) launch configuration Python: Remote Attach from the debug launch menu in VS Code.

I had a similar problem in VS 2019. I wanted to start python file with arguments in environment generated by VS. I wasn't able to find good simple solution, so basically I went to ENV\Scripts folder, opened terminal there and run

python "FullPath\MyFile.py" -some arguments

It works OK, but VS needs to be closed.

If you are using a virtual environment, be sure to use the full path to the environment's Python interpreter.