Module 14 — Object-Oriented Programming

Modeling real things as classes and objects — the backbone of large Python programs.

Prerequisite: Module 13 — Generators

Concept & Syntax

Object-oriented programming (OOP) organizes code around objects — bundles of data (attributes) and behavior (methods) modeled on real-world things. A class is the blueprint; an object (or instance) is one specific thing built from that blueprint. Every Dog object shares the same blueprint, but each has its own name, age, and so on.

self is simply how a method refers to "the particular object I was called on." It's always the first parameter of an instance method, and Python passes it automatically — you never supply it yourself when calling the method.

class ClassName:
    def __init__(self, attribute):
        self.attribute = attribute
 
    def method(self):
        return self.attribute
 
obj = ClassName("value")

Examples

Your first class Very Easy

class Dog:
    def __init__(self, name):
        self.name = name
 
    def bark(self):
        return self.name + " says Woof!"
 
rex = Dog("Rex")
print(rex.bark())

__init__ runs automatically when Dog("Rex") is called, storing "Rex" as this object's name attribute.

Multiple objects, independent state Easy

rex = Dog("Rex")
fido = Dog("Fido")
print(rex.bark())
print(fido.bark())

Each object keeps its own separate copy of name — that's what 'instance' variables means.

Class variables vs instance variables Intermediate

class Dog:
    species = "Canis familiaris"  # class variable — shared by all dogs
 
    def __init__(self, name):
        self.name = name  # instance variable — unique per dog
 
rex = Dog("Rex")
fido = Dog("Fido")
print(rex.species, fido.species)
print(rex.name, fido.name)

species is defined once on the class and shared by every instance; name is set per-object inside __init__.

Inheritance Real World

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return f"{self.name} makes a sound."
 
class Dog(Animal):
    def speak(self):
        return f"{self.name} barks."
 
rex = Dog("Rex")
print(rex.speak())

class Dog(Animal) means Dog inherits everything from Animal, then overrides speak() with its own version — this is called method overriding.

@property and __str__ Challenge

class Circle:
    def __init__(self, radius):
        self.radius = radius
 
    @property
    def area(self):
        return 3.14159 * self.radius ** 2
 
    def __str__(self):
        return f"Circle(radius={self.radius})"
 
c = Circle(4)
print(c)
print(c.area)

@property lets you call c.area like a plain attribute even though it's computed. __str__ controls what print() shows for an object.

Visual Explanation

Watch an object get created and used

Use the controls below to run this example one line at a time and watch the interpreter's memory update live.

class Dog:
    def __init__(self, name):
        self.name = name
 
    def bark(self):
        return self.name + " says Woof!"
 
rex = Dog("Rex")
print(rex.bark())

Common Mistakes

class Dog:
    def bark():
        return "Woof!"
 
rex = Dog()
rex.bark()

class Dog:
    def bark(self):
        return "Woof!"
 
rex = Dog()
rex.bark()

class Cart:
    items = []  # class variable — shared by ALL carts!
 
    def add(self, item):
        self.items.append(item)

class Cart:
    def __init__(self):
        self.items = []  # instance variable — one per cart
 
    def add(self, item):
        self.items.append(item)

Exercise & Challenge

class Cat:
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
whiskers = Cat("Whiskers", 3)
print(whiskers.age)

class BankAccount:
    def __init__(self):
        self.balance = 0
 
    def deposit(self, amount):
        self.balance += amount
 
    def withdraw(self, amount):
        if amount > self.balance:
            print("Insufficient funds")
        else:
            self.balance -= amount
 
acc = BankAccount()
acc.deposit(100)
acc.withdraw(30)
print(acc.balance)

Quiz

Answer every question, then submit to see your score and explanations.

Summary

• A class is a blueprint; an object is one instance built from it.
• self refers to the current object inside an instance method.
• Instance variables are per-object; class variables are shared by all instances.
• Inheritance (class Dog(Animal)) lets a subclass reuse and override a superclass's behavior.

Related lessons