# COURSE BLUEPRINT: Python for Data Analysis (Complete Beginner) **INPUT STATUS: ADJUSTED** — 18 total hours (6 weeks × 3 hrs) is workable for a complete beginner *only* if scope is held tightly to programming fundamentals + pandas basics. Statistics, machine learning, and advanced visualization are explicitly excluded — there isn't time to teach them without sacrificing depth on the core skills. This blueprint treats "data analysis" as: load → explore → clean → aggregate → visualize → communicate, using Python + pandas + matplotlib only. --- ## LEARNER PROFILE TABLE | Dimension | Detail | |-----------|--------| | Target learner | Adult upskilling for a career pivot or job requirement (e.g., marketing/ops professional told "learn some Python"); no prior coding exposure | | Prior knowledge assumed | Basic spreadsheet literacy (rows/columns, what a CSV is); comfortable navigating a web browser and installing/using an account-based tool | | Learning environment | Self-paced async with weekly live-coding-style video walkthroughs; light cohort check-ins optional | | Typical motivation | Job requirement or career-pivot pressure — wants visible, usable skill fast, not theory | | Most common misconception at this skill level | "Learning Python" and "doing data analysis" are the same linear skill — i.e., they believe they must master general-purpose programming (functions, OOP, algorithms) before they're "allowed" to touch a real dataset | | How this course design counters that misconception | Real CSV data is introduced in Module 3 (week 3 of 6), deliberately *before* the learner has "finished" programming fundamentals — proving early that minimal Python is enough to start doing real analysis | **Hard prerequisites (3–5):** 1. Can create a free Google account — *self-check:* able to log into Gmail or Google Drive without help. 2. Can download and locate a file in a folder on their own computer — *self-check:* can find a downloaded PDF in their Downloads folder without searching for it. 3. Basic familiarity with rows/columns (e.g., from Excel/Google Sheets) — *self-check:* can identify "this is a row" vs "this is a column" in any spreadsheet shown to them. 4. Comfortable typing at a normal pace and copy-pasting text — *self-check:* can copy a sentence from one document and paste it into another within 10 seconds. --- ## LEARNING OUTCOMES TABLE | # | Outcome | Bloom's Level | Delivering Module | |---|---------|---------------|--------------------| | 1 | By the end of this course, learners will be able to **explain** the purpose of variables, data types, and the assignment operator in a Python script | Understand | Module 1 | | 2 | Learners will be able to **describe** the structural difference between a pandas Series and a DataFrame | Understand | Module 3 | | 3 | Learners will be able to **write** Python scripts using loops and conditionals to filter and count items in a list | Apply | Module 2 | | 4 | Learners will be able to **load and clean** a real-world CSV dataset by handling missing values, duplicates, and incorrect data types | Apply | Module 4 | | 5 | Learners will be able to **analyze** a cleaned dataset using groupby and aggregation functions to identify trends across categories | Analyze | Module 5 | | 6 | Learners will be able to **construct** labeled, titled bar and line charts from a pandas DataFrame | Apply | Module 6 | | 7 | Learners will be able to **evaluate** which of several chart options most clearly communicates a given finding to a non-technical audience | Evaluate | Module 6 | | 8 | Learners will be able to **create** a complete exploratory data analysis notebook that synthesizes cleaning, aggregation, and visualization into stakeholder-ready findings | Create | Module 6 (Capstone) | --- ## MODULE BLOCKS ### MODULE 1 — Python Fundamentals & Environment Setup | Duration: 3 hrs | Theme: Foundations **Objective:** Set up a working Python environment and write basic scripts using variables, data types, and print statements. | Lesson | Topic | Teaching Method | Duration | |--------|-------|------------------|----------| | 1 | Setting up Google Colab (no local install) | simulation/live coding | 45 min | | 2 | Variables and data types: int, float, str, bool | worked example | 60 min | | 3 | Operators, `print()`, and `input()` | live coding | 45 min | | 4 | Practice: build a unit-conversion mini script | exercise | 30 min | **Formative Assessment:** Learner writes and runs a 5-line script that converts a temperature from Celsius to Fahrenheit using a variable and `print()`, then submits a screenshot of the output. **Common Confusion at This Stage:** Believing `=` means mathematical equality (as in algebra) rather than assignment, leading to confusion when `x = x + 1` "doesn't make sense." **Resolution:** Lesson 2 explicitly contrasts `=` (assignment) against `==` (equality) side-by-side with worked examples before any conditional logic is introduced in Module 2. **Dependency:** ENTRY POINT --- ### MODULE 2 — Data Structures & Control Flow | Duration: 3 hrs | Theme: Logic **Objective:** Apply loops, conditionals, and core data structures (lists, dictionaries) to process simple data collections. | Lesson | Topic | Teaching Method | Duration | |--------|-------|------------------|----------| | 1 | Lists and indexing (including negative indices) | worked example | 45 min | | 2 | Dictionaries: key-value pairs | worked example | 30 min | | 3 | Conditionals: `if` / `elif` / `else` | live coding | 45 min | | 4 | Loops: `for` and `while` over lists | live coding | 45 min | | 5 | Practice: filter a list of numbers above a threshold | exercise | 15 min | **Formative Assessment:** Given a list of 10 sample sales figures, the learner writes a `for` loop with an `if` condition that counts how many exceed a given threshold, and submits the code plus output. **Common Confusion at This Stage:** Off-by-one errors from misunderstanding 0-indexing, and forgetting the colon + indentation required to define a code block. **Resolution:** Lesson 1 dedicates explicit practice to indexing edge cases (first element, last element, negative indices) before loops are introduced in Lesson 4, so indexing is solid before it's combined with new syntax. **Dependency:** Module 1 --- ### MODULE 3 — Introduction to Pandas: Loading & Exploring Data | Duration: 3 hrs | Theme: Structure **Objective:** Load real-world datasets into pandas DataFrames and apply exploratory methods to describe their structure. | Lesson | Topic | Teaching Method | Duration | |--------|-------|------------------|----------| | 1 | What pandas is: Series vs. DataFrame | lecture | 30 min | | 2 | Loading a CSV with `read_csv()` | live coding | 45 min | | 3 | Exploring data: `.head()`, `.info()`, `.describe()`, `.shape` | worked example | 60 min | | 4 | Selecting rows/columns with `.loc` / `.iloc` | live coding | 45 min | **Formative Assessment:** Learner loads a provided retail sales CSV and submits the output of `.info()` and `.describe()`, plus one written sentence interpreting what the dataset contains. **Common Confusion at This Stage:** Treating a DataFrame like a "picture of a spreadsheet" and trying to edit values by typing directly into the output, rather than via methods. **Resolution:** Lesson 3's worked example deliberately demonstrates calling `.head()` versus attempting a direct edit on the printed output, showing concretely why the latter has no effect. **Dependency:** Module 2 --- ### MODULE 4 — Data Cleaning & Transformation | Duration: 3 hrs | Theme: Cleaning **Objective:** Clean a messy real-world dataset by handling missing values, duplicates, and incorrect data types. | Lesson | Topic | Teaching Method | Duration | |--------|-------|------------------|----------| | 1 | Identifying missing data with `.isnull().sum()` | worked example | 30 min | | 2 | Handling missing values: `dropna()` vs. `fillna()` | live coding | 45 min | | 3 | Removing duplicates and fixing types with `.astype()` | live coding | 45 min | | 4 | Renaming columns and filtering rows with conditions | live coding | 45 min | | 5 | Practice: clean a messy dataset end-to-end | case study | 15 min | **Formative Assessment:** Learner receives a deliberately messy CSV (missing values, duplicate rows, wrong dtypes) and must produce a cleaned version, submitting before/after `.info()` outputs. **Common Confusion at This Stage:** Assuming `dropna()` permanently changes the original DataFrame in place, rather than understanding it returns a new object unless reassigned. **Resolution:** Lesson 2 explicitly prints the DataFrame before and after an un-reassigned `dropna()` call to show the original is unchanged, then demonstrates the correct reassignment pattern. **Dependency:** Module 3 --- ### MODULE 5 — Analysis & Aggregation | Duration: 3 hrs | Theme: Insight **Objective:** Analyze a cleaned dataset using grouping, sorting, and aggregation methods to identify patterns and trends. | Lesson | Topic | Teaching Method | Duration | |--------|-------|------------------|----------| | 1 | Sorting with `.sort_values()` | live coding | 30 min | | 2 | `.groupby()` fundamentals | worked example | 60 min | | 3 | Aggregation functions (`sum`, `mean`, `count`) chained to groupby | live coding | 45 min | | 4 | Creating new calculated columns | live coding | 45 min | **Formative Assessment:** Using the cleaned dataset from Module 4, the learner groups sales by category and writes one sentence identifying which category performed best, citing the specific number. **Common Confusion at This Stage:** Expecting `.groupby()` alone to display a result, not realizing it returns an unevaluated grouping object until an aggregation function is chained to it. **Resolution:** Lesson 2's worked example deliberately shows the "empty-looking" groupby object first, then demonstrates how chaining `.mean()` produces the expected result. **Dependency:** Module 4 --- ### MODULE 6 — Visualization & Capstone Synthesis | Duration: 3 hrs | Theme: Synthesis **Objective:** Create clear, labeled visualizations of analyzed data and evaluate which presentation best communicates a finding. | Lesson | Topic | Teaching Method | Duration | |--------|-------|------------------|----------| | 1 | Plotting with pandas `.plot()`: bar and line charts | live coding | 30 min | | 2 | Customizing matplotlib charts: titles, axis labels, colors | live coding | 45 min | | 3 | Choosing the right chart type for the data story | discussion | 30 min | | 4 | Capstone work session: building the full analysis notebook | independent work | 75 min | **Formative Assessment:** Learner produces one bar chart and one line chart from the dataset, each with a title and labeled axes, plus a one-sentence caption explaining what each chart shows. **Common Confusion at This Stage:** Believing more colors, chart types, or decoration automatically make a chart "better," resulting in cluttered visuals that obscure the finding. **Resolution:** Lesson 3's discussion walks through paired "good vs. busy" chart examples built from the same data, asking the learner to identify which communicates the finding faster — and why. **Dependency:** Module 5 --- ## ASSESSMENT ARCHITECTURE TABLE | Assessment | Type | Timing | Bloom's Level Tested | Graded / Ungraded | |------------|------|--------|------------------------|---------------------| | Pre-course readiness check | Diagnostic | Before Module 1 | N/A | Ungraded | | Temperature converter script | Formative | After Module 1 | Understand/Apply | Ungraded | | List filter-and-count exercise | Formative | After Module 2 | Apply | Ungraded | | Dataset exploration summary | Formative | After Module 3 | Understand/Apply | Ungraded | | Messy dataset cleanup task | Formative | After Module 4 | Apply | Ungraded | | Groupby analysis writeup | Formative | After Module 5 | Analyze | Ungraded | | Midpoint integration check (Modules 1–3 combined) | Summative (minor) | Midpoint | Apply/Analyze | Graded | | Chart pair (bar + line) | Formative | After Module 6 | Apply | Ungraded | | Capstone analysis notebook | Summative | End of course | Evaluate/Create | Graded | **Progression gate:** A learner should repeat a module rather than advance if they cannot independently reproduce that module's formative assessment task on a new, unseen dataset variant without copying code directly from the lesson notebook — e.g., if after Module 4 they cannot identify and handle missing values in a *different* CSV without referring back to the original cleaning script line-by-line. --- ## CAPSTONE **Brief:** The learner selects one of three provided real-world datasets (retail sales, public health statistics, or local weather data) and produces a complete exploratory data analysis notebook that cleans the data, analyzes key patterns, and visualizes findings for a hypothetical small-business or community stakeholder. **Real-world deliverable:** A published Jupyter/Colab notebook titled "Data Analysis Report," containing cleaned data, at least 3 distinct analytical findings with supporting code, and 2 labeled, captioned visualizations — formatted as if delivered to a non-technical stakeholder. **Modules synthesized:** Module 3 (loading & exploring), Module 4 (cleaning), Module 5 (aggregation & analysis), Module 6 (visualization). **Evaluation rubric:** | Criterion | Excellent (4) | Proficient (3) | Developing (2) | Beginning (1) | Weight | |-----------|----------------|------------------|-------------------|-------------------|--------| | Data cleaning accuracy | All missing values, duplicates, and dtype issues correctly identified and resolved with justified method | Minor cleaning gaps that don't affect downstream analysis | Some cleaning steps missing or incorrectly applied, causing minor analysis errors | Data largely uncleaned; analysis built on flawed data | 25% | | Analytical insight | 3+ findings, each specific, numerically supported, and tied to a clear "so what" for the stakeholder | 3 findings present and numerically supported, but "so what" is generic | Findings present but vague or not clearly tied to numbers | Findings missing, incorrect, or unsupported by the data | 25% | | Visualization clarity | Both charts correctly chosen for the data type, clearly labeled, and easy to interpret in seconds | Charts labeled and correct but require some effort to interpret | Charts present but missing labels/titles or a poor chart-type choice | Charts missing, broken, or unreadable | 20% | | Code functionality | Notebook runs top-to-bottom with no errors; code is reasonably organized | Notebook runs with only trivial fixes needed | Notebook requires moderate debugging to run | Notebook does not run / major errors uncorrected | 15% | | Communication for non-technical audience | Every finding is stated in plain language with a clear implication for the stakeholder | Most findings are in plain language | Findings mix technical jargon with plain language inconsistently | Findings written as code/technical output only | 15% | **Stretch version:** Learner merges two of the three provided datasets (e.g., weather data with retail sales) using `pd.merge()` to test a hypothesis about correlation between them — requiring Evaluate-level judgment about which join type and merge key are appropriate, since the "right" choice isn't given. **Common failure mode in capstone submissions:** Learners often execute the technical steps correctly in isolation but fail to connect findings to a stakeholder-relevant conclusion (e.g., reporting "Category A has the highest mean sales" without stating what action that implies). The brief explicitly requires a one-sentence "so what" for each finding to force this synthesis rather than letting technical correctness substitute for communication. --- ## RESOURCE MATRIX | Resource | Type | Justification | Where in Course | |----------|------|----------------|-------------------| | "Python for Everybody" course materials (Dr. Chuck / freeCodeCamp) | video/book | Built specifically for learners with zero coding background, slower pace than most Python intros | Modules 1–2 | | Official pandas "Getting Started" documentation | article | Canonical, always current, free — best reference once syntax questions arise mid-exercise | Modules 3–6 | | Kaggle "Pandas" micro-course | interactive tutorial | Bite-sized, hands-on exercises that match this course's pacing and reinforce the same methods | Throughout | | Kaggle public datasets (retail/sales sample sets) | data/tool | Free, real-world, appropriately small and clean enough for beginners not to drown in edge cases | Modules 3–6, Capstone | | Matplotlib "Quick Start" guide | article | Minimal official reference covering exactly the customization options taught in Module 6 | Module 6 | ## TOOL MATRIX | Tool | Purpose | Setup Complexity | When Introduced | |------|---------|---------------------|--------------------| | Google Colab | Cloud-based notebook environment, no local install | Low — just needs a Google account | Module 1 | | pandas & matplotlib | Data loading, cleaning, analysis, and plotting | Low — pre-installed in Colab | Module 3 | | Kaggle account | Dataset access and supplementary micro-course practice | Low — free signup | Module 3 | **Post-course community:** r/learnpython on Reddit for beginner-friendly troubleshooting, plus Kaggle's discussion forums for continued dataset practice and feedback from other learners working with the same public datasets. --- ## DESIGN INTEGRITY CHECK | Check | Status | Note | |-------|--------|------| | Every learning outcome uses a Bloom's measurable verb | ✅ PASS | explain, describe, write, load and clean, analyze, construct, evaluate, create | | Every outcome is traceable to at least one module | ✅ PASS | All 8 outcomes mapped 1:1 or more to modules | | Module count fits the stated duration realistically | ✅ PASS | 6 modules × 3 hrs = 18 hrs matches 6 weeks × 3 hrs/week exactly | | No module's formative assessment is a generic multiple-choice quiz | ✅ PASS | All assessments are applied coding/analysis tasks with submitted output | | Capstone synthesizes ≥ 3 modules | ✅ PASS | Synthesizes 4 (Modules 3–6) | | Hard prerequisites are self-checkable by the learner | ✅ PASS | Each prerequisite includes a concrete self-check action | | The stated misconception is directly countered by a design choice | ✅ PASS | Real CSV data deliberately introduced in week 3, before "programming" feels complete |