AI & Machine Learning Roadmap

Master data processing, modeling, and deep learning algorithms.

Overall Progress0%

Python for Data Science

Explanation

Python for Data Science is the craft of turning raw, messy data into something you can reason about: loading it, inspecting it, cleaning it, transforming it, and summarizing it. Python became the standard tool for this because its ecosystem — NumPy for numerical arrays, Pandas for tabular data, and Matplotlib for plotting — makes each step concise and readable. This lesson builds the foundations in two layers. First, the core Python data structures and functions you use every day. Second, the ideas those libraries are built on: arrays versus lists, vectorization, DataFrames versus Series, selecting and filtering, and handling missing data. Along the way you will think about data quality, not just syntax. The running mental model is a workflow: Raw Data → Load → Inspect → Clean → Transform → Summarize → Analyze.

Why Python for Data Work

Readable syntax makes data logic easy to review and reproduce.
A rich ecosystem (NumPy, Pandas, Matplotlib, scikit-learn) covers the whole pipeline.
Interactive workflows let you explore data step by step.
It is free and runs almost everywhere.

The Data Workflow

Raw Data

↓

Load

↓

Inspect

↓

Clean

↓

Transform

↓

Summarize

↓

Analyze

Every data task follows the same shape: get the data in, look at it, fix it, reshape it, reduce it, and draw conclusions. Skipping "inspect" is the most common way to waste hours on a wrong assumption.

Core Python Data Structures

Structure	Ordered?	Mutable?	Use for
list	Yes	Yes	Ordered sequences of items
tuple	Yes	No	Fixed, immutable records
dict	No (insertion)	Yes	Lookups by key
set	No	Yes	Unique membership and deduplication

Lists vs Tuples

Use a list when the collection may grow or change.
Use a tuple when the value should not change (like a fixed record or row).
Tuples can be dictionary keys; lists cannot.

Dictionaries and Sets

A dict maps keys to values — ideal for labeled records and counting.
A set holds unique values — ideal for deduplication and membership tests.
Both give fast lookups compared to scanning a list.

Iteration and Functions

Iteration (for loops, comprehensions) processes each record in turn.
Functions package reusable transformations: load, clean, summarize.
Small, named functions make a workflow reproducible.

Arrays vs Python Lists

	Python list	NumPy array
Element type	Any (mixed)	One numeric type
Speed	Fast for small data	Fast for large numeric data
Operations	Per-element loops	Vectorized, whole-array ops
Memory	Overhead per element	Compact, contiguous

Vectorization

Vectorization applies an operation to an entire array at once instead of looping element by element. It is faster because the work happens in optimized compiled code, and clearer because the code expresses "add 1 to every value" directly.

Loops: `for i in range(n): a[i] = a[i] + 1`.
Vectorized: `a = a + 1` (the whole array at once).
Why it matters: the same logic runs orders of magnitude faster on large data.

NumPy Arrays (Conceptual)

An ndarray is a multidimensional grid of numbers with a fixed shape.
Shape describes dimensions, e.g. (3, 4) is 3 rows by 4 columns.
Arrays support vectorized arithmetic, slicing, and aggregation.

Pandas: Series and DataFrames

Object	What it is	Analogy
Series	One labeled column	A single column of a spreadsheet
DataFrame	A table of labeled columns	The whole spreadsheet

A DataFrame has rows and columns. Each column is a Series. Most data work is selecting, filtering, and transforming those columns.

Selecting and Filtering Data

Select a column by name; select rows by condition.
Filtering means "keep only the rows where a condition is true".
Combining conditions (AND/OR) narrows the subset you care about.

Missing Data and Cleaning

Missing values are common; first detect them, then decide.
Options: drop the row, fill with a sensible value, or keep as missing.
The right choice depends on why data is missing.

Summary Statistics and Data Quality

Mean, median, min, max, and count summarize a column.
Mean is sensitive to outliers; median is more robust.
Check types, ranges, and duplicates before trusting a summary.

Reproducible Workflows

Write the steps as code, not as manual edits.
Keep raw data untouched; produce cleaned data as a new file.
A reproducible pipeline gives the same result every run.

Syntax

Standard-library data toolspython

1import csv2import statistics3from collections import Counter4 5rows = [["name", "age"], ["Ada", "32"], ["Ben", ""], ["Cleo", "29"]]6reader = csv.reader(rows)7next(reader)  # skip header8 9ages = []10for name, age in reader:11    if age:  # skip missing values12        ages.append(int(age))13 14print("mean:", statistics.mean(ages))15print("cities:", Counter(["Accra", "Accra", "Tema"]))

csv, statistics, and collections are in the standard library. This shows the same ideas — load, clean, summarize — without NumPy/Pandas.

Examples

Choosing the right structure

Match the task to the data structure.

python

1names = ["Ada", "Ben", "Cleo"]            # list: ordered, mutable2point = (3.0, 4.0)                        # tuple: fixed record3scores = {"Ada": 92, "Ben": 87}           # dict: lookup by key4cities = {"Accra", "Tema", "Kumasi"}      # set: unique values

Output

(each structure fits a different job)

Vectorization idea (NumPy, conceptual)

The same operation written with a loop vs vectorized.

python

1# loop (what you avoid on large data)2for i in range(len(a)):3    a[i] = a[i] + 14 5# vectorized (NumPy)6a = a + 1

Output

(the vectorized form is concise and much faster)

Key Takeaways

The data workflow is load → inspect → clean → transform → summarize → analyze.
Choose structures by task: lists for sequences, dicts for lookups, sets for uniqueness.
NumPy arrays enable vectorization; Pandas gives labeled Series and DataFrames.
Inspect data, handle missing values, and reason about quality before trusting summaries.
The median is more robust to outliers than the mean.
Write reproducible pipelines as code, never manual edits.

Next →Math for ML