+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Home / Tutorials / 🐍 python
Part 29 of 365

📘 Command Line Arguments: sys.argv Basics

Master command line arguments: sys.argv basics in Python with practical examples, best practices, and real-world applications 🚀

🌱Beginner
20 min read

Prerequisites

  • Basic understanding of programming concepts 📝
  • Python installation (3.8+) 🐍
  • VS Code or preferred IDE 💻

What you'll learn

  • Understand the concept fundamentals 🎯
  • Apply the concept in real projects 🏗️
  • Debug common issues 🐛
  • Write clean, Pythonic code ✨

🎯 Introduction

Welcome to this exciting tutorial on command line arguments in Python! 🎉 In this guide, we’ll explore how to make your Python programs accept input from the command line using sys.argv.

You’ll discover how command line arguments can transform your Python scripts from simple static programs into flexible, reusable tools! Whether you’re building automation scripts 🤖, data processing tools 📊, or command-line utilities 🛠️, understanding sys.argv is essential for creating programs that adapt to different situations.

By the end of this tutorial, you’ll feel confident accepting and handling command line arguments in your own projects! Let’s dive in! 🏊‍♂️

📚 Understanding Command Line Arguments

🤔 What are Command Line Arguments?

Command line arguments are like ingredients you pass to a recipe 🍳. Think of your Python script as a chef, and the arguments as the ingredients you give them to work with!

In Python terms, command line arguments are values you provide when running your script from the terminal. This means you can:

  • ✨ Run the same script with different inputs
  • 🚀 Create flexible, reusable programs
  • 🛡️ Build professional command-line tools

💡 Why Use Command Line Arguments?

Here’s why developers love command line arguments:

  1. Flexibility 🔄: Run your script with different inputs without changing code
  2. Automation 🤖: Perfect for scripts that run in automated workflows
  3. User-Friendly 👤: No need to edit code to change behavior
  4. Professional 💼: Makes your scripts feel like real command-line tools

Real-world example: Imagine building a file converter 📁. With command line arguments, users can specify which file to convert without editing your code!

🔧 Basic Syntax and Usage

📝 Your First sys.argv Example

Let’s start with a friendly example:

# 👋 Hello, command line arguments!
import sys

# 🎨 sys.argv is a list containing all arguments
print("Script name:", sys.argv[0])  # The script itself
print("All arguments:", sys.argv)    # All arguments as a list
print("Number of arguments:", len(sys.argv))

# 🎯 Try to access the first user argument
if len(sys.argv) > 1:
    print("First argument:", sys.argv[1])
else:
    print("No arguments provided! 😢")

💡 Explanation: sys.argv is always a list where:

  • sys.argv[0] is the script name
  • sys.argv[1], sys.argv[2], etc. are the arguments you provide

🎯 Common Patterns

Here are patterns you’ll use daily:

# 🏗️ Pattern 1: Basic argument handling
import sys

# Check if enough arguments provided
if len(sys.argv) < 2:
    print("Usage: python script.py <name>")
    sys.exit(1)  # Exit with error code

name = sys.argv[1]
print(f"Hello, {name}! 👋")

# 🎨 Pattern 2: Multiple arguments
if len(sys.argv) >= 3:
    age = sys.argv[2]
    print(f"You are {age} years old! 🎂")

# 🔄 Pattern 3: Processing all arguments
print("\n📋 All arguments provided:")
for i, arg in enumerate(sys.argv[1:], 1):
    print(f"  {i}. {arg}")

💡 Practical Examples

🛒 Example 1: Simple Calculator

Let’s build something useful:

# 🧮 calculator.py - A command line calculator
import sys

def main():
    # 📝 Check if we have enough arguments
    if len(sys.argv) != 4:
        print("❌ Usage: python calculator.py <number1> <operation> <number2>")
        print("📌 Example: python calculator.py 10 + 5")
        sys.exit(1)
    
    # 🎯 Get our arguments
    try:
        num1 = float(sys.argv[1])
        operation = sys.argv[2]
        num2 = float(sys.argv[3])
    except ValueError:
        print("❌ Error: Please provide valid numbers!")
        sys.exit(1)
    
    # 🎨 Perform the calculation
    if operation == '+':
        result = num1 + num2
        emoji = "➕"
    elif operation == '-':
        result = num1 - num2
        emoji = "➖"
    elif operation == '*':
        result = num1 * num2
        emoji = "✖️"
    elif operation == '/':
        if num2 == 0:
            print("❌ Error: Can't divide by zero! 🚫")
            sys.exit(1)
        result = num1 / num2
        emoji = "➗"
    else:
        print(f"❌ Error: Unknown operation '{operation}'")
        print("✅ Supported: +, -, *, /")
        sys.exit(1)
    
    # 🎉 Show the result
    print(f"{emoji} {num1} {operation} {num2} = {result}")

if __name__ == "__main__":
    main()

🎯 Try it yourself: Run with python calculator.py 15 + 7 or python calculator.py 100 / 4

🎮 Example 2: Greeting Generator

Let’s make it fun:

# 🎊 greeter.py - Personalized greeting generator
import sys
from datetime import datetime

def get_time_greeting():
    """Return appropriate greeting based on time 🕐"""
    hour = datetime.now().hour
    if hour < 12:
        return "Good morning", "☀️"
    elif hour < 17:
        return "Good afternoon", "🌤️"
    else:
        return "Good evening", "🌙"

def main():
    # 📝 Default values
    name = "Friend"
    style = "friendly"
    
    # 🎯 Process arguments
    if len(sys.argv) > 1:
        name = sys.argv[1]
    
    if len(sys.argv) > 2:
        style = sys.argv[2].lower()
    
    # 🎨 Generate greeting based on style
    time_greeting, time_emoji = get_time_greeting()
    
    if style == "friendly":
        print(f"{time_emoji} {time_greeting}, {name}! Hope you're having an amazing day! 🎉")
    elif style == "formal":
        print(f"{time_greeting}, {name}. Welcome to our system. 🎩")
    elif style == "excited":
        print(f"🎊 OMG! {time_greeting}, {name}! SO EXCITED TO SEE YOU! 🚀✨")
    elif style == "pirate":
        print(f"🏴‍☠️ Ahoy, {name}! {time_greeting} to ye, matey! ⚓")
    else:
        print(f"❓ Unknown style '{style}'")
        print("✅ Try: friendly, formal, excited, or pirate")

if __name__ == "__main__":
    main()

🎯 Examples to try:

  • python greeter.py Alice
  • python greeter.py Bob excited
  • python greeter.py Captain pirate

🚀 Advanced Concepts

🧙‍♂️ Advanced Pattern: Options and Flags

When you’re ready to level up, try this pattern:

# 🎯 Advanced argument parsing
import sys

def parse_arguments():
    """Parse command line arguments with options 🎛️"""
    args = {
        'verbose': False,
        'output': 'output.txt',
        'files': []
    }
    
    i = 1
    while i < len(sys.argv):
        arg = sys.argv[i]
        
        # 🏷️ Check for flags
        if arg == '-v' or arg == '--verbose':
            args['verbose'] = True
        elif arg == '-o' or arg == '--output':
            # Next argument is the output file
            if i + 1 < len(sys.argv):
                args['output'] = sys.argv[i + 1]
                i += 1  # Skip next argument
            else:
                print("❌ Error: -o requires a filename")
                sys.exit(1)
        else:
            # 📁 Regular argument (probably a file)
            args['files'].append(arg)
        
        i += 1
    
    return args

# 🎮 Using the parser
args = parse_arguments()
if args['verbose']:
    print("🔊 Verbose mode enabled!")
print(f"📝 Output file: {args['output']}")
print(f"📁 Files to process: {args['files']}")

🏗️ Building a File Processor

For the brave developers:

# 🚀 fileinfo.py - Get info about files
import sys
import os

def format_size(bytes):
    """Convert bytes to human readable format 📏"""
    for unit in ['B', 'KB', 'MB', 'GB']:
        if bytes < 1024:
            return f"{bytes:.1f} {unit}"
        bytes /= 1024
    return f"{bytes:.1f} TB"

def main():
    if len(sys.argv) < 2:
        print("❌ Usage: python fileinfo.py <file1> [file2] ...")
        print("📌 Example: python fileinfo.py document.txt image.png")
        sys.exit(1)
    
    print("📊 File Information Tool\n")
    
    # 🔄 Process each file
    for filename in sys.argv[1:]:
        print(f"📁 Analyzing: {filename}")
        
        if not os.path.exists(filename):
            print(f"  ❌ File not found!\n")
            continue
        
        # 📏 Get file stats
        stats = os.stat(filename)
        size = format_size(stats.st_size)
        
        # 🎨 Determine file type emoji
        if filename.endswith('.py'):
            emoji = "🐍"
        elif filename.endswith(('.jpg', '.png', '.gif')):
            emoji = "🖼️"
        elif filename.endswith(('.txt', '.md')):
            emoji = "📝"
        else:
            emoji = "📄"
        
        print(f"  {emoji} Type: {os.path.splitext(filename)[1] or 'No extension'}")
        print(f"  📏 Size: {size}")
        print(f"  📅 Modified: {datetime.fromtimestamp(stats.st_mtime).strftime('%Y-%m-%d %H:%M')}")
        print()

if __name__ == "__main__":
    main()

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Forgetting to Check Argument Count

# ❌ Wrong way - will crash if no arguments!
name = sys.argv[1]  # 💥 IndexError if no arguments!

# ✅ Correct way - always check first!
if len(sys.argv) > 1:
    name = sys.argv[1]
else:
    name = input("Please enter your name: ")  # 🛡️ Fallback option

🤯 Pitfall 2: Not Handling Invalid Input

# ❌ Dangerous - user might not provide a number!
age = int(sys.argv[1])  # 💥 ValueError if not a number!

# ✅ Safe - validate your inputs!
try:
    age = int(sys.argv[1])
    if age < 0 or age > 150:
        print("⚠️ Please provide a realistic age!")
        sys.exit(1)
except ValueError:
    print("❌ Error: Age must be a number!")
    sys.exit(1)
except IndexError:
    print("❌ Error: Please provide your age!")
    sys.exit(1)

🛠️ Best Practices

  1. 🎯 Always Validate: Check argument count and types
  2. 📝 Provide Usage Help: Show users how to use your script
  3. 🛡️ Handle Errors Gracefully: Use try/except blocks
  4. 🎨 Use Meaningful Names: filename not arg1
  5. ✨ Give Feedback: Tell users what’s happening

🧪 Hands-On Exercise

🎯 Challenge: Build a Todo List Manager

Create a command-line todo list application:

📋 Requirements:

  • ✅ Add new todos: python todo.py add "Buy milk 🥛"
  • 📋 List all todos: python todo.py list
  • ✔️ Mark as complete: python todo.py done 1
  • 🗑️ Remove todos: python todo.py remove 1
  • 💾 Save todos to a file

🚀 Bonus Points:

  • Add priority levels (high, medium, low)
  • Add due dates
  • Show statistics (completed vs pending)

💡 Solution

🔍 Click to see solution
# 🎯 todo.py - Command line todo manager!
import sys
import os
import json
from datetime import datetime

TODO_FILE = "todos.json"

def load_todos():
    """Load todos from file 📂"""
    if os.path.exists(TODO_FILE):
        with open(TODO_FILE, 'r') as f:
            return json.load(f)
    return []

def save_todos(todos):
    """Save todos to file 💾"""
    with open(TODO_FILE, 'w') as f:
        json.dump(todos, f, indent=2)

def add_todo(description):
    """Add a new todo ➕"""
    todos = load_todos()
    todo = {
        "id": len(todos) + 1,
        "description": description,
        "completed": False,
        "created": datetime.now().isoformat(),
        "emoji": "📝"
    }
    todos.append(todo)
    save_todos(todos)
    print(f"✅ Added: {description}")

def list_todos():
    """List all todos 📋"""
    todos = load_todos()
    if not todos:
        print("📭 No todos yet! Add one with: python todo.py add 'Your task'")
        return
    
    print("\n📋 Your Todo List:")
    print("-" * 50)
    
    for todo in todos:
        status = "✅" if todo["completed"] else "⏳"
        print(f"{status} [{todo['id']}] {todo['description']}")
    
    # 📊 Show stats
    completed = sum(1 for t in todos if t["completed"])
    print(f"\n📊 Stats: {completed}/{len(todos)} completed")

def complete_todo(todo_id):
    """Mark todo as complete ✔️"""
    todos = load_todos()
    for todo in todos:
        if todo["id"] == todo_id:
            todo["completed"] = True
            todo["emoji"] = "✅"
            save_todos(todos)
            print(f"🎉 Completed: {todo['description']}")
            return
    print(f"❌ Todo {todo_id} not found!")

def remove_todo(todo_id):
    """Remove a todo 🗑️"""
    todos = load_todos()
    todos = [t for t in todos if t["id"] != todo_id]
    save_todos(todos)
    print(f"🗑️ Removed todo {todo_id}")

def main():
    if len(sys.argv) < 2:
        print("❌ Usage: python todo.py <command> [args]")
        print("📝 Commands:")
        print("  add 'description'  - Add new todo")
        print("  list              - Show all todos")
        print("  done <id>         - Mark as complete")
        print("  remove <id>       - Delete todo")
        sys.exit(1)
    
    command = sys.argv[1].lower()
    
    if command == "add":
        if len(sys.argv) < 3:
            print("❌ Please provide a description!")
            sys.exit(1)
        add_todo(sys.argv[2])
    
    elif command == "list":
        list_todos()
    
    elif command == "done":
        if len(sys.argv) < 3:
            print("❌ Please provide todo ID!")
            sys.exit(1)
        try:
            complete_todo(int(sys.argv[2]))
        except ValueError:
            print("❌ ID must be a number!")
    
    elif command == "remove":
        if len(sys.argv) < 3:
            print("❌ Please provide todo ID!")
            sys.exit(1)
        try:
            remove_todo(int(sys.argv[2]))
        except ValueError:
            print("❌ ID must be a number!")
    
    else:
        print(f"❌ Unknown command: {command}")

if __name__ == "__main__":
    main()

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

  • ✅ Access command line arguments with sys.argv 💪
  • ✅ Validate user input to prevent crashes 🛡️
  • ✅ Build flexible scripts that adapt to different inputs 🎯
  • ✅ Create professional command-line tools 🐛
  • ✅ Handle errors gracefully like a pro! 🚀

Remember: Command line arguments make your scripts powerful and reusable! They’re the key to building professional Python tools. 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered command line arguments with sys.argv!

Here’s what to do next:

  1. 💻 Practice with the todo list exercise above
  2. 🏗️ Convert one of your existing scripts to use command line arguments
  3. 📚 Learn about argparse module for more advanced argument parsing
  4. 🌟 Share your command-line tools with others!

Remember: Every professional Python tool started with simple sys.argv usage. Keep coding, keep learning, and most importantly, have fun! 🚀

Happy coding! 🎉🚀✨

Previous Tutorial
📘 Python Scripts vs Modules: Understanding the Difference
Next Tutorial
📘 Python Path and Module Search

More python Tutorials

Part 28

📘 Python Scripts vs Modules: Understanding the Difference

🌱Beginner • 25 min read
Part 29 - Currently Reading

📘 Command Line Arguments: sys.argv Basics

🌱Beginner • 20 min read
Part 30

📘 Python Path and Module Search

🌱Beginner • 25 min read
View all 365 python tutorials →

Tutorial Info

Series Progress
Part 29 of 365 8%
Category
🐍 python
Difficulty
🌱Beginner
Duration
20 min read
Published
June 26, 2025