---
# System prepended metadata

title: A Beginner’s Guide to Understanding Object-Oriented Programming in Python
tags: ["Python\_", "Object oriented programming\_", Beginner developer, OOP]

---


# A Beginner’s Guide to Understanding Object-Oriented Programming in Python.
![aafec1ee67e230a77f89463e421b006b](https://hackmd.io/_uploads/ryWN8gCSa.jpg)

In Python programming language, there are different programming styles that can be implemented. Object-Oriented Programming let's a developer structure their code in a way that mirrors real-world entities and their interactions. A car program that involves different parts of the car and their functions is a practical example. This article would give you an understanding as to how the basic concepts of object-oriented programming works through practical examples.

In this article, I will be talking about the following concepts:

- Understanding OOP
- Class vs Object
- Attributes vs Methods
- Inheritance

> ***Requirements***
> * A basic understanding of Python 
> * A code editor and python installed


## Understanding Object-Oriented Programming in python

Object-Oriented programming is a programming model that revolves around the concept of creating and using objects to design and build software systems. In simple terms, OOP in Python is like creating recipes (classes) for different things, like animals or cars. These recipes have ingredients (attributes) and instructions (methods). Then, you can use these recipes to make specific things (objects) that follow those instructions and have their own unique ingredients.


## Class vs Object

A class is a blueprint or template that defines the structure, attributes, and behaviors of objects. You can think of it as a sketch of a car containing all the details of a car. An object is a representation of a class, an object is a car with green color for example and 320km/h as maximum speed.
Here is a simple visualization of the differences between a class and an object:      ![Difference between class and object](https://hackmd.io/_uploads/SJJ7bXSHp.png)


## OOP in python

![Attribute vs Methods](https://hackmd.io/_uploads/ByHvZmBHp.png)

	
### Attributes
The attributes are the variables that store data associated with an object. They define the properties or characteristics of an object. Looking at the previous example, a class in python called 'Car' was defined. To define a class in python, we use the class keyword:
```python
    class Car:
	        pass
```

Now, let’s define our class with some attributes:
```python
    class Car:
        def __init__(self, color, brand, maxSpeed):
            self.color = color # (Color attribute)
            self.brand = brand # (Brand attribute)
            self.maxSpeed = maxSpeed # (Max speed attribute)
```

The 'init' function or the constructor is automatically called when an object (instance) of the class is created. It is used to set up the initial state of the object by assigning values to its attributes. Let’s say you want to create two cars with different properties, you would have to create two objects of the class Car naming them car1 and car2. 
For example:
```python
    car1 = Car("Red", "Toyota", 120)
    car2 = Car("Blue", "BMW", 300)
```

Now to get the attribute of an object, let’s say the color of car1, you type:
```python
    print(car1.color)
```

then you’ll get red as the output.

### Methods

Methods are functions that are defined within a class and are associated with objects created from that class. Methods define the behavior that objects of the class can perform.
For example, define a method called changeMaxSpeed():
```python
    class Car:
        def __init__(self, color, brand, maxSpeed)
            self.color = color
            self.brand = brand
            self.maxSpeed = maxSpeed
        def changeMaxSpeed(self, newMaxSpeed)
            self.maxSpeed = newMaxSpeed
```
            
> ***Note***
> A method must have an extra first parameter in the method definition usually called "self". You do not give a value for this parameter when you call the method, Python provides it. Even if you have a method that takes no arguments, then you still have to have one argument which is this "self" since it is a required place holder for the instance. 

This function takes two parameters, self which points to the instantiated object, and newMaxSpeed the new maximum speed value. Now instantiate a car with a maximum speed of 120 and modify it with our method:
```python
    car1 = Car(“blue”, “toyota”, 120)
    car1.changeMaxSpeed(300)
```


Here, car1 acts as self, so it is unnecessary to specify it, if you specify self, an error would occur saying it was expecting one parameter but got two.

### Inheritance

To understand the concept of inheritance, we will take a simple example, Imagine you have an initial class called "vehicle" before the previous class called "car", you created the class "vehicle" as follows :
```python
    class Vehicle:
        def __init__(self, color, maxSpeed):
            self.color = color 
            self.maxSpeed = maxSpeed

        def changeMaxSpeed(self, newMaxSpeed):
            self.maxSpeed = newMaxSpeed

        def changeColor(self, newColor):
            self.color = newColor
```          


Now when you create the class "Car", you want your class to inherit from the initial class "Vehicle", meaning that you don't have to define the previous attributes and methods again.

```python
    class Car(Vehicle):
       def __init__(self, color, maxSpeed, brand):
          self.brand = brand
```

Now, you can access the variables and methods of the parent class. 
So basically, Inheritance allows a class to inherit or derive properties  from another class. The class that derives properties is called the child class(eg. Car) and the class from which the properties are being derived is called the parent class(eg. Vehicle).
![A visual description of inheritance](https://hackmd.io/_uploads/ByDFyXrr6.jpg)


### Conclusion
So far, we have seen how to approach a real-world problem using object-oriented programming. We have also seen how to create classes and use them to create solutions to problems. You also saw how OOP lets classes share traits promoting efficient code reuse. So, in a nutshell, OOP in Python is about creating organized, reusable code using classes, objects, attributes, methods, and inheritance for smoother and more efficient programming adventures!

## Thank you for reading, and let's connect!

Thank you for reading my blog. Feel free to send me a message on [twitter ](https://x.com/Callum_Trace?t=_eDVpYc_qtHLIGiEWL2FkQ&s=09), if you have any questions or suggestions.
If you like this article! Don't miss the upcoming ones, [follow](https://hashnode.com/@callum083) me to read more!
Thank you and have a nice day, developer!
