Enrol to start learning
Reading is open to everyone. Enrolling is free, and it is what unlocks the audio lessons, practice tests and progress tracking.
3.2. LEGB Rule
Interactive Audio Lesson
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Today, we are going to discuss the LEGB rule in Python, which is crucial for understanding how variable names are resolved. Can anyone guess what each letter stands for?
I think 'L' could stand for Local variables?
Correct, 'L' is for Local! Local variables are defined within the current function. Now, what about 'E'?
'E' could be Enclosing, right? Like in nested functions?
Exactly! Enclosing scope refers to variables in surrounding functions. Let's move on to 'G'!
Is 'G' for Global variables that are defined outside of functions?
Right again! Global variables can be accessed from anywhere in the module, unless shadowed by local variables. Finally, what about 'B'?
'B' stands for Built-in variables, like print or len?
Perfect! Built-in scopes include names that Python has predefined.
To summarize, the LEGB rule prioritizes Local first, then Enclosing, then Global, and last, Built-in.
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Let’s look at an example. If I define x = 20 globally and then within a function, I redefine x = 10. What happens when I print x within that function?
We would see 10 printed, since it’s local now.
Exactly! The local variable overshadows the global one. What if we want to access the global variable x inside the function?
We could use the global keyword to specify that we mean the global variable.
Correct! Using global x allows us to modify the global variable inside the function. Let’s try implementing a small code snippet together!
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free accountLet’s talk about some pitfalls. What do you think happens if we declare a variable 'x' inside a nested function without the 'nonlocal' keyword?
We might get an error or it’d create a new local variable instead?
Correct! Without 'nonlocal,' the inner function creates its own 'x' rather than accessing the enclosing 'x'. When is 'nonlocal' useful?
When you want to modify a variable from an outer, non-global scope?
Exactly! Just remember to use 'global' for global variables and 'nonlocal' for enclosing scope. It helps avoid unintended behavior!
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free accountWhy is understanding LEGB key to writing clean code?
So we don’t overwrite important variables by mistake?
Absolutely! It ensures our code is safe from potential bugs due to name clashes.
And using consistent naming helps too, right?
Yes, good variable naming conventions make a significant difference. Let's always try to make variable scopes clear to improve the readability of our code.
In summary, remember the LEGB order—this will help you clarify which variable you're accessing and make your code cleaner!
Overview
Short Summary
The LEGB rule describes the order in which Python resolves variable names, identifying scopes as Local, Enclosing, Global, and Built-in.
Medium Summary
Understanding the LEGB rule is essential for Python programmers, as it dictates how variable names are resolved based on their scope. Variables can be local to a function, global to the module, in enclosing functions, or predefined by Python itself, impacting how code behaves and preventing name clashes.
Detailed Summary
Detailed Summary
The LEGB rule is a foundational concept in Python programming that illustrates how variable names are resolved. This acronym stands for:
- Local: Variables defined within the current function or block.
- Enclosing: Variables in the local scope of enclosing functions if nested.
- Global: Variables defined at the top-level of the module or script.
- Built-in: Names that are preassigned in Python's built-in namespace, like
lenandprint.
Understanding the LEGB rule is crucial for effective coding practices in Python to avoid variable shadowing—where a local variable overshadows a global variable with the same name. This section will explore each of these scopes, illustrated with examples and best practices, aiding in writing clean, efficient, and error-free code.
Audio Book
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free accountPython resolves variable names using the LEGB rule:
Detailed Explanation
The LEGB rule is a fundamental concept in Python that dictates how the interpreter searches for variable names. LEGB stands for Local, Enclosing, Global, and Built-in, representing the order in which Python looks for the variable. If you create a variable with the same name in different scopes, Python prioritizes these scopes in that specific order. First, it checks the Local scope within the current function. If the variable isn't found there, it looks in any Enclosing functions that may exist. After that, it searches for the variable in the Global scope, which consists of variables defined at the top level of the script or module. Lastly, if the variable still hasn't been found, Python checks the Built-in scope for pre-defined names and functions.
Examples & Analogies
Imagine you are in a company (the Local scope) where each department (Enclosing scope) has its own team of employees. If you need to reference an employee named 'John,' you would first look in your department. If he is not there, you would then check the other teams in your department before asking someone from the headquarters (Global scope). Finally, if nobody named 'John' exists in your company, you might look in a directory of all professionals (Built-in scope) for more common contacts.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free account• L – Local • E – Enclosing • G – Global • B – Built-in
Detailed Explanation
Each component of the LEGB rule represents a different layer of variable access in Python. The Local scope (L) refers to variables defined within the currently executing function. The Enclosing scope (E) consists of variables in any enclosing (outer) function, which is only relevant for nested functions. The Global scope (G) contains variables defined at the top level of a script or module and can be accessed by all functions within that module. Lastly, the Built-in scope (B) includes pre-defined functions and names provided by Python, like print() or len().
Examples & Analogies
Think of a family gathering. The Local scope is the immediate family members in your household (like siblings), while the Enclosing scope consists of your extended family members who live nearby (like cousins). The Global scope is like your entire community where everyone knows each other, and the Built-in scope is akin to public figures known by everyone, such as celebrities or email providers like Gmail that you frequently use.
--
Key Concepts
Core takeaways and short definitions to help you quickly recall the key ideas from this section.
LEGB Rule: The order in which Python looks for variable names: Local, Enclosing, Global, Built-in.
Local Variables: These are defined within a function and cannot be accessed outside.
Global Variables: Variables defined outside of function scopes and can be accessed globally.
Enclosing Variables: These are accessible in nested functions from their enclosing function.
Built-in Variables: Predefined names in Python that are always available.
Examples
Step-by-step examples to apply the section's ideas and test your understanding.
Example of Local Variable:
def my_function():
x = 10 # Local variable
print(x)
my_function() # Outputs: 10
Example of Global Variable:
x = 20 # Global variable
def my_function():
print(x)
my_function() # Outputs: 20
Example showing Enclosing Scope:
def outer_function():
x = 30
def inner_function():
print(x) # Accessing x from outer_function
inner_function()
outer_function() # Outputs: 30
Example using nonlocal:
def outer_function():
x = 10
def inner_function():
nonlocal x
x += 5
print(x)
inner_function() # Outputs: 15
outer_function()
Memory Aids
Interactive tools to help you remember key concepts
Stories
Memory Tools
Flash Cards
Glossary
Local Scope
Variables defined within a function, only accessible inside that function.
Enclosing Scope
Variables in the local scope of enclosing functions when nested.
Global Scope
Variables defined at the top level of a script or module, accessible throughout.
Builtin Scope
Names preassigned in Python’s built-in namespace, like print or len.
global Keyword
A declaration inside a function to modify a global variable.
nonlocal Keyword
A declaration to modify a variable in an enclosing function scope.