Prerequisites

To navigate this article effectively, ensure you have:

• Python version 3.0.0 or higher
• Basic knowledge of Python
• A code editor (like Pycharm, VS Code, Atom, etc.)
• A desire to learn

Basics of Object-Oriented Programming in Python

Object-oriented programming (OOP) is a programming paradigm that emphasizes the creation of applications using objects that encapsulate data and methods, rather than relying solely on functions and logic. This approach fosters modular and reusable code, leading to more manageable and efficient programs with reduced redundancy.

Moreover, OOP in Python simplifies complexity by representing real-world entities as software objects that possess certain data and operations. For instance, you might develop a program to model a car object, which could include attributes such as color, model, and mileage. The car could also perform actions like start, stop, drive, and honk.

Don't worry if you're not yet familiar with these concepts; they'll become clearer as we delve into classes and objects.

What are Classes and Objects in Python?

A class serves as a blueprint for creating objects. Python developers use classes to define data structures by combining attributes and methods into a single unit. The methods operate on the data encapsulated within the class.

Classes themselves do not hold actual data; think of them as templates from which objects, containing data, are constructed.

Creating a class involves using the 'class' keyword followed by the class name and a colon. Python identifies everything indented below this colon as part of the class. For example, let’s define a simple car class:

class Car:

pass

Currently, your Car class only includes a single statement—pass, which serves as a placeholder for future code. Running this program will not yield any errors, though it may seem unexciting at this stage. Soon, you’ll enhance it with meaningful properties.

Now that you've grasped the concept of classes, let's explore Python objects.

Python Objects

As mentioned earlier, classes are templates. Objects are the instances created from these templates. Think of classes as blueprints for a house, while objects are the actual buildings constructed from those blueprints, embodying all the defined characteristics.

Memory allocation for an object only occurs when you instantiate a class. Let’s enhance the Car class by adding the .__init__() method, also known as a constructor, which initializes the attributes of each instance of the class.

Here’s how you can modify the Car class to include attributes like color, model, and mileage:

class Car:

def __init__(self, color, model, mileage):

self.color = color

self.model = model

self.mileage = mileage

# Creating an instance of Car

car_1 = Car("blue", "XVZ23", 124)

# Accessing attributes

print(car_1.color)

print(car_1.model)

print(car_1.mileage)

Output:

blue

XVZ23

124

In this example:

• The Car class contains a .__init__() method with self and parameters for color, model, and mileage.
• self refers to the current instance of the class (in this case, car_1), allowing access to the class attributes.
• When creating the instance car_1, the arguments "blue", "XVZ23", and 124 are passed to the .__init__() method, initializing self.color, self.model, and self.mileage.

Core Principles of OOP

Object-oriented programming is founded on four fundamental principles, all of which Python adheres to. This section offers a brief overview of these principles, with further details provided later in the article.

1. Inheritance: This allows one class to inherit attributes and methods from another, promoting code reuse. The class that inherits is known as the child class, while the one being inherited from is the parent or base class.
2. Polymorphism: This principle enables entities to take on multiple forms. In OOP, polymorphism allows a method or function to serve multiple purposes based on the type of object it operates on. For example, as a pet shop owner, you may have various animals that respond differently to the command "Make a sound."
3. Encapsulation: This principle involves bundling data (attributes) and operations (methods) into a single unit (class), often restricting access to certain components. This serves to protect the integrity of the object by exposing only what's necessary.
4. Abstraction: This refers to simplifying complex systems by exposing only the essential features. For instance, while a car is a complex machine, in software, you can represent it simply as a car object without needing to delve into its internal workings.

How to Work with Classes and Objects

Creating a new object from a class is termed instantiation. You can instantiate a class by typing its name followed by parentheses:

House()

Each instantiation allocates a unique memory address for the object. The following demonstrates this:

class House:

pass

print(House())

Output:

<__main__.House object at 0x1043b1430>

This output signifies that you’ve created a House object located at the memory address 0x1043b1430. Note that this address will differ on your local machine. Try instantiating the House class again to observe a new memory address.

What are Attributes and Methods in Python?

Attributes represent the properties or features of an object, while methods are functions defined within a class that perform actions on the object's data. Attributes are created using variables, while methods are defined using functions inside the class. Each method must include self as its first parameter, representing an instance of the class.

Let’s enhance your Car class by adding methods drive() and honk():

class Car:

def __init__(self, color, model, mileage):

self.color = color

self.model = model

self.mileage = mileage

def drive(self):

return "Vroom Vroom!"

def honk(self):

return "Beep Beep!"

# Creating an instance of Car

car_1 = Car("blue", "XVZ23", 124)

# Accessing attributes and calling methods

print(car_1.color)

print(car_1.mileage)

print(car_1.honk())

print(car_1.drive())

Output:

blue

124

Beep Beep!

Vroom Vroom!

This example illustrates how methods can perform actions on a car object, returning strings that provide useful information about the instance.

Class Attribute vs. Instance Attribute

Sometimes, attributes need to be defined outside the .__init__() method. These attributes, known as class attributes, are shared across all instances of the class.

Here’s an example with a Dog class featuring a class attribute:

class Dog:

species = "Canis familiaris" # Class attribute

def __init__(self, name):

self.name = name

def bark(self):

return "Wooowoow"

# Creating instances

dog_1 = Dog("Max")

dog_2 = Dog("Leo")

# Accessing class attribute

print(dog_1.species)

print(dog_2.species)

Output:

Canis familiaris

Canis familiaris

In this scenario, species is a class attribute accessible by all instances of the class.

Now, let’s define another Dog class using only instance attributes:

class Dog:

def __init__(self, name, species):

self.name = name # Instance attribute

self.species = species

def bark(self):

return "Wooowoow"

# Creating instances

dog_1 = Dog("Max", "Canis familiaris")

dog_2 = Dog("Leo", "Canis lupus")

# Accessing instance attribute

print(dog_1.species)

print(dog_2.species)

Output:

Canis familiaris

Canis lupus

In this case, species is an instance attribute, unique to each Dog instance.

Implementing Inheritance and Polymorphism in Python

You've gained insight into inheritance and polymorphism. Inheritance allows a class to inherit properties and behaviors from another class, while polymorphism permits different class instances to be treated as instances of a common superclass.

Here’s how to implement these principles:

Implementing Encapsulation and Abstraction in Python

Previously, you were introduced to encapsulation and abstraction. Encapsulation involves bundling attributes and methods, while abstraction simplifies complex systems by revealing only essential features.

Conclusion

In this article, you’ve examined Python as an object-oriented programming language. Here are the key takeaways:

• Python enables programmers to organize code around classes and objects.
• The core OOP principles are inheritance, polymorphism, encapsulation, and abstraction.
• Inheritance allows classes to inherit attributes and methods from other classes, while polymorphism allows diverse objects to be treated as instances of a common class.
• Encapsulation safeguards the internal states of objects, whereas abstraction conceals complex details from users.

As you continue your learning journey, feel free to explore additional concepts, and remember to share your knowledge with the Python community.

References

To deepen your understanding of OOP in Python, consider exploring the following resources:

• Python Documentation — Object-Oriented Programming
• Read The Docs
• Microsoft Learn
• IBM

Thank you for reading! If you enjoyed this article, please clap (up to 50 times!) and follow me on Medium to stay updated with my new articles.

If you'd like to support my work, consider buying me a cup of coffee! :)

Feel free to connect with me on LinkedIn.