Python Variable Scope: Local & Global Variables

Introduction

Variables are used to store data that can be accessed and manipulated throughout a program. Understanding variable scope is essential because it helps developers write cleaner, more organized, and error-free code.

Python mainly provides two types of variable scope:

• Local Scope
• Global Scope

A local variable exists only within a specific function, while a global variable can be accessed throughout the program.

What is Variable Scope?

Variable scope refers to the region of a program where a variable is accessible.

In simple terms, scope determines:

• Where a variable can be used.
• Where a variable can be modified.
• How long a variable exists during program execution.

Example:

name = "John"
print(name)

Output:

Here, the variable can be accessed because it is within its valid scope.

Why is Variable Scope Important?

Variable scope helps:

• Avoid naming conflicts.
• Protect data from accidental changes.
• Improve code readability.
• Reduce bugs.
• Organize large programs efficiently.

Without proper scope management, programs can become difficult to maintain.

Types of Variable Scope in Python

Python primarily supports:

1. Local Scope
2. Global Scope

Additionally, Python also supports:

1. Enclosing Scope
2. Built-in Scope

However, local and global scopes are the most commonly used and important for beginners.

Local Variables

A local variable is a variable created inside a function.

It can only be accessed within that function.

Example:

def greet():
    message = "Hello"
    print(message)
greet()

Output:

The variable message exists only inside the function.

Accessing a Local Variable Outside a Function

Example:

def greet():
    message = "Hello"
greet()
print(message)

Output:

Note: The local variable cannot be accessed outside the function.

Local Variable Lifetime

Local variables are created when the function starts and destroyed when the function ends.

Example:

def demo():
    number = 10
    print(number)
demo()

After execution, the variable no longer exists.

Global Variables

A global variable is a variable declared outside all functions.

It can be accessed throughout the program.

Example:

name = "John"
def greet():
    print(name)
greet()

Output:

The global variable is accessible inside the function.

Accessing Global Variables

Example:

country = "India"
def display():
    print(country)
display()
print(country)

Output:

The variable is accessible both inside and outside the function.

Local Variable vs Global Variable

Example:

name = "Global"
def demo():
    name = "Local"
    print(name)
demo()
print(name)

Output:

The local variable temporarily hides the global variable inside the function.

Variable Shadowing

When a local variable has the same name as a global variable, the local variable takes priority within the function.

Example:

age = 25
def show_age():
    age = 30
    print(age)
show_age()
print(age)

Output:

This behavior is called variable shadowing.

Modifying Global Variables Inside Functions

Python does not allow modifying a global variable directly inside a function unless the global keyword is used.

Example:

counter = 10
def update():
    global counter
    counter = 20
update()
print(counter)

Output:

The global keyword tells Python to use the global variable.

What Happens Without global?

Example:

count = 5
def update():
    count = 10
update()
print(count)

Output:

Python creates a new local variable instead of modifying the global variable.

Understanding the global Keyword

The global keyword allows a function to modify a global variable.

Syntax

global variable_name

Example:

total = 100
def increase():
    global total
    total += 50
increase()
print(total)

Output:

Example:

name = "John"
city = "Delhi"
def display():
    print(name)
    print(city)
display()

Output:

Nested Functions and Scope

Functions can contain other functions.

Example:

def outer():
    message = "Hello"
    def inner():
        print(message)
    inner()
outer()

Output:

The inner function can access variables from the outer function.

LEGB Rule in Python

Python follows the LEGB rule for variable lookup:

Python searches variables in this order:

1. Local
2. Enclosing
3. Global
4. Built-in

Example of LEGB Rule

name = "Global"
def outer():
    name = "Outer"
    def inner():
        name = "Inner"
        print(name)
    inner()
outer()

Output:

Python finds the nearest variable first.

Real-Life Examples:

1. Website Settings

website_name = "My Tutorial Site"
def show_website():
    print(website_name)
show_website()

Output:

Global variables often store configuration settings.

2. User Login System

def login():
    username = "admin"
    print(username)
login()

Output:

User-specific data is typically local.

3. Banking Application

balance = 1000
def deposit():
    global balance
    balance += 500
deposit()
print(balance)

Output:

Global variables can track account information.

4. Game Score System

score = 0
def increase_score():
    global score
    score += 10
increase_score()
print(score)

Output:

5. Employee Management

company_name = "ABC Ltd"
def employee():
    employee_name = "John"
    print(company_name)
    print(employee_name)
employee()

Output:

Advantages of Local Variables

1. Better Security

Data is protected from unintended changes.

2. Reduced Memory Usage

Variables are destroyed after function execution.

3. Improved Maintainability

Functions become self-contained.

4. Avoid Naming Conflicts

Multiple functions can use the same variable names safely.

Advantages of Global Variables

1. Easy Access

Available throughout the program.

2. Shared Data

Multiple functions can use the same variable.

3. Configuration Storage

Ideal for application-wide settings.

Common Mistakes

1. Accessing Local Variables Outside Functions

Incorrect:

def demo():
    name = "John"
print(name)

Output:

2. Forgetting the global Keyword

count = 10
def update():
    count += 1

Output:

3. Overusing Global Variables

Too many global variables make programs difficult to manage.

4. Variable Shadowing

Using identical variable names can create confusion.

name = "Global"
def demo():
    name = "Local"

5. Modifying Global Data Accidentally

Changes to global variables affect the entire application.

Best Practices

Prefer Local Variables

Use local variables whenever possible.

Minimize Global Variables

Only use globals for truly shared data.

Use Meaningful Variable Names

student_name

Instead of:

s

Avoid Variable Shadowing

Use different names for local and global variables.

Use Functions to Return Values

Instead of modifying globals directly.

def add(a, b):
    return a + b

Conclusion

Understanding the scope of variables is essential for writing efficient and maintainable Python programs. Variable scope determines where variables can be accessed and modified. Local variables exist only within functions and help keep code organized, while global variables can be accessed throughout the program and are useful for shared data.

Related Python Tutorials