Local variables are specific to a method and cannot be accessed from outside of that method's scope. These variables are employed by programmers to fulfill temporary requirements within a method's context. They are referred to as local or temporary variables. Local variables are instantiated when a method is executed and are automatically destroyed once the method completes its execution.

Example 1

Consider the following code snippet:

# Define a class named 'Test'
class Test:
    # Define a method 'm1' within the class
    def m1(self):
        a = 1000  # Define a local variable 'a' with a value of 1000
        print(a)  # Print the value of 'a'

    # Define another method 'm2' within the class
    def m2(self):
        b = 2000  # Define a local variable 'b' with a value of 2000
        print(b)  # Print the value of 'b'

# Create an instance 't' of the 'Test' class
t = Test()

# Call the method 'm1' on the instance 't'
t.m1()  # Output: 1000 (prints the value of local variable 'a')

# Call the method 'm2' on the instance 't'
t.m2()  # Output: 2000 (prints the value of local variable 'b')

Output:

1000
2000

In this example, we have defined a class Test containing two methods, m1 and m2. Inside each method, there are local variables a and b, respectively. These variables are created when the methods are invoked and hold their respective values (a = 1000 and b = 2000). The print statements within each method display the values of these local variables.

Importantly, these local variables are confined to their respective methods. The variable a is only accessible within m1, and the variable b is only accessible within m2. Attempting to access these variables from outside their methods will result in an error due to their limited scope. This demonstrates the encapsulation of data within method boundaries, enhancing code organization and security by preventing unintended interference from external code.

Example 2

Now, let's consider another code snippet:

# Define a class named 'Test'
class Test:
    # Define a method 'm1' within the class
    def m1(self):
        a = 1000  # Define a local variable 'a' with a value of 1000
        print(a)  # Print the value of 'a'

    # Define another method 'm2' within the class
    def m2(self):
        b = 2000  # Define a local variable 'b' with a value of 2000
        print(a)  # Attempt to print the value of 'a' (Error: NameError)
        print(b)  # Print the value of 'b'

# Create an instance 't' of the 'Test' class
t = Test()

# Call the method 'm1' on the instance 't'
t.m1()  # Output: 1000 (prints the value of local variable 'a')

# Call the method 'm2' on the instance 't'
t.m2()  # Error: NameError: name 'a' is not defined

In this example, we have the same Test class with m1 and m2 methods. In the m2 method, an attempt is made to print the value of a, which is defined in the m1 method. However, this results in a NameError because a is a local variable confined to the scope of the m1 method. It cannot be accessed from within the m2 method, leading to the error message "name 'a' is not defined."

This demonstrates the strict isolation of local variables to their specific method scopes. Each method operates in its own context, and variables defined within one method are not accessible in another method, further highlighting the importance of scoping rules in maintaining code clarity and preventing unintended errors.