Why scope matters in Python - Visual Breakdown

Concept Flow - Why scope matters

Start program

↓

Define variable x = 5

↓

Enter function

↓

Check if function uses global or local x

↓

Uses local x

↓

Local x created

↓

Function ends

↓

Print x outside function

↓

End program

This flow shows how variables inside and outside functions can be different because of scope, affecting which variable is used or changed.

Execution Sample

Python

x = 5

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

func()
print(x)

This code shows a variable x outside and inside a function, printing both to see how scope affects their values.

Execution Table

Step	Action	Variable x value	Output
1	Assign x = 5 globally	5
2	Define function func()	5
3	Call func()	5
4	Inside func(), assign local x = 10	10 (local)
5	Inside func(), print local x	10 (local)	10
6	func() ends, local x discarded	5 (global)
7	Print global x	5	5

💡 Program ends after printing global x; local x inside func() does not affect global x.

Variable Tracker

Variable	Start	After func() call	Final
x (global)	5	5	5
x (local in func)	N/A	10	N/A

Key Moments - 3 Insights

Why does the print inside the function show 10 but the print outside shows 5?

Inside the function, x is a new local variable set to 10 (see step 4 and 5 in execution_table). Outside, the global x remains 5 (step 7). They are different variables because of scope.

Does changing x inside the function change the global x?

No, because the x inside the function is local and separate from the global x. The global x stays unchanged (see variable_tracker and steps 6 and 7).

What happens to the local x after the function ends?

The local x is discarded after the function finishes (step 6). It only exists during the function call.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of x inside the function at step 4?

A 5

B 10

C Undefined

D None

💡 Hint

Check the 'Variable x value' column at step 4 in the execution_table.

At which step does the program print the global x value?

A Step 5

B Step 3

C Step 7

D Step 1

💡 Hint

Look for the step where output is '5' in the execution_table.

If the function did not assign x locally, what would the print inside func() show?

A 5

B 10

C Error

D Nothing

💡 Hint

Think about what variable x the function would use if no local assignment exists, referencing variable_tracker.

Concept Snapshot

Scope means where a variable exists and can be used.
Variables inside functions are local by default.
Local variables do not change global variables with the same name.
Changing a local variable does not affect the global one.
Understanding scope helps avoid bugs and confusion.

Full Transcript

This lesson shows why scope matters in Python. We start by assigning x = 5 globally. Then we define a function func() that assigns x = 10 locally and prints it. When we call func(), it prints 10 because it uses the local x. After func() ends, the local x disappears. Printing x outside the function shows 5, the global x unchanged. This shows local and global variables with the same name are different because of scope. Changing local x does not affect global x. Understanding this helps avoid mistakes when working with variables inside and outside functions.

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'