Pooja Danu's Blog
Day 18: Object-Oriented Programming (OOP) in Python

Day 18: Object-Oriented Programming (OOP) in Python

Pooja Danu's photo
Pooja Danu
·

3 min read

Table of contents

Welcome to Day 18 of our Python blog series! Today, we'll explore Object-Oriented Programming (OOP) concepts in Python. OOP is a powerful programming principle that allows you to structure your code in terms of objects, which represent real-world entities and have attributes (data) and methods (functions) associated with them.

Object-Oriented Programming (OOP)

OOP is a programming principle that revolves around the concept of objects, which represent real-world entities with attributes (data) and behaviors (methods). OOP promotes code organization, reusability, and modularity by structuring programs in terms of classes and objects.

At the core of OOP are classes and objects:

  1. Class: A class is a blueprint or template for creating objects. It defines the attributes and methods that all objects of that class will have. Attributes represent the state of the object, while methods represent the behavior or actions that the object can perform.

    Example of a class:

     class Dog:
     def __init__(self, name):
         self.name = name

     def bark(self):
         return f"{self.name} barks!"

  2. Object: An object is an instance of a class. It is a concrete realization of the class blueprint, with its own unique state (attribute values) and behavior (method implementations).

    Example of creating objects from the Car class:

     #creating objects from the Dog class
 dog1 = Dog("Bambi")
 dog2 = Dog("Thumper")

 print(dog1.name)  #output: "Bambi"
 print(dog2.name)   #output: "Thumper"

 print(dog1.bark())  #output: "Bambi barks!"

the Dog class represents a dog entity, with attributes name initialized through the __init__() method. It also has a bark() method to simulate the sound a dog makes. Objects dog1 and dog2 are instances of the Dog class, representing different dogs. We access their attributes and call the bark() method to make them bark

The core principles of Object-Oriented Programming (OOP), often referred to as the pillars of OOP, are as follows:

  1. Encapsulation: Encapsulation involves bundling data (attributes) and methods (functions) that operate on that data within a single unit, known as a class. The class serves as a blueprint for creating objects, and it hides the internal state of objects from the outside world. Encapsulation promotes data hiding, which helps prevent accidental modification of object state and ensures data integrity.

  2. Inheritance: Inheritance is a mechanism that allows a class (subclass) to inherit attributes and methods from another class (superclass). It enables code reuse by allowing subclasses to extend or modify the behavior of the superclass. Inheritance establishes an "is-a" relationship between classes, where a subclass is a specialized version of its superclass.

  3. Abstraction: Abstraction involves hiding the complex implementation details of a system and presenting only the essential features or functionalities to the outside world. Abstraction allows developers to focus on the essential aspects of a system while hiding unnecessary details, making the code easier to understand, maintain, and extend.

  4. Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables flexibility and extensibility by allowing different classes to implement methods with the same name but different behaviors. There are two main types of polymorphism:

    1. Compile-time Polymorphism (Method Overloading) : Compile-time polymorphism occurs when multiple methods with the same name but different parameters are defined within a class. The compiler determines which method to call based on the number and types of arguments passed to it. This allows for the creation of methods that perform similar operations but with different input parameters.

    2. Runtime Polymorphism (Method Overriding): Runtime polymorphism occurs when a subclass provides its own implementation of a method that is already defined in its superclass. When a method is called on an object of the subclass, the overridden method in the subclass is executed instead of the method in the superclass.

Conclusion

Day 18 was into the fundamentals of Object-Oriented Programming (OOP) in Python, emphasizing the concepts of classes and objects. We explored how classes serve as blueprints for creating objects, encapsulating attributes and methods within them. By understanding OOP principles, developers can organize their code more effectively, promote reusability, and model real-world entities in their applications.

Python