[Edit] Python: Python CLI arguments (#7639)

* [Edit] Python: Python CLI arguments

* Update command-line-arguments.md

* [Edit] Python: Python CLI arguments

* Update content/python/concepts/command-line-arguments/command-line-arguments.md

---------

Author: mamtawardhani

content/python/concepts/command-line-arguments/command-line-arguments.md

@@ -1,106 +1,182 @@
 ---
 Title: 'Command Line Arguments'
-Description: 'Python offers several methods of parsing command line arguments that are used when launching a program.'
+Description: 'Provides methods to accept input values when running Python scripts from the terminal'
 Subjects:
+  - 'Code Foundations'
   - 'Computer Science'
-  - 'Data Science'
 Tags:
-  - 'Input'
   - 'Arguments'
-  - 'Bash/Shell'
   - 'Command Line'
+  - 'Input'
+  - 'Modules'
 CatalogContent:
   - 'learn-python-3'
   - 'paths/computer-science'
 ---
 
-Python offers several methods of parsing **command line arguments** that are used when launching a program. The user has the option of passing various parameters to the program by adding them after the program name. These parameters can be accessed through various modules. The parameter names are left up to the programmer. By convention the parameter `-h` or `--help` (and `/h` and `/help` in Windows) is reserved to print a help message to the console listing the various command line options recognized by the program.
-
-Arguments are passed differently depending on the operating system:
+**Command line arguments** are values passed to a Python program when running it from the terminal or command prompt. They allow users to provide input data to a program without modifying the source code, making programs more flexible and reusable by accepting different parameters at runtime.
 
-- Unix-like arguments are a single letter preceded by a dash (`-h`) or a word preceded by two dashes (`--help`).
-- Windows arguments are a letter or a whole word preceded by a slash (`/h` or `/help`).
+## Ways to Handle Command Line Arguments
 
-## Parsing With `sys.argv`
+Python provides several built-in modules to handle command line arguments, each with different levels of complexity and functionality.
 
-The `sys` module offers the most straightforward method of accessing command line arguments, but it also requires the programmer to do most of the work interpreting them. With the `sys` module, the arguments are passed along in a simple list structure named `sys.argv`.
+### Using `sys.argv`
 
-The first item in the list, `sys.argv[0]` is the name used to launch the Python program, along with the path used. Each subsequent item is a space-delimited argument from the command line used to launch the program. If an argument requires embedded spaces, it needs to be enclosed in quotes to be parsed correctly.
+The `sys.argv` module provides the simplest way to access command line arguments. It stores all arguments passed to the script as a list of strings, where `sys.argv[0]` contains the script name itself.
 
-### Example
+#### Example: Basic `sys.argv` Usage
 
-This prints the script name followed by a list of the command line arguments passed on to the program.
+This example demonstrates how to access and use Python command line arguments using the `sys` module:
 
 ```py
 import sys
 
-print(f"The program name used to launch me is {sys.argv[0]}.")
-print("I was passed the following arguments:")
-for arg in sys.argv[1:]:
-  print(arg)
+# Display all command line arguments
+print("Script name:", sys.argv[0])
+print("All arguments:", sys.argv)
+
+# Check if arguments are provided
+if len(sys.argv) > 1:
+  name = sys.argv[1]
+  print(f"Hello, {name}!")
+else:
+  print("No name provided. Usage: python script.py <name>")
 ```
 
-If this is named `test.py` it can be launched with the following result:
+When running this script with `python greet.py Alice`, it produces the following output:
 
-```bash
-$ test.py --arg1 --arg2 "arg 3"
-The program name used to launch me is test.py.
-I was passed the following arguments:
---arg1
---arg2
-arg 3
+```shell
+Script name: greet.py
+All arguments: ['greet.py', 'Alice']
+Hello, Alice!
 ```
 
-## Parsing With `getopt()`
+The `sys.argv` list contains the script name as the first element, followed by all arguments passed from the command line. All arguments are stored as strings, so type conversion is needed for numeric operations.
+
+### Using `getopt`
+
+The `getopt` module provides a more structured approach to parsing command line options, similar to the C `getopt()` function. It supports both short options (single letters with a hyphen) and long options (words with double hyphens).
 
-Using `getopt()` requires importing both the `sys` and `getopt` modules to work. With `getopt`, parameter validation is possible. This is done by passing a list of the command line arguments themselves, a string of short (one character) options, and a list of long (full word) options. To indicate that the option requires a value to be passed along with it, the short option is followed by a colon (`:`), and the long option is followed by an equals sign (`=`).
+#### Example: File Processing with `getopt`
 
-To set up options for "help", "argument", and a "value" that requires an additional passed value, would look like this:
+This example shows how to create a script that processes input and output files with optional help:
 
-- The short options would be a string like `"hav:"`.
-- The long options would be a list like `["help","argument","value="]`.
+```py
+import sys
+import getopt
+
+def main():
+  input_file = ""
+  output_file = ""
+
+  try:
+    # Parse command line options
+    opts, args = getopt.getopt(sys.argv[1:], "hi:o:", ["help", "input=", "output="])
+  except getopt.GetoptError as err:
+    print(f"Error: {err}")
+    print("Usage: python script.py -i <inputfile> -o <outputfile>")
+    sys.exit(2)
+
+  for opt, arg in opts:
+    if opt in ("-h", "--help"):
+      print("Usage: python script.py -i <inputfile> -o <outputfile>")
+      print("Options:")
+      print("  -i, --input   Input file path")
+      print("  -o, --output  Output file path")
+      print("  -h, --help    Show this help message")
+      sys.exit()
+    elif opt in ("-i", "--input"):
+      input_file = arg
+    elif opt in ("-o", "--output"):
+      output_file = arg
+
+  # Process the files
+  if input_file and output_file:
+    print(f"Processing: {input_file} -> {output_file}")
+  else:
+    print("Both input and output files are required")
+    sys.exit(1)
+
+if __name__ == "__main__":
+  main()
+```
 
-### Syntax
+Running this script with `python process.py -i data.txt -o result.txt` produces:
 
-```python
-options, values = getopt.getopt(arguments, short_options, long_options)
+```shell
+Processing: data.txt -> result.txt
 ```
 
-Where the results of `getopt()` are `options` which is a list of option/value pairs, and `values` which is a list of arguments left after the option list was stripped. The parameters passed to `getopt()` are `arguments`, a list of the arguments as provided by `sys.argv` without the initial program name, the string `short_options` and the list `long_options` as described above.
+The `getopt.getopt()` function parses the argument list and returns a tuple containing option-value pairs and remaining arguments. Short options require a colon after the letter if they expect a value.
 
-If `arguments` contains an option that is not in `short_options` or `long_options` then an `getopt.error` exception is thrown.
+### Using `argparse`
 
-### Example
+The `argparse` module is the most powerful and user-friendly way to handle command line arguments. It automatically generates help messages, handles errors gracefully, and supports various argument types including positional and optional arguments.
 
-This prints the option/value pairs passed as command line arguments.
+#### Example: User Greeting with `argparse`
+
+This example demonstrates creating a user-friendly command line interface:
 
 ```py
-import sys, getopt
+import argparse
+
+# Create argument parser
+parser = argparse.ArgumentParser(description="Greet users with customizable messages")
+
+# Add positional argument
+parser.add_argument("name", help="Name of the person to greet")
 
-arguments = sys.argv[1:]
-short_options = "hav:"
-long_options = ["help","argument","value="]
+# Add optional arguments
+parser.add_argument("-g", "--greeting", default="Hello",
+                   help="Greeting message (default: Hello)")
+parser.add_argument("-u", "--uppercase", action="store_true",
+                   help="Convert output to uppercase")
 
-options, values = getopt.getopt(arguments, short_options, long_options)
+# Parse arguments
+args = parser.parse_args()
 
-for o, v in options:
-  print(f"Option is {o}. Value is {v}.")
+# Create greeting message
+message = f"{args.greeting}, {args.name}!"
+
+# Apply uppercase if requested
+if args.uppercase:
+  message = message.upper()
+
+print(message)
 ```
 
-If this is named **test.py** it can be launched with the following results:
+When executed with `python greet.py Alice -g "Good morning" --uppercase`, the output is:
 
-```bash
-$ test.py -a --value=test
-Option is -a. Value is .
-Option is --value. Value is test.
+```shell
+GOOD MORNING, ALICE!
 ```
 
-**Note**: Since `-a` wasn't defined as requiring a value passed to it, the corresponding value for the option is empty.
+The `argparse` module automatically provides help documentation when using `-h` or `--help`, validates required arguments, and converts values to appropriate types. It handles argument parsing errors by displaying helpful error messages and usage information.
+
+## Frequently Asked Questions
+
+### 1. What are command-line arguments in Python?
+
+Command line arguments in Python are values passed to a script when executing it from the terminal. They provide a way to customize program behavior without modifying the source code, making scripts more flexible and reusable.
+
+### 2. What are the 5 arguments in Python?
+
+There isn't a fixed set of "5 arguments" in Python. The number and type of command line arguments depend on what the program is designed to accept. However, common argument types include: positional arguments (required values), optional arguments (flags with values), boolean flags (on/off switches), help arguments, and version arguments.
+
+### 3. How to pass an argument to a Python script from the command-line?
+
+To pass arguments to a Python script, include them after the script name when running it:
+
+- `python script.py argument1 argument2` - passes multiple arguments
+- `python script.py --option value` - passes an option with a value
+- `python script.py -f --verbose` - passes flags and options
+
+### 4. What is an example of a command-line argument?
 
-## Other Methods of Parsing the Command Line
+A simple example is running `python calculator.py 10 5 add`, where:
 
-There are other methods of parsing command line arguments in Python, which add varying functionality to the task. Some examples include:
+- `calculator.py` is the script name
+- `10` and `5` are numeric arguments
+- `add` is an operation argument
 
-- The `argparse` module, that's been available since Python 3.2, validates fixed and optional arguments and offers a default help message displaying the accepted arguments.
-- The `docopt` module, which is complex and versatile, provides its own language to describe command line options.
-- The `click` module provides arbitrary nesting of commands and automatic help page generation.
+The script can access these values using `sys.argv`, `getopt`, or `argparse` to perform the specified calculation.