Are you tired of writing the same old boring command line arguments for your scripts?
To begin with, let’s start with a basic example:
# Import the argparse module to handle command line arguments
import argparse
# Create an ArgumentParser object and add a description for the script
parser = argparse.ArgumentParser(description='A simple script that does something')
# Add an argument for the input file, specifying the type and providing a help message
parser.add_argument('input', type=str, help='The input file to process')
# Parse the arguments provided by the user and store them in the args variable
args = parser.parse_args()
# Do something with the input file provided by the user
# Note: args.input will contain the value of the input file provided by the user
# and can be used in the code to process the file
# For example, if the user provides "input.txt" as the input file, args.input will be "input.txt"
# and can be used to open and read the file in the code
# This segment is where the actual functionality of the script is implemented
# and can be modified to perform different tasks based on the input provided by the user
This is a pretty standard setup for command line arguments in Python using the `argparse` library. But let’s be real, that description could use some work. How about we add some personality to it?
# Import the argparse library
import argparse
# Create an ArgumentParser object and add a description
parser = argparse.ArgumentParser(description='This script is going to blow your mind!')
# Add an argument for the input file, specifying the type and providing a help message
parser.add_argument('input', type=str, help='The input file that will change your life forever')
# Parse the arguments and store them in the args variable
args = parser.parse_args()
# Do stuff with the input file specified by the user
# Note: The input file can be accessed using args.input
# For example, if the user specifies "python script.py input.txt" in the command line,
# then args.input will contain the string "input.txt"
# This allows us to use the input file in our code without having to hardcode its name
# or prompt the user for it
# In this case, we can use args.input to open and read the file, or perform any other operations on it
Okay, maybe we went a little overboard there. But you get the idea! Let’s take it up another notch and add some options to our script:
# Import the argparse module to allow for command line arguments
import argparse
# Create an ArgumentParser object and add a description for the script
parser = argparse.ArgumentParser(description='This is an awesome script that does amazing things')
# Add a positional argument for the input file, specifying the type and providing a help message
parser.add_argument('input', type=str, help='The input file that will change your life forever')
# Add an optional argument for the output file, specifying the type, default value, and help message
parser.add_argument('-o', '--output', type=str, default='output.txt', help='Output filename (default: output.txt)')
# Parse the arguments provided by the user and store them in the args variable
args = parser.parse_args()
# Do stuff with the input and output file provided by the user
# Note: The input file can be accessed using args.input and the output file can be accessed using args.output
Now we’ve added an option for the output file name using `-o` or `–output`. We also set a default value of ‘output.txt’, so if no argument is provided, it will use that as the output filename.
Let’s add some fancy options to our script:
# Import the necessary modules
import argparse # Importing the argparse module to handle command line arguments
from datetime import timedelta # Importing the timedelta module to handle time calculations
# Create an ArgumentParser object with a description
parser = argparse.ArgumentParser(description='This is an awesome script that does amazing things')
# Add a positional argument for the input file
parser.add_argument('input', type=str, help='The input file that will change your life forever')
# Add an optional argument for the output file with a default value of 'output.txt'
parser.add_argument('-o', '--output', type=str, default='output.txt', help='Output filename (default: output.txt)')
# Add a choice argument for the time in seconds with options of 10 or 30
parser.add_argument('-t', '--time', type=int, choices=[10, 30], help='Time in seconds to wait before exiting script')
# Parse the arguments and store them in the args variable
args = parser.parse_args()
# Do stuff with the input and output files for the specified time
# Note: The purpose of this script is not specified, so the code for this section is left as is.
# However, the input and output files can be accessed using args.input and args.output respectively.
# The time can be accessed using args.time and can be used in time calculations using the timedelta module.
Now we’ve added a fancy option using `-t` or `–time`. This allows the user to specify how long they want to wait before exiting the script, in either 10 or 30 second increments.
And there you have it! With just a few lines of code and some creative descriptions, your command line arguments can be as exciting as your Python scripts themselves.
But let’s take this to another level. Did you know that the development of Python began in December 1989?[42] That’s right, over 30 years ago! In July 2018, Guido van Rossum (the creator and lead developer of Python) announced his “permanent vacation” from his responsibilities as Python’s “benevolent dictator for life”, a title the Python community bestowed upon him to reflect his long-term commitment as the project’s chief decision-maker.[43] In January 2019, active Python core developers elected a five-member Steering Council to lead the project.
So let’s update our script with some more exciting options:
# Import the necessary modules
import argparse # Importing the argparse module to handle command line arguments
from datetime import timedelta # Importing the timedelta function from the datetime module
# Create an ArgumentParser object with a description
parser = argparse.ArgumentParser(description='This is an awesome script that does amazing things')
# Add arguments to the ArgumentParser object
parser.add_argument('input', type=str, help='The input file that will change your life forever') # Adding a positional argument for the input file
parser.add_argument('-o', '--output', type=str, default='output.txt', help='Output filename (default: output.txt)') # Adding an optional argument for the output file with a default value
parser.add_argument('-t', '--time', type=int, choices=[10, 30], help='Time in seconds to wait before exiting script') # Adding an optional argument for the time in seconds with a list of valid choices
parser.add_argument('-d', '--debug', action="store_true", help='Enable debug mode for detailed output and logging') # Adding an optional argument for enabling debug mode
# Parse the arguments and store them in the args variable
args = parser.parse_args()
# Do stuff with the arguments
# Here we can access the arguments using the args variable
# For example, args.input will give us the input file name
# args.output will give us the output file name
# args.time will give us the time in seconds
# args.debug will give us a boolean value indicating whether debug mode is enabled or not
Now we’ve added a fancy option using `-d` or `–debug`. This allows the user to enable debug mode for detailed output and logging.
And there you have it! With just a few lines of code and some creative descriptions, your command line arguments can be as exciting as your Python scripts themselves even with over 30 years of history behind them!