Describe the order Python executes code, the job of print(), and what a variable is (slides 2–3).

• Top to bottom — Python code runs top to bottom, one line at a time.
• print() — displays output; the deck calls it the very first command every Python programmer learns.
• Variable — a name that stores a value so you can reuse it later (name = "Ayesha", age = 20, gpa = 3.8).
• No type declaration — you don't declare a type; Python figures it out automatically.

Name the four types on slide 4, match each to its example value, and explain how to confirm a value's type.

• Every value has a type — the deck lists four: int, float, str, bool.
• Slide examples — 10 → int, 3.14 → float, "hello" → str, True → bool.
• type() — checks what kind of value you're working with; the slide's print line outputs <class 'int'> <class 'float'> <class 'str'> <class 'bool'>.

Explain what a list and a dictionary each store, how you get items out of each, and when the deck says each is useful (slides 5–6).

• List — stores an ordered collection of items, and it can change (it's mutable).
• Index from 0 — fruits[0] is the first item ("apple"); len(fruits) gives how many items — 4 after fruits.append("mango").
• Dictionary — stores key-value pairs; great for labeled data like a student record.
• Look up by key — student["name"] returns "Ayesha"; student["gpa"] = 3.8 adds a new key-value pair.

Explain what a function is, why the deck says to use one, and what the greet example returns (slide 7).

• Function — a reusable block of code you can call by name.
• Why — functions keep code organized and avoid repeating yourself.
• Slide example — def greet(name): / return f"Hello, {name}!"; print(greet("Data Science Class")) outputs Hello, Data Science Class!.

Explain when each loop repeats and trace the output of both slide-8 loops.

• for loop — repeats an action once for each item in a collection; for fruit in fruits: prints apple, banana, cherry, mango.
• while loop — repeats an action as long as a condition stays true; while i < 3: prints count: 0, count: 1, count: 2.
• i += 1 — the line inside the while loop that changes i on each pass.

Describe what NumPy arrays do well, NumPy's role under other libraries, and the slide-9 results.

• Arrays — NumPy arrays store numbers efficiently and support fast math operations.
• Foundation — the deck calls NumPy the foundation that pandas and most ML libraries are built on.
• Slide example — import numpy as np; arr = np.array([1, 2, 3, 4, 5]) → arr.mean() = 3.0, arr.sum() = 15.

Explain what a DataFrame is, what pandas is used for, and how read_csv() and head() start a project (slides 10–11).

• DataFrame — how pandas stores data; think of it as a spreadsheet in Python.
• pandas' job — the core tool for loading, exploring, and cleaning real datasets.
• read_csv() — loads a CSV file straight into a DataFrame; usually the very first line of code in a real project.
• df.head() — shows the first 5 rows; students.csv has 10 rows and 5 columns (name, age, major, score, passed).

Explain filtering and sorting, write the slide code for each, and state the results (slides 12–13).

• Filtering — keeps only the rows that match a condition; it's how you ask a dataset a question.
• df[df["score"] > 80] — returns 4 rows: Ali 88, Sara 92, Noor 95, Emma 82.
• sort_values() — reorders rows by a column, ascending or descending; ascending=False puts Noor (95) first and Yuki (45) last.
• Why sort — useful for finding the top (or bottom) performers at a glance.

Explain aggregation, list the deck's examples, and state the students.csv results (slide 14).

• Aggregation — summarizes a column into a single number: mean, sum, max, count.
• Results — df["score"].mean() → 72.6; df["score"].max() → 95.
• describe() — gives a full statistical summary in one line (on the run: count, mean, std, min, 25%, 50%, 75%, max for age, score, passed).

Explain what groupby() does and state the average score per major (slide 15).

• groupby() — splits data into groups, then applies a calculation to each group.
• Question it answers — "what's the average score, per major?"
• Result — df.groupby("major")["score"].mean() → Business 59.67 · CS 72.5 · Math 85.67.

Define features and label, identify both in students.csv, and explain why a supervised model needs both (slides 16–17).

• Features (X) — the input columns a model learns patterns from; here X = df[["age", "score"]].
• Choosing features — the deck calls it one of the most important parts of the job.
• Label / target (y) — the target column, what you're trying to predict; here y = df["passed"].
• Both required — every supervised model needs both features and a label to learn from; uppercase X, lowercase y.

Explain why feature selection matters and how the deck starts it, with the slide-18 results.

• Feature selection — not every column helps a model; feature selection keeps the useful ones.
• Starting point — check which features correlate with the label.
• Result — df[["age", "score", "passed"]].corr()["passed"] → score 0.844 · age 0.611 · passed 1.0 (itself).

Explain why encoding is needed and how slide 19 encodes "major" and attaches it to X.

• Why encode — models need numbers, not text; encoding converts categories into numeric columns.
• pd.get_dummies() — a quick, common way to one-hot encode a column.
• prefix="major" — produces the columns major_Business, major_CS, major_Math.
• pd.concat([X, major_encoded], axis=1) — attaches the new columns to X → 5 columns: age, score, major_Business, major_CS, major_Math.

Contrast the two techniques, name the tool for each, and identify which columns the slides transform (slides 20–21).

• Scaling — puts features on a comparable range using their mean and standard deviation; tool: StandardScaler.
• Normalization — rescales features into a fixed [0, 1] range; tool: MinMaxScaler.
• Same pattern — both from sklearn.preprocessing: create the object, then call fit_transform() on X[["age", "score"]].
• Only age and score — the major_ dummy columns are left out of both calls.

Explain why data is held back and read every part of the slide-22 split call.

• Why split — hold back some data to fairly test the model after training.
• train_test_split() — from sklearn.model_selection; does the split in one line.
• Four outputs, in order — X_train, X_test, y_train, y_test.
• Result — with test_size=0.2, random_state=42 on 10 rows: Train rows: 8 · Test rows: 2.