Working with Command Line Arguments

Every item in sys.argv is a string, even if you type a number at the command line. If you need to use an argument as a number, you must convert it explicitly using int() or float().

Programming

What Are Command Line Arguments?

When you run a Python program from the terminal, you can pass information directly to it without waiting for the program to prompt you. These pieces of information are called command line arguments. For example, if you type python greet.py Alice Bob at the terminal, you are passing two arguments (Alice and Bob) to your program. Your Python code can then access and use these arguments to customize its behavior.

Command line arguments allow you to pass data into your program at runtime without hardcoding values or prompting the user interactively. This makes your programs more flexible and reusable. The operating system collects everything you type after the program name and makes it available to your Python code through a special variable called sys.argv.

How sys.argv Stores Arguments

Definition

sys.argv is a list of strings that contains all the command line arguments passed to your program. The first element (index 0) is always the name of the Python script itself. The remaining elements (indices 1, 2, 3, and so on) are the arguments you typed after the program name.

Key point

Every item in sys.argv is a string, even if you type a number at the command line. If you need to use an argument as a number, you must convert it explicitly using int() or float().

What does sys.argv contain when you run 'python greet.py Alice Bob' at the terminal? How do individual arguments map to index positions?

The diagram above shows what happens when you run python greet.py Alice Bob at the command line. The sys.argv list contains three strings: the program name at index 0, and the two arguments you provided at indices 1 and 2. This structure is consistent regardless of how many arguments you pass.

From Terminal to Your Code

How do arguments typed at the terminal end up inside sys.argv in my code?

When you type a command at the terminal, the operating system parses what you typed and separates it into the program name and individual arguments. The Python interpreter receives this parsed information and automatically populates the sys.argv list before your code even runs. By the time your program starts executing, sys.argv is already ready for you to use.

Accessing and Iterating Through Arguments

To use command line arguments in your program, you must first import the sys module. Then you can access individual arguments by index (like any list) or loop through all of them with a for loop.

python

import sys

print('The command line arguments are:')
for i in sys.argv:
    print(i)

import sys

print('The command line arguments are:')
for i in sys.argv:
    print(i)

If you save this code as show_args.py and run it with python show_args.py we are arguments, the output will be:

Output

The command line arguments are:
show_args.py
we
are
arguments

What happens at each step as the for loop processes each argument?

The for loop iterates through each element of sys.argv in order. On the first iteration, the variable i holds the program name. On subsequent iterations, i holds each argument in the order you typed them. The loop continues until all elements have been processed.

Worked Example: A Simple Greeting Program

Worked example

Using Command Line Arguments to Greet Users

Write a program that takes names as command line arguments and greets each person by name.

1
Import sys and set up the loop
Start by importing the sys module and creating a for loop that iterates through sys.argv starting at index 1 (to skip the program name).
2
Access each argument
Use sys.argv[1:] to get all arguments except the program name, or manually start your loop at index 1.
3
Process and display each argument
For each name in the arguments, print a personalized greeting.

Result

When you run python greet.py Alice Bob Charlie, the program outputs:

Hello, Alice!Hello, Bob!Hello, Charlie!

python

import sys

for name in sys.argv[1:]:
    print('Hello, ' + name + '!')

import sys

for name in sys.argv[1:]:
    print('Hello, ' + name + '!')

This example uses sys.argv[1:] to create a slice of the list that excludes the program name. The slice notation [1:] means start at index 1 and go to the end of the list. This is a common pattern when you want to process only the user-provided arguments and ignore the program name.

The Special Role of sys.argv[0]

The first element of sys.argv (index 0) is always the name of the Python script itself, not an argument provided by the user. This is fundamentally different from the remaining elements. Understanding this distinction is crucial for correctly processing user-provided arguments.

Key point

When you want to process only the arguments the user provided (not the program name), always start from sys.argv[1]. You can use the slice sys.argv[1:] or loop starting at index 1.

The program name at sys.argv[0] can be useful in some advanced scenarios, such as when you want your program to print its own name in an error message or log file. However, in most basic programs, you will ignore sys.argv[0] and focus on the arguments that follow.

Common Mistakes When Working with Arguments

Common mistake
Forgetting to import sys before using sys.argv
What it looks like
```
print(sys.argv[1]) without import sys at the top
```
Why it fails
The sys module must be imported before you can access any of its attributes, including sys.argv. Without the import statement, Python will raise a NameError.
Do this instead
Always begin your program with import sys if you plan to use sys.argv.
Common mistake
Treating command line arguments as numbers instead of strings
What it looks like
python calculate.py 5 3 and then trying to add sys.argv[1] + sys.argv[2] expecting 8
Why it fails
All command line arguments are strings, so '5' + '3' results in the string '53', not the number 8.
Do this instead
Convert arguments to the appropriate type using int() or float() before performing arithmetic: int(sys.argv[1]) + int(sys.argv[2])
Common mistake
Trying to access sys.argv[1] when no arguments were provided
What it looks like
python script.py without any arguments, then accessing sys.argv[1]
Why it fails
If no arguments are provided, sys.argv contains only the program name at index 0. Trying to access index 1 will raise an IndexError.
Do this instead
Check the length of sys.argv before accessing specific indices, or use a for loop that safely handles an empty argument list.
Common mistake
Including the program name in your argument processing
What it looks like
```
for arg in sys.argv: process(arg) when you only want to process user arguments
```
Why it fails
This will process the program name as if it were a user argument, which is usually not intended and can cause logic errors.
Do this instead
Use for arg in sys.argv[1:] to skip the program name and process only the actual arguments.

Using Command Line Arguments in IDEs

The easiest way to test command line arguments is to run your program directly from the terminal or command prompt. This ensures that the arguments are passed correctly and gives you full control over what you type.

Practice: Building a Simple Argument Processor

MEDIUM

Write a Python program that accepts a list of numbers as command line arguments, converts each one to an integer, and prints the sum. For example, running python sum_args.py 10 20 30 should print 60. Remember to handle the case where no arguments are provided by printing an appropriate message.

Hints

Use sys.argv[1:] to get only the user-provided arguments.
Use int() to convert each string argument to a number.
Use a for loop or the sum() function to add all the numbers together.
Check if len(sys.argv) is greater than 1 before trying to process arguments.

Your attempt (not saved)

Summary

1
Command line arguments are values you pass to a Python program when you run it from the terminal, allowing you to customize program behavior without hardcoding values.
2
sys.argv is a list of strings that stores all command line arguments. The first element (index 0) is always the program name; subsequent elements are the arguments you provided.
3
To use command line arguments, you must import the sys module and then access sys.argv by index or iterate through it with a for loop.
4
Always remember that command line arguments are strings, even if they look like numbers. Convert them using int() or float() if you need to perform arithmetic.
5
Use sys.argv[1:] to process only user-provided arguments and skip the program name, which is a common pattern in real programs.

At a glance

Command line arguments let you pass data to a Python program at runtime via the terminal.
sys.argv is a list where index 0 is the program name and indices 1+ are the user-provided arguments.
All arguments in sys.argv are strings; convert them to int or float if you need numeric operations.
Use sys.argv[1:] to loop through only the user arguments, skipping the program name.
IDEs require special configuration to pass command line arguments; the terminal is the simplest way to test.

Related concepts

More concepts starting with W