Why scope matters in Python - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code with variable scope?

Look at the code below. What will it print?

Python

x = 10

def func():
    x = 5
    print(x)

func()
print(x)

A 10\n5

B 10\n10

C 5\n5

D 5\n10

💡 Hint

Remember, variables inside a function are local unless declared global.

The x inside func() is local and set to 5, so print(x) inside prints 5. Outside, x is still 10.

❓ Predict Output

intermediate

What error does this code raise due to scope?

What error will this code produce?

Python

def func():
    print(x)
    x = 3

func()

A UnboundLocalError

B NameError

C SyntaxError

D No error, prints 3

💡 Hint

Python treats variables assigned in a function as local, even if used before assignment.

Because x is assigned inside func(), Python treats it as local. The print(x) tries to access it before assignment, causing UnboundLocalError.

❓ Predict Output

advanced

What is the output when modifying a global variable inside a function?

What will this code print?

Python

count = 0

def increment():
    global count
    count += 1

increment()
increment()
print(count)

A 2

B 0

C NameError

D 1

💡 Hint

Using global allows modifying the variable outside the function.

The global keyword tells Python to use the global count. Each call to increment() adds 1, so after two calls, count is 2.

❓ Predict Output

advanced

What is the output of nested function scope?

What will this code print?

Python

def outer():
    x = 'outer'
    def inner():
        nonlocal x
        x = 'inner'
    inner()
    print(x)

outer()

A SyntaxError

B inner

C outer

D NameError

💡 Hint

nonlocal lets inner functions modify variables in the nearest enclosing scope.

The nonlocal keyword allows inner() to change x in outer(). So print(x) prints 'inner'.

🧠 Conceptual

expert

Why does this code produce an error related to scope?

Consider this code:

def f():
    print(a)
    a = 5
f()

Why does it raise an error?

A Because <code>a</code> is not defined anywhere globally

B Because <code>print</code> cannot be used inside functions

C Because <code>a</code> is used before assignment in the local scope

D Because Python does not allow variable assignment inside functions

💡 Hint

Think about how Python decides if a variable is local or global.

Python sees the assignment a = 5 inside f() and treats a as local. The print(a) tries to access this local a before it is assigned, causing an UnboundLocalError.

Practice

1. What does the term scope mean in Python programming?

easy

A. The area where a variable can be accessed or used

B. The size of a variable in memory

C. The speed at which a program runs

D. The type of a variable

Solution

1. Step 1: Understand variable accessibility

   Scope defines where a variable can be accessed in the code.

2. Step 2: Differentiate scope from other concepts

   Scope is not about size, speed, or type but about accessibility.

3. Final Answer:

   The area where a variable can be accessed or used -> Option A

4. Quick Check:

   Scope = variable accessibility [OK]

Hint: Scope means where variables can be used in code [OK]

Common Mistakes:

• Confusing scope with variable size
• Thinking scope affects program speed
• Mixing scope with variable type

2. Which of the following is the correct way to declare a global variable inside a function?

easy

A. global = x

B. def global x

C. global x

D. var global x

Solution

1. Step 1: Recall Python syntax for global variables

   To modify a global variable inside a function, use the keyword global followed by the variable name.

2. Step 2: Check each option's syntax

   Only global x is valid Python syntax; others are incorrect.

3. Final Answer:

   global x -> Option C

4. Quick Check:

   Use 'global' keyword correctly [OK]

Hint: Use 'global' keyword before variable name inside functions [OK]

Common Mistakes:

• Using 'def' or 'var' with global
• Assigning 'global = x' which is invalid
• Forgetting to declare global before use

3. What will be the output of this code?

count = 5

def increment():
    count = 10
    print(count)

increment()
print(count)

medium

A. 10\n5

B. 10\n10

C. 5\n5

D. 5\n10

Solution

1. Step 1: Analyze variable scope inside the function

   Inside increment(), count = 10 creates a local variable named count that shadows the global one.

2. Step 2: Check print statements

   The first print inside the function prints local count (10). The second print outside prints global count (5).

3. Final Answer:

   10 5 -> Option A

4. Quick Check:

   Local shadows global inside function [OK]

Hint: Local variables inside functions don't change globals unless declared [OK]

Common Mistakes:

• Assuming global variable changes inside function without 'global'
• Confusing which 'count' is printed
• Expecting both prints to show 10

4. Find the error in this code related to variable scope:

def add_one():
    x += 1
    print(x)

x = 5
add_one()

medium

A. No error, output will be 6

B. SyntaxError due to missing colon

C. NameError because x is not defined anywhere

D. UnboundLocalError because x is used before assignment inside function

Solution

1. Step 1: Understand variable modification inside function

   Inside add_one(), x += 1 tries to modify x locally, but x is not declared local or global.

2. Step 2: Identify error type

   Python raises UnboundLocalError because it thinks x is local but it's used before assignment.

3. Final Answer:

   UnboundLocalError because x is used before assignment inside function -> Option D

4. Quick Check:

   Modifying global without 'global' causes UnboundLocalError [OK]

Hint: Declare 'global x' to modify global variable inside function [OK]

Common Mistakes:

• Thinking it's a NameError
• Expecting code to print 6 without error
• Ignoring need for 'global' keyword

5. Given this code, what will be the output?

def outer():
    x = 'local'
    def inner():
        nonlocal x
        x = 'nonlocal'
        print('inner:', x)
    inner()
    print('outer:', x)

outer()

hard

A. inner: local\nouter: local

B. inner: nonlocal\nouter: nonlocal

C. inner: nonlocal\nouter: local

D. SyntaxError due to nonlocal usage

Solution

1. Step 1: Understand 'nonlocal' keyword effect

   The nonlocal keyword allows inner() to modify x defined in outer(), not create a new local variable.

2. Step 2: Trace print outputs

   inner() prints inner: nonlocal after changing x. Then outer() prints outer: nonlocal showing the updated value.

3. Final Answer:

   inner: nonlocal outer: nonlocal -> Option B

4. Quick Check:

   'nonlocal' changes outer function variable [OK]

Hint: Use 'nonlocal' to modify outer function variables inside nested functions [OK]

Common Mistakes:

• Thinking 'nonlocal' causes syntax error
• Assuming inner creates a new local variable
• Expecting outer's x to remain 'local'