Writing Command-Line Programs

What Command-Line Arguments Are

When you run a program from the terminal or command prompt, you can pass information to it directly on the command line. For example, if you type python my_program.py hello world, you are running my_program.py and passing hello and world as arguments to that program. Command-line arguments let your program receive input without requiring the user to type responses interactively after the program starts. This is especially useful for scripts that process files, configure behavior, or chain together with other programs.

Accessing Arguments with sys.argv

The sys.argv variable is a list of strings that contains the command-line arguments passed to your program. The first element, sys.argv[0], is always the name of the script itself. The remaining elements, sys.argv[1], sys.argv[2], and so on, are the arguments you typed after the program name. For instance, if you run python greet.py Alice Bob, then sys.argv[0] is 'greet.py', sys.argv[1] is 'Alice', and sys.argv[2] is 'Bob'. To use sys.argv in your program, you must first import the sys module at the top of your file.

Single Logical Line Per Physical Line

Python allows you to write multiple logical statements on a single physical line by separating them with semicolons. However, this practice is strongly discouraged. The recommended convention is to write a maximum of one logical line on each physical line of code. A logical line is a complete Python statement, such as an assignment, a function call, or a control structure. A physical line is what you see on your screen—each line that ends when you press Enter. By keeping one logical line per physical line, your code becomes much easier to read, debug, and maintain. In fact, experienced Python programmers rarely use semicolons in their code at all.

Common Mistakes When Writing Command-Line Programs

• Forgetting to import sys before using sys.argv

  Python will raise a NameError because sys is not defined in your program's namespace.

  Fix: Always include import sys at the beginning of any program that accesses command-line arguments.

• Assuming sys.argv[1] exists without checking the argument count

  If the user runs the program without arguments, sys.argv will only contain the script name, and accessing sys.argv[1] will raise an IndexError.

  Fix: Check len(sys.argv) before accessing specific indices, or use a try-except block to handle missing arguments gracefully.

• Using semicolons to put multiple statements on one line

  While Python allows this, it violates the single logical line per physical line convention and makes code harder to read and debug.

  Fix: Write each statement on a separate physical line without semicolons.

• Forgetting that sys.argv contains strings, not other data types

  sys.argv[1] and sys.argv[2] are the strings '5' and '10', so adding them produces '510', not 15.

  Fix: Convert command-line arguments to the appropriate type using int(), float(), or other conversion functions before performing operations on them.

Writing a Complete Command-Line Program

Let's trace through a complete example that demonstrates both proper command-line argument handling and the single logical line per physical line convention. This program will calculate the sum of two numbers passed as command-line arguments.

import sys

if len(sys.argv) != 3:
    print('Usage: python add.py <number1> <number2>')
    sys.exit(1)

num1 = float(sys.argv[1])
num2 = float(sys.argv[2])
result = num1 + num2

print(f'The sum of {num1} and {num2} is {result}')

When run as: python add.py 7.5 3.2
The sum of 7.5 and 3.2 is 10.7

Why Python Differs from Other Languages

Many programming languages, such as C, Java, and JavaScript, require semicolons at the end of every statement. These languages use the semicolon as the statement terminator, so you can write multiple statements on one line and the language will still parse them correctly. Python takes a different approach: it uses the newline character as the statement terminator. In Python, a new line typically means a new statement, so semicolons are unnecessary. While Python does support semicolons for backward compatibility and for rare cases where you need to separate multiple statements on one line, the language's design philosophy encourages writing one logical line per physical line. This design choice makes Python code more readable and less prone to certain formatting errors.

Practice: Build Your Own Argument Handler

Summary

1. Command-line arguments are values passed to a program when it is executed from the terminal. Python stores these arguments in the sys.argv list, where sys.argv[0] is the script name and sys.argv[1], sys.argv[2], etc. are the actual arguments.
2. Always import sys at the top of your program before using sys.argv. Check the length of sys.argv before accessing specific indices to avoid IndexError exceptions.
3. Remember that all elements of sys.argv are strings. Convert them to the appropriate type (int, float, etc.) before performing operations on them.
4. Follow the single logical line per physical line convention: write one complete Python statement per line and never use semicolons to combine multiple statements on a single line. This makes your code more readable and maintainable.
5. When writing command-line programs, validate user input by checking argument counts and handling errors gracefully. This makes your programs robust and user-friendly.