Python for Machine Learning

Meet the four tools every ML project leans on — NumPy, pandas, scikit-learn, and matplotlib — and learn the one workflow (split → fit → predict → score) that ties them together.

Learn Python for Machine Learning in our free AI & Machine Learning course — a beginner-friendly interactive lesson with worked examples, a practice exercise…

Part of the free AI & Machine Learning course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

🛠️ Real-World Analogy: A Workshop and Its Tools

Picture building a piece of furniture in a workshop. You don't reach for one magic machine — you reach for the right tool at the right step . The Python ML stack works the same way: four specialised tools, each doing one job well, used in a fixed order.

📐 NumPy — the workbench

Fast arrays and matrix maths. Every other tool stacks its work on this surface.

📊 pandas — the parts bins

Labelled tables (DataFrames) to load, clean, filter, and sort your raw materials.

🧪 scikit-learn — the power tools

The algorithms that do the cutting and joining: fit, predict, score — same handles on every one.

📈 matplotlib — the tape measure

Charts to check your work before and after — it measures and inspects, it doesn't build.

Keep this picture in mind: pandas prepares the materials, NumPy holds the numbers, scikit-learn does the work, matplotlib checks it.

1 NumPy Arrays — The Container for the Numbers

A NumPy array is a grid of numbers that all share one type, stored together in memory. That layout is why maths on an array is fast: one operation runs across every element at once — called a vectorised operation — instead of you writing a Python loop.

Two words you'll meet constantly: a 1D array is a vector (a single row of values), and a 2D array is a matrix (a table where rows are samples and columns are features ). The array's .shape tells you how many of each.

Worked example — read the comments, every line states its result:

2 pandas DataFrames — Your Data as a Table

Real data rarely arrives as a tidy grid of one type — it has named columns like age , city , and price , mixing numbers, text, and true/false. A DataFrame is pandas' answer: a labelled table you can program, like a spreadsheet with code.

The move you'll repeat in every project is splitting that table into X (the feature columns the model learns from) and y (the single target column it learns to predict). Everything after this lesson assumes you can do that split.

Notice df[df["temp_c"] > 12] : you build a column of True/False values, then use it to keep only the matching rows. That boolean-filter trick is the single most-used pandas operation.

3 The scikit-learn Pattern — fit / predict / score

scikit-learn's superpower is consistency : a decision tree, a linear model, and a support-vector machine all expose the same three methods. Learn them once and you can drive any model.

• .fit(X, y) — train : learn the patterns linking features X to labels y .
• .predict(X) — use : guess labels for new, unseen rows.
• .score(X, y) — check : for a classifier, the fraction of predictions that were correct (accuracy).

Two supporting pieces make those three honest. train_test_split holds back a slice of data the model never trains on, so the score is earned, not memorised. A Pipeline glues a transformer (something that reshapes the data, like a scaler that re-scales features) to the model, so the transformer is fitted on the training data only — never on the test data.

Worked example — the full pattern in one place:

4 Under the Hood — A Prediction Is Just Arithmetic

np.dot and .score sound advanced, but underneath they are plain arithmetic you can write without any library. Seeing that demystifies the whole stack — and it runs in the editor right now.

A single linear prediction is a dot product : multiply each feature by its weight, sum the results, and add a constant bias . That's all np.dot(features, weights) + bias does.

📈 Where matplotlib Fits

matplotlib (and Seaborn, which is built on top of it) is for seeing your data — it never trains a model. You reach for it at two moments: before modelling to explore patterns, and after to inspect how the model did.

Keep the boundary clear: pandas/NumPy hold the data, scikit-learn models it, matplotlib pictures it. A chart never changes a prediction — it changes your understanding.

! Common Errors (And How to Fix Them)

These four trip up almost every beginner. Spotting them early saves hours.

Scaling or fitting using the whole dataset before splitting:

✅ Fix: split first, then fit on train only (a Pipeline does this for you):

Scoring on the same rows the model trained on:

ValueError: Found input variables with inconsistent numbers of samples — X and y have different lengths, or a 1D array was passed where 2D was expected:

✅ Fix: check shapes line up, and reshape a single feature to 2D:

❌ Scaling after the split, but fitting the scaler on test too

You split correctly, then re-fit the scaler on the test set:

✅ Fix: fit once on train; only transform the test set:

📋 Quick Reference

Call

Does

np.array([1,2,3])

Make an array (vector / matrix)

arr.shape

Rows & columns: (samples, features)

arr * 2, arr + arr2

Vectorised maths, no loop

np.dot(a, b)

Dot / matrix product

arr.mean(), arr.std()

Summary statistics

pd.DataFrame(data)

Build a labelled table

df["col"]

Select one column (a Series)

df[df["x"] > 0]

Filter rows by a condition

df.groupby("g").mean()

Aggregate by group

df.describe()

Quick stats for every column

train_test_split(X, y)

Hold back a test set

model.fit(X_train, y_train)

Train the model

model.predict(X_test)

Guess labels for new data

model.score(X_test, y_test)

Accuracy on held-out data

make_pipeline(scaler, model)

Chain transformer + model, no leakage

❓ Frequently Asked Questions

🎯 Mini-Challenge: Train, Predict, Score (Plain Python)

Put the whole workflow together — no libraries. Your "model" is a simple threshold rule, and you'll score it by hand, exactly the way scikit-learn's .score() works. The starter below is a comment outline only.

Lesson 2 complete — you know the ML toolkit and the workflow!

You can describe a NumPy array and its shape, split a DataFrame into X and y, drive any scikit-learn model with fit / predict / score, split data to avoid leakage, and place matplotlib correctly in the pipeline. You even computed a prediction and an accuracy by hand — so none of it is a black box.

🚀 Up next: Data Preprocessing — turn messy, real-world data into clean features a model can actually learn from.

Practice quiz

Continue this course

• Previous: Introduction to AI & ML
• Next: Data Preprocessing