Data Structures Sprint

Overview

Today students will build and explain small Python programs that use dictionaries, control flow, functions/scope, and basic file I/O. The work will be organized as a short “mini-tech write-up,” aligning with Common Core writing standards for organizing complex information with formatting and graphics when helpful.

Learning intentions

Students will be able to:

• Use dictionaries, sets, tuples, and stacks/queues appropriately in Python tasks.
• Write nested loops and comprehensions to solve multi-step problems.
• Define functions with parameters and return values, using correct scope rules.
• Read from and write to a CSV/text file to persist results.
• Organize and explain their program’s logic in a clear, structured write-up with headings and a simple table/figure.

Success criteria

• I can choose the right data structure and justify it using a clear efficiency or purpose claim (e.g., fast lookup in dictionaries).
• I can produce correct output using if/else and nested control flow.
• I can write a function that takes inputs, returns a result, and avoids scope mistakes.
• I can create a short write-up with headings and a table that accurately summarizes my approach and results.

Curriculum links

• W.9-10.2a and WHST.9-10.2a: Introduce a topic and organize complex ideas with headings and useful formatting.
• WHST.9-10.4: Produce clear writing with appropriate organization, development, and style for a technical audience.
• WHST.9-10.2c: Use varied transitions to connect sections and clarify relationships among ideas.

Lesson structure (120 minutes)

1. 0–10 min · Hook (scenario + quick demo). Teacher shows a short “problem” prompt: “Track how many times each word appears in three user-entered sentences.” Students discuss in pairs which data structure seems best for counting and why.

2. 10–25 min · Direct teach: Data structures + control flow. Teacher models building a dictionary counter, then extends to a set to show unique words and a tuple to store (word, count); teacher draws attention to nested loops and comprehensions. Students annotate a provided code template by circling where decisions happen (if/else) and where loops process elements.

3. 25–45 min · Guided coding (structures). Teacher runs a live example of dictionary lookup (O(1)-style reasoning claim) and contrasts it with a list search; students implement the same logic in their own environment using a starter file:

• Part A: build a dictionary from a list of tokens
• Part B: create a set of unique words
• Part C: produce a list of tuples for output sorting Teacher checks correctness by circulating and asking each pair for one “choice explanation” sentence.

4. 45–65 min · Functions & scope mini-lab. Teacher introduces a function signature and return value using a local variable example (e.g., def count_words(text):), then demonstrates a scope mistake (using an undefined global). Students complete a worksheet: write a function header, implement the body, and add a return so results can be reused in later steps.

5. 65–85 min · File I/O build. Teacher demonstrates writing results to a CSV (header + rows) and reading them back to display a top-N summary. Students:

• Read a provided input_sentences.csv (or input.txt)
• Generate counts using their function
• Write results.csv
• Read results.csv again and print a formatted summary

6. 85–105 min · Technical write-up drafting (structured, assessed). Teacher provides a one-page template with headings:

• “Topic & Goal”
• “Data Structures Used (and Why)” (includes a small table: structure → purpose → one efficiency/purpose claim)
• “Program Logic” (how loops/conditionals work)
• “Functions & Scope” (1–2 sentences: parameters, return, local vs global)
• “Results & File Output” Students draft their write-up, using at least 3 transitions (e.g., “First,” “Next,” “As a result,” “However”).

7. 105–118 min · Share-out + quick revision. Teacher prompts pairs to swap write-ups and check for clarity: headings present, table accurate, logic explained, and file steps described. Students revise one weak section based on peer feedback.

8. 118–120 min · Exit ticket (individual, 2 minutes). Students answer: “Which data structure did you use for counting, and what is one reason it was efficient or appropriate?” (1–2 sentences.)

Resources

• Python environment (IDE or notebook) for 2 students
• Starter code template for dictionary counting, CSV writing/reading
• Worksheet for function signature, scope notes, and completion prompts
• Provided input file: input_sentences.csv or input.txt
• Output check: expected format for results.csv
• One-page writing template with headings and a table scaffold
• Timer for coding blocks and revision window

Assessment

• Formative: teacher spot-checks dictionary correctness, function return usage, and whether file output can be re-read correctly
• Formative: during share-out, peer checklist for headings, table accuracy, and explanation of logic/data structure choice
• Exit ticket: data structure choice + justification in 1–2 sentences

Differentiation

• Support: provide sentence starters for the “Why this data structure?” section (e.g., “I used a dictionary because…” “Lookup is fast when…” “I used a set to…”).
• Support: offer a completed example of a function outline with blanks only in the loop and return lines.
• Extension (for the faster student): add a “top-N” filter using sorting and show how changing N affects output; include one extra row in the table comparing list vs dictionary for lookup.
• EAL/SEN: allow the write-up to include a simple diagram/flow description (e.g., “Read → Parse → Count → Write → Read back”) to support organization and comprehension.

Assessment alignment note for teaching (quick reminder)

Focus students on writing structure and cohesion: headings, a table/figure, and clear connections among sections (goal → data structures → logic → functions/scope → file results). This supports the Common Core writing standards targeted today.