Computing · Secondary 3 · Programming with Python · Semester 1

Scope of Variables: Local vs. Global

Students will explore the concept of variable scope, understanding the difference between local and global variables and their accessibility.

• MOE Syllabus Outcomes
• MOE: Programming - S3

About This Topic

Variable scope defines where variables can be accessed in a Python program. Secondary 3 students distinguish local variables, which exist only within a function or block, from global variables, available throughout the module. They predict program outputs by tracing variable access and justify using parameters over globals to promote clean, modular code. This aligns with MOE standards for programming, emphasizing functions and data flow in Semester 1.

In the broader computing curriculum, scope concepts strengthen procedural programming skills and prepare students for object-oriented approaches. Students recognize that improper scope leads to errors like UnboundLocalError, fostering debugging habits essential for larger projects. They also weigh trade-offs: globals suit constants, while locals encapsulate data, reducing bugs in collaborative code.

Active learning shines here because students experiment directly in Python environments. Pair programming to modify code and observe scope errors makes abstract rules concrete. Predicting outputs before running code, then verifying, builds prediction skills and reveals misconceptions instantly.

Key Questions

1. Differentiate between local and global variables in terms of their accessibility.
2. Predict the output of a program involving both local and global variables.
3. Justify when it is appropriate to use a global variable versus passing parameters.

Learning Objectives

• Compare the accessibility of local and global variables within a Python program.
• Predict the output of Python code snippets that utilize both local and global variables.
• Analyze scenarios to justify the choice between using global variables and passing parameters to functions.
• Identify potential errors, such as UnboundLocalError, that arise from incorrect variable scope management.

Before You Start

Introduction to Functions

Why: Students need to understand what functions are and how they execute before learning about variables confined within them.

Basic Python Syntax and Data Types

Why: Students must be familiar with declaring and assigning values to variables to understand scope.

Key Vocabulary

Variable Scope	The region or context within a program where a variable is recognized and can be accessed.
Local Variable	A variable declared inside a function or block, accessible only within that specific function or block.
Global Variable	A variable declared outside of any function, accessible from anywhere within the program module.
Function Scope	The scope that limits a variable's accessibility to the function in which it is defined.

Watch Out for These Misconceptions

Common Misconception

All variables created in a program are global and accessible everywhere.

What to Teach Instead

Local variables vanish after the function ends, causing NameError if accessed outside. Pair prediction activities help students trace execution step-by-step, visualizing scope boundaries and correcting overgeneralized views.

Common Misconception

Using the global keyword inside a function always makes a local variable global.

What to Teach Instead

It links to an existing global, but assigning without it creates a local. Hands-on rewriting tasks reveal this nuance, as students test and compare outputs to build precise mental models.

Common Misconception

Global variables are better because they avoid passing parameters.

What to Teach Instead

Globals cause side effects and hard-to-track changes. Group debates on rewritten code highlight modularity benefits, shifting preferences toward parameters through real error experiences.

Active Learning Ideas

Code Prediction Challenge: Scope Hunt

Provide printed code snippets with local and global variables. Students predict outputs in pairs, discuss access rules, then test in Python IDLE. Debrief as a class on surprises.

30 min·Pairs

Debugging Relay: Fix Scope Errors

Divide class into small groups. Each group gets buggy code with scope issues. They fix one error, pass to next group. Final groups run and explain fixes.

40 min·Small Groups

Parameter vs Global Debate: Rewrite Functions

Give functions using globals. In small groups, rewrite with parameters, test both versions. Groups present pros and cons to class.

35 min·Small Groups

Scope Visualizer: Draw and Code

Individually sketch variable lifetimes on paper, then code matching programs. Share sketches in pairs to check understanding before running.

25 min·Individual

Real-World Connections

• Software developers building a customer relationship management (CRM) system must carefully manage variable scope. For instance, a variable storing a customer's ID might be global to all modules accessing customer data, while a temporary variable used only for calculating a discount would be local to the discount calculation function.
• Game developers use scope to control game state. A variable representing the player's score might be global, accessible by various game elements like score displays and achievement trackers, whereas a variable for a temporary power-up effect would be local to the function that manages that specific power-up's duration.

Assessment Ideas

Quick Check

Present students with 2-3 short Python code snippets involving both local and global variables. Ask them to write down the predicted output for each snippet and briefly explain their reasoning, focusing on variable accessibility.

Discussion Prompt

Pose the scenario: 'Imagine you are building a simple calculator program. When would it be more appropriate to use a global variable for a value like PI, and when would it be better to pass a number to be squared as a parameter to a squaring function?' Facilitate a class discussion on the trade-offs.

Exit Ticket

On an index card, have students define 'local variable' and 'global variable' in their own words. Then, ask them to write one sentence explaining a situation where using a global variable might lead to a bug.

Frequently Asked Questions

What is the difference between local and global variables in Python?

Local variables are defined inside a function and accessible only there, limiting their scope to avoid unintended changes. Global variables, declared outside functions or with the global keyword, are accessible program-wide. Students master this by predicting outputs in code challenges, which reveals access rules clearly and prepares them for complex programs.

When should you use global variables versus passing parameters?

Use globals sparingly for constants like PI or program-wide settings. Prefer parameters for function inputs to keep code modular and testable. Justification activities help students evaluate: parameters prevent hidden dependencies, making code easier to debug and reuse in MOE projects.

How can active learning help teach variable scope?

Active approaches like pair prediction and debugging relays engage students in running code, observing errors firsthand. They trace variable lifetimes collaboratively, turning abstract rules into tangible experiences. This builds confidence in predicting outputs and justifies design choices, aligning with inquiry-based MOE computing.

How do students predict program output with mixed scopes?

Trace execution line-by-line: check if a variable is local first, then global. Practice with snippets in IDLE confirms predictions. Common pitfalls like shadowed globals emerge, and class discussions refine strategies for reliable output forecasting in assessments.