Global scope in Python - Deep Dive

Overview - Global scope

What is it?

Global scope in Python means variables or names that are created outside of any function or block and can be accessed anywhere in the program. These variables live in the main body of the code and are visible to all parts of the program unless shadowed by a local variable. They hold their values throughout the program's run unless changed explicitly. Understanding global scope helps you know where and how variables can be used.

Why it matters

Without the concept of global scope, every variable would only exist inside small parts of the program, making it hard to share information or keep track of important data. Global scope allows different parts of a program to access and update shared information easily. This makes programs simpler and more organized, especially when many functions need to work with the same data.

Where it fits

Before learning global scope, you should understand what variables are and how functions work in Python. After mastering global scope, you can learn about local scope, nonlocal variables, and how Python manages variable namespaces and lifetimes.

Mental Model

Core Idea

Global scope means a variable lives in one shared place accessible everywhere in the program unless a local variable hides it.

Think of it like...

Imagine a big whiteboard in a classroom that everyone can see and write on. This whiteboard is like the global scope. Anyone in the room (any function) can read or write information on it. But if someone writes on their personal notebook (local scope), only they can see that note.

┌─────────────────────────────┐
│        Global Scope          │
│  (variables accessible to   │
│   all functions and code)    │
│                             │
│  ┌───────────────┐          │
│  │ Function A    │          │
│  │ (local scope) │          │
│  └───────────────┘          │
│                             │
│  ┌───────────────┐          │
│  │ Function B    │          │
│  │ (local scope) │          │
│  └───────────────┘          │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

What is a variable and scope

Concept: Introduce variables and the idea that where you create a variable affects where you can use it.

In Python, a variable is a name that holds a value, like a label on a box. The place where you create a variable decides where you can use it. For example, if you create a variable inside a function, only that function can see it. If you create it outside any function, it can be seen everywhere.

Result

You understand that variables have a 'home' that controls their visibility.

Knowing that variables have a location that controls their visibility is the first step to understanding how programs organize data.

2

Foundation

Defining global variables

Concept: Show how to create variables outside functions that are accessible everywhere.

When you write a variable outside any function, it is global. For example: x = 10 # global variable def print_x(): print(x) print_x() # prints 10 Here, x is global and can be used inside print_x().

Result

The function prints 10 because it can see the global variable x.

Creating variables outside functions makes them accessible everywhere, which helps share data across the program.

3

Intermediate

Local vs global variable conflict

🤔Before reading on: If a function creates a variable with the same name as a global one, which one does it use inside the function? The global or the local?

Concept: Explain what happens when a local variable has the same name as a global variable.

If a function creates a variable with the same name as a global variable, the local one hides the global inside that function. For example: x = 5 # global def func(): x = 10 # local print(x) func() # prints 10 print(x) # prints 5 Inside func, x is local and different from the global x.

Result

The function prints 10, but outside it prints 5, showing local hides global inside the function.

Understanding that local variables can hide global ones prevents confusion about which value is used.

4

Intermediate

Modifying global variables inside functions

🤔Before reading on: Can you change a global variable inside a function without special syntax? Yes or no?

Concept: Introduce the 'global' keyword to modify global variables inside functions.

By default, if you assign a value to a variable inside a function, Python treats it as local. To change a global variable inside a function, you must use the 'global' keyword: count = 0 # global def increment(): global count count += 1 increment() print(count) # prints 1 Without 'global', Python would create a new local variable named count.

Result

The global variable count is increased to 1 and printed.

Knowing the 'global' keyword lets you intentionally change shared data from inside functions.

5

Intermediate

Reading global variables without 'global'

Concept: Explain that you can read global variables inside functions without declaring them global.

You can use global variables inside functions without 'global' if you only read them, not assign: name = 'Alice' def greet(): print('Hello,', name) greet() # prints Hello, Alice Here, name is global and used inside greet without 'global' because we only read it.

Result

The function prints the global variable's value.

Understanding that reading global variables is allowed without 'global' helps avoid unnecessary declarations.

6

Advanced

Global scope and nested functions

🤔Before reading on: If a nested function changes a variable, does it affect the global variable by default? Yes or no?

Concept: Show how global scope interacts with nested functions and the need for 'global' or 'nonlocal'.

In nested functions, to change a global variable, you still need 'global'. For example: counter = 0 def outer(): def inner(): global counter counter += 1 inner() outer() print(counter) # prints 1 Without 'global', inner would create a local variable named counter.

Result

The global counter is incremented by the nested inner function.

Knowing how global scope works with nested functions prevents bugs when updating shared data deep inside code.

7

Expert

Why global variables can cause bugs

🤔Before reading on: Do you think using many global variables makes programs easier or harder to maintain? Commit to your answer.

Concept: Explain the risks and hidden problems of overusing global variables in large programs.

Global variables can be changed from anywhere, which makes it hard to track where and when their values change. This can cause unexpected bugs and make programs difficult to understand and maintain. Experts often limit global variables and prefer passing data explicitly or using other structures to keep code clear and safe.

Result

Programs with many global variables tend to have hidden bugs and are harder to maintain.

Understanding the dangers of global variables helps you write cleaner, safer, and more maintainable code.

Under the Hood

Python stores global variables in a special dictionary called the global namespace, which is linked to the module where the code runs. When Python looks up a variable name, it first checks local variables, then enclosing functions, then global variables, and finally built-in names. The 'global' keyword tells Python to use the global namespace for assignments instead of creating a new local variable.

Why designed this way?

This design keeps variable lookup efficient and predictable. It allows functions to have their own local variables without interference, while still enabling shared data through globals. The 'global' keyword was introduced to avoid accidental changes to globals, making code safer and clearer about intent.

┌───────────────┐
│ Built-in Names│
└──────┬────────┘
       │
┌──────▼────────┐
│ Global Scope  │  <--- global variables stored here
└──────┬────────┘
       │
┌──────▼────────┐
│ Enclosing     │  <--- for nested functions
│ Functions     │
└──────┬────────┘
       │
┌──────▼────────┐
│ Local Scope   │  <--- variables inside current function
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: If you assign a value to a variable inside a function, does it always change the global variable with the same name? Commit yes or no.

Common Belief: Assigning a variable inside a function always changes the global variable if it has the same name.

Reality: Assigning a variable inside a function creates a new local variable unless you use the 'global' keyword.

Why it matters: Without this knowledge, you might think your global data changed when it actually didn't, causing confusing bugs.

Quick: Can you read a global variable inside a function without declaring it global? Commit yes or no.

Common Belief: You must always declare a variable as global inside a function to use it, even for reading.

Reality: You can read global variables inside functions without declaring them global; 'global' is only needed to assign.

Why it matters: Misunderstanding this leads to unnecessary code and confusion about variable usage.

Quick: Do global variables keep their values between function calls? Commit yes or no.

Common Belief: Global variables reset every time a function is called.

Reality: Global variables keep their values throughout the program unless explicitly changed.

Why it matters: Expecting globals to reset causes errors in logic and state management.

Quick: Is it good practice to use many global variables in large programs? Commit yes or no.

Common Belief: Using many global variables makes programs easier to write and understand.

Reality: Overusing global variables makes programs harder to debug, maintain, and understand.

Why it matters: Ignoring this leads to fragile code that breaks easily and is costly to fix.

Expert Zone

1

Global variables are stored in the module's __dict__, which means importing modules can affect global state if not careful.

2

Using 'global' only affects the current module's global namespace, so globals in imported modules are separate unless explicitly referenced.

3

Mutable global objects can be changed without 'global' keyword, but rebinding a global name requires 'global'. This subtlety often confuses learners.

When NOT to use

Avoid using global variables when you need clear, testable, and maintainable code. Instead, pass variables as function arguments, use class attributes, or use closures with 'nonlocal' for nested scopes.

Production Patterns

In real-world Python projects, global variables are often constants (all caps) to indicate they should not change. Shared state is managed via classes, modules, or dependency injection to keep code modular and testable.

Connections

Local scope

Opposite concept

Understanding global scope is clearer when contrasted with local scope, which limits variable visibility to inside functions.

Closures and nonlocal variables

Builds-on

Knowing global scope helps grasp how 'nonlocal' allows inner functions to modify variables in enclosing scopes, bridging local and global concepts.

Shared memory in operating systems

Similar pattern

Global variables in programming are like shared memory in operating systems, where multiple processes or threads access common data, requiring careful control to avoid conflicts.

Common Pitfalls

#1 Trying to modify a global variable inside a function without 'global' keyword.

Wrong approach:

count = 0
def increment():
count += 1 # Error: UnboundLocalError

increment()

Correct approach:

count = 0
def increment():
global count
count += 1

increment()

Root cause:

Python treats assignment inside functions as creating local variables unless 'global' is declared.

#2 Assuming reading a global variable inside a function requires 'global' keyword.

Wrong approach:

x = 5
def print_x():
global x
print(x)

print_x()

Correct approach:

x = 5
def print_x():
print(x)

print_x()

Root cause:

Confusing the need for 'global' only when assigning, not reading.

#3 Overusing global variables for all shared data.

Wrong approach:

config = {}
def update_config():
global config
config['mode'] = 'dark'

def reset_config():
global config
config = {}

Correct approach:

class Config:
def __init__(self):
self.settings = {}
def update(self):
self.settings['mode'] = 'dark'
def reset(self):
self.settings = {}

config = Config()

Root cause:

Not using better structures like classes leads to fragile and hard-to-maintain code.

Key Takeaways

Global scope means variables defined outside functions are accessible everywhere in the program unless hidden by local variables.

Assigning to a global variable inside a function requires the 'global' keyword; otherwise, Python creates a new local variable.

Reading global variables inside functions does not require 'global', only writing does.

Overusing global variables can cause bugs and make code hard to maintain; prefer passing variables or using classes.

Understanding how Python looks up variables in local, enclosing, global, and built-in scopes helps avoid common mistakes.