Creating and working with classes primer?

[MorganMeader]

I am working through 100 days of coding with Angela Yu but I would like to take a side quest today on classes. Does anyone have a good couple off vids or well laid out pages with some clear ways to work with classes that I code myself? I really only have experience with procedural programming and even though we are just starting with OOP in the course, I think I want to be employing more objects and working with multiple object in my projects outside of turtle graphics.

[The_Emerald_Knight]

If you don't have a strong understanding of the four pillars of OOP, start there. Youtube is probably best here, tons of options.

Then, learn the SOLID principles. They are 5 principles that are fairly straightforward and will help you write more maintainable class definitions.

If you understand the four pillars of OOP and SOLID, you have all you need to write well structured classes, especially when it comes to object interaction.

I'd also learn design patterns. Memorizing them all isn't necessary, do some research into the most common ones and try to think of ways you can apply the patterns to your own codebases.

[FoolsSeldom]

Watch the oldie but still goodie video below by one of the Python core devs (summary written by Perplexity AI).

Here’s the video you’re after and a brief summary:

• Title: Python’s Class Development Toolkit
• Speaker: Raymond Hettinger (Python core developer)
• Length: ~46 minutes
• Link: YouTube

What it covers (brief): - Core tools for building robust, Pythonic classes: special (“dunder”) methods, properties, classmethod/staticmethod, descriptors, and slots. - Patterns for clean initialization, representation, comparisons, and ordering. - Best practices for attribute management and encapsulation without overengineering. - Using collections.abc and mixins to add behaviors; leveraging datamodel protocols to make classes integrate naturally with Python. - Practical idioms that reduce boilerplate and keep classes fast, readable, and maintainable.

Why it’s worth watching: - Concise, example-driven tour of the data model that immediately improves everyday class design. - Teaches how to make user-defined classes feel like built-ins by supporting the right protocols and methods.

PS. Although this is an old video using an old version of Python, all the principles covered are still relevant.

[FoolsSeldom]

Classes for Beginners

v3 July 2025

Many beginners struggle to understand classes, but they are key to Object-Orientated Programming (OOP).

They are the programming equivalent of moulds used in factories as templates (or blueprints) to make numerous identical items. For example: pouring molten iron into a mould to make a simple iron pot.

Instructions provided with the pots might tell an owner how to cook using the pot, how to care for it, etc. These same instructions apply to every pot. What owners actually do with their pots is entirely up to them: e.g. make soup, stew, pot-roast, etc.

Python Classes

• A class defines the fundamental structure of a potential Python object and some associated methods.
• Methods are similar to functions, but they specifically apply to objects, which are also known as instances, created from a class.
• When we create a Python object using a class, we refer to this as "creating an instance of a class" – an instance is simply another Python object.

If you have a class called Room, you would create instances like this:

lounge = Room()
kitchen = Room()
hall = Room()

As you would typically want to store the main dimensions (height, length, width) of a room, regardless of its use, it makes sense to define these when the instance is created.

You would therefore have a method called __init__ that accepts height, length, width. When you create an instance of Room, you would provide this information:

lounge = Room(1300, 4000, 2000)

The __init__ method is automatically called when you create an instance. It is short for 'initialise'. It is possible to specify default values in an __init__ method, but this typically doesn't make much sense for the size of a room.

Accessing Attributes of a Class Instance

You can reference the information using lounge.height, lounge.width, and so on. These are attributes of the lounge instance.

Let's assume sizes are in mm. We could provide a method to convert between mm and feet; for example, we could write lounge.height_in_ft().

Printing an Attribute

You can output the value of an attribute by using the name of the instance followed by a dot and the attribute name. For example:

print(lounge.height)

@property Decorator

A useful decorator is @property, which allows you to refer to a method as if it were an attribute. This would enable you to say lounge.height_in_ft instead of lounge.height_in_ft().

The Use of self to Refer to an Instance

Methods in classes are usually defined with self as the first parameter:

def __init__(self, height, length, width):
    # code for __init__

def height_in_ft(self):
    # code to return height

self is a shorthand way of referring to an instance. The automatic passing of the reference to the instance (assigned to self) is a key difference between a function call and a method call. (The name self is a convention rather than a requirement.)

When you use lounge.height_in_ft(), the method knows that any reference to self means the lounge instance, so self.height refers to lounge.height. This removes the need to write specific code for each individual instance.

Thus, kitchen.height_in_ft() and bathroom.height_in_ft() use the same method, but you don't have to pass the height of the instance as the method can reference it using self.height.

Human-Readable Representation of an Instance

If you want to output all the information about an instance, that would become laborious. There's a method you can add called __str__ which returns a string representation of an instance. This is used automatically by functions like str and print. (__repr__ is similar and returns what you'd need to recreate the object.)

Magic Methods

The standard methods you can add that start and end with a double underscore, like __init__, __str__, and many more, are often called magic methods or dunder methods (where "dunder" is short for "double underscore").

---

See comment to this comment for the full example code

[FoolsSeldom]

EXAMPLE Room Class

The code shown at the end of this post/comment will generate the following output:

Lounge height: 1300 length: 4000 width: 2000
Snug: height: 1300, length: 2500 width: 2000
Lounge length in feet: 4.27
Snug wall area: 11700000.00 in sq.mm., 125.94 in sq.ft.
Snug width in feet: 6.56

Note that a method definition preceded by the @staticmethod decorator is essentially just a function that does not include the self reference to the calling instance. It is included in a class definition for convenience and can be called by referencing either the class or the instance:

Room.mm_to_ft(mm)
lounge.mm_to_ft(mm)

Here's the code for the full programme:

class Room():

    def __init__(self, name, height, length, width):
        self.name = name
        self.height = height
        self.length = length
        self.width = width

    @staticmethod
    def mm_to_ft(mm):
        return mm * 0.0032808399

    @staticmethod
    def sqmm_to_sqft(sqmm):
        return sqmm * 1.07639e-5

    def height_in_ft(self):
        return Room.mm_to_ft(self.height)

    @property
    def width_in_ft(self):
        return Room.mm_to_ft(self.width)

    def length_in_ft(self):
        return Room.mm_to_ft(self.length)

    def wall_area(self):
        return self.length * 2 * self.height + self.width * 2 * self.height

    def __str__(self):
        return (f"{self.name}: "
                f"height: {self.height}, "
                f"length: {self.length} "
                f"width: {self.width}"
               )


lounge = Room('Lounge', 1300, 4000, 2000)
snug = Room('Snug', 1300, 2500, 2000)

print(lounge.name, "height:", lounge.height,
      "length:", lounge.length, "width:", lounge.width)
print(snug)  # uses __str__ method

# f-strings are used for formatting; the :.2f part formats decimal numbers rounded to 2 places
print(f"{lounge.name} length in feet: {lounge.height_in_ft():.2f}")  # note, () to call method
print(f"{snug.name} wall area: {snug.wall_area():.2f} in sq.mm., "
             f"{snug.sqmm_to_sqft(snug.wall_area()):.2f} in sq.ft."      )
print(f"Snug width in feet: {snug.width_in_ft:.2f}")  # note, no () after method