How to handle command line arguments in Python
Sep 21, 2025 am 03:49 AMThe argparse module is the recommended way to handle command-line arguments in Python, providing robust parsing, type validation, help messages, and error handling; use sys.argv for simple cases requiring minimal setup.
Handling command line arguments in Python is straightforward and useful for making scripts more flexible. You can pass values directly from the terminal when running a script, which avoids hardcoding inputs. The most common and recommended way to do this is using the argparse module, part of Python’s standard library.
Using argparse for robust argument handling
The argparse module lets you define expected arguments, their types, help messages, and even handle optional flags. It automatically generates usage instructions and handles errors gracefully.
- Create an ArgumentParser object to configure your command-line interface
- Add arguments using add_argument(), specifying name, type, default value, and help text
- Call parse_args() to process the input and access the values
Example:
import argparse
parser = argparse.ArgumentParser(description="Process some numbers.")
parser.add_argument('number', type=int, help='a number to square')
parser.add_argument('--verbose', '-v', action='store_true', help='increase output verbosity')
args = parser.parse_args()
result = args.number ** 2
if args.verbose:
????print(f"The square of {args.number} is {result}")
else:
????print(result)
Run it via command line:
python script.py 5 -v
Handling optional and positional arguments
Positional arguments are required and given in order. Optional arguments start with -- or a short flag like -v. You can set defaults, make arguments required optionally, or allow multiple values.
- Use nargs='*' to accept zero or more values, or ' ' for one or more
- Set default= for fallback values when an optional argument isn’t provided
- Use choices=[...] to restrict input to specific values
Example with multiple inputs:
parser.add_argument('inputs', nargs=' ', type=float, help='numbers to sum')
Accessing raw arguments with sys.argv
If you need a lightweight approach without parsing logic, use sys.argv. It gives a list of all command-line inputs, where sys.argv[0] is the script name and the rest are arguments.
This method requires manual parsing and error handling but works for simple cases.
Example:
import sys
if len(sys.argv) > 1:
????print("Hello,", sys.argv[1])
else:
????print("No name provided")
Run: python script.py Alice
Basically just pick argparse for anything beyond basic input. It's clean, scalable, and user-friendly. For quick scripts, sys.argv gets the job done with minimal setup.
The above is the detailed content of How to handle command line arguments in Python. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

ArtGPT
AI image generator for creative art from text prompts.

Stock Market GPT
AI powered investment research for smarter decisions

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Run pipinstall-rrequirements.txt to install the dependency package. It is recommended to create and activate the virtual environment first to avoid conflicts, ensure that the file path is correct and that the pip has been updated, and use options such as --no-deps or --user to adjust the installation behavior if necessary.

Python is a simple and powerful testing tool in Python. After installation, test files are automatically discovered according to naming rules. Write a function starting with test_ for assertion testing, use @pytest.fixture to create reusable test data, verify exceptions through pytest.raises, supports running specified tests and multiple command line options, and improves testing efficiency.

Theargparsemoduleistherecommendedwaytohandlecommand-lineargumentsinPython,providingrobustparsing,typevalidation,helpmessages,anderrorhandling;usesys.argvforsimplecasesrequiringminimalsetup.

Table of Contents What is Bitcoin Improvement Proposal (BIP)? Why is BIP so important? How does the historical BIP process work for Bitcoin Improvement Proposal (BIP)? What is a BIP type signal and how does a miner send it? Taproot and Cons of Quick Trial of BIP Conclusion?Any improvements to Bitcoin have been made since 2011 through a system called Bitcoin Improvement Proposal or “BIP.” Bitcoin Improvement Proposal (BIP) provides guidelines for how Bitcoin can develop in general, there are three possible types of BIP, two of which are related to the technological changes in Bitcoin each BIP starts with informal discussions among Bitcoin developers who can gather anywhere, including Twi

Import@contextmanagerfromcontextlibanddefineageneratorfunctionthatyieldsexactlyonce,wherecodebeforeyieldactsasenterandcodeafteryield(preferablyinfinally)actsas__exit__.2.Usethefunctioninawithstatement,wheretheyieldedvalueisaccessibleviaas,andthesetup

For beginners in data science, the core of the leap from "inexperience" to "industry expert" is continuous practice. The basis of practice is the rich and diverse data sets. Fortunately, there are a large number of websites on the Internet that offer free public data sets, which are valuable resources to improve skills and hone your skills.

Identifyrepetitivetasksworthautomating,suchasorganizingfilesorsendingemails,focusingonthosethatoccurfrequentlyandtakesignificanttime.2.UseappropriatePythonlibrarieslikeos,shutil,glob,smtplib,requests,BeautifulSoup,andseleniumforfileoperations,email,w

Big data analysis needs to focus on multi-core CPU, large-capacity memory and tiered storage. Multi-core processors such as AMDEPYC or RyzenThreadripper are preferred, taking into account the number of cores and single-core performance; memory is recommended to start with 64GB, and ECC memory is preferred to ensure data integrity; storage uses NVMeSSD (system and hot data), SATASSD (common data) and HDD (cold data) to improve overall processing efficiency.
