What Is Global Variable in Python?   

What is Python?   

Python is a high-level programming language known for its readable and simple syntax, which attracts a large community of developers worldwide. What makes Python a popular choice is its versatile nature, which lets you use it for writing simple scripts to complex machine learning and AI applications.   

Its extensive built-in library is an all-time favorite for beginners, enabling them to code seamlessly. Developers usually prefer NumPy for numerical computing, Pandas for data analysis, and TensorFlow for machine learning.   

Unlike other programming languages, Python is beginner-friendly, dynamically typed, cross-platform compatible, interpreted, interactive, and ideal for rapid development.  

 

What are the types of variables in Python?   

Variables in Python store data in Python programming. In simple words, understand these as containers that store different types of data.    

You don’t have to declare the type of data in the variable, as it is recognized by the value stored in it. So, to declare a variable in Python, you must use “=” and assign a value to it.   

The variables in Python are divided into 5 categories based on their scope and data. Python has various data types, such as numerical, string, Boolean, tuple, list, set, dictionary, and NoneType.   

The four types of variables in Python are:  

• Local variables  

• Global variables  

• Static variable in Python  

• Instance variables  

Let’s understand these in detail.

   

What are global and local variables in Python?   

In Python, a local variable is defined and called within a function. Its scope is limited to the Function in which it is accessed.   

These are mainly used for storing data temporarily within a function and don’t affect the program.  

  

Example:  

def my_function():  

y = 5  # Local variable  

print(y)  

my_function()  # Output: 5  

# print(y)  # This would raise an error as y is not accessible outside the Function  

Global variables declared outside of a function or class, offer unique flexibility. They can be accessed from anywhere within a program, inside or outside of a function. Their scope isn’t limited to the Function they’re declared but extends throughout the program, empowering developers with their versatility.   

Developers use global variables when they need to apply data across multiple functions or classes.   

Example:  

x = 10  # Global variable  

  

def print_x():  

print(x)  # Accessing global variable  

  

print_x()  # Output: 10   

Now that you know what a global variable is in Python, let’s learn how to create it.   

Similar Blog: Advantages Of Python Over Other Programming Languages

 

How to create a global variable in Python?   

To create a global variable in Python, you need to declare it outside the Function or within a worldwide scope. By scope, we mean the areas of the program that can access the variable. So, global scope means that the variable is accessible throughout the program.   

Example of how to declare a global variable in Python:  

# This Function uses global variable s  

def f():  

    print(“Inside Function”, s)  

# Global scope  

s = “I love India my homeland”  

f()  

print(“Outside Function”, s)  

The output you will get is as follows:  

• Inside Function I love India my homeland  

• Outside Function I love India my homeland  

In the above example, you see how we accessed the global variable both inside and outside the Function.    

Informative blog: What is Multi Line Comment Line in Python?

 

How to access global variables in Python inside and outside of a function?   

What is Global Variable in Python: Accessing a global variable in Python is straightforward. A global variable is available throughout the Python program, whether you want to access it within the Function or outside.   

Accessing Python global variable outside a function  

  

# Global variable  

greeting = “Hello, World!”  

  

# Accessing global variables outside of any function  

print(greeting)  # Output: Hello, World!  

Accessing Python global variable inside a function  

# Global variable  

greeting = “Hello, World!”  

  

def print_greeting():  

# Accessing the global variable inside the Function  

print(greeting)  # Output: Hello, World!  

  

# Call the Function  

print_greeting()  

 

What happens if global and local variables in Python have the same name?   

Now, there are times when local and global variables have the same name.   

In such cases, will the local variable affect the global variable? Or will the global variable overshadow the local variable in the program? How does Python prioritize both variables in the program?

Related Article: Top 10 Python Frameworks List

And what will happen if we change the value of the global variable in a function?    

Python follows a set of rules to determine which variable to prioritize in a program based on its scope.   

As discussed above, a variable scope is an area or part of the program that has access to the variable.    

Global scope means the variable defined outside of a function. Variables can be called or accessed outside and inside of a function unless a local variable overrides them.   

Local scope refers to the variables defined within the Function. These can be accessed only inside the Function and do not affect the global variable.   

So, when we have a situation where both local and global variables have the same name:   

Inside Function: Within the Function, a local variable is always given priority over the global variable. Any reference to the variable inside the Function will mean a local variable, not a global one.   

Outside Function: Outside of the Function, a global variable is more vital than a local variable. This is because local variables cannot be accessed outside of a function. So, even if both local and global variables have the same name, any reference to variables outside the Function only refers to a global variable.  

Example:  

# Global variable  

x = 10  

  

def my_function():  

# Local variable with the same name as the global variable  

x = 5  

    print(“Value of x inside the function:”, x)  

  

# Calling the Function  

my_function()  # Output: Value of x inside the function: 5  

  

# Accessing the global variable outside the Function  

print(“Value of x outside the function:”, x)  # Output: Value of x outside the function: 10  

As you can see in the above example, the variable called within the Function means variable “x” with value 5 and not the global variable with value 10.   

So when “print(x)” is called within the Function, the code prints the value 5.   

Moreover, when a variable is called outside the Function, the interpreter understands that the global variable “x” with value 10 is called. So, for “print(x)” outside of a function, the output is 10.   

Informative blog: Top 10 Web Development Frameworks to Use in 2024

What happens if you try to change the value of a global variable inside the Function?    

You will get an error as “UnboundLocalError.” Why?   

Because you cannot modify the value of a global variable inside a function.    

This is because Python interprets the variable inside the Function as a local variable. It is the nature of Python to take any variable inside the Function as local.    

So, when you declare a variable “x” globally and try to modify it in a function, Python will treat “x” as local.     

As you have not defined the variable “x” locally beforehand, Python does not know where to refer to and shows an error.    

Example of the issue:  

x = 10  # Global variable  

  

def myfunc():  

print(x)  # Trying to access global x before modifying it  

x = x + 5  # Attempt to modify x  

print(x)  

  

myfunc()  

Python will not catch the global variable value for modifications within a function unless you use the “global” keyword.  

  

The Global Keyword   

The global keyword function is used when you need to modify a global variable inside a function or within its current scope. It instructs the interpreter to take up the global version of the variable value.    

The “global” keyword plays a crucial role in updating the value of a global variable within the Function, instilling confidence in your ability to manage global variables.   

Let’s understand this in detail.   

We know Python’s default behavior is to treat any variables inside the Function as local. If you try to edit global variables inside the Function, Python will show an error.    

The “global” keyword reverses this nature and enables you to modify the global variable in the Function.    

So, in the preceding section’s example, if we use the “global” keyword, we can avoid the “UnboundLocalError” and easily edit the value of the global variable.    

  

Corrected example:  

x = 10  # Global variable  

  

def myfunc():  

global x  # Declare x as global  

print(x)  # Now this refers to the global x  

x = x + 5  # Modify the global x  

print(x)  

  

myfunc()  

Please note that once you use “global” before the variable, any changes made inside the Function will affect the global variable.    

Also, overusing the “global” keyword in your code will make it hard to understand and debug. You should consider using return values and function arguments in your program.   

Example of accessing and modifying global variables inside and outside a function:  

# Global variable  

total = 50  

  

def add_to_total(amount):  

global total  # Declare that we are using the global variable  

total += amount  # Modify the global variable  

  

def print_total():  

# Accessing the global variable inside the Function  

    print(f”Total inside function: {total}”)  

  

# Accessing the global variable outside the Function  

print(f”Total before function call: {total}”)  # Output: 50  

  

# Modify the global variable inside the Function  

add_to_total(30)  

  

# Accessing the global variable outside the Function after modification  

print(f”Total after function call: {total}”)  # Output: 80  

  

# Accessing the global variable inside another function  

print_total()  # Output: Total inside Function: 80  

  

Best practices on how to use global variables in Python   

Handling global variables in Python is easy if you follow the rules. Here are some best practices to use Python global variables.   

Use descriptive names for global variables. The name should tell the purpose or nature of the value.   

Use the “global” keyword only where necessary to modify the value of global variables in the Function.   

Refrain from carelessly using the “global” keyword in your code. This makes your code hard to understand.   

Minimize the use of global variables in your code. Go for alternatives like classes, return values, and function attributes.   

Always clarify the purpose and intent when using the global variables. Use single-line comments to document why they are being used.   

Remember to test your code rigorously when using global variables. This is to ensure that there are no side effects and that no part of the program is affected by them.   

Global variables are best suited for simple applications and scripts. If your program grows, consider refactoring the code to eliminate them. This will make your code robust and scalable.    

Important Article: What is the Difference Between Framework vs Library

Conclusion   

Variables in Python are essential elements that, when judiciously used, can help you write clear and bug-free code. Global variables are powerful tools in Python that should be used with caution. By naming them clearly, minimizing their use, and correctly documenting and thoroughly testing your code, you can handle global variables while keeping your code clean and maintainable. 

Learn Python with Kochiva and get ready for a career in tech. Our expert trainers will teach you everything you need to know in the field of IT, and help you find a job.