{"id":9864,"date":"2025-06-17T09:01:57","date_gmt":"2025-06-17T09:01:57","guid":{"rendered":"https:\/\/www.examsnap.com\/certification\/?p=9864"},"modified":"2026-10-28T07:37:11","modified_gmt":"2026-10-28T07:37:11","slug":"working-with-command-line-arguments-in-python","status":"publish","type":"post","link":"https:\/\/www.examsnap.com\/certification\/working-with-command-line-arguments-in-python\/","title":{"rendered":"Working with Command Line Arguments in Python"},"content":{"rendered":"

Command-line arguments allow a Python script to accept filenames, options and commands without editing source code. For a tiny throwaway script, sys.argv may be enough. For a reusable tool, argparse from the standard library offers help messages, typed values, option flags and subcommands with more predictable error handling.<\/p>\n

A robust command-line interface also treats its inputs as untrusted. Validate paths and numeric ranges, avoid building shell commands from arguments, and do not place secret tokens in ordinary command-line parameters where process listings or shell histories may expose them.<\/p>\n

Read raw arguments with sys.argv<\/h2>\n

sys.argv is a list of strings. The first item normally represents the script name or invocation path, so user-supplied values start at index one. Explicit length checks prevent IndexError.<\/p>\n

import sys\nif len(sys.argv) < 2:\n    print(\"Usage: script.py NAME\")\nelse:\n    print(sys.argv[1])<\/code><\/pre>\n
Start with argparse for reusable scripts<\/h2>\n
ArgumentParser creates a help interface and reports many input errors automatically. It supports required positionals, optional flags and typed conversion.<\/p>\n
import argparse\nparser = argparse.ArgumentParser(description=\"Task demo\")\nparser.add_argument(\"name\")\nparser.add_argument(\"--count\", type=int, default=1)\nargs = parser.parse_args()\nprint(args.name, args.count)<\/code><\/pre>\n
Boolean flags and defaults<\/h2>\n
action=’store_true’ creates a flag that is false unless supplied. Prefer explicit flags to manually searching sys.argv for strings, because parsing libraries handle help output and unknown option errors consistently.<\/p>\n
parser.add_argument(\"--verbose\", action=\"store_true\")\n# parser.parse_args() returns a namespace with verbose<\/code><\/pre>\n
Input validation after parsing<\/h2>\n
Type conversion alone does not prove that a value is acceptable. A timeout may need to be positive and a path may need to belong to an allowed directory. Reject invalid values before touching files or networks.<\/p>\n
parser.add_argument(\"--timeout\", type=float, default=3.0)\nargs = parser.parse_args()\nif args.timeout <= 0:\n    parser.error(\"--timeout must be positive\")<\/code><\/pre>\n
Build subcommands with subparsers<\/h2>\n
A CLI with distinct actions can use subparsers to organize required inputs. Keep operations narrow and document their effects.<\/p>\n
parser = argparse.ArgumentParser()\nsub = parser.add_subparsers(dest=\"command\", required=True)\nshow = sub.add_parser(\"show\")\nshow.add_argument(\"item\")\nargs = parser.parse_args()<\/code><\/pre>\n
getopt and third-party parsers<\/h2>\n
The standard-library getopt module supports traditional option parsing, but its interface is lower level. Third-party docopt-style parsers can express usage-driven interfaces yet require dependency review. For most new Python tools, argparse is a maintainable default.<\/p>\n
import getopt\noptions, rest = getopt.getopt([\"-v\", \"file.txt\"], \"v\")\nprint(options, rest)<\/code><\/pre>\n
Handle paths, encoding and errors<\/h2>\n
For file-oriented commands, use pathlib and explicit text encodings. Catch known exceptions such as FileNotFoundError and PermissionError, and return meaningful exit codes. Avoid broad except blocks that silently hide failures.<\/p>\n
from pathlib import Path\npath = Path(\"items.txt\")\ntry:\n    print(path.read_text(encoding=\"utf-8\"))\nexcept FileNotFoundError:\n    print(\"File not found\")<\/code><\/pre>\n
Avoid shell injection and secret leakage<\/h2>\n
Do not concatenate user arguments into a shell command string. For authorized subprocess execution, pass a list of arguments with shell=False by default. Use protected configuration or credential stores for secrets rather than public process command lines.<\/p>\n
import subprocess\nsubprocess.run([\"python\", \"--version\"], check=True)\n# Avoid shell=True with untrusted text<\/code><\/pre>\n
Conclusion<\/h2>\n
Use sys.argv for understanding the mechanics, argparse for most maintained command-line tools, and carefully selected alternatives only when justified. A good CLI is discoverable, validates input, reports failures and protects paths and credentials.<\/p>\n","protected":false},"excerpt":{"rendered":"
Command-line arguments allow a Python script to accept filenames, options and commands without editing source code. For a tiny throwaway script, sys.argv may be enough. For a reusable tool, argparse from the standard library offers help messages, typed values, option flags and subcommands with more predictable error handling. A robust command-line interface also treats its inputs as untrusted. Validate paths and numeric ranges, avoid building shell commands from arguments, and do not place secret tokens in ordinary command-line parameters where process listings or shell histories may expose them. Read raw…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[711],"tags":[],"class_list":["post-9864","post","type-post","status-publish","format-standard","hentry","category-programming"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t