Building CLIs With Command-Line Arguments

A script becomes a real tool the moment it accepts command-line arguments. Python provides three layers — sys.argv for quick scripts, argparse for production CLIs, and third-party libraries like click and typer for fancy interfaces. This chapter focuses on the first two, which cover 95% of real-world needs.

• Import sys to access sys.argv.
• Use argparse.ArgumentParser() for proper CLI parsing.
• Add arguments with add_argument(); positional vs optional via the leading --.
• Parse with parser.parse_args() and access via attribute syntax.

# Quick way
import sys
print("Script:", sys.argv[0])
print("Args  :", sys.argv[1:])

# Production way
import argparse
parser = argparse.ArgumentParser(description="Greeter")
parser.add_argument("name", help="who to greet")
parser.add_argument("--shout", action="store_true",
                    help="shout the greeting")
args = parser.parse_args()
msg = f"Hello, {args.name}!"
print(msg.upper() if args.shout else msg)

• sys.argv: A list of strings. Position 0 is the script path; positions 1+ are the user's arguments. Quick but no validation, no help text.
• argparse — Positional args: Required by default. parser.add_argument('name') creates a positional argument. The user must supply it or argparse exits with an error.
• argparse — Optional args: Begin the name with - or --. Optional unless you pass required=True. Example: --verbose.
• Type conversion: add_argument('--count', type=int) converts string input automatically. Standard types: int, float, str, file objects via argparse.FileType().
• Flags & defaults: Use action='store_true' for boolean flags. Use default= for fallback values. Use choices=[...] to restrict valid options.
• Help text: argparse auto-generates -h/--help. Always provide a short help= for every argument — your users will thank you.

import sys
print("name:", sys.argv[0])
print("args:", sys.argv[1:])
# usage: python script.py hello world

import argparse
p = argparse.ArgumentParser()
p.add_argument("name")
args = p.parse_args(["Riya"])
print("Hello,", args.name)

import argparse
p = argparse.ArgumentParser()
p.add_argument("--verbose", action="store_true")
args = p.parse_args(["--verbose"])
print("verbose =", args.verbose)

import argparse
p = argparse.ArgumentParser()
p.add_argument("--count", type=int, default=1)
args = p.parse_args([])
print("Count:", args.count)
args = p.parse_args(["--count", "5"])
print("Count:", args.count)

import argparse
p = argparse.ArgumentParser()
p.add_argument("--mode", choices=["dev","prod"], default="dev")
args = p.parse_args(["--mode", "prod"])
print("Mode:", args.mode)

import argparse
p = argparse.ArgumentParser()
p.add_argument("a", type=float)
p.add_argument("b", type=float)
p.add_argument("--op", choices=["+","-","*","/"], default="+")
a = p.parse_args(["10", "4", "--op", "/"])
result = {"+":a.a+a.b,"-":a.a-a.b,"*":a.a*a.b,"/":a.a/a.b}[a.op]
print("Result:", result)

• Use argparse for any script that grows beyond one or two arguments.
• Always set description= on the parser — it appears in -h.
• Use type= to convert strings into the right type automatically.
• Use required=True for optional arguments that must always be provided.
• Use choices= to restrict invalid inputs.
• For subcommands (git-style CLIs), use parser.add_subparsers().

• Indexing sys.argv blindly: raises IndexError when the user forgets an argument.
• Forgetting type conversion: all args from sys.argv are strings.
• Re-implementing argparse: writing manual parsers is error-prone and unfriendly.
• No help messages: users guess what each argument means.
• Wrong dest names: --my-flag becomes args.my_flag (dash → underscore).
• Mixing positional and optional incorrectly: argparse expects optional flags before or after positionals — be consistent.

• Problem 1: Print all command-line arguments passed to your script.
• Problem 2: Build a CLI that takes two numbers and an operator and prints the result.
• Problem 3: Use argparse to read a filename and print the file's word count.
• Problem 4: Add a --verbose flag to a script and print extra debug info when set.
• Problem 5: Build a CLI with --mode restricted to train or predict.
• Problem 6: Create a CLI that takes a folder path and lists all .py files inside it.

• Q1. What is sys.argv and what does sys.argv[0] contain?
• Q2. Why is argparse preferred over manual parsing?
• Q3. How do you create a positional vs optional argument in argparse?
• Q4. What does action='store_true' do?
• Q5. How do you convert a CLI argument to an integer?
• Q6. How do you build subcommands with argparse (like git add / git commit)?

• Q1: What is sys.argv?
  A list of strings containing the script name and the arguments passed to it on the command line.
• Q2: Why use argparse?
  It validates inputs, generates help text, converts types, and prevents many bugs from rolling your own parser.
• Q3: How do I make an argument optional?
  Prefix the name with -- (e.g. --verbose). Optional by default unless you set required=True.
• Q4: How do I create a boolean flag?
  Use action='store_true' (or 'store_false'). When the flag is present, the value becomes True.
• Q5: How are values converted to int/float?
  Pass type=int or type=float to add_argument; argparse converts user input before storing.
• Q6: How do I print help automatically?
  argparse adds -h and --help by default. Provide help= for each argument to populate the auto-generated text.