# A Beginner’s Guide to Understanding Object-Oriented Programming in Python.
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: 
## OOP in python
### 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).
### 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!
Sign in with Wallet
Connect another wallet