Learn Python Programming

Python Main Function

The if __name__ == "__main__" pattern lets you write code that runs only when the file is executed directly, not when imported as a module.

How __name__ Works

# Every Python file has a special __name__ variable:
# - When run directly: __name__ == "__main__"
# - When imported: __name__ == "module_name"

# File: greet.py
print(f"__name__ is: {__name__}")

def hello(name):
    return f"Hello, {name}!"

if __name__ == "__main__":
    # This block runs ONLY when you execute: python greet.py
    print(hello("World"))

# Run directly:
# $ python greet.py
# __name__ is: __main__
# Hello, World!

# Import from another file:
# >>> import greet
# __name__ is: greet
# (the if block does NOT execute)

The main() Function Pattern

# Best practice: define a main() function and call it from the guard

def parse_args():
    """Parse command-line arguments."""
    import argparse
    parser = argparse.ArgumentParser(description="Process data files")
    parser.add_argument("filename", help="Input file path")
    parser.add_argument("-v", "--verbose", action="store_true")
    return parser.parse_args()

def process_file(filename, verbose=False):
    """Main processing logic."""
    if verbose:
        print(f"Processing {filename}...")
    with open(filename) as f:
        data = f.read()
    return len(data)

def main():
    """Entry point for the script."""
    args = parse_args()
    result = process_file(args.filename, args.verbose)
    print(f"File size: {result} characters")

if __name__ == "__main__":
    main()

Why Use This Pattern

# WITHOUT the guard — causes problems when imported

# File: calculator.py (BAD)
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

# This runs every time the file is imported!
print("Calculator loaded")
result = add(5, 3)
print(f"5 + 3 = {result}")

# File: app.py
import calculator  # prints "Calculator loaded" and "5 + 3 = 8" — unwanted!

# WITH the guard — clean and reusable

# File: calculator.py (GOOD)
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

if __name__ == "__main__":
    # Only runs when executed directly for testing
    print("Calculator loaded")
    result = add(5, 3)
    print(f"5 + 3 = {result}")

# File: app.py
import calculator  # silent — only imports functions
print(calculator.add(10, 20))  # 30

Practical Examples

# Example 1: Script with error handling
import sys

def main():
    try:
        filename = sys.argv[1]
    except IndexError:
        print("Usage: python script.py <filename>")
        sys.exit(1)

    try:
        with open(filename) as f:
            for line in f:
                print(line.strip().upper())
    except FileNotFoundError:
        print(f"Error: {filename} not found")
        sys.exit(1)

if __name__ == "__main__":
    main()

# Example 2: Module that works both ways
# File: converter.py
def celsius_to_fahrenheit(c):
    return c * 9/5 + 32

def fahrenheit_to_celsius(f):
    return (f - 32) * 5/9

if __name__ == "__main__":
    # Interactive mode when run directly
    temp = float(input("Enter temperature in Celsius: "))
    print(f"{temp}°C = {celsius_to_fahrenheit(temp):.1f}°F")

# Can also be imported:
# from converter import celsius_to_fahrenheit

• __name__ equals "__main__" when a file is run directly, or the module name when imported.
• Always wrap script logic in if __name__ == "__main__" so modules stay importable.
• Define a main() function for better organization and testability.
• This pattern is essential for writing reusable code that also works as a standalone script.
• Use sys.argv or argparse inside main for command-line argument handling.