Object orientated programming isn’t that new of a concept. It was introduced back in the 1960s by Alan Kay, but didn’t hit the mainstream until the 1990s (thanks C++). Today we’ll look at the basics of OOP through the Python programming language.
Don’t feel like reading? Check out my video on the topic:
Covering everything there is on OOP isn’t possible in a single article. Entire books are written on the topic, but we will use the 80:20 principle to cover 80% of things you’ll use daily in 20% of the time.
The article is structured as follows:
What is OOP?
Object orientated programming isn’t language-specific. It is a programming paradigm used in many languages, such as Python, Java, C#, and so on. OOP skills are transferable – so learning the concepts in Python makes you somewhat skilled in other languages, if we don’t take the syntactical differences into account.
OOP is all about creating objects from classes. A single class contains numerous fields and methods that are somehow related. A class is used as a blueprint for creating objects.
For example, you could declare a Customer class and use it to create many Customer objects. In this case, the Customer class is a blueprint for creating a single customer. Not all customers are equal, but they can all be described with the same fields, such as age, gender, membership type, and so on.
The goal of OOP is to implement real-world entities into code. You can model almost anything in your life with OOP. For example, you interact with people every day. Even though people are different, they are still just people. In OOP terms, you could model people with a single class and create as many instances with different properties.
But that’s too complex of an example for today. Instead, we’ll explore OOP concepts with cars. Let’s see how classes and objects work in practice next.
Classes and objects
Think of classes as your own data types. There are built-in data types in Python, such as lists and strings, but those aren’t enough for more advanced use cases.
In Python, a class is defined by putting a keyword
class followed by a class name and a colon. The class name is arbitrary, but it’s a good practice to write it in a title case. For example, write
Once you have the class declared, you can make as many instances as needed. Let’s take a look at an example:
In the above example, we’ve created an empty
Car class. Just below, we’ve made an instance of it (stored in the variable
car) and printed the results. By default, only the memory address is printed to the console:
<__main__.Car object at 0x7fda5cefb3d0>.
This empty class is pretty much useless, so let’s start adding things to it. We’ll start with a constructor.
A class constructor has only one goal: assigning values to the class variables when an object is created.
We are working with cars here, so it would be a good idea to take a moment and think about what every car has in common. For our example, three properties are enough – car brand, color, and license plate.
The properties of a car must be inside the
__init__() method. This method is also called an initializer or a constructor – so keep in mind that these are synonyms. The
__init__() method is called immediately whenever an object is created.
The first parameter of the constructor must be
self. It is a keyword that has a job of assigning the passed values to class variables. In other programming languages such as Java, it’s named
Let’s now see how to add a constructor with the three mentioned properties and how to make an instance:
That’s the general syntax you want to remember. Upon making an instance, you can see that three arguments are required now, and not providing them would result in an error. The print statement still outputs a memory address, but that’s expected.
Car class is still pretty dull. Luckily, we have methods to spice things up. Let’s explore them next.
In the most simple terms, methods are functions used to describe the behavior of objects. Covering everything you can do with methods would take an entire article, at least, so let’s stick with the 80:20 principle.
This section covers regular, static, private, and special methods. The term private is open for debate in Python, as there’s no corresponding keyword, as is the case with Java.
You can declare regular methods just as you would any other functions, with a
def keyword followed by the method name and the argument list. The regular method must contain
self as the first argument.
On the other hand, a static method doesn’t. It is exactly the same as regular methods, but we need to put a
@staticmethod decorator above the declaration.
Private methods are very similar to regular ones. The convention is to use an underscore before the method name. This doesn’t make the method private, as you can still access it from the outside. The underscore is a way of telling other developers they shouldn’t use this method explicitly and shouldn’t modify its functionality.
Last but not least, we have special methods. These modify the original behavior of the class. For example, instead of outputting the memory address every time the instance is printed, we can modify the output with the
__str__ method (note the double underscore). When dealing with an array of objects, the print behavior is modified with the
__repr__ method. There are many more, but these two will get you started.
Here’s the code snippet demonstrating every type of method and how to call it:
And here is the corresponding output:
Up next, let’s discuss inheritance.
Inheritance is an essential pillar of OOP. Because of it, one class can inherit attributes and methods of another. The class whose properties and methods are inherited is called the Parent class. Similarly, the class which is inheriting is called the Child class.
In a car analogy, you can think of it like this: every Audi is a car, but not all cars are Audi. Audi is a child class, inheriting basic properties and methods from the car class.
To make inheritance work, you’ll have to put the name of a class you are inheriting from in the parenthesis after the child’s class name. Let’s take a look at an example:
Here’s the output:
describe method is new and specific to the
Audi class. We’ve overridden the
__str__ method, as you can see from the first two print statements. We can use the
stop method from the
Car class inside the
Audi class because of inheritance.
Building classes like this is limited. We still need something else. For example, in the
Audi class, we can’t access the
start method because it requires the fields that the
Audi class doesn’t have. The
super() keyword comes to the rescue.
super() in the constructor calls the constructor of the parent class and gives us access to everything inside. Let’s take a look at an example:
Here’s the output:
As you can see, the
BMW class doesn’t have any methods but can access anything from its parent.
And there you have it – the basics of object orientated programming with Python. This was a relatively short guide on essential OOP concepts packed with examples. I hope you’ve managed to follow along and that the concepts are much clear now.
Everything you’ve learned today is more than enough to get you started. OOP paradigm can be used in all types of projects. I like to do machine learning in this way and extend the functionality of built-in predictive algorithms.
Thanks for reading.