Object Oriented Programming: Classes and Objects

The idea

So far, data and the code that works on it have been separate. Object oriented programming puts them together.

A class is a blueprint. An object is a thing built from that blueprint.

Think of a class as the plan for a house and objects as the actual houses. One plan, many houses, each with its own address, its own occupants and its own front door colour.

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

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


rex = Dog("Rex", "Labrador")
bella = Dog("Bella", "Collie")

rex.bark()             # Rex says woof!
bella.bark()           # Bella says woof!
print(rex.breed)       # Labrador

The parts

• class Dog: defines the blueprint. Class names use CapitalCase by convention.
• __init__ is the constructor. It runs automatically whenever a new object is created, and it sets up that object's starting data.
• self refers to this particular object. Every method takes it as its first parameter.
• self.name is an attribute, a piece of data belonging to this object.
• bark is a method, a function belonging to the class.

Building a useful class

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []

    def deposit(self, amount):
        if amount <= 0:
            return False
        self.balance += amount
        self.transactions.append(("deposit", amount))
        return True

    def withdraw(self, amount):
        if amount <= 0 or amount > self.balance:
            return False
        self.balance -= amount
        self.transactions.append(("withdraw", amount))
        return True

    def statement(self):
        lines = [f"Account: {self.owner}"]
        for kind, amount in self.transactions:
            lines.append(f"  {kind:<9} {amount:>8.2f}")
        lines.append(f"Balance: {self.balance:.2f}")
        return "\n".join(lines)


account = BankAccount("Aisha", 100)
account.deposit(50)
account.withdraw(30)
account.withdraw(9999)        # refused, returns False
print(account.statement())

Notice that the account cannot go overdrawn, because the rule lives inside the class alongside the data it protects. That is the real value of OOP: the object looks after its own correctness.

Special methods

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

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

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y


p = Point(3, 4)
print(p)                        # (3, 4), because of __str__
print(Point(1, 2) == Point(1, 2))   # True, because of __eq__

__str__ decides what print() shows. Without it you get something unhelpful like <__main__.Point object at 0x7f...>.

Encapsulation

Encapsulation means bundling data together with the methods that operate on it, and controlling access to that data from outside.

Why it matters

If any part of a program can reach in and change an object's data directly, the object cannot guarantee anything about itself.

account.balance = -5000     # nothing stops this

Private attributes by convention

A leading underscore signals that an attribute is internal and should not be touched from outside. Two underscores makes Python actively mangle the name to discourage it.

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius

    def get_celsius(self):
        return self._celsius

    def set_celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero")
        self._celsius = value

    def get_fahrenheit(self):
        return self._celsius * 9 / 5 + 32


t = Temperature(20)
print(t.get_fahrenheit())      # 68.0
t.set_celsius(25)

Properties, the Pythonic way

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero")
        self._celsius = value

    @property
    def fahrenheit(self):
        return self._celsius * 9 / 5 + 32


t = Temperature(20)
print(t.celsius)        # 20, looks like an attribute
print(t.fahrenheit)     # 68.0, calculated on demand
t.celsius = 30          # runs the setter, which validates

This gives clean syntax with full control. The validation runs every time, but the code using it reads like a simple attribute.

Key terms you must be able to define

Class

A blueprint defining the attributes and methods that objects of that type will have.

Object

A specific instance created from a class, with its own data.

Instance

Another word for an object created from a class.

Attribute

A piece of data belonging to an object.

Method

A function defined inside a class that operates on an object.

Constructor

The __init__ method, which runs automatically when an object is created.

self

The parameter referring to the particular object a method is operating on.

Encapsulation

Bundling data with the methods that act on it, and controlling access from outside.

Property

A method that is accessed like an attribute, allowing validation on assignment.

Flashcards

Say the definition out loud before you flip the card. Retrieving it from memory is what builds recall, reading it again is not.

Reach the top grade on this topic

• Explain the difference between a class and an object using a concrete example
• Write a constructor that sets up every attribute the object needs
• Put validation inside the class so the object cannot be put into an invalid state
• Add __str__ to every class so printing an object is useful
• Explain encapsulation as the object controlling its own data, not just as hiding

Mistakes that cost marks here