Enclosing scope in Python - Mini Project: Build & Apply

Understanding Enclosing Scope with Nested Functions

📖 Scenario: Imagine you are creating a simple calculator that can add a fixed number to any input number. You want to keep the fixed number hidden inside the calculator so it cannot be changed directly.

🎯 Goal: Build a nested function where the inner function uses a number from the outer function's scope (enclosing scope) to add to its input.

📋 What You'll Learn

Create an outer function called make_adder that takes one parameter fixed_number.

Inside make_adder, define an inner function called adder that takes one parameter num.

The inner function adder should return the sum of num and fixed_number from the enclosing scope.

The outer function make_adder should return the inner function adder.

Create a variable add_five by calling make_adder(5).

Call add_five(10) and print the result.

💡 Why This Matters

🌍 Real World

Enclosing scope is used in real-world programming to create functions that remember settings or data without using global variables.

💼 Career

Understanding enclosing scope helps in writing clean, reusable code and is important for jobs involving Python programming, especially in web development and data science.

1

Create the outer function make_adder with parameter fixed_number

Write a function called make_adder that takes one parameter called fixed_number. Inside it, define an inner function called adder that takes one parameter called num. Do not write the inner function body yet.

Python

def make_adder(fixed_number):
    def adder(num):
        # Your code here

Hint

Remember to indent the inner function adder inside make_adder.

2

Make the inner function adder return the sum of num and fixed_number

Inside the inner function adder, write a return statement that adds num and fixed_number from the enclosing scope.

Python

def make_adder(fixed_number):
    def adder(num):
        # Your code here

Hint

Use return num + fixed_number to add the inner parameter and the outer parameter.

3

Make make_adder return the inner function adder

Add a return statement at the end of make_adder that returns the inner function adder (without calling it).

Python

def make_adder(fixed_number):
    def adder(num):
        return num + fixed_number
    # Your code here

Hint

Return the inner function adder itself, not the result of calling it.

4

Create add_five and print the result of add_five(10)

Create a variable called add_five by calling make_adder(5). Then call add_five(10) and print the result.

Python

def make_adder(fixed_number):
    def adder(num):
        return num + fixed_number
    return adder

# Your code here

Hint

Calling add_five(10) should add 5 to 10 and print 15.

Practice

1. What does enclosing scope mean in Python functions?

easy

A. Inner functions can access variables from outer functions

B. Variables inside a function are always global

C. Functions cannot access variables outside their own block

D. Only global variables can be used inside functions

Solution

1. Step 1: Understand function nesting

   In Python, functions can be defined inside other functions, creating an inner and outer function relationship.

2. Step 2: Access rules for variables

   Inner functions can use variables defined in their outer functions, which is called the enclosing scope.

3. Final Answer:

   Inner functions can access variables from outer functions -> Option A

4. Quick Check:

   Enclosing scope = inner function accesses outer variables [OK]

Hint: Inner functions see outer variables unless shadowed [OK]

Common Mistakes:

• Thinking all variables inside functions are global
• Believing inner functions cannot use outer variables
• Confusing local and global scopes

2. Which of the following is the correct syntax to modify an outer variable inside an inner function?

easy

A. Just assign the variable directly without any keyword

B. Use global keyword inside the inner function

C. Use nonlocal keyword inside the inner function

D. Use outer keyword inside the inner function

Solution

1. Step 1: Understand variable modification rules

   To change a variable from an outer (enclosing) function inside an inner function, Python requires the nonlocal keyword.

2. Step 2: Differentiate from global

   global is for variables at the module level, not enclosing functions.

3. Final Answer:

   Use nonlocal keyword inside the inner function -> Option C

4. Quick Check:

   Modify outer variable = use nonlocal [OK]

Hint: Change outer function vars with 'nonlocal' inside inner function [OK]

Common Mistakes:

• Using 'global' instead of 'nonlocal' for outer function variables
• Trying to assign without any keyword causing UnboundLocalError
• Using a non-existent 'outer' keyword

3. What is the output of this code?

def outer():
    x = 5
    def inner():
        return x + 3
    return inner()
print(outer())

medium

A. 3

B. 5

C. Error

D. 8

Solution

1. Step 1: Trace variable usage

   Variable x is defined in outer() as 5. The inner function returns x + 3, which is 8.

2. Step 2: Function call and return

   outer() calls inner() and returns its result, so print(outer()) prints 8.

3. Final Answer:

   8 -> Option D

4. Quick Check:

   Inner uses outer x=5, returns 5+3=8 [OK]

Hint: Inner function can read outer variables directly [OK]

Common Mistakes:

• Expecting an error due to variable scope
• Confusing inner return value with outer variable
• Thinking inner cannot access outer variables

4. What is wrong with this code?

def outer():
    x = 10
    def inner():
        x = x + 5
        return x
    return inner()
print(outer())

medium

A. It will print 15

B. UnboundLocalError because inner tries to modify x without nonlocal

C. SyntaxError due to wrong indentation

D. NameError because x is not defined anywhere

Solution

1. Step 1: Analyze variable assignment in inner()

   Inside inner(), x = x + 5 tries to modify x. Python treats x as local but it is used before assignment.

2. Step 2: Understand error cause

   This causes an UnboundLocalError because x is referenced before assignment locally. The fix is to declare nonlocal x.

3. Final Answer:

   UnboundLocalError because inner tries to modify x without nonlocal -> Option B

4. Quick Check:

   Modify outer var inside inner needs nonlocal [OK]

Hint: Assigning outer var inside inner needs 'nonlocal' keyword [OK]

Common Mistakes:

• Assuming it prints 15 without error
• Confusing UnboundLocalError with NameError
• Ignoring the need for 'nonlocal' when modifying outer vars

5. Consider this code:

def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment
c = counter()
print(c())
print(c())
print(c())

What will be the output?

hard

A. [1, 2, 3]

B. [0, 1, 2]

C. [1, 1, 1]

D. Error due to missing global keyword

Solution

1. Step 1: Understand closure with nonlocal

   The counter() function returns increment(), which modifies count using nonlocal. This keeps count persistent across calls.

2. Step 2: Trace calls to c()

   Each call to c() increases count by 1 and returns it. So outputs are 1, then 2, then 3.

3. Final Answer:

   [1, 2, 3] -> Option A

4. Quick Check:

   Closure with nonlocal increments count each call [OK]

Hint: Use nonlocal to keep and update outer variable state [OK]

Common Mistakes:

• Expecting count to reset each call
• Confusing nonlocal with global
• Thinking it will raise an error without global