What are the 4 scope rules in python for loop

What are the 4 scope rules in python for loop

The four scope rules in Python for loops refer to how variables are accessed and modified within the loop. Understanding these rules is crucial for writing efficient and correct code. Here's a detailed explanation of each rule:

Rule 1: The Loop Variable is Local

In Python, the loop variable (usually denoted as i, j, or k) is local to the loop and is only accessible within its scope. This means that once the loop finishes executing, the loop variable is discarded, and any attempts to access it will result in a NameError.

For example:

for i in range(5):
print(i)
print(i)  # NameError: name 'i' is not defined

Rule 2: The Global Scope

Variables declared outside the loop, such as global variables or constants, are accessible within the loop. This means that any changes made to these variables within the loop will be reflected globally.

For example:

x = 10
for i in range(5):
x += 1
print(x)
print(x)  # Output: 15

Rule 3: The Non-Local Scope

Variables declared within an outer scope, but not necessarily within the loop itself, are accessible within the loop. This includes variables declared within a parent function or class.

For example:

def outer():
x = 10
def inner():
for i in range(5):
print(x)
inner()
outer()

Rule 4: The Enclosing Scope

Variables declared within the same scope as the loop, such as variables declared within the function or class containing the loop, are accessible within the loop.

For example:

class MyClass:
def init(self):
self.x = 10
def my_method(self):
for i in range(5):
print(self.x)
my_obj = MyClass()
my_obj.my_method()  # Output: 10, 10, 10, 10, 10

In conclusion, Python's scope rules for loops are crucial to understanding how variables are accessed and modified within the loop. By following these rules, you can write efficient, correct, and maintainable code.

Remember:

What are the 4 scope rules in python w3schools

I'll respond in English as per your request.

In Python, a scope refers to the region of code where a variable is defined and can be accessed. There are four main types of scopes in Python, which are governed by the LEGB rule (Local, Enclosing, Global, Built-in). Here's an explanation of each scope:

For example:

def my_function():
x = 10  # local scope
print(x)  # prints 10
my_function()
print(x)  # NameError: name 'x' is not defined

As you can see, trying to access x outside the function results in a NameError.

For example:

def outer_function():
x = 5   # enclosing scope
def inner_function():
print(x)  # prints 5
inner_function()

In this example, the inner_function has access to the x variable defined in the outer_function, but not outside it.

For example:

x = 10  # global scope
def my_function():
print(x)  # prints 10
my_function()
print(x)  # prints 10

In this case, x is a global variable and can be accessed from within the function or outside it.

For example:

def my_function():
print(len("hello"))  # prints 5
my_function()

Here, the len() function is accessed from within the function, which is part of the built-in scope.

When you try to access a variable with the same name in multiple scopes, Python follows the LEGB rule:

Understanding these four scopes is crucial for writing efficient, readable, and maintainable code in Python.