RugvAI Labs

Classes & Object-Oriented Programming

Every Pydantic model, every PyTorch nn.Module, every Django ORM entity — they're all classes. The Anthropic SDK's Anthropic() client is a class. Classes group related state and behavior into one cohesive unit, and they're the foundation of every framework you'll ever build on.

Learning Objectives

After this lesson, you will be able to:

Create classes with __init__, attributes, and methods
Explain what self means and why every method needs it
Use inheritance to build specialized classes from general ones
Override methods to customize behavior in subclasses (polymorphism)
Know when to use a class versus a plain function or dictionary
Add @property decorators for computed attributes and validation
Distinguish instance methods, class methods, and static methods — when to use each
Use __slots__ to reduce memory usage for high-volume objects

Prerequisites

Before You Start

Review

#What Is a Class?

A class is a blueprint for creating objects. An object is a specific instance built from that blueprint.

You have already used objects without knowing it. When you write "hello".upper(), the string "hello" is an object of the class str, and .upper() is a method defined in that class.

pythonrunnable cell

class Dog:
    """A simple Dog class."""

    def __init__(self, name, breed, age):
        """Initialize a new Dog instance."""
        self.name = name      # attribute
        self.breed = breed    # attribute
        self.age = age        # attribute

    def bark(self):
        """Make the dog bark."""
        return f"{self.name} says: Woof!"

    def describe(self):
        """Return a description of the dog."""
        return f"{self.name} is a {self.age}-year-old {self.breed}"

# Create instances (objects)
dog1 = Dog("Buddy", "Golden Retriever", 3)
dog2 = Dog("Luna", "Husky", 5)

print(dog1.bark())       # Buddy says: Woof!
print(dog2.describe())   # Luna is a 5-year-old Husky
print(dog1.name)         # Buddy -- accessing an attribute directly

Loading visualization...

Even with no inheritance, rex.name and rex.bark are still attribute lookups: Python checks the instance first, then walks up to the class. That's why methods defined on Dog are callable on every Dog instance — they live on the class, not the instance.

Let us break down the syntax:

class Dog: -- defines a new class (use PascalCase for class names)
__init__ -- the constructor method, called automatically when you create a new object
self -- a reference to the current object being created or used
self.name = name -- stores the name argument as an attribute on the object
dog1 = Dog("Buddy", ...) -- creates a new Dog instance and calls __init__

What Do You Think?

What does self refer to inside a method?

The answer is the specific object calling the method. When you write dog1.bark(), Python automatically passes dog1 as the self parameter. So inside bark(), self.name is dog1.name, which is "Buddy". When you call dog2.bark(), self becomes dog2, and self.name is "Luna".

Think of it this way: dog1.bark() is secretly Dog.bark(dog1) behind the scenes.

Hit AttributeError: '...' object has no attribute '...'? This means you typed obj.foo but the class never assigned self.foo — usually a typo or you forgot to set it in __init__. See the error decoder for plain-English fixes.

#Attributes and Methods

Attributes store data about an object. Methods define actions an object can perform.

#Instance Attributes vs Class Attributes

pythonrunnable cell

class Student:
    """A student in a course."""

    # Class attribute -- shared by ALL instances
    school = "RugvAI Academy"

    def __init__(self, name, grade):
        # Instance attributes -- unique to EACH instance
        self.name = name
        self.grade = grade
        self.courses = []  # mutable default -- safe here because it is in __init__

    def enroll(self, course):
        """Add a course to this student's schedule."""
        self.courses.append(course)
        return f"{self.name} enrolled in {course}"

    def gpa_status(self):
        """Return academic standing based on grade."""
        if self.grade >= 90:
            return "Honor Roll"
        elif self.grade >= 70:
            return "Good Standing"
        else:
            return "Needs Improvement"

alice = Student("Alice", 95)
bob = Student("Bob", 72)

print(alice.school)        # RugvAI Academy -- class attribute
print(bob.school)          # RugvAI Academy -- same for all

print(alice.enroll("ML 101"))   # Alice enrolled in ML 101
print(alice.enroll("Python"))   # Alice enrolled in Python
print(alice.courses)            # ['ML 101', 'Python']
print(bob.courses)              # [] -- Bob has his own list

print(alice.gpa_status())  # Honor Roll
print(bob.gpa_status())    # Good Standing

Key difference: Class attributes are defined outside __init__ and shared by all instances. Instance attributes are defined inside __init__ with self. and are unique per object.

The `str` Method

When you print() an object, Python calls its __str__ method. You can customize it:

pythonrunnable cell

class Vector:
    """A 2D vector."""

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

    def magnitude(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5

v = Vector(3, 4)
print(v)             # Vector(3, 4) -- thanks to __str__
print(v.magnitude()) # 5.0

#Inheritance

Inheritance lets you create a new class based on an existing one. The new class (child/subclass) inherits all attributes and methods from the existing class (parent/superclass), and can add or override them.

pythonrunnable cell

class Animal:
    """Base class for all animals."""

    def __init__(self, name, species):
        self.name = name
        self.species = species

    def speak(self):
        """Default speak -- subclasses will override this."""
        return f"{self.name} makes a sound"

    def describe(self):
        return f"{self.name} is a {self.species}"


class Dog(Animal):
    """A dog -- inherits from Animal."""

    def __init__(self, name, breed):
        super().__init__(name, species="Dog")  # call parent __init__
        self.breed = breed

    def speak(self):
        """Override the parent's speak method."""
        return f"{self.name} says: Woof! Woof!"

    def fetch(self, item):
        """Dogs can fetch -- a method unique to Dog."""
        return f"{self.name} fetches the {item}"


class Cat(Animal):
    """A cat -- inherits from Animal."""

    def __init__(self, name, indoor=True):
        super().__init__(name, species="Cat")
        self.indoor = indoor

    def speak(self):
        return f"{self.name} says: Meow!"

    def purr(self):
        return f"{self.name} purrs contentedly..."


# Create instances
buddy = Dog("Buddy", "Golden Retriever")
whiskers = Cat("Whiskers", indoor=True)

# Inherited method from Animal
print(buddy.describe())    # Buddy is a Dog
print(whiskers.describe()) # Whiskers is a Cat

# Overridden method
print(buddy.speak())       # Buddy says: Woof! Woof!
print(whiskers.speak())    # Whiskers says: Meow!

# Subclass-specific methods
print(buddy.fetch("ball"))   # Buddy fetches the ball
print(whiskers.purr())       # Whiskers purrs contentedly...

#Key Inheritance Concepts

class Dog(Animal): -- Dog inherits from Animal
super().__init__(...) -- calls the parent class's __init__ to set up inherited attributes
Method overriding -- Dog and Cat define their own speak(), replacing the parent version
Unique methods -- Dog has fetch(), Cat has purr(). Each subclass can add new behavior

Loading visualization...

Watch how Python finds speak on Dog (not Animal) — the subclass wins because it appears earlier in the chain. describe falls all the way back to Animal. fly isn't found anywhere, so Python raises AttributeError. This is the heart of polymorphism: the MRO chain decides which version of a method runs.

Quick check

If Dog inherits from Animal and BOTH define a method called `speak()`, which one runs when you call `Dog('Rex').speak()`?

#Polymorphism

Polymorphism means "many forms." The same method name behaves differently depending on the object's class.

pythonreference · read-only

# All these animals have a speak() method, but each behaves differently
pets = [
    Dog("Buddy", "Retriever"),
    Cat("Whiskers"),
    Dog("Rex", "Shepherd"),
    Cat("Mittens", indoor=False),
]

# Polymorphism in action -- same method call, different behavior
for pet in pets:
    print(pet.speak())
# Buddy says: Woof! Woof!
# Whiskers says: Meow!
# Rex says: Woof! Woof!
# Mittens says: Meow!

This is incredibly powerful because the code pet.speak() does not need to know whether pet is a Dog or a Cat. It just calls speak() and the right version runs. This is exactly how AI frameworks work -- model.forward(x) runs different code depending on whether model is a CNN, an RNN, or a Transformer.

See Object-Oriented Programming in ActionInteractive

Loading visualization...

#Real-World AI Example

pythonrunnable cell

class Model:
    """Base class for ML models."""

    def __init__(self, name):
        self.name = name
        self.trained = False

    def train(self, data):
        """Train the model -- subclasses implement specifics."""
        raise NotImplementedError("Subclasses must implement train()")

    def predict(self, x):
        """Make a prediction -- subclasses implement specifics."""
        raise NotImplementedError("Subclasses must implement predict()")


class LinearRegression(Model):
    def __init__(self):
        super().__init__("Linear Regression")
        self.slope = 0
        self.intercept = 0

    def train(self, data):
        # Simplified training: average slope from data points
        xs = [p[0] for p in data]
        ys = [p[1] for p in data]
        n = len(data)
        self.slope = (n * sum(x * y for x, y in data) - sum(xs) * sum(ys)) / \
                     (n * sum(x ** 2 for x in xs) - sum(xs) ** 2)
        self.intercept = (sum(ys) - self.slope * sum(xs)) / n
        self.trained = True
        print(f"{self.name} trained: y = {self.slope:.2f}x + {self.intercept:.2f}")

    def predict(self, x):
        return self.slope * x + self.intercept


class KNearestNeighbors(Model):
    def __init__(self, k=3):
        super().__init__(f"{k}-Nearest Neighbors")
        self.k = k
        self.data = []

    def train(self, data):
        self.data = data  # KNN just stores the data
        self.trained = True
        print(f"{self.name} trained on {len(data)} points")

    def predict(self, x):
        # Find k nearest points, return average y
        distances = [(abs(x - px), py) for px, py in self.data]
        distances.sort()
        nearest = distances[: self.k]
        return sum(y for _, y in nearest) / self.k


# Polymorphism: same interface, different algorithms
training_data = [(1, 2), (2, 4), (3, 5), (4, 8), (5, 10)]

models = [LinearRegression(), KNearestNeighbors(k=2)]

for model in models:
    model.train(training_data)
    prediction = model.predict(6)
    print(f"  {model.name} predicts f(6) = {prediction:.2f}\n")

#Encapsulation and Best Practices

Encapsulation means bundling data with the methods that operate on that data, and controlling access.

pythonrunnable cell

class BankAccount:
    """A bank account with controlled access to the balance."""

    def __init__(self, owner, initial_balance=0):
        self.owner = owner
        self._balance = initial_balance  # underscore = "private by convention"
        self._transactions = []

    def deposit(self, amount):
        """Add money to the account."""
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self._balance += amount
        self._transactions.append(f"+{amount}")
        return self._balance

    def withdraw(self, amount):
        """Remove money from the account."""
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if amount > self._balance:
            raise ValueError(f"Insufficient funds (balance: {self._balance})")
        self._balance -= amount
        self._transactions.append(f"-{amount}")
        return self._balance

    def get_balance(self):
        """Read the balance safely."""
        return self._balance

    def get_statement(self):
        """Return transaction history."""
        return f"Account: {self.owner} | Balance: {self._balance} | Transactions: {self._transactions}"


account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_statement())
# Account: Alice | Balance: 1300 | Transactions: ['+500', '-200']

The underscore prefix _balance is a Python convention meaning "this is internal -- do not access it directly from outside." Unlike Java or C++, Python does not enforce private access. It trusts developers to respect the convention.

#When to Use Classes vs Functions

Use a class when...	Use a function when...
You have data + behavior together	You have a single, stateless operation
Multiple instances with different state	No need to track state between calls
You need inheritance or polymorphism	The logic is straightforward and standalone
Building a library or framework component	Writing a utility or transformation

#Code Playground

pythonplayground.py · Pyodide

# OOP in Python -- classes, inheritance, polymorphism

# Base class
class Pet:
  def __init__(self, name: str, species: str):
      self.name = name
      self.species = species
      self.energy = 100

def speak(self) -> str:
      return f"{self.name} makes a sound"

def play(self, minutes: int) -> str:
      self.energy = max(0, self.energy - minutes * 2)
      return f"{self.name} played for {minutes} min (energy: {self.energy})"

def __str__(self) -> str:
      return f"{self.name} the {self.species} (energy: {self.energy})"

# Subclass -- Dog
class Dog(Pet):
  def __init__(self, name: str, breed: str):
      super().__init__(name, "Dog")
      self.breed = breed
      self.tricks: list[str] = []

def speak(self) -> str:
      return f"{self.name} says: Woof! Woof!"

def learn_trick(self, trick: str) -> str:
      self.tricks.append(trick)
      return f'{self.name} learned "{trick}"!'

def show_tricks(self) -> str:
      if not self.tricks:
          return f"{self.name} knows no tricks yet"
      return f"{self.name} knows: {', '.join(self.tricks)}"

# Subclass -- Cat
class Cat(Pet):
  def __init__(self, name: str, indoor: bool = True):
      super().__init__(name, "Cat")
      self.indoor = indoor

def speak(self) -> str:
      return f"{self.name} says: Meow!"

def purr(self) -> str:
      return f"{self.name} purrs contentedly..."

# Create instances
buddy = Dog("Buddy", "Golden Retriever")
whiskers = Cat("Whiskers", indoor=True)

# Test methods
print(buddy.speak())
print(whiskers.speak())

print(buddy.learn_trick("sit"))
print(buddy.learn_trick("shake"))
print(buddy.show_tricks())

print(buddy.play(20))       # inherited from Pet
print(whiskers.purr())

# Polymorphism -- same method, different behavior
pets = [buddy, whiskers, Dog("Rex", "Shepherd"), Cat("Luna")]
print("\nAll pets speak:")
for pet in pets:
  print(f"  {pet.speak()}")

# CHALLENGES:
# 1. Add a Bird subclass with a fly() method
# 2. Add a feed() method to Pet that increases energy by 30 (max 100)
# 3. Create a PetShop class that stores a list of pets
#    with methods: add_pet(), list_pets(), find_by_name()
# 4. Add an age attribute and a birthday() method that increments it

Tests · Create subclasses, test inheritance, and verify polymorphism works!

#@property: Computed Attributes and Validation

The @property decorator lets you define methods that behave like attributes — called when you access obj.attribute without parentheses:

pythonrunnable cell

class Circle:
    def __init__(self, radius):
        self._radius = radius  # private by convention (single underscore)
    
    @property
    def radius(self):
        """Getter — called when you access circle.radius"""
        return self._radius
    
    @radius.setter
    def radius(self, value):
        """Setter — called when you write circle.radius = 5"""
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value
    
    @radius.deleter
    def radius(self):
        """Deleter — called when you write del circle.radius"""
        del self._radius
    
    @property
    def area(self):
        """Computed property — no setter, read-only"""
        import math
        return math.pi * self._radius ** 2
    
    @property
    def diameter(self):
        return self._radius * 2


c = Circle(5)
print(c.radius)   # 5 — calls the getter
print(c.area)     # 78.53... — computed on access, no ()
print(c.diameter) # 10

c.radius = 10    # calls the setter (with validation!)
# c.radius = -1  # ValueError: Radius cannot be negative

# c.area = 100   # AttributeError: can't set attribute (no setter)

Properties are how you add validation and computation to attribute access without changing the public interface. If you later need to validate radius, you add a @radius.setter — callers do not need to change their code.

#Class Methods and Static Methods

pythonrunnable cell

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius
    
    # Instance method — has access to self (the instance)
    def to_fahrenheit(self):
        return self.celsius * 9/5 + 32
    
    # Class method — has access to cls (the class itself), not an instance
    # Used for alternative constructors
    @classmethod
    def from_fahrenheit(cls, fahrenheit):
        celsius = (fahrenheit - 32) * 5/9
        return cls(celsius)  # creates a new instance using the class
    
    @classmethod
    def from_kelvin(cls, kelvin):
        return cls(kelvin - 273.15)
    
    # Static method — no access to self or cls
    # Just a regular function that lives in the class namespace
    @staticmethod
    def is_valid_celsius(value):
        return value >= -273.15  # absolute zero
    
    def __repr__(self):
        return f"Temperature({self.celsius:.2f}°C)"


# Instance method
t = Temperature(100)
print(t.to_fahrenheit())  # 212.0

# Class method — alternative constructor (no instance needed!)
t2 = Temperature.from_fahrenheit(32)
print(t2)  # Temperature(0.00°C)

t3 = Temperature.from_kelvin(373.15)
print(t3)  # Temperature(100.00°C)

# Static method
print(Temperature.is_valid_celsius(-300))  # False
print(Temperature.is_valid_celsius(0))     # True

When to use each

Instance method (self): needs to read or modify instance state — the most common type
Class method (cls): alternative constructors, factory methods, or operations on the class itself
Static method: utility functions logically related to the class but not needing instance or class state

slots: Memory Optimization

By default, Python stores instance attributes in a __dict__ (a dictionary) per object. For a class with millions of instances, this overhead adds up:

pythonrunnable cell

class PointNormal:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class PointSlots:
    __slots__ = ['x', 'y']  # pre-declare allowed attributes
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

import sys
p1 = PointNormal(1, 2)
p2 = PointSlots(1, 2)

print(sys.getsizeof(p1))  # ~152 bytes (includes __dict__)
print(sys.getsizeof(p2))  # ~56 bytes (no __dict__, fixed array)

# Can't add new attributes with __slots__:
p1.z = 3    # OK for normal class
# p2.z = 3  # AttributeError: 'PointSlots' object has no attribute 'z'

Use __slots__ when you will create millions of instances (e.g., machine learning training samples, game entities, graph nodes). The trade-off: no dynamic attribute addition.

#Classes in ML: What Real Framework Code Looks Like

Every ML framework is built on classes. Now that you understand __init__, methods, and inheritance — here's what you'll actually write:

pythonrunnable cell

# sklearn transformers use fit() and transform() — your class can too
from sklearn.base import BaseEstimator, TransformerMixin

class TextLengthFeature(BaseEstimator, TransformerMixin):
    """Extract character count as a numeric feature."""

    def fit(self, X, y=None):
        return self  # Nothing to learn from data

    def transform(self, X):
        return [[len(text)] for text in X]

extractor = TextLengthFeature()
print(extractor.transform(["hello world", "hi", "how are you?"]))
# [[11], [2], [12]]

pythonreference · read-only

# PyTorch models inherit from nn.Module — same pattern you just learned
import torch.nn as nn

class SimpleClassifier(nn.Module):
    def __init__(self, input_size: int, num_classes: int):
        super().__init__()              # ← always call parent __init__
        self.layer1 = nn.Linear(input_size, 64)
        self.layer2 = nn.Linear(64, num_classes)
        self.relu   = nn.ReLU()

    def forward(self, x):              # ← called when you do model(x)
        x = self.relu(self.layer1(x))
        return self.layer2(x)

model = SimpleClassifier(input_size=784, num_classes=10)

You already know all the pieces: __init__, self, method definitions, inheritance. Every ML model you'll ever write is a class.

#Key Takeaways

A class is a blueprint; an object is an instance -- class Dog: defines the blueprint, buddy = Dog("Buddy") creates an actual dog object with specific values
__init__ is the constructor -- it runs automatically when you create a new object. Use self.attribute = value to store data on the instance
self refers to the current object -- it is how methods access the object's own attributes and other methods. Every instance method must have self as its first parameter
Inheritance creates specialized classes -- class Dog(Animal): means Dog inherits everything from Animal and can add or override behavior. Use super() to call the parent's methods
Polymorphism means same interface, different behavior -- calling pet.speak() runs different code depending on whether pet is a Dog, Cat, or Bird. This is the foundation of how AI frameworks let you swap models seamlessly

Quick Check1 / 5

What is the purpose of __init__ in a Python class?

Your Reflection

Continue Learning

Discussion

Classes & Object-Oriented Programming

After this lesson, you will be able to:

Before You Start

#What Is a Class?

#Attributes and Methods

#Instance Attributes vs Class Attributes

The `str` Method

#Inheritance

#Key Inheritance Concepts

#Polymorphism

#Real-World AI Example

#Encapsulation and Best Practices

#When to Use Classes vs Functions

Dunder Methods and the Python Data Model

#Code Playground

#@property: Computed Attributes and Validation

#Class Methods and Static Methods

When to use each

slots: Memory Optimization

#Classes in ML: What Real Framework Code Looks Like

#Key Takeaways

Your Reflection

Continue Learning

Discussion

Classes & Object-Oriented Programming

#What Is a Class?

#Attributes and Methods

#Instance Attributes vs Class Attributes

The __str__ Method

#Inheritance

#Key Inheritance Concepts

#Polymorphism

#Real-World AI Example

#Encapsulation and Best Practices

#When to Use Classes vs Functions

Dunder Methods and the Python Data Model

#Code Playground

#@property: Computed Attributes and Validation

#Class Methods and Static Methods

When to use each

slots: Memory Optimization

#Classes in ML: What Real Framework Code Looks Like

#Key Takeaways

The `str` Method