Why scope matters in Python - Quick Recap

Recall & Review

beginner

What is scope in programming?

Scope is the area in a program where a variable or function is accessible or can be used.

beginner

Why does scope matter when writing code?

Scope helps prevent mistakes by controlling where variables can be seen and changed, making programs easier to understand and fix.

intermediate

What happens if two variables have the same name but different scopes?

They are treated as separate variables. The program uses the one in the closest scope to where it is called.

beginner

How does scope help in real life, like in a kitchen?

Just like you keep spices in one shelf and utensils in another, scope keeps variables organized so you don’t mix things up.

beginner

What is the difference between local and global scope?

Local scope means a variable is only available inside a function. Global scope means it can be used anywhere in the program.

What does local scope mean?

A Variable is stored permanently on disk

B Variable can be used anywhere in the program

C Variable is only accessible inside a function or block

D Variable is shared between different programs

Local scope means the variable exists only inside the function or block where it is defined.

Why is it good to limit variable scope?

A To use more memory

B To avoid accidentally changing variables in other parts of the program

C To make the program run faster

D To make variables global

Limiting scope helps prevent bugs by keeping variables from interfering with each other.

If a variable is defined inside a function, where can it be used?

A Only inside that function

B Anywhere in the program

C Only outside the function

D In other programs

Variables inside a function have local scope and cannot be used outside it.

What happens if you have two variables with the same name in different scopes?

A They are treated as different variables

B The program crashes

C They combine into one variable

D The first variable is deleted

Variables with the same name in different scopes do not interfere; the closest one is used.

Which scope allows a variable to be used anywhere in the program?

A Local scope

B Temporary scope

C Block scope

D Global scope

Global scope means the variable is accessible throughout the entire program.

Explain in your own words why scope is important when writing programs.

Think about how knowing where a variable can be used helps avoid mistakes.

Describe the difference between local and global scope with a simple example.

Imagine a variable you can only use inside a room versus one you can use in the whole house.

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'