3. Scope and Lifetime of Variables

Scope refers to the area of the program where a variable is accessible.

Types of Scope:

• Local Scope: Variables defined inside a function.
• Global Scope: Variables defined outside any function.
• Enclosing Scope: Variables in the outer function in nested functions.
• Built-in Scope: Names preassigned in Python (like print, len).

Scope in programming is simply the region in a code where a variable can be accessed or used. It tells you where the variable can 'live' and be meaningful.

1. Local Scope: This is for variables created within a function. They are only known within that function.
2. Global Scope: Variables that are defined outside functions can be accessed from anywhere in the code.
3. Enclosing Scope: This is relevant when you have nested functions - a variable defined in an outer function can be accessed by an inner function.
4. Built-in Scope: These are the functions and names that Python has pre-defined, like print and len, which are available anywhere in your code.

Imagine a school:

• Local Scope is like a classroom where only the students inside that classroom can use the materials and resources available there.
• Global Scope is like the entire school where any student can access the library books anywhere within the school.
• Enclosing Scope could represent a situation where you have a school district (outer function) where multiple schools (inner functions) can access some resources shared by the district, but they cannot access each other's school-specific resources.
• Built-in Scope is like the school's infrastructure that everyone uses, such as classrooms, halls, and restrooms.

Python resolves variable names using the LEGB rule:

• L – Local
• E – Enclosing
• G – Global
• B – Built-in

The LEGB rule is a hierarchy Python follows when searching for variables. When you use a variable, Python looks for it in the following order:

1. Local: First, it checks if the variable is defined in the current function (local scope).
2. Enclosing: If it doesn't find it, it looks for the variable in any enclosing functions, moving outward.
3. Global: Next, it checks the global scope to see if the variable is defined outside of all functions.
4. Built-in: Finally, if it still can't find the variable, it looks for predefined built-in functions.

Think of the LEGB rule like a hierarchy in a business:

• Local would be an employee that looks for resources only within their department (local scope).
• Enclosing would be an employee asking their direct manager (enclosing function) if resources are available in that department.
• Global would be reaching out to the company's main office (global scope) where larger resources are managed.
• Built-in would be checking the company handbook (built-in scope) for standard procedures that everyone can access.

Global Variable Example:

x = 10
def display():
    print(x)
display()

Local Variable Example:

def func():
    x = 5
    print(x)
func()
print(x) # This will give an error if x is not defined globally

In programming, variables can be classified as global or local based on where they are defined:

• Global Variables are defined outside functions and can be accessed from any place in the program. In the example, x = 10 is a global variable and can be printed inside the display() function.
• Local Variables are defined within a function and can only be accessed within that function. In the func() example, x is local, and trying to print x outside of func() will raise an error since x doesn't exist in the global scope.

Imagine a public library as a Global Variable where everyone can access the books from anywhere. In contrast, a specific book in a school's classroom (Local Variable) can only be used by the students in that classroom. If someone outside the classroom tries to get that book, they won't be able to find it.

• global: Used to modify global variables inside a function. • nonlocal: Used in nested functions to modify a variable in the outer (non-global) scope.

Example:

x = 5
def change():
    global x
    x = 10
change()
print(x) # Output: 10

In Python, you can modify variables from different scopes using two keywords:

• global: When you want to change the value of a global variable inside a function, you use the global keyword. In the example, x is made a global variable inside the change() function, allowing it to update x to 10.
• nonlocal: This keyword is used in nested functions to indicate that you want to use a variable from an enclosing (but not global) scope. This is important when you intend to modify variables in a parent function from a child function.

Think of global and nonlocal keywords like different types of permissions:

• The global keyword is like a child who is given permission by their parent (the function) to use the family car (the global variable) for any errand.
• The nonlocal keyword is like a student being allowed to modify a project that is shared by their school club (the outer function) while they are working in a specific group (the inner function).

--