How do I declare a global variable inside a function in Python?

You can use the global keyword. Example: def set_value(): global x x = 10

Why do I get an “UnboundLocalError” in Python even when a variable exists globally?

This happens when a variable is used before it's assigned within a function, and Python treats it as a local variable. Use the global keyword to modify the global variable inside the function.

Can I have a variable with the same name in local and global scope?

Yes, but the local variable will shadow the global one inside that function. Be cautious, it can lead to confusion or bugs.

When should I use global variables in Python?

Use global variables sparingly. They're useful when multiple functions need access to shared data, but too many globals can make your code harder to maintain and debug.

Difference Between Local and Global Variables in Python

Q: What is the difference between local and global variables in Python?

Local variables are declared inside a function and can only be accessed within that function, while global variables are declared outside all functions and can be accessed anywhere in the program.

Variables in Python Explained

Have you ever tried to change a variable inside a Python function? And realized that it did not change outside the function? This is the most common confusion beginner Python Programmers often face, and it all comes down to one thing, i.e., variable scope.

Putting this in simple words, variables play a very important role in storing data and information. Variable scope means the position at which the variable is placed in a Python program and where it can be used in the entire code. Some variables work only with a function, which are known as local variables, while other variables work across the Python program and are known as global variables.

Whether you are building a small script or a looking for full web application development with Python, learning the difference between local and global variables is important for writing clean and error-free Python code.

Therefore, in this blog, we will talk about:

What does variable scope mean in Python
How local, global, and static-like variables work
Common mistakes like UnboundLocalError, and how to fix them
Real code examples with outputs to make you understand things clearly

Also, in this blog, we will give you tips from real-world projects and best practices that even experienced Python developers follow. If you want to get your product developed by experts, hire python developers from a trusted software development company.

So, let’s get started from the very basics.

What is Variable Scope in Python?

Python variable scope refers to the place in the program where the variable is defined and can be used. It defines the visibility and lifetime of a variable. Understanding variable scope is important for writing organized, error-free, and maintainable code.

Python defines different types of variable scopes, primarily controlled by the LEGB rule (Local, Enclosed, Global, Built-in):

Local Scope: Variables that are defined within a function belong to the local scope of that function. These variables can be used only within that specific function and become inaccessible once the function finishes execution.

Python Code:

def function_name(): local_variable = “I am a local variable” print(local_variable) function_name() # print(local_variable) #This would raise a NameError

Enclosing Scope: In nested functions, the inner function can use variables from its immediate outer function’s scope. This is also known as a “nonlocal” scope. The nonlocal keyword can be used to modify variables in this scope.

Python Code:

def outer_fuction(): enclosing_variable = “I am in the enclosing scope” def inner_function(): nonlocal enclosing_variable enclosing_variable = “Modified by inner function” print(enclosing_variable) inner_function() print (enclosing_variable) outer_fuction()

Global Scope: Variables that are defined outside any function or class, at the top level of a script or module, have global scope. These variables can be used from anywhere across that module. You can use the ‘global’ keyword within a function to indicate that the assigned variable is global, and not just another local variable.

global_variable = “I am a global variable” def access_global(): print(global_variable) def modify_global(): global global_variable global_variable = “Modified global” access_global() modify_global() print(global_variable)

Built-in Scope: Built-in scope contains the names of the built-in functions and exceptions that are always available in Python, including print(), len(), str(), Exception, etc. These names can be shadowed by user-defined variables if a variable with the same name is created in a more specific scope.

print(len("Hello")) # Output: 5

The LEGB Rule Lookup Order

Local
Enclosing
Global
Built-in

Once it finds a match, it stops searching

Scope Conflict Example

x = “Global” def outer(): x = “Enclosing” def inner(): x = “Local” print(x) inner() outer()

Even though there’s a global and an enclosing variable named x, Python picks the closest scope, the Local.

Why Scope Matters?

It prevents bugs by keeping variables separate in different parts of your code.
It helps you organize your logic better in functions and classes.
It reduces the chance of accidentally overwriting variables with the same name.

How to Define Variables in Python?

Variables in Python are defined by assigning a value to a name with the help of an assignment operator (=). Python is a dynamically typed language, which means that you do not need to explicitly declare the data type of a variable before assigning a value to it. The interpreter automatically infers the type based on the assigned value.

How to define a variable in Python?

Choose a variable name: Variable names must start with a letter (a-z, A-Z) or an underscore (_), and can be followed by letters, numbers (0-9), or underscores. They are case-sensitive (for example, age and Age, both are different variables). Ensure not to use Python keywords as variable names.

Assign value: Use the assignment operator (=) to assign a value to the chosen variable name.

Code Example 1: Defining Basic Variables #Assigning different types of values

Name = Rahul #String Age = 26 #Integer Height = 5.6 #Float is_developer = True #Boolean print(Name, Age, Height, is_writer)

Output: Rahul 26 2.5 True Code Example 2: Variables Inside a Function (Local Scope)

def show_info() language = “Python” print(“Working with”, language) show_info() print(language) #Error

Output:

Working with Python

NameError: name ‘language’ is not defined

Explanation: The name ‘language’ is defined locally inside show_info(), so it cannot be accessed outside the show_info() function.

Pro Tip: Use Meaningful Variable Names

Avoid using generic names like x, data, or temp, especially when working with multiple functions. Python code is readable by design, and descriptive variable names make your logic much easier to follow.

Python variables don’t need a type declaration.
Variables are created when you assign a value to them.
A variable’s position in the code determines its scope.

Need Expert Help with Python Development

Python Local Variables

What is a local variable in python?

Local variable Python are those that are created within the function. These variables are created when the function starts running and exist only during its execution.

A locally created variable is useful for temporary operations or isolated logic, where the variable is only needed within the function.

Example 1: Basic Local Variable

def greet() msg = “Hello from inside the function!” print(msg) greet()

Output: Hello from inside the function! Example 2: Defining basic local variable

def calculate_area(): Radius = 5 Area = 3.14 * Radius * Radius print(“Area inside function:”, area) calculate_area() print(“Area outside function:”, area)

Output:

Area inside function: 78.5

NameError: name ‘area’ is not defined

The Variable ‘area’ is local to the function ‘calculate_area’ and does not exist outside it. When we try to access it outside, Python throws a NameError.

Example 3: Same Variable Name, Different Scopes

message = “Global Message” def show(): message = “Local Message” print(“Inside function:”, message) show() print(“Outside function:”, message)

Output:

Inside function: Local Message

Outside function: Global Message

When to Use Local Variables

Inside loops or conditionals, where the use of variables is temporary
For intermediate calculations or results that do not need to be stored permanently
To avoid interference with global variables in the larger program

Things to Watch Out For

Local variables cannot be accessed outside their function
If you try to assign a value to a variable inside a function without declaring it globally, Python will treat it as local, even if there is a global variable with the same name.

Python Global Variables

Python Global variables are defined outside all the functions. These variables can be accessed and used anywhere in the program, including inside functions. Global variable Python is useful when you need a shared state or configuration accessible across multiple functions. Let’s see below how to make a global variable in python:

Example 1: Accessing a Global Variable Inside a Function

X = 10 #Global Variable def show(): print(“Value of X inside function:”, X) show() print(“Value of X outside function:”, X)

Output: Value of X inside function: 10 Value of X outside function: 10 Since X is defined globally, the function can read it without any problem. Example 2: Modifying a Global Variable Inside a Function

count = 0 def increment(): Count = count + 1 print(“Inside Function:”, count) increment()

Output:

UnboundLocalError: local variable ‘count’ referenced before assignment.

This throws an error because Python assumes that you are trying to create a local variable named ‘count’. But you are referencing it before the assignment, which causes confusion.

Example 3: Using global keyword to Modify Global Variables

count = 0 def increment(): global count count += 1 print(“Inside function:”, count) increment() print(“Outside function:”, count)

Output: Inside Function: 1 Outside Function: 1

By using the global keyword, you are indicating to Python that you are referring to the global count, not creating a new local one. If you are looking for a python programmer for hire, WEDOWEBAPPS can be a great help.

Best Practices for Using Global Variables

Do Use	Do Not Use
For constants and config values (eg, API keys)	As substitutes for proper data passing
For sharing small accounts of state across functions	When the logic gets complex, it leads to tight coupling
With careful documentation and naming	When working in multithreaded or collaborative environments without control.

When to Avoid Global Variables

In large projects, the global state becomes hard to track and debug
They break modularity and make code harder to test
Too many global variables = tight coupling and poor scalability

Difference Between Local Variable vs. Global Variable

Comparison Basis	Global Variable	Local Variable
Definition	These are declared outside the functions	These are declared within the functions
Lifetime	They are created at the start of the program execution and cease to exist when the program comes to an end	They are created when the function starts its execution and are lost when the function ends.
Data Sharing	Offers data sharing	It does not offer data sharing
Scope	Can be accessed throughout the code	Can be accessed only inside the function
Parameters Needed	Parameter passing is not necessary	Parameter passing is necessary
Storage	A fixed location selected by the compiler	They are kept on the stack
Value	Once the value changes, it is reflected throughout the code	Once changed, the variable does not affect other functions of the program

Understanding local and global variables in Python is important, as they differ in scope and lifetime. Locals exist inside functions, and global variables are accessible anywhere. This knowledge helps prevent bugs and write cleaner code.

Code Example: Local vs. Global Variables

x = 50 #Global Variable def my_func(): x = 10 #Local Variable print(“Inside function (local x):”, x) my_func() print(“Outside function (global x):”, x)

Output: Inside function (local x): 10 Outside function (global x): 50

Even though both variables are named x, Python treats them independently because of their scope.

The nonlocal Keyword in Python

The nonlocal keyword in Python is used within nested functions to declare that a variable refers to a variable in the nearest enclosing (non-global) scope, rather than creating a new local variable within the nested function. This allows the inner function to modify the value of a variable defined in an outer, but not global, function.

Key Characteristics of nonlocal:

Scope: It targets variables in the enclosing function’s scope, which is different from both the local scope of the inner function and the global scope.
Modification: When a variable is declared nonlocal, assignments to that variable within the inner function will modify the variable in the outer function’s scope.
Purpose: It enables inner functions to directly interact with and change the state of their enclosing functions, facilitating closures and maintaining shared state within nested function structures.

Code Example for nonlocal

def outer_function(): x = 10 #This is a variable in the outer function’s scope def inner_function(): nonlocal x x = 20 print(f”Inside inner_function: x = {x}”) inner_function() print(f”Inside outer_function: x = {x}”) outer_function()

In the above example, inner-function uses nonlocal x to indicate that x refers to the x defined in the outer-function. When x is reassigned to 20 within inner-function, the change is reflected in outer-function’s x. Without nonlocal, x=20 would create a new local variable within the inner function, leaving the x in the outer function unchanged.

When to Use nonlocal?

When working with closures that need to retain and modify state
In decorators or function factories
Avoid using it in deeply nested functions, as it can reduce readability.

Pro Tip:

If you find yourself needing nonlocal frequently, it might be a sign to refactor your code into a class with instance variables for better structure.

Variable Shadowing in Python

Variable Shadowing in Python occurs when a variable declared in an inner scope has the same name as a variable defined in an outer scope. In such a case, the inner variable shadows or hides the outer variable within the inner scope. This means that any reference to that variable name within the inner scope will refer to the locally defined variable, rather than the one from the outer scope.

Consider the following example:

global_var = “I am global” def my_function(): local_var = “I am local” print(local_var) #This prints “I am local” my_function() print(global_var) #This prints “I am global”

In this case, local_var and global_var are different variables. Nonetheless, if a variable within my_function had the same name as global_var:

global_var = "I am global" def my_function(): global_var = "I am a local variable with the same name as global_var" print(global_var) # This prints "I am a local variable with the same name as global_var" my_function() print(global_var) # This still prints "I am global"

In the above code snippet, global_var inside my_function is a new, local variable that shadows the global global_var. The assignment within the function creates a new local variable, and subsequent uses of global_var within my_function refer to this local variable. The original global global_var remains unchanged and is accessible outside the function.

While variable shadowing is a feature of Python’s scope rules, it can sometimes lead to confusion and unintended behavior, particularly for less experienced developers. It is generally recommended to use different variable names across different scopes to enhance code clarity and reduce the potential for bugs.

Code Example for Variable Shadowing

x = 50 def example() x = 25 #This shadows the global variable x print(“Inside function:”, x) example() print(“Outside function:”, x)

Output: Inside function: 25 Inside function: 50 What’s Happening?

The function defines its own x, separate from the global x.
The global x remains unchanged because the local version shadows it.

Static-Like Variables in Functions

In Python, the concept of a "python static variable in function" as found in languages like C++ (where a static keyword within a function creates a variable with static storage duration, initialized once and retaining its value across function calls) is not directly implemented. However, similar functionality can be achieved using various Pythonic approaches.

Function Attributes:

Python functions are objects, and like other objects, they can have attributes. This allows you to attach data directly to the function object itself, which persists across calls.

def my_function(): if not hasattr(my_function, 'counter'): my_function.counter = 0 # Initialize the "static" variable my_function.counter += 1 print(f"Function called {my_function.counter} times") my_function() my_function() my_function()

Closures:

A closure allows a nested function to "remember" and access variables from its enclosing scope, even after the outer function has finished executing. This can be used to create a persistent state for a function.

def create_counter(): count = 0 # This variable persists within the closure def counter_function(): nonlocal count # Declare intent to modify the outer scope variable count += 1 print(f"Function called {count} times") return counter_function my_counter = create_counter() my_counter() my_counter() my_counter()

Class Variables (for methods within a class):

If the function is a method within a class, class variables serve as static variables, shared among all instances of that class.

class MyClass: call_count = 0 # Class variable acts as a static variable def my_method(self): MyClass.call_count += 1 print(f"Method called {MyClass.call_count} times") obj1 = MyClass() obj2 = MyClass() obj1.my_method() obj2.my_method()

Choosing the right approach:

Function attributes are concise for simple cases where a single function needs a persistent internal state.
Closures offer more encapsulation and are suitable when you need to create multiple independent instances of a function with their own persistent states.
Class variables are the standard way to implement static behavior when working within an object-oriented context, where the "static" variable is logically associated with the class itself.

Best Practices for Using Global and Local Variables.

The best practices mentioned below focus on promoting code clarity, maintainability, and preventing unintended side effects.

Local Variables

Prefer Local Variables: Prefer using local variables wherever possible, as they limit the scope of data to specific functions or blocks, reducing the risk of accidental modification by other parts of the program.
Encapsulation: Use local variables to encapsulate data within functions, enhancing modularity and making code easier to understand and debug.
Meaningful Naming: Employ descriptive names for local variables to improve readability and avoid confusion, especially when working on complex programs.

Global Variables

Minimize Use: Limit the use of global variables to situations where they are truly necessary, such as for configuration constants or truly shared, immutable data. Excessive use can lead to complex dependencies and make debugging difficult.

# Not recommended count = 0 def increment(): global count count += 1

# Better approach def increment(count): return count + 1

Use Constants for Immutability: If a global variable's value should not change, declare it as a constant (e.g., using const in C++ or final in Java) to prevent accidental modifications.
Controlled Access (Encapsulation): If global variables are necessary, consider encapsulating them within classes or modules and providing controlled access through methods (getters and setters) to manage their state.
Clear Documentation: Document global variables thoroughly, explaining their purpose, expected values, and any potential side effects to ensure other developers understand their role.
Avoid Modification from Multiple Functions: Minimize or avoid direct modification of global variables from multiple functions to prevent unexpected behavior and race conditions in concurrent environments.
Consider Alternatives: Before resorting to global variables, explore alternative data-sharing mechanisms like passing arguments to functions, returning values, or using design patterns like dependency injection or context managers.

General Practices

Consistent Naming Conventions: Adopt clear and consistent naming conventions to differentiate between global and local variables.
Initialization: Always initialize variables (both local and global) with known values before use to prevent unpredictable program behavior.
Avoid Name Collisions: Do not use the same name for a local variable and a global variable within the same scope to avoid confusion and potential errors.
Use Global and nonlocal Sparingly: Use global only when absolutely necessary. Use nonlocal for modifying variables in enclosing (non-global) scopes, and only when needed.

def outer(): x = "hello" def inner(): nonlocal x x = "hi" inner() print(x) # hi

Common Errors and Debugging Tips in Python Variable Management

Common errors in Python variable management and their debugging tips are outlined below:

1. NameError: Name is not defined

Error:

This occurs when a variable is used before it has been assigned a value or if there's a typo in the variable name.

Debugging Tips:

Check for typos: Ensure the variable name is spelled consistently throughout the code.
Verify assignment: Confirm the variable is assigned a value before its first use.
Scope awareness: Understand variable scope (local vs. global) and ensure the variable is accessible in the current context.

2. UnboundLocalError: Local variable 'x' referenced before assignment

Error:

This happens when a local variable within a function is referenced before it's assigned a value within that function, even if a global variable with the same name exists.

Debugging Tips:

Explicitly declare global: If intending to modify a global variable within a function, use the global keyword.
Initialize local variables: Ensure all local variables are assigned a value before use within the function.

3. TypeError: Cannot concatenate 'str' and 'int' objects

Error:

Occurs when attempting an operation (like concatenation) between incompatible data types, such as a string and an integer.

Debugging Tips:

Type conversion: Convert variables to compatible types before performing operations (e.g., str(integer_variable)).
Inspect types: Use type() to check the data type of variables at different points in the code.

4. IndentationError: Unexpected indent / Expected an indented block

Error:

Python uses indentation to define code blocks. Incorrect indentation (mixing tabs and spaces, inconsistent spacing) leads to these errors.

Debugging Tips:

Consistent indentation: Use a consistent number of spaces (typically four) for each indentation level.
Avoid mixing tabs and spaces: Configure your editor to use spaces exclusively for indentation.

5. AttributeError: 'NoneType' object has no attribute 'x'

Error:

This indicates an attempt to access an attribute or method on an object that is None, meaning it was not successfully assigned an object.

Debugging Tips:

Check function return values: Ensure functions intended to return an object are actually returning one and not None.
Verify object creation: Confirm the object you're trying to use has been properly initialized.

General Debugging Tips:

Read error messages carefully: Python's error messages (tracebacks) provide valuable information about the type of error and its location.
Use print() statements: Insert print() statements to inspect variable values at various stages of execution.
Utilize a debugger: Tools like pdb (Python Debugger) or integrated IDE debuggers allow stepping through code, setting breakpoints, and inspecting variables interactively.
Isolate the problem: Narrow down the code section causing the error by commenting out parts or simplifying inputs.

Struggling with Python variable scope in real-world applications

Real-World Scenario: Scope Bugs in Web Applications

In web development, especially when using Python frameworks like Flask or Django, incorrect variable scope can lead to frustrating bugs, inconsistent behavior, or even security issues. Let’s explore how scope mishandling plays out in a Python real-world use-case and how to fix it.

Scenario: Buggy Counter in a Flask Web App

Imagine a Flask-based web app that maintains a visitor count using a global variable.

from flask import Flask app = Flask(__name__) visitor_count = 0 @app.route('/') def home(): visitor_count += 1 # Scope issue here return f"Visitor number: {visitor_count}"

Output:

UnboundLocalError: local variable 'visitor_count' referenced before assignment

Even though visitor_count is global, modifying it inside home() without declaring it global causes Python to treat it as a local variable, hence the error.

Solution:

@app.route('/') def home(): global visitor_count visitor_count += 1 return f"Visitor number: {visitor_count}"

However, this solution is not scalable in a real production environment due to:

Lack of thread safety
No persistence across server restarts
Issues in distributed deployments

Better Alternative: Use a Persistent Store (e.g., Redis)

import redis r = redis.Redis() @app.route('/') def home(): r.incr("visitor_count") return f"Visitor number: {r.get('visitor_count').decode()}"

This approach is:

Thread-safe
Persistent
Suitable for production-level deployments

Takeaway

Misunderstanding variable scope isn’t just an academic problem, it can break your web app. Global variables might seem convenient, but in web development using Python:

Always consider concurrency and scalability
Prefer external state management (like Redis, databases, or caching systems)
Use global and nonlocal with caution

Conclusion: Mastering Python Variable Scope the Right Way

Understanding variable scope in Python is essential for writing clean, efficient, and bug-free code. Whether you're debugging a tricky Flask app, writing nested functions, or simply trying to avoid UnboundLocalError, knowing where and how your variables live is a game-changer.

Here's a quick recap:

Local scope is confined to the current function.
Global scope spans the entire script or module.
Use global and nonlocal with intent, not as quick fixes.
Variable scope plays a critical role in closures, recursion, class methods, and decorators.
Poor scope management in web apps can lead to real-world bugs and scalability issues.

As a leading Python development company, we’ve helped global clients build scalable, high-performance applications by applying these exact principles, ensuring code is clean, secure, and maintainable from day one.

By mastering Python’s scoping rules and pairing them with best practices, you can write code that's not only correct but also elegant and scalable.