Classes

Jon Reades - j.reades@ucl.ac.uk

1st October 2025

A tight coupling of the data, and the functions that act on the data.

It is the template for producing new objects…

What’s an Object?

Objects are instantiated versions of classes:

• "hello world" is an instance of a string, and
• ['A','B',1,3] is an instance of a list.

The class is your recipe, the object is your 🍕…

Really… Like a Pizza!

class pizza(object):
  base = 'sourdough'
  
  def __init__(self, sauce:str='tomato', cheese:str='mozzarella'):
    self.toppings = []
    self.sauce = sauce
    self.cheese = cheese
    
  def add_topping(self, topping:str) -> None:
    self.toppings.insert(len(self.toppings), topping)
  
  def get_pizza(self) -> list:
    ingredients = [self.base, self.sauce, self.cheese]
    ingredients.extend(self.toppings)
    return ingredients

Class Definition

class pizza(object):

    base = 'sourdough'
    ...

Follows the pattern: class <name>(<parent class>).

You can find many examples in: /opt/conda/envs/sds2020/lib/python3.7/site-packages (Docker).

The Constructor

  def __init__(self, sauce:str='tomato', cheese:str='mozzarella'):
    self.toppings = []
    self.sauce    = sauce
    self.cheese   = cheese

Follows the pattern: def __init__(self, <params>)

Notice also the namespace: the parameters sauce and cheese are the same as the instance variables self.sauce and self.cheese because they occupy different namespaces.

Adding Toppings

def add_topping(self, topping:str) -> None:
    self.toppings.insert(len(self.toppings), topping)

Follows the pattern: def <function>(self, <params>):

Getting the Pizza

def get_pizza(self) -> list:
    ingredients = [self.base, self.sauce, self.cheese]
    ingredients.extend(self.toppings)
    return ingredients

Pizza in Action

p = pizza(sauce='white')
p.add_topping('peppers')
p.add_topping('chillis')
p.get_pizza()
> ['sourdough', 'white', 'mozzarella', 'peppers', 'chillis']

Check it Out

p1 = pizza(sauce='white')
p1.add_topping('peppers')
p1.add_topping('chilis')

p2 = pizza()
p2.base = "Plain old base"
p2.add_topping('pineapple')
p2.add_topping('ham')

p1.get_pizza()
> ['sourdough', 'white', 'mozzarella', 'peppers', 'chilis']
p2.get_pizza()
> ['Plain old base', 'tomato', 'mozzarella', 'pineapple', 'ham']

But…

pizza.base='Crusty' # Like changing a package var!
p1.get_pizza()      # Base has changed
# ['Crusty', 'white', 'mozzarella', 'peppers', 'chilis']
p2.get_pizza()      # Base has not changed!
# ['Plain old base', 'tomato', 'mozzarella', 'pineapple', 'ham']

p3 = pizza()
p3.get_pizza()      # Base has changed
# ['Crusty', 'tomato', 'mozzarella']

Recap: How to Make a Pizza

A class is defined by:

class <name>(<parent class):
  ...

A class is initialised by:

  def __init__(self, <any_parameters>):
    ...

All methods have to have this:

  def <method>(self, <any_parameters>):
    ...

Recap: How to Make a Pizza (cont’d)

This is an instance variable:

  self.<var> = <something>

This is a class variable (in the class definition):

  <var> = <something>

Respect Your Self

So the keyword self refers to the instantiated object: the object always passes a reference to itself as the first parameter in any method.

Decorating a Class

Classes have additional decorators you can use:

1. @staticmethod: binds any function to a class so objects can use it (but no object or class information is passed to static methods).
2. @classmethod: decorates a function for use by a class, not an object (accesses and modifies class state).
3. @property: create ‘managed’ attributes in classes to ‘hide’ them from users but keep code clean.

Class and Static Methods¹

from datetime import date
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # a class method to create a Person object by birth year.
    @classmethod
    def fromBirthYear(cls, name, year):
        return cls(name, date.today().year - year)

    # a static method to check if a Person is adult or not.
    @staticmethod
    def isAdult(age):
        return age > 18

person1 = Person('Andy', 31)
person2 = Person.fromBirthYear('Jon', 1976)

print(person1.age)
print(person2.age)
print(Person.isAdult(22))

31
49
True

1. From Geeks for Geeks.

Properties¹

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        """The radius property."""
        print("Get radius")
        return self._radius

    @radius.setter
    def radius(self, value):
        print("Set radius")
        self._radius = value

    @radius.deleter
    def radius(self):
        print("Delete radius")
        del self._radius

circle = Circle(42.0)
print(circle.radius)
circle.radius = 100
print(circle.radius)
del(circle.radius)

Get radius
42.0
Set radius
Get radius
100
Delete radius

This is a simple example, but notice how we are accessing an attribute with the potential to ‘do things’ before or after accessing the value of interest. This could have all sorts of useful applications in the real world where lots of things are happening to an application at the same time.

1. Example from Real Python.

Additional Resources

• Classes
• Objects
• Basic class definition
• Instance methods and attributes
• Checking instance types
• Class methods and members

• Creating a class
• Constructing an object
• Class methods
• Class vs Instance Variables
• Object data
• Inheritance
• An Introduction to Object-Oriented Programming (by a CASA alum)

Thank You

References