DEV Community: Ruqiya Arshad

Scope and LEGB: Collaboration in Python

Ruqiya Arshad — Sat, 24 Jan 2026 05:21:40 +0000

Scope in Python is an inner system of rules in a namespace that has variable visibility rules. Variable visibility means how the variable can be seen, referenced, or accessed. Before mentioning and discussing the rules, we should discuss the types of scope in the system.

Local Scope: is inside the function.
Global Scope: is present in the module.
Enclosing Scope: is present in the outer function and its inner nested functions.
Built-In Scope: is present in language-based designed functions.

Now prior to jumping to the sequence of LEGB, let’s discuss rules of scope first. These scope rules check where you can observe and use the variable:

Rule 1: The variable named inside a function cannot be used outside the function.

def citizen_identity():
    cnic_number = "35200-000000-1" #Local variable.
    print("The citizen identity card number is " + cnic_number + ".")
citizen_identity()#It prints only when below code line is removed.
                  #Output: "The citizen identity card number is 35200-000000-1."
print(cnic_number)#Error! as the local variable is used outside the function.
                  #Output: "NameError: name 'cnic_number' is not defined"

In the Rule 1 example, we see that when the local variable cnic_number is accessed globally by print outside the function, then it will give a NameError as shown in the code.
For better understanding, you can try the example in your code environment.

Rule 2: Global variables can be accessed inside a local scope and modified by using the “global” keyword.

cnic_number = "35200-000000-0" #Global variable

def citizen_identity():
    global cnic_number #Global keyword indicates that no new variable is declared with the same name.
    cnic_number = "35200-000000-1" #Modifying the global variable value at output.
    print("The citizen identity card number is " + cnic_number + ".")
citizen_identity()#Output: "The citizen identity card number is 35200-000000-1."

In the Rule 2 example, the global keyword concept is explained. In Python, when two variables exist with the same name, then they can cause confusion, and also the shadow effect occurs (explained in Rule 4). When we use the global keyword with the local variable cnic_number, then it tells the interpreter that no new variable is declared locally, or we are using the global variable inside the function whose value can also be modified there.

-Rule 3: Function-to-function, the local variables cannot be reached or accessed.

def citizen_identity():
    cnic_number = "35200-000000-1"
    print("The citizen identity card number is " + cnic_number + ".")
citizen_identity()

def citizen_nationality():
    user_input = input("Mention your nationality here. ") #The program works fine upto here.
    nationality = ("Pakistani", "Kuwaiti", "Saudi Arabian")
    if user_input in nationality:
        print(cnic_number) #Error! "NameError: name 'cnic_number' is not defined".
                           #Local variable from another function cannot be used.
    else:
        print("Metioned nationality is not in the list!")
citizen_nationality()

In the Rule 3 example, it explains the variable declared inside the local scope of one function cannot be accessed by another function's local scope. When in the first function citizen_identity(), the declared variable cnic_number is accessed by the other function named citizen_nationality(), then the runtime error occurs, as shown in the code block.

-Rule 4: Both global and local scopes can have the same variable names, but the local variable causes a shadowing effect, making the global variable inaccessible.

cnic_number = "35200-000000-0" 

def citizen_identity():
    cnic_number = "35200-000000-1" #Local variable treated here as a new variable.
    print("The citizen identity card number is " + cnic_number + ".")
citizen_identity()
print(cnic_number)#Output: 35200-000000-0
                  #This shows that the global variable value is not changed.

In the Rule 4 example, the shadowing effect of the local variable is explained. When both local and global have the same variable names, then the local variable value shadows the global variable.
When the print(cnic_number) statement is used inside the function, then it will print the value of the local variable as 35200-000000-1; however, when print(cnic_number) is used globally, then it prints 35200-000000-0.It shows that global value remains unchanged. To show the shadow effect on the global variable, let's reuse this code snippet as follows:

cnic_number = "35200-000000-0" 

def citizen_identity():
    cnic_number = "35200-000000-1" #Local variable treated here as a new variable.
    print("The citizen identity card number is " + cnic_number + ".")
citizen_identity() #Output: "The citizen identity number is 35200-000000-1"

In this code snippet we see that the local variable shadows the global variable value at the output. Instead of, global variable value, 35200-000000-0 the local variable value, 35200-000000-1 is printed at the output. Making it inaccessible.

How scope rules are implemented can only be understood by coding practice.

The question arises: why does the local scope have preference first, then the global scope? The answer lies in the LEGB sequence, which will be discussed now.

The LEGB sequence (Local, Enclosing, Global, Built-In) is a blueprint in Python that locates variables in the scopes of namespaces when referenced in the code. For a smooth LEGB search of variables, the scope rules should be followed while coding, or else the errors will occur in the runtime.
Let’s understand the LEGB sequence in a practical manner.

The below example explains the sequence in which LEGB (Local->Enclosing->Global->Built-In) searches for the referenced variables in all four scopes in Python. We will use the same code examples as above in this article but with a bit of change by adding a nested function in an enclosing scope. Point to keep in mind: LEGB search or lookup begins when the variable is referenced during execution because we often get confused at the variable declaration. And when LEGB finds the variable, it stops searching for that specific referenced variable, and then that variable is used.

cnic_number = "35200-000000-0" #global variable
def citizen_identity():
    cnic_number = "35200-000000-1" #local variable
    print("The citizen identity card number is " + cnic_number + ".") #LEGB search starts. Local(found)
citizen_identity()

print(cnic_number)#LEGB Lookup starts. Global(Found)

def citizen_nationality(): #enclosing scope (outer)
    user_input = input("Mention your nationality here...") #local to outermost enclosing scope
    nationality = ("Pakistani", "Kuwaiti", "Saudi Arabian")#local variable

    if user_input in nationality: #LEGB variable lookup.
        print(cnic_number)#global variable from the module level. Local(not found)->Enclosing(not active)->Global(found)
    else:
        print("Metioned nationality is not in the list!")

    def citizen_name(): #inner enclosing scope
        name_input = input("Mention your name...")#local variable
        print(name_input) # LEGB Lookup.Local(found)
        print(user_input) #non-local variable. LEGB Lookup. Enclosing(found)
    citizen_name()

citizen_nationality()

In the above code example, when the local variable is referenced inside the function, LEGB starts finding it first in the local scope. We need to remind ourselves every time that LEGB works in a sequence, but code structure also matters. If there is no local scope, then in the LEGB sequence, it simply is not active. Coming back to the example, when LEGB finds the referenced variable, cnic_number = 35200-000000-1, it stops and uses that variable to print it at runtime. Similarly, when a global variable is referenced, the LEGB search starts. As the first "local" and second priority scope, "enclosing scope," simply do not exist in the code structure, so it moves towards the third priority, "global scope," where it is found. LEGB stops and uses that variable.

In the second part of code,
The enclosing scope citizen_nationality() has a nested function, citizen_name(). Now, in this code structure, we will see how the LEGB sequence works for enclosing scope. It searches for referenced variables from the innermost to outermost enclosing scope. As we see that in a nested innermost function when the local variable of the enclosing outermost function user_input is referenced (which is non-local to the innermost function), then the LEGB lookup begins and it is found in the enclosing scope.

To understand the LEGB sequence, the small exercise will help you. Try to design a code structure that includes LEGB search for built-in scope. (Hint: Try using len())

AI code maintenance: from code maintenance to training AI on user-based code datasets.

Ruqiya Arshad — Mon, 01 Sep 2025 18:14:55 +0000

Are we humans incorporating AI in our software work field, as it should be? We are happy with how we model AI in coding. However, what about maintenance? In our work environment, why is it a must to keep up with code? The way we are using AI coding tools as newcomers in the programming world can show our recklessness, as these tools serve everything on a plate? We are still learning how to optimize AI. Can we build better datasets on which these coding tools are modeled? What if, due to unintentional bias, a programmer loses his signature coding style?

Most of the part that constitutes programming is "maintenance of code." Positionally, code is not something at rest; it revolves around adaptation to a new environment, evolution. Have you ever seen a messed-up code and had a brief moment of "What is going on?" For this, we need to understand what a messed-up code and a good code feel like. The journey to maintaining code begins with writing clean code and making it adaptive to developers who will cross-check your code. Imagine, in code review, they are not able to understand what we have written. It makes no sense to them. These mistakes of ours can cause companies to requit at the production line. And ultimately, everything has to shut down.

One of the examples of software destruction and bad maintenance is Therac-25. Back in the 1980s, in Canada, the Therac-25 Radiation Therapy Machine, with its former versions (Therac-6 and Therac-20), was designed to treat tumors in cancer patients. Ascribed to technical negligence in its latest version, Therac-25, it caused casualties among patients under treatment. What errors or glitches caused it are not informed by the company? Even so, if we study its case, it is clear that patients died due to autonomous overradiation. Here arises a question: why was it not under human supervision? Have machines reached human-consciousness level?

Today we are living in the great era of AI hype turned into reality. Where we see non-developers building apps sensed by vibe-coding. Andrej Karpathy, who introduced the term "vibe-coding," said in a tweet:

There's a new kind of coding I call "vibe coding", where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's possible because the LLMs (e.g. Cursor Composer w Sonnet) are getting too good. Also I just talk to Composer with SuperWhisper…

— Andrej Karpathy (@karpathy) February 2, 2025

It should be noted that it is a must to keep AI on track before good vibes turn into bad vibes. Putatively, everything seems to be fine in the AI era. By degrees, what can happen in the future, related to problems with speeding AI, will not be something new. Maintenance is still required at the coding side of AI. We need to train AI in a way that it will sense bad code. For that, the person who is training AI should himself practice how to write clean code?

What is clean code? and why it is must? There are many books on this perspective. One of the books that is under my reading list is "Clean Code: A Handbook of Agile Software Craftsmanship" by Robert C. Martin. What I understood from the introduction of clean code in this book is that we as programmers/coders need a code sense to transform bad code to clean code. How to attain that code sense is a struggle. It is discipline and a sense of cleanliness that should be present in us, or else we should acquire it. Only then can we differentiate between good and bad code.

How to train AI that can sense bad code? The smart tech developers are building AI tools that are great in assisting us while coding, but they can surely make newbies to programming lazy. If we are the ones who enjoy coding, then we will use these tools as they should be used. But when we are stuck on errors or bugs, then we will simply go for autonomous suggestions by these tools rather than understanding those autonomous suggestions. We just want to rush to reach the top, where we can get monetary assets from our product. First thing first, we do not need to cope with the fast-notion trends. Good innovation takes time and patience.

Training AI should be done by data crunching. As we have bulky data, we miss quality over quantity. We need to refine our data. The database to train AI should be language conventions rather than training it on crude datasets based on users' code. As every coder has its signature style of coding and solving a problem, it should not be generalized by such a training approach of coding tools. At the end I also want to mention that to steer AI in the direction of replacing humans as a sci-fi motive will be biased to the human community.