DEV Community

Cover image for The Secret Life of Python: The Uncontained Script
Aaron Rose
Aaron Rose

Posted on

The Secret Life of Python: The Uncontained Script

#coding #python #programming

Why your variables are colliding (and how to fix it).

Timothy scrolled to the bottom of his data processing script. It was a long, flat column of code—no functions, just command after command.

"It works," he said, "but it feels... fragile."

Margaret leaned in. "Why do you say that?"

"I'm reusing variable names," Timothy admitted. "I use total to count users at the top. Then I use total to count revenue at the bottom. I'm terrified that if I delete a line in the middle, the 'old' total will accidentally be used by the new calculation."

He showed her the structure. It looked something like this:

# Timothy's "Flat" Script (All Global)

# Step 1: Count Users
users = ["Alice", "Bob", "Charlie"]
total = len(users)
print(f"User Count: {total}")

# ... (20 lines of code later) ...

# Step 2: Calculate Revenue
# Timothy *intends* to calculate a new total here.
# But what if he makes a typo or conditionally skips this block?
sales = [100, 200, 50]
# total = sum(sales)  <-- Imagine he forgets this line!

print(f"Revenue: {total}")
Enter fullscreen mode Exit fullscreen mode

Output:

User Count: 3
Revenue: 3
Enter fullscreen mode Exit fullscreen mode

Timothy winced. "See? I forgot to recalculate total, so the revenue calculation just grabbed the total from the user count. It didn't crash; it just gave me the wrong number."

The Global Soup

"This is the danger of the Global Scope," Margaret said. "In a flat script like this, every variable you create lives forever. users, total, sales—they are all swimming in the same soup."

"Could I just delete the variables when I'm done?" Timothy asked. "Like, type del total after line 5?"

Margaret shook her head. "You could, but that is manual labor. If you forget one del, the bug returns. We want a system that cleans itself up automatically. Think of functions like hotel rooms that are scrubbed clean the moment you check out."

"Also," she added, "Local variables are faster for Python to access than Global ones. So we are going to clean up your code and speed it up."

The Orchestrator Pattern

Margaret took the keyboard. "We are going to take your script and wrap it into functions. We will have one function to run the show—the Orchestrator—and smaller functions to do the work."

She refactored the code:

# Margaret's Solution: The Orchestrator

def process_users():
    users = ["Alice", "Bob", "Charlie"]
    count = len(users)  # 'count' is LOCAL to this function
    print(f"User Count: {count}")

def process_revenue():
    sales = [100, 200, 50]
    revenue = sum(sales) # 'revenue' is LOCAL to this function
    print(f"Revenue: {revenue}")

def main():
    # The Orchestrator
    # Its job is to control the flow, not do the work.
    print("Starting Job...")
    process_users()
    process_revenue()
    print("Job Complete.")

# Run the Orchestrator
if __name__ == "__main__":
    main()
Enter fullscreen mode Exit fullscreen mode

"Now," Margaret explained, "look at the scope."

"When process_users() finishes," she continued, "its variables—users and count—are destroyed. When process_revenue() starts, it starts with a clean slate. There is no 'old' total variable floating around to cause bugs."

The Gatekeeper

Timothy pointed to the last two lines.
if __name__ == "__main__": main()

"What is that?" he asked.

"That is the Gatekeeper," Margaret said. "It ensures that your Orchestrator (main) only runs when you specifically ask it to. It turns your script from a loose list of commands into a structured application."

Timothy looked at his new code. "It's cleaner. I don't have to worry about what variable name I used fifty lines ago."

"Exactly," Margaret smiled. "Don't let your variables wander the halls, Timothy. Keep them in their rooms."

Margaret’s Cheat Sheet

Margaret opened her notebook to the "Structure" section.

  • The Trap: Writing "flat" scripts (no functions).
  • The Problem: Global Scope Pollution. Every variable lives forever, leading to naming collisions and "zombie data."
  • The Fix: The Orchestrator Pattern.
  • Move logic into specific functions (process_data()).
  • Create a main() function to orchestrate the flow.

  • Use the Gatekeeper: if __name__ == "__main__":.

  • The Benefit: Variables are created, used, and destroyed locally. This is safer and faster.

In the next episode, Margaret and Timothy will face "The Hidden Return." The Orchestrator is great, but what if process_revenue() needs to hand that money back to main()? Timothy is about to find out that if you don't ask for it, Python gives you... nothing.

Aaron Rose is a software engineer and technology writer at tech-reader.blog and the author of Think Like a Genius.

Top comments (0)