Module 1 Lesson: Data Analysis Mindset and Notebook Workflow

Let us begin

Data analysis does not start with code. It starts with a question.

If someone says, "Analyze course data", that is not enough. We do not yet know what to look for. We do not know which rows matter. We do not know which columns are useful. We do not know what answer would help.

A better starting point is:

> Which learner activities are connected with steady course progress, and where should the academy improve the learner experience?

This is still broad, but now we have direction. We are looking at learner activity, progress, and possible improvements.

In this course, we will learn Python tools. But the deeper skill is this: make every data decision visible.

What a data question does

A data question gives shape to the work.

It tells us:

• what we want to understand;
• which data may help;
• what kind of summary or chart may be useful;
• what the answer can support;
• what the data cannot prove.

Weak question:

> What is happening in the data?

Stronger question:

> How does weekly practice time differ between learners who complete a module and learners who pause before completing it?

The stronger question names a measure, a group, and a comparison.

Rows and columns

Before code, always ask:

> What does one row represent?

This is called the unit of analysis.

Examples:

• one learner;
• one enrolment;
• one activity event;
• one course;
• one support ticket;
• one week of activity.

If we misunderstand the row meaning, every summary can become wrong.

For example, if one row is an activity event, then counting rows counts events. It does not count learners. One active learner may create many event rows.

Columns usually play different roles:

• Measures are numbers we summarize, such as minutes spent or rating.
• Dimensions are groups or labels, such as course level or activity type.
• Keys connect tables, such as learner_id or course_id.
• Dates help place records in time.
• Notes or metadata explain context.

Data moves through stages

A real analysis should not treat the first file as final truth.

Think of four stages:

1. Raw data: the original file supplied to the project.
2. Cleaned data: the file after errors, types, missing values, and labels are handled.
3. Analysis data: the version shaped for summaries and charts.
4. Final evidence: the tables, charts, and written findings used in the report.

Do not overwrite raw data. Keep it as evidence.

A clean notebook structure

A notebook should tell a story, but it should also rerun like a program.

Use this simple structure:

1. Title and question.
2. Setup and imports.
3. Load data.
4. Inspect data.
5. Record data dictionary notes.
6. Clean and validate.
7. Analyze with tables.
8. Visualize.
9. Interpret.
10. State limits and next steps.

At the start of the course, you may not fill every section. That is fine. The habit matters.

Safe data

For this course, use only supplied synthetic or rights-cleared data.

Do not use:

• real learner data;
• customer records;
• payment information;
• health information;
• employer files;
• private messages;
• passwords, tokens, or secret keys.

Learning analysis does not need unsafe data.

Write a limitation early

A limitation is not a failure. It is honesty.

Before you analyze, write one thing the data cannot prove.

Example:

> This dataset can show patterns in learner activity, but it cannot prove that one activity caused completion.

That sentence protects the analysis from overclaiming.

Mini worked example

Topic:

> Course engagement.

Weak question:

> Are learners active?

Better question:

> How does weekly practice time change during the first four weeks of a course?

Unit of analysis:

> One learner-week.

Possible measures:

• practice_minutes;
• quiz_attempts;
• lessons_completed.

Possible dimensions:

• course_name;
• week_number;
• starting_skill.

Known limit:

> Practice time may be recorded only when the learner is logged in, so offline study is not visible.

That is enough to begin.

Takeaway

Good analysis is not only code. It is a chain of visible choices. In the next module, we start using NumPy to learn array thinking, numeric summaries, and vectorized operations.