Python Based Project Ideas (25+ Portfolio Ideas with Source Code)

# Supervised Learning with Python & Scikit-Learn
import numpy as np
import pandas as pd
from sklearn import preprocessing, model_selection
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris

# 1. Load Dataset and Extract Features
iris = load_iris(as_frame=True)
data = iris.frame
x = data[['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']].values
y = data['target'].values
var = list(iris.target_names)

# 2. Iterate Iterative Training & Validation
best, worst = 0, 100
for i in range(20):
    x_train, x_test, y_train, y_test = model_selection.train_test_split(
        x, y, test_size=0.3, random_state=i)
    model = KNeighborsClassifier(n_neighbors=5)
    model.fit(x_train, y_train)
    accuracy = model.score(x_test, y_test)
    if accuracy > best: best = accuracy
    if accuracy < worst: worst = accuracy
    prediction = model.predict(x_test)
    print(f"Iter {i+1:02d} | Accuracy: {round(accuracy*100, 2)}% | Pred: {var[prediction[0]]} | Actual: {var[y_test[0]]}")

print(f"\nHighest Accuracy: {round(100*best, 2)}%")
print(f"Lowest Accuracy:  {round(100*worst, 2)}%")

# Sudoku Solver using Backtracking Algorithm in Python
b = [
    [7,8,0,4,0,0,1,2,0],
    [6,0,0,0,7,5,0,0,9],
    [0,0,0,6,0,1,0,7,8],
    [0,0,7,0,4,0,2,6,0],
    [0,0,1,0,5,0,9,3,0],
    [9,0,4,0,6,0,0,0,5],
    [0,7,0,3,0,0,0,1,2],
    [1,2,0,0,0,7,4,0,0],
    [0,4,9,2,0,6,0,0,7]
]

def solve(b):
    find = find_empty(b)
    if not find:
        return True # Solved state
    row, col = find
    for i in range(1, 10):
        if valid(b, i, (row, col)):
            b[row][col] = i
            if solve(b):
                return True
            b[row][col] = 0
    return False

def valid(b, num, pos):
    for i in range(len(b[0])): # Check row
        if b[pos[0]][i] == num and pos[1] != i: return False
    for i in range(len(b)):    # Check column
        if b[i][pos[1]] == num and pos[0] != i: return False
    box_x, box_y = pos[1] // 3, pos[0] // 3 # Check 3x3 box
    for i in range(box_y*3, box_y*3 + 3):
        for j in range(box_x*3, box_x*3 + 3):
            if b[i][j] == num and (i, j) != pos: return False
    return True

def find_empty(b):
    for i in range(len(b)):
        for j in range(len(b[0])):
            if b[i][j] == 0: return (i, j)
    return None

def print_board(b):
    for i in range(len(b)):
        if i % 3 == 0 and i != 0: print("- - - - - - - - - - - - - ")
        for j in range(len(b[0])):
            if j % 3 == 0 and j != 0: print(" | ", end="")
            print(str(b[i][j]) + ("\n" if j == 8 else " "), end="")

print("--- Original Sudoku Board ---")
print_board(b)
solve(b)
print("\n--- Solved Sudoku Board ---")
print_board(b)

# Binary Search Algorithm (Iterative & Recursive)
import time

def binary_search_iterative(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

def binary_search_recursive(arr, low, high, target):
    if high >= low:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] > target:
            return binary_search_recursive(arr, low, mid - 1, target)
        else:
            return binary_search_recursive(arr, mid + 1, high, target)
    return -1

# Prefix Autocomplete Application
def autocomplete(word_list, prefix):
    return [w for w in word_list if w.lower().startswith(prefix.lower())]

# Verification Test
dataset = sorted([f"signal_dsp_{i:04d}" for i in range(10000)])
target_item = "signal_dsp_4520"

idx_iter = binary_search_iterative(dataset, target_item)
idx_rec = binary_search_recursive(dataset, 0, len(dataset)-1, target_item)
print(f"Target '{target_item}' found at index: {idx_iter} (Recursive: {idx_rec})")
print(f"Autocomplete suggestions for 'signal_dsp_001': {autocomplete(dataset, 'signal_dsp_001')[:3]}")

# Acronyms Generator with Stop-Word Filtering
def generate_acronym(phrase, ignore_stopwords=True):
    stopwords = {"of", "and", "the", "in", "for", "with", "to", "on", "at"}
    words = phrase.strip().split()
    acronym_letters = []
    
    for word in words:
        cleaned_word = word.strip(".,!?:;\"'()[]{}")
        if ignore_stopwords and cleaned_word.lower() in stopwords:
            continue
        if cleaned_word:
            acronym_letters.append(cleaned_word[0].upper())
            
    return "".join(acronym_letters)

# Demonstration Samples
test_phrases = [
    "Natural Language Processing",
    "Finite Impulse Response Digital Filter",
    "National Aeronautics and Space Administration",
    "Orthogonal Frequency Division Multiplexing"
]

print("--- Generated Technical Acronyms ---")
for p in test_phrases:
    print(f"Phrase:  '{p}'\nAcronym: {generate_acronym(p)}\n")

# Alarm Clock with Python datetime & time synchronization
from datetime import datetime
import time

def start_alarm(target_time_str):
    # Target time format: "HH:MM:SS AM/PM" (e.g. "07:30:00 AM")
    print(f"[STATUS] Alarm initialized for: {target_time_str}")
    
    while True:
        now = datetime.now()
        current_time = now.strftime("%I:%M:%S %p")
        
        if current_time == target_time_str:
            print("\n" + "="*40)
            print(f"⏰ [WAKE UP!] Alarm triggered at {current_time}")
            print("="*40)
            # In Windows: import winsound; winsound.Beep(1000, 2000)
            break
        time.sleep(1)

# Example usage demonstration
current_target = datetime.now().strftime("%I:%M:%S %p")
print(f"Current System Time: {current_target}")
# start_alarm("08:00:00 AM")

# GUI Calculator using Tkinter with Error Protection
from tkinter import Tk, StringVar, Entry, Button

expression = ""

def press(num):
    global expression
    expression += str(num)
    equation.set(expression)

def equalpress():
    global expression
    try:
        total = str(eval(expression))
        equation.set(total)
        expression = total
    except Exception:
        equation.set("Error")
        expression = ""

def clear():
    global expression
    expression = ""
    equation.set("")

if __name__ == "__main__":
    gui = Tk()
    gui.configure(background="#f1f5f9")
    gui.title("Python Tkinter Calculator")
    gui.geometry("280x260")
    
    equation = StringVar()
    field = Entry(gui, textvariable=equation, font=('Arial', 14), justify='right')
    field.grid(row=0, column=0, columnspan=4, ipadx=8, ipady=8, padx=10, pady=10)
    
    buttons = [
        ('7', 1, 0), ('8', 1, 1), ('9', 1, 2), ('/', 1, 3),
        ('4', 2, 0), ('5', 2, 1), ('6', 2, 2), ('*', 2, 3),
        ('1', 3, 0), ('2', 3, 1), ('3', 3, 2), ('-', 3, 3),
        ('0', 4, 0), ('.', 4, 1), ('=', 4, 2), ('+', 4, 3),
    ]
    
    for (text, r, c) in buttons:
        cmd = equalpress if text == '=' else lambda t=text: press(t)
        Button(gui, text=text, width=5, height=2, font=('Arial', 10, 'bold'),
               command=cmd).grid(row=r, column=c, padx=3, pady=3)
    
    Button(gui, text='Clear', width=24, height=1, bg='#ef4444', fg='white',
           command=clear).grid(row=5, column=0, columnspan=4, pady=5)
    gui.mainloop()

# Real-Time Face & Eye Detection using OpenCV
import cv2

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')

cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret: break
    
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)
    
    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 86, 179), 2)
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = frame[y:y+h, x:x+w]
        
        eyes = eye_cascade.detectMultiScale(roi_gray, scaleFactor=1.1, minNeighbors=10)
        for (ex, ey, ew, eh) in eyes:
            cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (16, 185, 129), 2)

    cv2.putText(frame, f"Faces Detected: {len(faces)}", (20, 30),
                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 86, 179), 2)
    cv2.imshow('Face & Eye Detector - MATLAB Solutions', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'): break

cap.release()
cv2.destroyAllWindows()

# Automated Web Scraping Pipeline with BeautifulSoup & Pandas
import requests
from bs4 import BeautifulSoup
import pandas as pd

def scrape_quotes_dataset():
    url = "https://quotes.toscrape.com/"
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
    response = requests.get(url, headers=headers)
    
    if response.status_code != 200:
        print(f"Error fetching page: HTTP {response.status_code}")
        return
        
    soup = BeautifulSoup(response.text, 'html.parser')
    quotes_data = []
    
    for quote_div in soup.find_all('div', class_='quote'):
        text = quote_div.find('span', class_='text').get_text(strip=True)
        author = quote_div.find('small', class_='author').get_text(strip=True)
        tags = [tag.get_text() for tag in quote_div.find_all('a', class_='tag')]
        quotes_data.append({"Text": text, "Author": author, "Tags": ", ".join(tags)})
        
    df = pd.DataFrame(quotes_data)
    df.to_csv("scraped_quotes.csv", index=False)
    print(f"Successfully scraped {len(df)} records. Top 3 rows:\n")
    print(df.head(3))

scrape_quotes_dataset()

# Automated Exploratory Data Analysis with Pandas & Seaborn
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Load Sample Dataset
df = sns.load_dataset('iris')
print("--- Dataset Information ---")
print(df.info())
print("\n--- Summary Statistics ---")
print(df.describe().round(2))

# Correlation Heatmap Visualization
plt.figure(figsize=(8, 6))
numeric_df = df.select_dtypes(include=['float64', 'int64'])
sns.heatmap(numeric_df.corr(), annot=True, cmap='Blues', fmt='.2f', square=True)
plt.title("Feature Pearson Correlation Matrix")
plt.tight_layout()
# plt.savefig('eda_correlation.png', dpi=300)
print("\nCorrelation matrix computed successfully.")

# PyTorch CNN Image Classifier Architecture
import torch
import torch.nn as nn
import torch.optim as optim

class ConvNet(nn.Module):
    def __init__(self, num_classes=10):
        super(ConvNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.classifier = nn.Sequential(
            nn.Linear(64 * 8 * 8, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes)
        )
        
    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        return self.classifier(x)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ConvNet().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
print(f"Model initialized on device: {device}")

# NLP Sentiment Analysis with NLTK VADER
import nltk
from nltk.sentiment.vader import SentimentIntensityAnalyzer

# Initialize VADER Lexicon
nltk.download('vader_lexicon', quiet=True)
sia = SentimentIntensityAnalyzer()

sample_reviews = [
    "The engineering support and code documentation from MATLAB Solutions was phenomenal!",
    "The simulation script had several runtime bugs and delayed our delivery schedule.",
    "The algorithm performance was average, neither exceptional nor failing."
]

print("--- Sentiment Polarity Evaluation ---")
for text in sample_reviews:
    scores = sia.polarity_scores(text)
    compound = scores['compound']
    sentiment = "Positive" if compound >= 0.05 else ("Negative" if compound <= -0.05 else "Neutral")
    print(f"Review: '{text}'")
    print(f"Sentiment: {sentiment} (Compound Score: {compound:.3f})\n")

# Time Series Forecasting using LSTM Neural Networks
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from sklearn.preprocessing import MinMaxScaler

# Generate Synthetic Financial Trend
t = np.linspace(0, 100, 1000)
prices = 50 + 0.5*t + 10*np.sin(0.2*t) + np.random.normal(0, 1, 1000)
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(prices.reshape(-1, 1))

# Construct 60-day Sliding Windows
X, y = [], []
for i in range(60, len(scaled_data)):
    X.append(scaled_data[i-60:i, 0])
    y.append(scaled_data[i, 0])
X, y = np.array(X), np.array(y)
X = np.reshape(X, (X.shape[0], X.shape[1], 1))

# Build Stacked LSTM Architecture
model = Sequential([
    LSTM(50, return_sequences=True, input_shape=(X.shape[1], 1)),
    Dropout(0.2),
    LSTM(50, return_sequences=False),
    Dense(25),
    Dense(1)
])
model.compile(optimizer='adam', loss='mean_squared_error')
print("LSTM Architecture compiled successfully.")

# Audio FFT & Frequency Domain Spectral Analysis
import numpy as np
from scipy.fft import fft, fftfreq
import matplotlib.pyplot as plt

# Synthesize Audio Tone (440 Hz + 1200 Hz Harmonic + Noise)
fs = 44100  # Sampling Rate (Hz)
duration = 1.0
t = np.linspace(0, duration, int(fs * duration), endpoint=False)
signal = 0.6 * np.sin(2 * np.pi * 440 * t) + 0.3 * np.sin(2 * np.pi * 1200 * t)
noisy_signal = signal + 0.2 * np.random.normal(size=t.shape)

# Compute Fast Fourier Transform
N = len(t)
yf = fft(noisy_signal)
xf = fftfreq(N, 1 / fs)[:N//2]
magnitude = 2.0/N * np.abs(yf[0:N//2])

print(f"Dominant Detected Peak Frequency: {xf[np.argmax(magnitude)]:.1f} Hz")

# Production ML Inference API using FastAPI & Pydantic
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
import numpy as np

app = FastAPI(title="ML Prediction Service - MATLAB Solutions", version="1.0.0")

class FeatureInput(BaseModel):
    sepal_length: float = Field(..., example=5.1)
    sepal_width: float = Field(..., example=3.5)
    petal_length: float = Field(..., example=1.4)
    petal_width: float = Field(..., example=0.2)

@app.get("/")
def health_check():
    return {"status": "online", "model_version": "2026.1"}

@app.post("/predict")
def predict_species(features: FeatureInput):
    inputs = np.array([[features.sepal_length, features.sepal_width,
                        features.petal_length, features.petal_width]])
    # Mock Inference or load joblib.load('model.pkl')
    species_map = {0: "Setosa", 1: "Versicolor", 2: "Virginica"}
    pred_class = int(np.argmax([0.92, 0.05, 0.03]))
    return {
        "prediction": species_map[pred_class],
        "confidence": 0.92,
        "input_echo": features.dict()
    }

# A* Pathfinding Algorithm for 2D Grid Maze
import heapq

def astar_search(maze, start, goal):
    rows, cols = len(maze), len(maze[0])
    open_set = [(0 + abs(start[0]-goal[0]) + abs(start[1]-goal[1]), 0, start, [start])]
    visited = set()
    
    while open_set:
        f, g, current, path = heapq.heappop(open_set)
        if current == goal:
            return path
        if current in visited: continue
        visited.add(current)
        
        for dx, dy in [(-1,0), (1,0), (0,-1), (0,1)]:
            r, c = current[0] + dx, current[1] + dy
            if 0 <= r < rows and 0 <= c < cols and maze[r][c] == 0:
                if (r, c) not in visited:
                    h = abs(r - goal[0]) + abs(c - goal[1])
                    heapq.heappush(open_set, (g + 1 + h, g + 1, (r, c), path + [(r, c)]))
    return None

maze = [
    [0, 1, 0, 0, 0],
    [0, 1, 0, 1, 0],
    [0, 0, 0, 1, 0],
    [1, 1, 0, 0, 0]
]
path = astar_search(maze, (0, 0), (3, 4))
print(f"A* Optimal Path Found: {path}")

# Desktop File Organizer Automation
import os
import shutil

EXT_DIRECTORIES = {
    'Documents': ['.pdf', '.docx', '.txt', '.xlsx'],
    'Images': ['.jpg', '.png', '.svg', '.webp'],
    'Code': ['.py', '.m', '.cpp', '.ipynb'],
    'Archives': ['.zip', '.tar', '.gz', '.7z']
}

def organize_folder(target_dir):
    for entry in os.scandir(target_dir):
        if entry.is_file():
            _, ext = os.path.splitext(entry.name)
            for folder, extensions in EXT_DIRECTORIES.items():
                if ext.lower() in extensions:
                    dest_folder = os.path.join(target_dir, folder)
                    os.makedirs(dest_folder, exist_ok=True)
                    shutil.move(entry.path, os.path.join(dest_folder, entry.name))
                    print(f"Moved: {entry.name} -> {folder}/")
                    break

print("File automation script ready.")

# Real-Time Object Tracking with Ultralytics YOLOv8
from ultralytics import YOLO
import cv2

# Load Pretrained YOLOv8 Nano Model
model = YOLO('yolov8n.pt')

# Track Objects in Video Stream
results = model.track(source="https://ultralytics.com/images/bus.jpg", conf=0.4, show=False)

for r in results:
    boxes = r.boxes
    for box in boxes:
        cls_id = int(box.cls[0])
        cls_name = model.names[cls_id]
        conf = float(box.conf[0])
        print(f"Detected: {cls_name.upper()} | Confidence: {conf:.2f} | BBox: {box.xyxy[0].tolist()}")

# Churn Prediction with Random Forest & Feature Importance
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score

# Generate Synthetic Customer Churn Features
np.random.seed(42)
N = 1000
tenure = np.random.randint(1, 72, N)
monthly_charges = np.random.uniform(20, 120, N)
contract_type = np.random.randint(0, 3, N)
churn = (monthly_charges > 70) & (tenure < 24) | (np.random.rand(N) < 0.1)

X = pd.DataFrame({'Tenure': tenure, 'MonthlyCharges': monthly_charges, 'Contract': contract_type})
y = churn.astype(int)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
clf = RandomForestClassifier(n_estimators=100, max_depth=6, random_state=42)
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)
print(f"ROC-AUC Score: {roc_auc_score(y_test, clf.predict_proba(X_test)[:,1]):.3f}")
print("\nClassification Report:\n", classification_report(y_test, y_pred))

# Coupled Non-Linear ODE Solver with SciPy odeint
import numpy as np
from scipy.integrate import odeint

def lotka_volterra(state, t, alpha=1.1, beta=0.4, delta=0.1, gamma=0.4):
    x, y = state  # x: prey, y: predator
    dxdt = alpha * x - beta * x * y
    dydt = delta * x * y - gamma * y
    return [dxdt, dydt]

# Initial Conditions and Time Grid
initial_state = [10.0, 5.0]
t = np.linspace(0, 50, 1000)

solution = odeint(lotka_volterra, initial_state, t)
print(f"Simulation completed across {len(t)} time steps.")
print(f"Final State -> Prey: {solution[-1, 0]:.2f}, Predators: {solution[-1, 1]:.2f}")

# Handwritten Digit Recognition with MLP Neural Network
from sklearn.datasets import load_digits
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

digits = load_digits()
X = digits.data / 16.0  # Normalize pixel intensities
y = digits.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
mlp = MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=300, activation='relu',
                    solver='adam', random_state=42)
mlp.fit(X_train, y_train)

y_pred = mlp.predict(X_test)
print(f"Handwritten Digit Test Accuracy: {accuracy_score(y_test, y_pred)*100:.2f}%")

# Cryptographic Password Vault with Fernet Symmetric Encryption
from cryptography.fernet import Fernet
import sqlite3

class PasswordVault:
    def __init__(self, key=None):
        self.key = key or Fernet.generate_key()
        self.cipher = Fernet(self.key)
        
    def encrypt_password(self, plain_text):
        return self.cipher.encrypt(plain_text.encode()).decode()
        
    def decrypt_password(self, cipher_text):
        return self.cipher.decrypt(cipher_text.encode()).decode()

vault = PasswordVault()
encrypted = vault.encrypt_password("SuperSecretP@ssword2026")
decrypted = vault.decrypt_password(encrypted)
print(f"Ciphertext: {encrypted[:25]}...")
print(f"Decrypted:  {decrypted}")

# Dense Optical Flow Vehicle Motion Computation
import cv2
import numpy as np

def compute_dense_flow(prev_gray, curr_gray):
    flow = cv2.calcOpticalFlowFarneback(
        prev_gray, curr_gray, None,
        pyr_scale=0.5, levels=3, winsize=15,
        iterations=3, poly_n=5, poly_sigma=1.2, flags=0
    )
    magnitude, angle = cv2.cartToPolar(flow[..., 0], flow[..., 1])
    return magnitude, angle

print("Optical flow velocity estimator initialized.")

# Clinical Heart Disease Risk Prediction
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score, classification_report

# Mock Clinical Features (Age, Chol, MaxHR, RestBP)
np.random.seed(10)
X = np.random.randn(250, 4)
y = (X[:, 0]*0.8 + X[:, 1]*0.6 - X[:, 2]*0.9 + np.random.randn(250)*0.5 > 0).astype(int)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
model = LogisticRegression(penalty='l2', C=1.0)
model.fit(X_scaled, y)

print(f"Clinical Model AUC Score: {roc_auc_score(y, model.predict_proba(X_scaled)[:, 1]):.3f}")
print("Feature Coefficients (Odds Multipliers):", model.coef_[0].round(3))

# Headless Browser Automation with Selenium
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

options = Options()
options.add_argument("--headless=new")
options.add_argument("--disable-gpu")
options.add_argument("--no-sandbox")

# Initialize Browser Driver
driver = webdriver.Chrome(options=options)
try:
    driver.get("https://quotes.toscrape.com/js/")
    wait = WebDriverWait(driver, 10)
    quotes = wait.until(EC.presence_of_all_elements_located((By.CLASS_NAME, "quote")))
    print(f"Dynamic quotes rendered on page: {len(quotes)}")
finally:
    driver.quit()

# Tabular Q-Learning Reinforcement Learning Algorithm
import numpy as np

# 4x4 GridWorld Environment Setup
n_states, n_actions = 16, 4  # Actions: 0:Up, 1:Down, 2:Left, 3:Right
Q = np.zeros((n_states, n_actions))
alpha = 0.1     # Learning Rate
gamma = 0.99    # Discount Factor
epsilon = 1.0   # Exploration Rate
epsilon_decay = 0.995

# Q-Learning Training Loop Demonstration
for episode in range(500):
    state = 0
    done = False
    while not done:
        action = np.random.choice(n_actions) if np.random.rand() < epsilon else np.argmax(Q[state])
        next_state = min(state + 1, n_states - 1)
        reward = 10 if next_state == 15 else -0.1
        done = (next_state == 15)
        
        # Bellman Equation Update
        Q[state, action] += alpha * (reward + gamma * np.max(Q[next_state]) - Q[state, action])
        state = next_state
        
    epsilon = max(0.01, epsilon * epsilon_decay)

print("Q-Learning Policy Converged. Sample Q-Values for State 0:\n", Q[0].round(2))