I. Understanding `global` in Python#

The global keyword lets you modify global variables (全局变量) inside functions. Without it, assignments create local variables (局部变量) instead.

1. Scope Basics in Python#

Every variable in Python has a defined scope (作用域) – the region of code where it is accessible.

Global scope: Variables defined outside any function
Local scope: Variables defined inside a function

1
# Global variable
2
x = 10
3

4
def my_function():
5
    # Local variable (different from global x)
6
    x = 5
7
    print("Inside function:", x)
8

9
my_function()  # Output: Inside function: 5
10
print("Outside function:", x)  # Output: Outside function: 10

Note: In the example above, the x inside the function is completely separate from the global x. This is Python's way of preventing accidental modification of global variables.

2. The Problem: Modifying Global Variables#

When you try to modify a global variable inside a function without declaring it as global, Python creates a new local variable instead.

1
counter = 0
2

3
def increment():
4
    # This creates a NEW local variable 'counter'
5
    counter += 1  # ❌ ERROR!
6

7
# increment()  # Uncommenting this line causes UnboundLocalError

Pitfall: This code raises UnboundLocalError: local variable ‘counter’ referenced before assignment because Python sees the assignment and treats counter as a local variable, but it’s being referenced before it’s defined.

3. The Solution: Using `global`#

The global keyword tells Python: “This variable belongs to the global scope”.

1
counter = 0  # Global variable
2

3
def increment():
4
    global counter  # Declare that we're using the global counter
5
    counter = counter + 1
6
    print(f"Counter is now: {counter}")
7

8
increment()  # Output: Counter is now: 1
9
increment()  # Output: Counter is now: 2
10
print(f"Global counter: {counter}")  # Output: Global counter: 2

Note: The global statement must come before any use of the variable in the function.

4. Multiple Global Variables#

You can declare multiple global variables in a single statement:

1
name = "Python"
2
version = 3.9
3
year = 2023
4

5
def update_info():
6
    global name, version, year
7
    name = "Python 3"
8
    version = 3.11
9
    year = 2024
10

11
update_info()
12
print(f"{name} {version} ({year})")  # Output: Python 3 3.11 (2024)

5. Global vs Local: A Comparison#

Aspect	Local Variable	Global Variable
Scope (作用域)	Inside function only	Throughout the module
Declaration	Automatic on assignment	`global` keyword required inside functions
Read access	Direct access	Direct access (without `global` for reading)
Write access	Direct assignment	Requires `global` declaration
Memory (内存)	Created when function runs	Created when module loads
Best practice	Preferred for temporary values	Use sparingly, prefer parameters

6. Reading Global Variables (Without `global`)#

Interesting fact: You can read global variables without the global keyword:

1
message = "Hello, World!"
2

3
def show_message():
4
    # No 'global' needed for reading
5
    print(message)  # This works!
6

7
show_message()  # Output: Hello, World!

Warning: This only works for reading (读取). The moment you try to assign a value, Python treats it as a local variable unless you use global.

7. Nested Functions and `global`#

The global keyword always refers to the module-level (模块级别) scope, not the enclosing function scope.

1
x = "global x"
2

3
def outer():
4
    x = "outer x"
5

6
    def inner():
7
        global x  # This refers to the module-level 'x', not outer's 'x'
8
        x = "changed by inner"
9

10
    inner()
11
    print("outer x:", x)  # Output: outer x: outer x
12

13
outer()
14
print("global x:", x)  # Output: global x: changed by inner

Note: To modify variables in an enclosing (but non-global) scope (外部嵌套作用域), use the nonlocal keyword instead, which we'll cover in a separate note.

8. Mutable Objects: A Special Case#

For mutable objects (可变对象) like lists and dictionaries, you can modify their contents without using global:

1
my_list = [1, 2, 3]
2
my_dict = {"count": 0}
3

4
def modify_mutable():
5
    # No 'global' needed - we're modifying, not reassigning
6
    my_list.append(4)
7
    my_dict["count"] += 1
8
    print("Inside function:", my_list, my_dict)
9

10
modify_mutable()
11
print("Outside function:", my_list, my_dict)
12
# Output: Outside function: [1, 2, 3, 4] {'count': 1}

Pitfall: This works because we’re modifying (修改) the object, not reassigning (重新赋值) the variable. If we tried my_list = [4, 5, 6], that would require global.

💡 One-line Takeaway
Use global only when you must modify a module-level variable from inside a function; otherwise, pass values as parameters and return results for cleaner, more maintainable code.

I. Understanding global in Python#