# Global and Local Processing of Variable Names in Python Python uses variables to store references to objects, and the way it processes variable names depends mainly on the scope in which those names are defined. Scope determines where a variable can be accessed in a program. Python follows a well-defined rule for resolving variable names, commonly known as the LEGB rule: Local, Enclosing, Global, and Built-in. Understanding global and local variables is particularly important in Data Structures and Algorithms Lab because algorithms frequently use functions, loops, recursion, and data structures whose operations depend on variable scope. A variable defined inside a function is generally a local variable. It can be accessed only within that function. A variable defined outside all functions is normally a global variable and can be accessed from functions, provided it is not hidden by a local variable having the same name. Python determines which variable a name refers to according to the scope in which the name occurs. For example: ```python x = 10 def display(): y = 20 print("Global x:", x) print("Local y:", y) display() print("Outside function:", x) ``` Here, `x` is a global variable because it is defined outside the function. The variable `y` is local because it is created inside `display()`. When Python encounters `x` inside the function, it searches the local scope first. Since no local `x` exists, Python searches the global scope and finds `x = 10`. The name `y`, however, exists only in the local scope of `display()` and cannot normally be