Python for Data Science, Machine Learning & AI

1. Visit the official Python downloads page.
2. Download the current Python 3 installer for Windows.
3. Open the installer.
4. Select “Add python.exe to PATH” before continuing.
5. Choose “Install Now”.
6. Open Command Prompt or PowerShell after installation.
7. Run the verification commands below.

Optional:
Install Visual Studio Code and add the official Python extension.

py --version
py -m pip --version

# Start Python
py

# Leave the Python interpreter
exit()

Recommended beginner route:

1. Visit the official Python downloads page.
2. Download the signed macOS installer.
3. Open the downloaded .pkg file.
4. Follow the installation wizard.
5. Open Terminal.
6. Verify the installation with python3 and pip3.

Do not rely on an older system-provided Python installation for your projects.

python3 --version
python3 -m pip --version

# Start Python
python3

# Leave the interpreter
exit()

# Ubuntu or Debian
sudo apt update
sudo apt install python3 python3-pip python3-venv

# Fedora
sudo dnf install python3 python3-pip

# Verify
python3 --version
python3 -m pip --version

mkdir python-learning
cd python-learning

# Windows
py -m venv .venv
.venv\Scripts\activate

# macOS or Linux
python3 -m venv .venv
source .venv/bin/activate

# Leave the environment later
deactivate

python -m pip install --upgrade pip

python -m pip install \
  numpy \
  pandas \
  matplotlib \
  scipy \
  scikit-learn \
  jupyterlab \
  openpyxl \
  joblib

jupyter lab

import sys
import numpy as np
import pandas as pd
import sklearn

print("Python:", sys.version)
print("NumPy:", np.__version__)
print("pandas:", pd.__version__)
print("scikit-learn:", sklearn.__version__)

print("Your Python data-science environment is ready.")

name = "Imonikhe"       # string
age = 38                 # integer
height = 1.78            # float
is_learning = True       # Boolean
result = None            # no value yet

print(type(name))
print(f"{name} is {age} years old.")

a = 10
b = 3

print(a + b)    # addition
print(a - b)    # subtraction
print(a * b)    # multiplication
print(a / b)    # division
print(a // b)   # whole-number division
print(a % b)    # remainder
print(a ** b)   # power

print(a > b)
print(a == 10)
print(a != b)

message = "  Python for Data Science  "

print(message.strip())
print(message.lower())
print(message.upper())
print(message.replace("Python", "AI"))
print(message.split())
print("Data" in message)

scores = [78, 82, 91, 65, 88]

print(scores[0])
print(scores[-1])
print(scores[1:4])

scores.append(95)
scores.remove(65)
scores.sort(reverse=True)

average = sum(scores) / len(scores)
print(average)

patient = {
    "name": "John",
    "age": 65,
    "diagnosis": "Diabetes"
}

print(patient["name"])
print(patient.get("diagnosis"))

patient["hospital"] = "Cardiff"
patient["age"] = 66

for key, value in patient.items():
    print(key, value)

coordinates = (51.4816, -3.1791)
latitude, longitude = coordinates

group_a = {"Python", "SQL", "R"}
group_b = {"Python", "Power BI", "Excel"}

print(group_a | group_b)   # union
print(group_a & group_b)   # intersection
print(group_a - group_b)   # difference

score = 75

if score >= 70:
    print("Distinction")
elif score >= 60:
    print("Merit")
elif score >= 50:
    print("Pass")
else:
    print("Fail")

scores = [70, 80, 90]

for score in scores:
    print(score)

for index, score in enumerate(scores):
    print(index, score)

for number in range(1, 6):
    print(number)

count = 1

while count <= 5:
    if count == 3:
        count += 1
        continue

    print(count)

    if count == 4:
        break

    count += 1

squares = [number ** 2 for number in range(1, 6)]
even_numbers = [number for number in range(10) if number % 2 == 0]

scores = [45, 67, 82, 39, 91]
passed = [score for score in scores if score >= 50]

def calculate_mean(values: list[float]) -> float:
    if not values:
        raise ValueError("The list cannot be empty.")

    return sum(values) / len(values)


scores = [70, 80, 90]
average = calculate_mean(scores)
print(average)

def calculate_total(price: float, quantity: int = 1) -> float:
    return price * quantity


print(calculate_total(20))
print(calculate_total(20, 3))

try:
    number = int("hello")
except ValueError as error:
    print(f"Conversion failed: {error}")
finally:
    print("Operation finished.")

with open("notes.txt", "r", encoding="utf-8") as file:
    content = file.read()

with open("output.txt", "w", encoding="utf-8") as file:
    file.write("Python is useful for data science.")

class MachineLearningModel:
    def __init__(self, name: str, accuracy: float):
        self.name = name
        self.accuracy = accuracy

    def display_result(self) -> None:
        print(f"{self.name}: {self.accuracy:.2%}")


model = MachineLearningModel("Random Forest", 0.91)
model.display_result()

import numpy as np

scores = np.array([70, 80, 90, 100])
matrix = np.array([
    [1, 2, 3],
    [4, 5, 6]
])

print(scores.shape)
print(matrix.ndim)
print(matrix.dtype)
print(matrix.size)

zeros = np.zeros(5)
ones = np.ones(5)
sequence = np.arange(0, 10, 2)
evenly_spaced = np.linspace(0, 1, 5)

rng = np.random.default_rng(seed=42)
random_values = rng.random(5)
random_integers = rng.integers(1, 100, size=5)

scores = np.array([70, 80, 90, 100])

print(scores + 5)
print(scores * 2)
print(np.mean(scores))
print(np.median(scores))
print(np.std(scores))

high_scores = scores[scores >= 90]
print(high_scores)

values = np.array([10, 20, np.nan, 40])

print(np.isnan(values))
print(np.nanmean(values))

numbers = np.array([1, 2, 3, 4, 5, 6])
matrix = numbers.reshape(2, 3)
print(matrix)

import pandas as pd

data = {
    "name": ["Alice", "Ben", "Chidi", "David"],
    "age": [25, 32, 41, 29],
    "score": [85, 72, 91, 68]
}

df = pd.DataFrame(data)
print(df)

df_csv = pd.read_csv("patients.csv")
df_excel = pd.read_excel("patients.xlsx", sheet_name="Responses")
df_json = pd.read_json("patients.json")

print(df.head())
print(df.tail())
print(df.shape)
print(df.columns)

df.info()
print(df.describe(include="all"))

ages = df["age"]
selected_columns = df[["name", "score"]]

high_scores = df[df["score"] >= 80]

selected = df[
    (df["score"] >= 80) &
    (df["age"] < 40)
]

rows_by_label = df.loc[0:2, ["name", "score"]]
rows_by_position = df.iloc[0:3, 0:2]

import numpy as np

df["score_percentage"] = df["score"] / 100
df["result"] = np.where(df["score"] >= 70, "Pass", "Fail")

df = df.rename(columns={
    "score": "test_score",
    "age": "participant_age"
})

print(df.isna().sum())

missing_rows = df[df.isna().any(axis=1)]

df["score"] = df["score"].fillna(df["score"].median())
df["gender"] = df["gender"].fillna("Unknown")

df_clean = df.dropna(subset=["patient_id"])

print(df.duplicated().sum())

df = df.drop_duplicates(
    subset=["patient_id"],
    keep="first"
)

df["age"] = pd.to_numeric(df["age"], errors="coerce")
df["date"] = pd.to_datetime(df["date"], errors="coerce")

df = df.sort_values(
    ["hospital", "score"],
    ascending=[True, False]
)

df["hospital"] = (
    df["hospital"]
    .str.strip()
    .str.title()
)

summary = (
    df.groupby("gender")
      .agg(
          mean_score=("score", "mean"),
          median_score=("score", "median"),
          participants=("score", "count")
      )
      .reset_index()
)

print(summary)

counts = df["gender"].value_counts()
percentages = df["gender"].value_counts(normalize=True) * 100

print(counts)
print(percentages)

combined = pd.merge(
    patients,
    hospitals,
    on="hospital_id",
    how="left"
)

all_years = pd.concat(
    [data_2025, data_2026],
    ignore_index=True
)

pivot = pd.pivot_table(
    df,
    values="score",
    index="hospital",
    columns="gender",
    aggfunc="mean"
)

table = pd.crosstab(
    df["gender"],
    df["response_method"],
    normalize="index"
) * 100

df["date"] = pd.to_datetime(df["date"], errors="coerce")

df["year"] = df["date"].dt.year
df["month"] = df["date"].dt.month
df["day_name"] = df["date"].dt.day_name()

df["days_waited"] = (
    df["appointment_date"] -
    df["referral_date"]
).dt.days

df = df.sort_values("date").set_index("date")

monthly = df["energy_use"].resample("ME").mean()
df["energy_lag_1"] = df["energy_use"].shift(1)
df["rolling_mean_7"] = df["energy_use"].rolling(7).mean()
df["percentage_change"] = df["energy_use"].pct_change() * 100

split_position = int(len(df) * 0.8)

train = df.iloc[:split_position]
test = df.iloc[split_position:]

# Do not randomly shuffle observations when future values
# must be predicted from earlier values.

import matplotlib.pyplot as plt

months = ["Jan", "Feb", "Mar", "Apr"]
scores = [70, 75, 73, 82]

plt.plot(months, scores)
plt.xlabel("Month")
plt.ylabel("Score")
plt.title("Monthly Scores")
plt.show()

hospitals = ["A", "B", "C"]
response_rates = [65, 72, 58]

plt.bar(hospitals, response_rates)
plt.xlabel("Hospital")
plt.ylabel("Response rate (%)")
plt.title("Response Rate by Hospital")
plt.show()

plt.hist(df["age"].dropna(), bins=10)
plt.xlabel("Age")
plt.ylabel("Frequency")
plt.title("Age Distribution")
plt.show()

plt.scatter(df["age"], df["score"])
plt.xlabel("Age")
plt.ylabel("Score")
plt.title("Age and Score")
plt.show()

from scipy import stats

online = df.loc[
    df["response_method"] == "Online",
    "score"
].dropna()

paper = df.loc[
    df["response_method"] == "Paper",
    "score"
].dropna()

statistic, p_value = stats.ttest_ind(
    online,
    paper,
    equal_var=False
)

print(f"Statistic: {statistic:.3f}")
print(f"P-value: {p_value:.4f}")

contingency_table = pd.crosstab(
    df["gender"],
    df["response_method"]
)

chi2, p_value, degrees_of_freedom, expected = (
    stats.chi2_contingency(contingency_table)
)

print(f"Chi-square: {chi2:.3f}")
print(f"P-value: {p_value:.4f}")

correlation = df["age"].corr(df["score"])
print(f"Correlation: {correlation:.3f}")

features = [
    "age",
    "blood_pressure",
    "cholesterol"
]

X = df[features]
y = df["has_disease"]

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

model = LinearRegression()
model.fit(X_train, y_train)

predictions = model.predict(X_test)

mae = mean_absolute_error(y_test, predictions)
rmse = mean_squared_error(y_test, predictions) ** 0.5
r_squared = r2_score(y_test, predictions)

print(mae, rmse, r_squared)

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score

model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)

predictions = model.predict(X_test)
probabilities = model.predict_proba(X_test)[:, 1]

print(classification_report(y_test, predictions))
print(roc_auc_score(y_test, probabilities))

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier(
    max_depth=5,
    random_state=42
)

model.fit(X_train, y_train)
predictions = model.predict(X_test)

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(
    n_estimators=200,
    max_depth=10,
    class_weight="balanced",
    random_state=42
)

model.fit(X_train, y_train)
predictions = model.predict(X_test)

importance = pd.DataFrame({
    "feature": X_train.columns,
    "importance": model.feature_importances_
}).sort_values("importance", ascending=False)

from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC

knn_model = KNeighborsClassifier(n_neighbors=5)
svm_model = SVC(kernel="rbf", probability=True, random_state=42)

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Fit on training data only.
# Never fit the scaler separately on the test data.

encoded = pd.get_dummies(
    df,
    columns=["gender", "region"],
    drop_first=True,
    dtype=int
)

from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.linear_model import LogisticRegression

numeric_features = ["age", "blood_pressure", "cholesterol"]
categorical_features = ["gender", "region"]

numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])

categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore"))
])

preprocessor = ColumnTransformer([
    ("numeric", numeric_pipeline, numeric_features),
    ("categorical", categorical_pipeline, categorical_features)
])

model = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", LogisticRegression(
        max_iter=1000,
        class_weight="balanced"
    ))
])

model.fit(X_train, y_train)
predictions = model.predict(X_test)

from sklearn.model_selection import cross_val_score

scores = cross_val_score(
    model,
    X,
    y,
    cv=5,
    scoring="roc_auc"
)

print(scores)
print(scores.mean())
print(scores.std())

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

parameter_grid = {
    "n_estimators": [100, 200],
    "max_depth": [5, 10, None],
    "min_samples_split": [2, 5]
}

search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid=parameter_grid,
    cv=5,
    scoring="roc_auc",
    n_jobs=-1
)

search.fit(X_train, y_train)

print(search.best_params_)
best_model = search.best_estimator_

from sklearn.metrics import (
    accuracy_score,
    classification_report,
    confusion_matrix,
    roc_auc_score
)

print(accuracy_score(y_test, predictions))
print(confusion_matrix(y_test, predictions))
print(classification_report(y_test, predictions))
print(roc_auc_score(y_test, probabilities))

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

features = df[["income", "spending_score"]]

scaler = StandardScaler()
features_scaled = scaler.fit_transform(features)

kmeans = KMeans(
    n_clusters=3,
    random_state=42,
    n_init=10
)

df["cluster"] = kmeans.fit_predict(features_scaled)

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
components = pca.fit_transform(features_scaled)

df["principal_component_1"] = components[:, 0]
df["principal_component_2"] = components[:, 1]

print(pca.explained_variance_ratio_)

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

model = keras.Sequential([
    layers.Input(shape=(X_train_scaled.shape[1],)),
    layers.Dense(64, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(32, activation="relu"),
    layers.Dense(1, activation="sigmoid")
])

model.compile(
    optimizer="adam",
    loss="binary_crossentropy",
    metrics=["accuracy"]
)

history = model.fit(
    X_train_scaled,
    y_train,
    validation_split=0.2,
    epochs=30,
    batch_size=32
)

early_stopping = keras.callbacks.EarlyStopping(
    monitor="val_loss",
    patience=5,
    restore_best_weights=True
)

history = model.fit(
    X_train_scaled,
    y_train,
    validation_split=0.2,
    epochs=100,
    batch_size=32,
    callbacks=[early_stopping]
)

# Four-class classification output
multiclass_output = layers.Dense(4, activation="softmax")

# Regression output
regression_output = layers.Dense(1)

# Common losses
binary_loss = "binary_crossentropy"
multiclass_loss = "sparse_categorical_crossentropy"
regression_loss = "mean_squared_error"

model = keras.Sequential([
    layers.Input(shape=(128, 128, 3)),
    layers.Conv2D(32, kernel_size=3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Conv2D(64, kernel_size=3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Flatten(),
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(10, activation="softmax")
])

model = keras.Sequential([
    layers.Input(shape=(sequence_length, number_of_features)),
    layers.LSTM(64),
    layers.Dense(1)
])

model.compile(
    optimizer="adam",
    loss="mean_squared_error"
)

import torch
import torch.nn as nn

features = torch.tensor(
    [[1.0, 2.0], [3.0, 4.0]]
)

targets = torch.tensor(
    [[0.0], [1.0]]
)

class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()

        self.network = nn.Sequential(
            nn.Linear(2, 16),
            nn.ReLU(),
            nn.Linear(16, 1),
            nn.Sigmoid()
        )

    def forward(self, inputs):
        return self.network(inputs)


model = NeuralNetwork()
loss_function = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(100):
    predictions = model(features)
    loss = loss_function(predictions, targets)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 10 == 0:
        print(epoch, loss.item())

text = "Python is GREAT for AI!"

clean_text = (
    text.lower()
        .replace("!", "")
        .strip()
)

words = clean_text.split()
print(words)

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

text_model = Pipeline([
    ("tfidf", TfidfVectorizer(stop_words="english")),
    ("classifier", LogisticRegression(max_iter=1000))
])

text_model.fit(training_texts, training_labels)

prediction = text_model.predict([
    "The service was excellent."
])

print(prediction)

from transformers import pipeline

sentiment_model = pipeline("sentiment-analysis")

result = sentiment_model(
    "The service was excellent."
)

print(result)

from sentence_transformers import SentenceTransformer

embedding_model = SentenceTransformer(
    "all-MiniLM-L6-v2"
)

sentences = [
    "Python is used for data science.",
    "Machine-learning models learn from data."
]

embeddings = embedding_model.encode(sentences)
print(embeddings.shape)

from sklearn.metrics.pairwise import cosine_similarity

documents = [
    "Python is a programming language.",
    "SQL is used to query databases.",
    "Machine-learning models learn patterns from data."
]

document_embeddings = embedding_model.encode(documents)

question = "How do computers learn from information?"
question_embedding = embedding_model.encode([question])

similarities = cosine_similarity(
    question_embedding,
    document_embeddings
)[0]

best_index = similarities.argmax()
print(documents[best_index])

Documents
   ↓
Split into chunks
   ↓
Create embeddings
   ↓
Store vectors
   ↓
Retrieve relevant chunks
   ↓
Send context and question to a language model
   ↓
Generate a grounded answer

import joblib

joblib.dump(
    model,
    "patient_risk_model.joblib"
)

loaded_model = joblib.load(
    "patient_risk_model.joblib"
)

prediction = loaded_model.predict(new_patient_data)

df.to_csv("cleaned_data.csv", index=False)
df.to_excel("cleaned_data.xlsx", index=False)

with pd.ExcelWriter("analysis_output.xlsx") as writer:
    df.to_excel(writer, sheet_name="Clean Data", index=False)
    summary.to_excel(writer, sheet_name="Summary", index=False)

import joblib
import pandas as pd

from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

df = pd.read_csv("patient_data.csv")

numeric_features = [
    "age",
    "blood_pressure",
    "cholesterol"
]

categorical_features = [
    "gender",
    "smoking_status"
]

features = numeric_features + categorical_features

X = df[features]
y = df["has_disease"]

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])

categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore"))
])

preprocessor = ColumnTransformer([
    ("numeric", numeric_pipeline, numeric_features),
    ("categorical", categorical_pipeline, categorical_features)
])

model = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", LogisticRegression(
        max_iter=1000,
        class_weight="balanced"
    ))
])

model.fit(X_train, y_train)

predictions = model.predict(X_test)
print(classification_report(y_test, predictions))

joblib.dump(model, "patient_risk_model.joblib")

RANDOM_STATE = 42
TEST_SIZE = 0.2

analysis_data = df.copy()

if "target" not in analysis_data.columns:
    raise ValueError("The target column is missing.")

print(analysis_data.shape)
print(analysis_data.head())
print(analysis_data.isna().sum())

# Incorrect: learns from all data before splitting.
scaler.fit(X)

# Correct: fit only on the training data.
scaler.fit(X_train)
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test)

• Use = for assignment and == for comparison.
• Place a colon after if, elif, else, for, while, def and class.
• Python is case-sensitive: score and Score are different names.
• Put pandas conditions in parentheses and use & or |.
• Read error messages from the final line upward.
• Test code on a small sample before running it on a large dataset.

Variables, data types, collections, conditions, loops, functions, files and exceptions.

Practice projects:
• Calculator
• Grade classifier
• Expense tracker
• Simple patient-record program

NumPy, pandas, missing values, grouping, merging, dates, visualisation and basic statistics.

Practice project:
• Exploratory analysis of a public health, NHS, sales or survey dataset

Regression, classification, preprocessing, pipelines, evaluation, cross-validation and tuning.

Practice projects:
• One regression project
• One classification project

Neural networks, TensorFlow or PyTorch, NLP, transformers, embeddings and semantic search.

Practice project:
• Text classifier or document-question-answering prototype