Introduction

Command-line arguments are values you pass to a program when you launch it from a terminal or command prompt. They let you control a program's behaviour without changing its code — telling it which file to open, which mode to run in, or how verbose to be. When you type something like python script.py input.txt --verbose, the words after the program name are its command-line arguments, and the operating system delivers them to the program at startup.

Real-World Analogy

Anatomy of a Command

A typical command is made of several distinct parts:

python  backup.py  data.csv  --output  out.zip  --verbose
  |         |          |          |         |         |
program   script   positional   option    value     flag
          name      argument

Prerequisites

Reading Arguments in Python (sys.argv)

The simplest way in Python is sys.argv, a list of strings. The first element is the script name.

import sys

# sys.argv is a list of strings
print("Script name:", sys.argv[0])
print("Arguments:", sys.argv[1:])

# Example: python demo.py hello 42
# Script name: demo.py
# Arguments: ['hello', '42']

A small practical example

import sys

if len(sys.argv) < 3:
    print("Usage: python add.py <a> <b>")
    sys.exit(1)

a = int(sys.argv[1])
b = int(sys.argv[2])
print("Sum:", a + b)

The Better Way: argparse

For anything beyond trivial scripts, use argparse — it adds validation, help, and typed values automatically.

import argparse

parser = argparse.ArgumentParser(description="Add two numbers")
parser.add_argument("a", type=int)
parser.add_argument("b", type=int)
parser.add_argument("--verbose", action="store_true")
args = parser.parse_args()

result = args.a + args.b
if args.verbose:
    print(f"{args.a} + {args.b} = {result}")
else:
    print(result)

Command-Line Arguments in Other Languages

C

#include <stdio.h>

// argc = argument count, argv = argument values
int main(int argc, char *argv[]) {
    printf("Program: %s\n", argv[0]);
    for (int i = 1; i < argc; i++) {
        printf("Arg %d: %s\n", i, argv[i]);
    }
    return 0;
}

Java

public class Main {
    public static void main(String[] args) {
        // args does NOT include the program name
        System.out.println("Count: " + args.length);
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

JavaScript (Node.js)

// process.argv: [node, script, ...args]
const args = process.argv.slice(2);
console.log("Arguments:", args);

// Example: node app.js hello 42
// Arguments: [ 'hello', '42' ]

How Each Language Exposes Them

Common Conventions

Argument Count

If a program receives \(n\) arguments after its name, the total number of tokens the OS passes (including the program name itself) is:

\[ \text{argc} = n + 1 \]

This is why in C, argc is always at least \(1\) — the program name always occupies argv[0].

Best Practices

Common Mistakes

Interview Questions

Quick Revision