Global and Local Variables in Python
Last Updated :
25 Jul, 2024
Python Global variables are those which are not defined inside any function and have a global scope whereas Python local variables are those which are defined inside a function and their scope is limited to that function only. In other words, we can say that local variables are accessible only inside the function in which it was initialized whereas the global variables are accessible throughout the program and inside every function.
Python Local Variables
Local variables in Python are those which are initialized inside a function and belong only to that particular function. It cannot be accessed anywhere outside the function. Let’s see how to create a local variable.
Creating local variables in Python
Defining and accessing local variables
Python
def f():
# local variable
s = "I love Geeksforgeeks"
print(s)
# Driver code
f()
OutputI love Geeksforgeeks
Can a local variable be used outside a function?
If we will try to use this local variable outside the function then let’s see what will happen.
Python
def f():
# local variable
s = "I love Geeksforgeeks"
print("Inside Function:", s)
# Driver code
f()
print(s)
Output:
NameError: name 's' is not defined
Python Global Variables
These are those which are defined outside any function and which are accessible throughout the program, i.e., inside and outside of every function. Let’s see how to create a Python global variable.
Create a global variable in Python
Defining and accessing Python global variables.
Python3
# This function uses global variable s
def f():
print("Inside Function", s)
# Global scope
s = "I love Geeksforgeeks"
f()
print("Outside Function", s)
OutputInside Function I love Geeksforgeeks
Outside Function I love Geeksforgeeks
The variable s is defined as the global variable and is used both inside the function as well as outside the function.
Note: As there are no locals, the value from the globals will be used but make sure both the local and the global variables should have same name.
Why do we use Local and Global variables in Python?
Now, what if there is a Python variable with the same name initialized inside a function as well as globally? Now the question arises, will the local variable will have some effect on the global variable or vice versa, and what will happen if we change the value of a variable inside of the function f()? Will it affect the globals as well? We test it in the following piece of code:
Example
If a variable with the same name is defined inside the scope of the function as well then it will print the value given inside the function only and not the global value.
Python3
# This function has a variable with
# name same as s.
def f():
s = "Me too."
print(s)
# Global scope
s = "I love Geeksforgeeks"
f()
print(s)
OutputMe too.
I love Geeksforgeeks
Now, what if we try to change the value of a global variable inside the function? Let’s see it using the below example.
Python
# This function uses global variable s
def f():
s += 'GFG'
print("Inside Function", s)
# Global scope
s = "I love Geeksforgeeks"
f()
Output:
UnboundLocalError: local variable 's' referenced before assignment
To make the above program work, we need to use the “global” keyword in Python. Let’s see what this global keyword is.
The global Keyword
We only need to use the global keyword in a function if we want to do assignments or change the global variable. global is not needed for printing and accessing. Python “assumes” that we want a local variable due to the assignment to s inside of f(), so the first statement throws the error message. Any variable which is changed or created inside of a function is local if it hasn’t been declared as a global variable. To tell Python, that we want to use the global variable, we have to use the keyword “global”, as can be seen in the following example:
Example 1: Using Python global keyword
Python3
# This function modifies the global variable 's'
def f():
global s
s += ' GFG'
print(s)
s = "Look for Geeksforgeeks Python Section"
print(s)
# Global Scope
s = "Python is great!"
f()
print(s)
OutputPython is great! GFG
Look for Geeksforgeeks Python Section
Look for Geeksforgeeks Python Section
Now there is no ambiguity.
Example 2: Using Python global and local variables
Python3
a = 1
# Uses global because there is no local 'a'
def f():
print('Inside f() : ', a)
# Variable 'a' is redefined as a local
def g():
a = 2
print('Inside g() : ', a)
# Uses global keyword to modify global 'a'
def h():
global a
a = 3
print('Inside h() : ', a)
# Global scope
print('global : ', a)
f()
print('global : ', a)
g()
print('global : ', a)
h()
print('global : ', a)
Outputglobal : 1
Inside f() : 1
global : 1
Inside g() : 2
global : 1
Inside h() : 3
global : 3
Difference b/w Local Variable Vs. Global Variables
| Comparision Basis | Global Variable | Local Variable |
| Definition | declared outside the functions | declared within the functions |
| Lifetime | They are created the execution of the program begins and are lost when the program is ended | They are created when the function starts its execution and are lost when the function ends |
| Data Sharing | Offers Data Sharing | It doesn’t offers Data Sharing |
| Scope | Can be access throughout the code | Can access 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 don’t affect other functions of the program |
Global and Local Variables in Python – FAQs
What Is the Difference Between Global and Local Variables in Python?
Global Variables:
- Scope: Accessible throughout the entire program or script, including all functions.
- Declaration: Defined outside any function or class.
- Lifetime: Exists for the duration of the program’s execution.
- Example:
global_var = 10 # Global variable
def my_function():
print(global_var) # Accessing global variable
Local Variables:
- Scope: Accessible only within the function or block where they are defined.
- Declaration: Defined inside a function or block.
- Lifetime: Exists only during the function’s execution.
- Example:
def my_function():
local_var = 5 # Local variable
print(local_var) # Accessing local variable
my_function()
print(local_var) # Raises an error because local_var is not accessible here
How Can We Change a Global Variable from Inside a Function in Python?
To modify a global variable inside a function, use the global keyword. This tells Python that you are referring to the global variable, not creating a new local one.
Example:
global_var = 10
def change_global():
global global_var
global_var = 20 # Modify the global variable
change_global()
print(global_var) # Output: 20
What Is the Scope of a Local Variable in Python?
The scope of a local variable is limited to the function or block in which it is defined. It is not accessible outside that function or block.
Example:
def my_function():
local_var = 5 # Local variable
print(local_var) # Accessible here
my_function()
print(local_var) # Raises an error because local_var is not accessible outside the function
How Does Python Handle Variable Scopes in Nested Functions?
In nested functions, Python uses the LEGB rule (Local, Enclosing, Global, Built-in) to resolve variable scopes:
- Local: Variables defined in the current function.
- Enclosing: Variables in any enclosing functions (functions that are nested inside another function).
- Global: Variables defined at the top level of the script or module.
- Built-in: Python’s built-in names.
What Are the Best Practices for Using Global Variables in Python?
- Minimize Usage: Use global variables sparingly to avoid potential issues with code readability and maintainability.
- Encapsulation: Encapsulate global variables within classes or modules to limit their scope and manage their state more effectively.
- Avoid Side Effects: Be cautious when modifying global variables from different functions or modules to avoid unintended side effects.
- Use Constants: For immutable values, consider using constants and defining them in uppercase to signify their immutability.
- Document Changes: Clearly document where and why global variables are being modified, especially if changes occur in multiple places.
- Testing: Ensure thorough testing when using global variables to prevent unexpected behavior or bugs in different parts of the program.
Similar Reads
How to Learn Python from Scratch in 2024
Python is a general-purpose high-level programming language and is widely used among the developersâ community. Python was mainly developed for emphasis on code readability, and its syntax allows programmers to express concepts in fewer lines of code. If you are new to programming and want to learn
15+ min read
Python Introduction
Python is a widely used high-level, interpreted programming language. It was created by Guido van Rossum in 1991 and further developed by the Python Software Foundation. It was designed with an emphasis on code readability, and its syntax allows programmers to express their concepts in fewer lines o
5 min read
Python 3 basics
Python was developed by Guido van Rossum in the early 1990s and its latest version is 3.11.0, we can simply call it Python3. Python 3.0 was released in 2008. and is interpreted language i.e it's not compiled and the interpreter will check the code line by line. This article can be used to learn the
10 min read
Important differences between Python 2.x and Python 3.x with examples
In this article, we will see some important differences between Python 2.x and Python 3.x with the help of some examples. Differences between Python 2.x and Python 3.x Here, we will see the differences in the following libraries and modules: Division operatorprint functionUnicodexrangeError Handling
5 min read
Download and Install Python 3 Latest Version
If you have started learning of Python programming, then for practice, Python installation is mandatory, and if you are looking for a guide that teaches you the whole process from downloading Python to installing it, then you are on the right path. Here in this download and install Python guide, we
6 min read
Statement, Indentation and Comment in Python
Here, we will discuss Statements in Python, Indentation in Python, and Comments in Python. We will also discuss different rules and examples for Python Statement, Python Indentation, Python Comment, and the Difference Between 'Docstrings' and 'Multi-line Comments. What is Statement in Python A Pytho
7 min read
Python | Set 2 (Variables, Expressions, Conditions and Functions)
Introduction to Python has been dealt with in this article. Now, let us begin with learning python. Running your First Code in Python Python programs are not compiled, rather they are interpreted. Now, let us move to writing python code and running it. Please make sure that python is installed on th
3 min read
Global and Local Variables in Python
Python Global variables are those which are not defined inside any function and have a global scope whereas Python local variables are those which are defined inside a function and their scope is limited to that function only. In other words, we can say that local variables are accessible only insid
7 min read
Type Conversion in Python
Python defines type conversion functions to directly convert one data type to another which is useful in day-to-day and competitive programming. This article is aimed at providing information about certain conversion functions. There are two types of Type Conversion in Python: Python Implicit Type C
5 min read
Private Variables in Python
Prerequisite: Underscore in PythonIn Python, there is no existence of âPrivateâ instance variables that cannot be accessed except inside an object. However, a convention is being followed by most Python code and coders i.e., a name prefixed with an underscore, For e.g. _geek should be treated as a n
3 min read