Yes. You have the basic idea. Here's my guide to flesh that out a bit more ... Classes for Beginners v2.1 May 2023 A lot of beginners struggle to get their heads around classes, but they are pretty much fundamental to object orientated programming (OOPs). They can be thought of as the programming equal of moulds used in factories as templates (or blueprints) for making lots of things that are identical. Imagine pouring molten iron into a mould to make a simple iron pot. You might produce a set of instructions to be included with the pots that tell an owner how to cook using the pot, how to care for it, etc. The same instructions apply to every pot, but what owners actually do is entirely up to them. Some might make soup, another person a stew, etc. Python classes A class defines the basics of a possible Python object and some methods that come with it Methods are like functions, but apply to objects, known as instances, made using a class When we create a Python object using a class, we call it "creating an instance of a class" - an instance is just 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, whatever it is used for, it makes sense to define that when the instance is created. You would therefore have a method called __init__ that accepts height, length, width and when you create an instance of Room you would provide that information: lounge = Room(1300, 4000, 2000) The __init__ method is called automatically when you create an instance. It is short for initialise (intialize). It is possible to specify default values in an __init__ method, but this doesn't make a lot of 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. We are assuming the measurements are in mm. A method can be included in the class that converts between mm and ft. Thus, for example, we can then write lounge.height_in_ft(). printing an attribute You can output the value of any attribute by just 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 is an attribute. This would allow you to say lounge.height_in_ft instead of lounge.height_in_ft(). In the example code shown later, @property is used for width_in_ft but not height_in_ft. The use of self to refer to an instance Methods in classes are usually defined with a first parameter of self: def __init__(self, height, length, width): # code for __init__ def height_in_ft(self): # code to return height The 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. When you use lounge.height_in_ft() the method knows that any reference to self means the lounge instance, so self.height means lounge.height but you don't have to write the 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 get 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. The example code below includes both the laborious way and using the above method. 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. 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 that is preceded by the command, @staticmethod (a decorator) is really 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 reference to 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 More on reddit.com

There's a massive Wikipedia page on OOP that will give you every little gritty detail. And, there are a lot of OOP evangelists and an ever increasing amount of OOP cynics. Either of which will try to sell you benefits of Language-X, and why Language-Z is the greatest invention since the wheel. Including these 30,000 words of rhetoric, fallacies, and pure garbage.

Here is everything you need to know about OOP. There are three features that make a language an OO language. Any language can have one or two of the features and not be OO, but any language that has all three can be considered OO. They are:

1. Encapsulation

2. Inheritance

3. Polymorphism

Encapsulation is a feature that allows for a data structure to be associated with a set of methods*; An object. In a language without encapsulation, like C, then you will have libraries of functions* and each piece of data is passed to a function. In a language with OO, like Python, you can define a Class that, when instantiated, creates an object. That object, usually, is an aggregate datatype with added logic, methods*. Each instance method has an implicit argument, typically, named self.

* A note on the terms "method" and "function". They're both just synonymous with "subroutine" or a sequence of instructions. However, most programmers differentiate them. A "subroutine" is blockless piece of code that must be reached by a goto statement. A "function" is a block of code that operates exclusively on it's arguments. And, a "method" is a block of code that is associated with an object.

Most languages have generic base "types" like strings, integers, floats, and arrays. When have a need for a "type" with several associated values, then you need an 'aggregated data type'. In a language without Encapsulation, the term is usually called a "struct". With Encapsulation, a "type" is nearly synonymous with a "class" and an instance is called an "object". There's, also, a spectrum of OO-ness. Java base types are NOT objects. An int in Java is not an object, it is a type, but an Integer is an object. In Python everything is an object.

A crude example in Python would be:

class Greeter(object):
    def __init__(self, phrase):
        self.phrase = phrase

    def greet(self, name):
        print(self.phrase.format(name))

hello_greeter = Greeter("Hello, {}!")
hello_greeter.greet("Ms. Smith")

In the above example, we see our first hint of Inheritance. The Greeter class inherits from object (Note: (object) is implicit in Python3.) Inheritance is the ability to associate and expand on another class's data structure and functionality. We could very easily create a HelloWorldGreeter from Greeter.

class HelloWorldGreeter(Greeter):
    def __init__(self):
        super(HelloWorldGreeter, self).__init__("Hello, {}!")

    def greet(self):
        super(HelloWorldGreeter, self).greet("World")

In the Inheritance realm there is single-inheritance and multiple-inheritance. The HelloWorldGreeter is an example of a class with single-inheritance. In fact, must OO languages are specifically only single-inheritance. However, I mention it here because Python isn't most languages as it allows for multiple-inheritance. Which is the reason for the very explicit super(...) function. This function is able to solve the "diamond problem" which is an issue about how inheritance is ordered. I'll just stop here because it's a lengthy topic in itself; follow the link to Wikipedia for more. If you want to know more Python's super(...) method, then read Raymond Hettinger's post "Python's super() considered super!"

A lot of detractors consider inheritance -- especially, multiple inheritance -- as a complicated obfuscation that makes code harder to debug.

That leaves us with Polymorphism. This will be the most difficult for me to explain and, I suspect, the most contentious of OO features. And, it's going to require us to take a step back.

All languages have a "type system". There are a few adjectives that get thrown around. The two that most people confuse (and I might do so myself) are the mutually exclusive "weakly" (or "loosely") typed and "strongly" typed languages. Also, there are other concepts that are frequently confused as 'strong' and 'weak' which are "static type-checking" and "dynamic type-checking". To unravel all of this, here is the best I can do to concisely describe these concepts:

• Strongly Typed: A strongly typed language is one that will cause an error if a piece of logic tries to operate on an unexpected type. Something that tends to confuse a lot of people is the fact that Python (and Ruby) are strongly typed. I'll try to explain later in 'Dynamic Type-Checking'.

• Weakly Typed: A language that attempts to perform type conversion would be considered "weakly" typed. Java, for instance, does "auto-boxing" and "auto-unboxing" for it's basic types; ex int fortytwo = 20 + new Integer(22). In C, one can add pointers to numeric types and numeric types can be coerced into another numeric types; ex. an int can safely converted to long.

• Static Type-Checking: A static type-checking language is one that tracks each object's type to prevent type-specifc logic errors. For example, one shouldn't pass a string to a function that expects to receive two integers. Typically, this is a compile time feature which gives an added performance benefit because the resulting program does not need runtime type checking.

However, languages like javascript and Python (PEP 484) are adding "type hinting" which can be thought of as "unenforced static type-checking". Rather than halting compilation, errors and warnings will be presented.

• Dynamic Type-Checking: A dynamic type-checking language is one that does not make any attempt to protect the program for logic errors based on object type. That is to say, type checking must be done at runtime through language-specific functionality. For example, if one wanted to run a specific function on an object, then one might want to be certain that the object provides that functionality or, else, risk a runtime error. This is commonly known as "duck typing"; Coming from the common phrase, 'If it walks like a duck and quacks like a duck, then it is a duck'.

Okay. Back to Polymorphism. A language is considered polymorphic if an object can be treated as its own specific type or any of the inherited types, or "subtypes". A quick example just to wrap this up (because I've written way to much):

class Vehicle(object):
    pass

class Truck(Vehicle):
    pass

class Car(Vehicle):
    pass

isinstance(Car(), Car) # True
isinstance(Truck(), Car) # False

isinstance(Car(), Vehicle) # True
isinstance(Truck(), Vehicle) # True

Hope it helps.

More on reddit.com