📚 AIO2025 - Week 3: Object-Oriented Programming, SQL & Data Structures

🎯 Learning Objectives: Master object-oriented programming principles, advanced SQL operations, and fundamental data structures through interactive visualizations and practical examples.

📚 Table of Contents

🎯 1. Object-Oriented Programming (OOP)
💾 2. Database - SQL Advanced Techniques
🏗️ 3. Data Structures Fundamentals

🎯 1. Object-Oriented Programming (OOP)#

💡 Core Concept: OOP is a programming paradigm based on “objects” - entities that encapsulate data (attributes) and behavior (methods) together.

💻 1.1. Classes and Objects Fundamentals#

Concept	Definition	Key Characteristics
Class	Blueprint for creating objects	Defines attributes and methods
Object	Instance of a class	Contains actual data and can execute methods
Attributes	Data stored in objects	Variables that hold object state
Methods	Functions defined in classes	Operations that objects can perform

🎨 Interactive Class-Object Relationship Visualization#

💻 Practical Python Implementation#

1
# Define a class named 'Dog'
2
class Dog:
3
    # Class attribute (shared by all instances)
4
    species = "Canis familiaris"
5

6
    # Initializer / Instance attributes
7
    def __init__(self, name, age):
8
        self.name = name        # Public attribute
9
        self.age = age          # Public attribute
10
        self._breed = None      # Protected attribute
11
        self.__id = id(self)    # Private attribute
12

13
    # Instance method
14
    def describe(self):
15
        return f"{self.name} is {self.age} years old."
16

17
    # Another instance method
18
    def speak(self, sound):
19
        return f"{self.name} says {sound}."
20

21
    # Getter method
22
    def get_breed(self):
23
        return self._breed
24

25
    # Setter method
26
    def set_breed(self, breed):
27
        self._breed = breed
28

29
# Create instances (objects) of the Dog class
30
dog1 = Dog("Buddy", 5)
31
dog2 = Dog("Lucy", 3)
32

33
# Accessing attributes and calling methods
34
print(f"Name: {dog1.name}")              # Output: Name: Buddy
35
print(f"Description: {dog1.describe()}")  # Output: Description: Buddy is 5 years old.
36
print(f"Sound: {dog2.speak('Woof!')}")    # Output: Sound: Lucy says Woof!
37

38
# Working with breed
39
dog1.set_breed("Golden Retriever")
40
print(f"Breed: {dog1.get_breed()}")       # Output: Breed: Golden Retriever

🔍 Key Insights: Notice how the class serves as a template, while each object (dog1, dog2) has its own unique data but shares the same structure and behavior.

🏗️ 1.2. Four Core Principles of OOP#

🔒 1.2.1. Encapsulation#

Definition: Encapsulation bundles data (attributes) and methods into a single unit while restricting direct access to internal components.

Access Level	Python Convention	Visibility	Usage
Public	`attribute`	Accessible everywhere	General use attributes/methods
Protected	`_attribute`	Internal use (convention)	Subclass access intended
Private	`__attribute`	Name mangled	Strictly internal use

🎨 Interactive Encapsulation Visualization#

💻 Practical Encapsulation Example#

1
class BankAccount:
2
    def __init__(self, account_holder, initial_balance=0):
3
        # Public attributes
4
        self.account_holder = account_holder
5
        self.account_type = "Savings"
6

7
        # Protected attributes (internal use)
8
        self._account_number = self._generate_account_number()
9
        self._creation_date = "2024-12-16"
10

11
        # Private attributes (strictly internal)
12
        self.__balance = initial_balance
13
        self.__security_key = "SECRET_KEY_12345"
14
        self.__transaction_history = []
15

16
    # Public methods (safe interface)
17
    def get_balance(self):
18
        """Provides controlled read-only access to balance"""
19
        return self.__balance
20

21
    def deposit(self, amount):
22
        """Safe deposit method with validation"""
23
        if self._validate_transaction(amount):
24
            self.__balance += amount
25
            self.__log_transaction("DEPOSIT", amount)
26
            print(f"✅ Deposited: ${amount:.2f}")
27
            return True
28
        return False
29

30
    def withdraw(self, amount):
31
        """Safe withdrawal with balance checking"""
32
        if self._validate_transaction(amount) and amount <= self.__balance:
33
            self.__balance -= amount
34
            self.__log_transaction("WITHDRAW", amount)
35
            print(f"✅ Withdrawn: ${amount:.2f}")
36
            return True
37
        print("❌ Insufficient funds or invalid amount")
38
        return False
39

40
    def get_account_info(self):
41
        """Public method returning safe information"""
42
        return {
43
            "holder": self.account_holder,
44
            "type": self.account_type,
45
            "balance": self.__balance,
46
            "account_number": self._account_number[-4:]  # Only last 4 digits
47
        }
48

49
    # Protected methods (intended for subclasses)
50
    def _validate_transaction(self, amount):
51
        """Internal validation logic"""
52
        return isinstance(amount, (int, float)) and amount > 0
53

54
    def _generate_account_number(self):
55
        """Internal account number generation"""
56
        import random
57
        return f"ACC{random.randint(100000, 999999)}"
58

59
    # Private methods (strictly internal)
60
    def __log_transaction(self, transaction_type, amount):
61
        """Private transaction logging"""
62
        self.__transaction_history.append({
63
            "type": transaction_type,
64
            "amount": amount,
65
            "timestamp": "2024-12-16 10:30:00"
66
        })
67

68
# Usage demonstration
69
account = BankAccount("Alice Smith", 1000)
70

71
# ✅ Public interface - Safe and controlled access
72
print(f"Account Holder: {account.account_holder}")  # Direct access OK
73
print(f"Balance: ${account.get_balance():.2f}")     # Controlled access
74
account.deposit(500)                                # Safe method
75
account.withdraw(200)                               # Safe method
76
print(account.get_account_info())                   # Safe info retrieval
77

78
# 🔒 Protected access - Not recommended but possible
79
print(f"Account Number: {account._account_number}") # Discouraged but works
80

81
# ❌ Private access - Will fail
82
try:
83
    print(account.__balance)  # AttributeError!
84
except AttributeError as e:
85
    print(f"Error: {e}")
86

87
# ⚠️ Name mangling - Python's way of hiding private attributes
88
print(f"Actual private attribute name: {account._BankAccount__balance}")  # Still accessible but discouraged

🎯 Key Benefits of Encapsulation:

Data Security: Prevents accidental modification of critical data

Controlled Access: Validates inputs before changing state

Code Maintainability: Changes to internal implementation don’t break external code

Error Prevention: Reduces bugs by limiting direct data manipulation

🎭 1.2.2. Abstraction#

Abstraction means hiding the complex implementation details and showing only the essential features of the object. It helps in reducing programming complexity and effort. An abstract class is a class that contains one or more abstract methods. An abstract method is a method that is declared, but contains no implementation.

🎨 Interactive Abstraction Visualization#

Example using abc module:

1
from abc import ABC, abstractmethod
2

3
class Shape(ABC): # Abstract class
4
    @abstractmethod
5
    def area(self):
6
        pass
7

8
    @abstractmethod
9
    def perimeter(self):
10
        pass
11

12
class Square(Shape):
13
    def __init__(self, side):
14
        self.__side = side
15

16
    def area(self):
17
        return self.__side * self.__side
18

19
    def perimeter(self):
20
        return 4 * self.__side

🧬 1.2.3. Inheritance#

Inheritance is a mechanism in which one class (child/derived) acquires the properties (methods and fields) of another class (parent/base). This promotes code reusability.

Types of Inheritance: Single, Multiple, Multilevel, Hierarchical.

🎨 Interactive Inheritance Types Visualization#

Example:

1
# Parent class
2
class Animal:
3
    def __init__(self, name):
4
        self.name = name
5

6
    def eat(self):
7
        print(f"{self.name} is eating.")
8

9
# Child class inheriting from Animal
10
class Dog(Animal):
11
    def __init__(self, name, breed):
12
        super().__init__(name) # Call parent constructor
13
        self.breed = breed
14

15
    def bark(self):
16
        print(f"{self.name} says woof!")
17

18
my_dog = Dog("Rex", "German Shepherd")
19
my_dog.eat()   # Inherited method
20
my_dog.bark()  # Child's own method

🎭 1.2.4. Polymorphism#

Polymorphism, which means “many forms,” allows us to perform a single action in different ways. It allows methods to do different things based on the object it is acting upon. Method overriding is a key example.

🎨 Interactive Polymorphism Visualization#

Example (Method Overriding):

1
class Bird:
2
    def intro(self):
3
        print("There are many types of birds.")
4

5
    def flight(self):
6
        print("Most of the birds can fly but some cannot.")
7

8
class Sparrow(Bird):
9
    # Overriding the flight method
10
    def flight(self):
11
        print("Sparrows can fly.")
12

13
class Ostrich(Bird):
14
    # Overriding the flight method
15
    def flight(self):
16
        print("Ostriches cannot fly.")
17

18
obj_bird = Bird()
19
obj_sparrow = Sparrow()
20
obj_ostrich = Ostrich()
21

22
obj_bird.flight()
23
obj_sparrow.flight()
24
obj_ostrich.flight()

🧠 1.3. Custom Class in PyTorch (nn.Module)#

In PyTorch, all neural network modules, including layers and activation functions, are subclasses of torch.nn.Module. To create a custom layer or model, you must inherit from this class.

__init__(self): Define the layers (e.g., nn.Linear, nn.Conv2d) you will use. You must call super().__init__().
forward(self, x): Defines the forward pass of the module. This is where the computation happens, connecting the defined layers.

Example: Custom Sigmoid Function#

The sigmoid function is given by: \( \text{sigmoid}(x) = \frac{1}{1 + e^{-x}} \)

1
import torch
2
import torch.nn as nn
3

4
class CustomSigmoid(nn.Module):
5
    def __init__(self):
6
        super().__init__() # Call the constructor of the parent class (nn.Module)
7

8
    def forward(self, x):
9
        # Define the forward pass computation
10
        return 1 / (1 + torch.exp(-x))
11

12
# Usage
13
data = torch.tensor([1.0, 5.0, -4.0])
14
custom_sigmoid = CustomSigmoid()
15
output = custom_sigmoid(data)
16
print(output)
17
# Expected output: tensor([0.7311, 0.9933, 0.0180])

Example: Custom Softmax Function#

The softmax function is: \( \text{softmax}(x_i) = \frac{\exp(x_i)}{\sum_j \exp(x_j)} \)

A numerically stable version is: \( \text{softmax}_{\text{stable}}(x_i) = \frac{\exp(x_i - c)}{\sum_j \exp(x_j - c)} \) where \( c = \max(x) \).

1
import torch
2
import torch.nn as nn
3

4
class StableSoftmax(nn.Module):
5
    def __init__(self):
6
        super().__init__()
7

8
    def forward(self, x):
9
        c = torch.max(x, dim=0).values
10
        exp_x_minus_c = torch.exp(x - c)
11
        sum_exp = torch.sum(exp_x_minus_c)
12
        return exp_x_minus_c / sum_exp
13

14
# Usage
15
data = torch.tensor([1.0, 2.0, 3.0])
16
stable_softmax = StableSoftmax()
17
output = stable_softmax(data)
18
print(output)
19
# Expected output: tensor([0.0900, 0.2447, 0.6652])

💾 2. Database - SQL Advanced Techniques#

Structured Query Language (SQL) is used to communicate with a database. It is the standard language for relational database management systems.

🔗 2.1. SQL JOIN Clause#

Joins are used to combine rows from two or more tables, based on a related column between them.

Join Type	Description
INNER JOIN	Returns records that have matching values in both tables.
LEFT JOIN	Returns all records from the left table, and the matched records from the right table.
RIGHT JOIN	Returns all records from the right table, and the matched records from the left table.
FULL OUTER JOIN	Returns all records when there is a match in either left or right table. (MySQL doesn’t support this directly; it can be emulated with UNION)
SELF JOIN	A regular join, but the table is joined with itself.
CROSS JOIN	Creates the Cartesian product of the two tables, returning all possible combinations of rows.

🎨 Interactive SQL JOINs Visualization#

Example: Joining orders and customers tables

1
SELECT
2
    o.order_id,
3
    c.first_name,
4
    c.last_name,
5
    os.name AS status
6
FROM orders AS o
7
JOIN customers AS c ON o.customer_id = c.customer_id
8
JOIN order_statuses AS os ON o.status = os.order_status_id
9
WHERE c.state = 'VA'; -- Example of filtering after joining

🔍 2.2. Subqueries (Nested Queries)#

A subquery is a query nested inside another query. It can be used in SELECT, FROM, WHERE, or HAVING clauses.

Example: Find clients with an invoice total above the average.

1
SELECT *
2
FROM invoices
3
WHERE invoice_total > (
4
    -- Subquery to calculate the average invoice total
5
    SELECT AVG(invoice_total)
6
    FROM invoices
7
);

📋 2.3. Common Table Expressions (CTEs)#

A CTE provides a temporary, named result set that you can reference within another SELECT, INSERT, UPDATE, or DELETE statement. CTEs improve readability and help break down complex queries.

Example: Find the client with the highest total invoice amount.

1
WITH client_sales AS (
2
    -- CTE to calculate total sales per client
3
    SELECT
4
        client_id,
5
        SUM(invoice_total) AS total_sales
6
    FROM invoices
7
    GROUP BY client_id
8
)
9
SELECT
10
    c.name,
11
    cs.total_sales
12
FROM clients c
13
JOIN client_sales cs ON c.client_id = cs.client_id
14
ORDER BY cs.total_sales DESC
15
LIMIT 1;

🗃️ 2.4. Temporary Tables#

A temporary table is a table that is created and exists only for the duration of a database session. It’s useful for storing intermediate results.

1
-- Create a temporary table to hold aggregated data
2
CREATE TEMPORARY TABLE temp_client_summary AS
3
SELECT
4
    client_id,
5
    SUM(invoice_total) AS total_spent,
6
    COUNT(invoice_id) AS number_of_invoices
7
FROM invoices
8
GROUP BY client_id;
9

10
-- Now you can query this temporary table multiple times
11
SELECT * FROM temp_client_summary WHERE total_spent > 500;

⚙️ 2.5. Stored Procedures and Triggers#

Stored Procedure: A prepared SQL code that you can save, so the code can be reused over and over again. You can pass parameters to a stored procedure.
Trigger: A special type of stored procedure that automatically runs when an event (INSERT, UPDATE, DELETE) occurs in a database table.

Example: Stored Procedure

1
DELIMITER $$
2

3
CREATE PROCEDURE get_clients_by_state(IN state_abbreviation CHAR(2))
4
BEGIN
5
    SELECT * FROM clients
6
    WHERE state = state_abbreviation;
7
END$$
8

9
DELIMITER ;
10

11
-- To use it:
12
CALL get_clients_by_state('CA');

🏗️ 3. Data Structures Fundamentals#

💡 Core Concept: Data structures are a way of organizing and storing data so that they can be accessed and worked with efficiently.

📚 3.1. Stack#

A stack is a linear data structure that follows the LIFO (Last-In, First-Out) principle. The last element added to the stack will be the first one to be removed.

Key Operations:

push: Adds an element to the top of the stack
pop: Removes the top element from the stack
peek/top: Returns the top element without removing it
is_empty: Checks if the stack is empty

🎨 Interactive Stack Visualization#

Python Implementation:

1
class MyStack:
2
    def __init__(self, capacity):
3
        self._capacity = capacity
4
        self._stack = []
5

6
    def is_empty(self):
7
        return len(self._stack) == 0
8

9
    def is_full(self):
10
        return len(self._stack) == self._capacity
11

12
    def push(self, item):
13
        if self.is_full():
14
            raise Exception("Stack Overflow")
15
        self._stack.append(item)
16

17
    def pop(self):
18
        if self.is_empty():
19
            raise Exception("Stack Underflow")
20
        return self._stack.pop()
21

22
    def top(self):
23
        if self.is_empty():
24
            return "Stack is empty"
25
        return self._stack[-1]

🚀 3.2. Queue#

A queue is a linear data structure that follows the FIFO (First-In, First-Out) principle. The first element added to the queue will be the first one to be removed.

Key Operations:

enqueue: Adds an element to the rear of the queue
dequeue: Removes an element from the front of the queue
front: Returns the first element
rear: Returns the last element
is_empty: Checks if the queue is empty

🎨 Interactive Queue Visualization#

Python Implementation:

1
from collections import deque
2

3
class MyQueue:
4
    def __init__(self, capacity):
5
        self._capacity = capacity
6
        self._queue = deque()
7

8
    def is_empty(self):
9
        return len(self._queue) == 0
10

11
    def is_full(self):
12
        return len(self._queue) == self._capacity
13

14
    def enqueue(self, item):
15
        if self.is_full():
16
            raise Exception("Queue Overflow")
17
        self._queue.append(item)
18

19
    def dequeue(self):
20
        if self.is_empty():
21
            raise Exception("Queue Underflow")
22
        return self._queue.popleft()
23

24
    def front(self):
25
        if self.is_empty():
26
            return "Queue is empty"
27
        return self._queue[0]

🌳 3.3. Tree#

A tree is a non-linear hierarchical data structure that consists of nodes connected by edges.

Key Terminology:

Node: The fundamental part of a tree. It can have a name, which we call a ‘key’, and it holds the data
Root: The topmost node in a tree
Edge: The link between two nodes
Parent: The node which has a branch from it to any other node
Child: A node that is a descendant of another node
Leaf Node: A node with no children
Height: The length of the longest path to a leaf
Depth: The length of the path to its root

🎨 Interactive Tree Structure Visualization#

🔄 Tree Traversal Algorithms#

Tree traversal is the process of visiting each node in a tree data structure exactly once. There are two main categories:

Breadth-First Search (BFS): Explores all nodes at the present depth prior to moving on to the nodes at the next depth level. It uses a queue.

Depth-First Search (DFS): Explores as far as possible along each branch before backtracking. It uses a stack.

DFS Variants:

In-order: Left, Root, Right
Pre-order: Root, Left, Right
Post-order: Left, Right, Root

🎨 Interactive DFS Traversal Variants#

🎨 Interactive BFS vs DFS Traversal Comparison#

🌲 3.4. Binary Search Tree (BST)#

A binary tree where for each node, all keys in the left subtree are less than the node’s key, and all keys in the right subtree are greater than the node’s key. This property makes searching very efficient.

Key Properties:

Left Subtree: All values are smaller than the current node
Right Subtree: All values are larger than the current node
Search Time: \( O(\log n) \) average case, \( O(n) \) worst case
Insertion/Deletion: \( O(\log n) \) average case

🎨 Interactive Binary Search Tree Visualization#

📊 4. Interactive Learning Dashboard#

🎯 Progress Tracker#

🎯 5. Self-Assessment & Action Plan#

✅ Knowledge Check#

Topic	Confidence Level	Next Steps
OOP Principles	⭐⭐⭐⭐⭐	Practice advanced patterns
PyTorch Custom Modules	⭐⭐⭐⭐☆	Build more complex architectures
SQL Advanced Queries	⭐⭐⭐⭐⭐	Optimize query performance
Data Structures	⭐⭐⭐☆☆	Implement algorithms

💡 Key Takeaways#

🌟 This Week’s Achievements:

Mastered OOP fundamentals with practical examples

Explored advanced SQL techniques for data manipulation

Built solid foundation in data structures

Created interactive visualizations for better understanding

📖 Keep Learning! The journey to AI mastery requires consistent practice and application. Use these concepts in your daily coding practice!