Local and Global Variables in Python

Last Updated on July 12, 2023 by Mayank Dham

In Python, global variables are defined outside of any function and have a scope that extends throughout the program, while local variables are defined within a function and their scope is limited to that specific function. Essentially, local variables are accessible only within the function in which they are initialized, whereas global variables can be accessed throughout the program and within any function.
To put it simply, Python global variables have a wider scope, visible to the entire program, while local variables have a narrower scope, confined to the function in which they are declared.

Global Variable

As mentioned earlier, a global variable in programming is a variable that exists outside of any function and can be accessed from any part of the program. In contrast, a local variable is limited in scope and can only be accessed within the specific code block or function where it is defined. It’s worth noting that while global variables can provide broad accessibility, their use can introduce challenges in terms of code maintainability, comprehension, and debugging. Therefore, it is generally recommended to use global variables judiciously to avoid potential issues.

A global variable in Python is a variable that is defined outside of a function or class and can be accessed from anywhere within the program. Global variables are defined using the "global" keyword and are typically used to store information that needs to be shared across different parts of the program. However, it is generally considered best practice to avoid using global variables as they can make code more difficult to understand and maintain.

Example of Global Variable:

In this example, we will create a global variable(outside the function scope ).

Code Implementation:

x = 10

def func1():
    print(x)

def func2():
    print(x)

func1() # prints 10
func2() # prints 10

Output:

10
10

Explanation:
In the above python program we have created a variable x and assigned the value 10, and this variable can be accessible in both functions func1 and func2 because this is a global variable

Local Variable

A local variable is a variable that can be accessed and utilized only within the specific scope or block of code where it is defined. Typically, local variables are declared within functions or specific code blocks and are not accessible outside of that particular scope. They are visible and usable only by the code executing within the same scope.

The use of local variables promotes modularity, maintainability, and clarity in code. By limiting the visibility and accessibility of variables to their defined scopes, the code becomes more organized and easier to understand. Local variables ensure that the value assigned to them remains unaffected by other parts of th e program. It is important to note that in some programming languages, when a local variable shares the same name as a global variable, the local variable takes precedence within its respective scope.

In Python, a local variable is a variable that is defined within a function or a block of code and is only accessible within that scope. Local variables are defined using the assignment operator (=) and are typically only used within the function or block of code in which they are defined.

Example of Local Variable:

In this example, we will create a local variable(outside the function scope ).

Code Implementation:

def func1():
    x = 20
    print(x)

def func2():
    print(x) # this will raise an error because x is not defined in this function

func1() # prints 20
func2() # raises an error

Output:

20
Traceback (most recent call last):
  File "./prog.py", line 9, in 
  File "./prog.py", line 6, in func2
NameError: name 'x' is not defined

Explanation:
In above python program we created two functions func1 and func2 and a variable x in function 1, so the print statement in func1 run properly and print 20 in output screen but print statements in func2 gives an error (name ‘x’ not defined).
We can solve this problem by taking x as a global variable. By global keyword.

Code Implementation:

# your code goes here

def func1():
    global x
    x=20
    print(x)

def func2():
    print(x) # this will raise an error because x is not defined in this function

func1() # prints 20
func2() # raises an error

Output:

20
20

Explanation:
Now here we observe that the print statement of func2 run properly did not give an error
Because of the global keyword (the keyword "global" is used to indicate that a variable is a global variable, as opposed to a local variable. This means that the variable can be accessed and modified from anywhere in the code, rather than just within the scope of the function or block in which it is defined.)so on output, we have 20 and 20.

Difference between Local Variable and Global Variable

• Scope: Global variables have a global scope and can be accessed and modified from anywhere in the code. Local variables, on the other hand, have a local scope and can only be accessed and modified within the scope of the function or class they are defined.
• Visibility: Local variables are only visible within the scope in which they are defined. They cannot be accessed or manipulated outside of their defined scope. Global variables, on the other hand, are visible throughout the program, allowing them to be accessed and modified from any part of the code.
• Initialization: Local variables must be explicitly declared and initialized within the block of code or function where they are used. Global variables, however, can be initialized at the point of declaration or at any other part of the program.
• Memory Allocation: Local variables are typically allocated memory when the block of code or function they belong to is executed, and the memory is deallocated once the scope is exited. Global variables, on the other hand, are allocated memory at the start of the program and persist in memory until the program terminates.
• Impact of Changes: Modifying the value of a local variable within a function or code block does not affect the value of the variable outside of that scope. In contrast, modifying the value of a global variable can impact its value across the entire program.
• Precedence: If a local variable and a global variable share the same name, the local variable takes precedence within its scope. This means that the local variable will be used instead of the global variable within the specific code block or function where it is defined.

Advantages and Disadvantages of Local and Global Variables

Advantages of Global Variables:

• Easy to access: Global variables can be accessed from anywhere in the code, making them easy to use.
• Shared data: Global variables can be used to share data between different functions or classes.
• Persistent data: Global variables can be used to store data that needs to persist throughout the lifetime of the program.

Disadvantages of Global Variables:

• Name collision: As mentioned earlier, global variables can have the same name as local variables, which can cause confusion.
• Side effects: Global variables can have side effects on the code when they are modified. For example, modifying a global variable in one function may cause unexpected behavior in another function that uses the same variable.
• Security: Global variables can be accessed and modified by anyone with access to the code, making them a security risk.

Advantages of Local Variables:

• Improved readability: Local variables are only visible within the scope of the function or code block in which they are defined. This makes the code more readable and easier to understand, as developers can tell exactly where and when a variable is being used.
• Reduced naming conflicts: Local variables are only accessible within the scope in which they are defined, which helps to reduce naming conflicts. This is especially important in large projects where multiple developers may be working on different parts of the codebase.
• Increased security: Local variables are not accessible from outside the scope in which they are defined, making it more difficult for malicious actors to access sensitive data. This added security can help protect against data breaches and other security threats.
• Simplified debugging: When a bug occurs, it can be easier to track down the cause if the variables are limited in scope. If a variable is only accessible within a specific function, it can narrow down the search for the problem to that specific function.

Disadvantages of Local Variables:

• Limited scope: The main disadvantage of local variables is that they are only accessible within the scope in which they are defined. This can make it difficult to share data between different functions or code blocks.
• Increased memory usage: Local variables are only stored in memory while the function or code block in which they are defined is running. This can lead to increased memory usage, especially if a large number of local variables are defined in a single function or code block.
• Extra effort: Local variables need to be defined within the function or code block in which they are being used, which can add extra effort and complexity to the development process.

Conclusion
In Python, local and global variables serve different purposes and have distinct scopes. Local variables are accessible only within the specific block of code or function where they are defined, while global variables can be accessed from any part of the program. Local variables provide modularity, maintainability, and clarity by limiting their visibility and ensuring their value is not affected by other parts of the program. Global variables offer broad accessibility but should be used judiciously to avoid potential issues with code maintainability and comprehension.

FAQs related to Local and Global variables in Python:

Frequently asked questions related to Local and Global variables in Python are discussed below:

Q1. Can a local variable have the same name as a global variable in Python?
Yes, a local variable can have the same name as a global variable in Python. In such cases, the local variable takes precedence within its scope, overshadowing the value of the global variable within the specific code block or function.

Q2. What happens if a local variable is accessed outside its scope in Python?
Attempting to access a local variable outside of its scope will result in a NameError since the variable is not visible or accessible beyond its defined scope.

Q3. How can a global variable be modified within a function in Python?
To modify a global variable within a function in Python, the "global" keyword needs to be used before the variable name within the function. This informs Python that the variable being referred to is the global one, rather than creating a new local variable.

Q4. Are local variables stored in memory throughout the program’s execution in Python?
No, local variables are stored in memory only while the block of code or function in which they are defined is executing. Once the scope is exited, the memory allocated for the local variables is deallocated.

Q5. Can global variables be accessed and modified by multiple functions in Python?
Yes, global variables can be accessed and modified by multiple functions in Python since they have a broader scope. However, it is generally recommended to minimize the use of global variables to maintain code clarity and reduce potential issues related to variable dependencies and unintended modifications.

Q6. What is the advantage of using local variables over global variables in Python?
Using local variables promotes modularity and encapsulation in Python code. Local variables have a limited scope, which prevents unintended modifications and allows for better organization of code. They also make it easier to understand and maintain the code since their value is confined to the specific block or function where they are defined.