Python Functions and Scope Questions and Answers

Question 1

A developer writes a function to log messages, intending for each call to start with a fresh list of tags unless specified. However, they notice that tags from previous calls are persisting. What is the most likely cause of this bug?

```python
def log_message(message, tags=[]):
    tags.append('INFO')
    print(f"{message}: {tags}")

log_message("System start")
log_message("User login")
```

Accepted Answer

A mutable object (a list) is used as a default argument, which is evaluated only once when the function is defined.

Answer

In Python, default function arguments are evaluated once at the time the function is defined, not each time it is called. When a mutable object like a list or dictionary is used as a default argument, all calls to the function that don't provide a value for that argument will share the *same* object. In this case, the list `tags` is created once, and each subsequent call to `log_message` appends to the same list, leading to the accumulation of tags.

Question 2

In Python's scope resolution, what is the LEGB rule?

Accepted Answer

The sequence Python follows to find a variable: Local, Enclosing, Global, Built-in.

Answer

The LEGB rule dictates the order in which Python searches for a name (variable, function, etc.). It checks scopes in the following order: 1. **L**ocal: The current function's scope. 2. **E**nclosing: The scope of any enclosing functions (in nested functions). 3. **G**lobal: The top-level module scope. 4. **B**uilt-in: The scope containing Python's built-in names like `print()` and `len()`.

Question 3

What is the primary purpose of the `nonlocal` keyword in Python?

Accepted Answer

To allow an inner function to modify a variable from its nearest enclosing (but non-global) scope.

Answer

The `nonlocal` keyword is used inside nested functions. It indicates that a variable is not local to the inner function but belongs to the nearest enclosing function's scope. This allows the inner function to rebind or modify that variable directly, rather than creating a new local variable with the same name.

Question 4

Consider the following code. What will be the output?

```python
def multiplier_factory(n):
    def multiplier(x):
        return x * n
    return multiplier

double = multiplier_factory(2)
triple = multiplier_factory(3)

print(double(5), triple(5))
```

Accepted Answer

10 15

Answer

This code demonstrates a closure. The `multiplier_factory` function returns another function, `multiplier`. The returned `multiplier` function "remembers" the value of `n` from the environment where it was created. When `multiplier_factory(2)` is called, it creates a function that remembers `n=2`. When `multiplier_factory(3)` is called, it creates a different function that remembers `n=3`. Therefore, `double(5)` returns 10 (5*2) and `triple(5)` returns 15 (5*3).

Question 5

A programmer needs to modify a global variable from within a function. Which of the following code snippets correctly accomplishes this?

Accepted Answer

```python
count = 0
def increment():
    global count
    count += 1
```

Answer

To modify a variable in the global scope from within a function, you must explicitly declare your intent using the `global` keyword. Without it, Python would treat `count` as a new local variable within the `increment` function and raise an `UnboundLocalError` because it's being referenced before assignment. The `nonlocal` keyword is for modifying variables in an enclosing scope, not the global scope.

Python Practice Test

Python Practice Test

Python Functions and Scope Questions and Answers