Exploring Object-Oriented Programming (OOP) Concepts in Python (Part -1)

Exploring Object-Oriented Programming (OOP) Concepts in Python (Part -1)

Empower Your Code with OOP Mastery in Python: Where Objects Unleash Infinite Possibilities!


Welcome to today's investigation of Object-Oriented Programming (OOP) ideas in Python, dear viewers. Python's clean syntax and strong capabilities make it a good platform for studying and implementing OOP ideas.

We will delve deep into the realm of OOP in this interactive workshop, breaking down complicated concepts into simple components. You'll discover helpful ideas here whether you're a newbie or an experienced programmer wishing to update your OOP skills.

What is Object-Oriented Programming?

Object-Oriented Programming (OOP) is a programming paradigm centered on the idea of objects. An object is a self-contained entity that combines data (attributes) and behaviors (methods). This method provides for better organized and modular code design and organization.

Problems in the Procedure-Oriented Programming (POP)

The Structured Programming Approach, also known as the Procedure-oriented Approach, is a programming paradigm that stresses the use of procedures or functions to break down a program into smaller, more manageable sections. While it has advantages, it also has limitations and problems:

  • Lack of Data Encapsulation

  • Limited Reusability

  • Poor Scalability

  • Difficulty in Understanding

  • Lack of Abstraction

  • Limited Support for Modularity

  • Maintenance Challenges

  • Inefficiency

  • Limited Support for Parallelism

  • Code Readability

Lack of Data Encapsulation: Data is frequently global or shared among multiple procedures in a Procedure Oriented Approach. This might result in inadvertent data alteration, making data encapsulation and data integrity challenging.

Limited Reusability: Procedures are often built for distinct purposes, making code reuse difficult. This can lead to code duplication and lower maintainability.

Poor Scalability: As a program expands, managing numerous procedures can become overwhelming, making it challenging to scale the program to efficiently handle complex tasks.

Difficulty in Understanding: The Procedure Oriented Approach can be challenging to comprehend and debug for those who didn't initially write the code.
Lack of Abstraction: The Procedure Oriented Approach can be challenging for those who haven't written the code initially.

Limited Support for Modularity: In POP, code can become monolithic, making it challenging to manage and debug.

Maintenance Challenges: Changing one section of a program can have an impact on other areas, especially when global variables are involved. This makes maintenance and debugging more difficult.

Inefficiency: Procedures can be run numerous times, resulting in multiple function calls and argument passing, which can influence program performance, particularly in resource-intensive applications.

Limited Support for Parallelism: The Procedure Oriented Approach is not well-suited for taking advantage of modern multi-core processors and parallel processing, making it less suitable for certain types of applications.

Code Readability: Large programs developed using a Procedure-Oriented Approach can become difficult to read and understand due to the lack of clear organization and encapsulation of functionality.

Note: The Approach, while suitable for smaller applications and simplicity, is less suitable for complex projects due to its lack of clear organization and functionality encapsulation.

However, for larger and more complex projects, developers often prefer using other paradigms like Object-Oriented Programming or Functional Programming.

Features of Object-Oriented Programming System (OOPS)

Object-oriented programming(OOPS) revolves around these key principles

Objects and Classes

  • Objects in object-oriented programming (OOP) are essential building blocks for modeling and representing entities or concepts, encapsulating data and behaviors related to these entities.

  • In OOP, an object is a basic unit that represents a real-world thing or notion.


"Objects are instances of classes. They are created based on the class definition and represent specific instances of the entity described by the class."

  • Objects include characteristics (also known as properties) and methods (related functions).

  • In Python, objects may be created from classes, which act as blueprints for such things.

my_car = Car("Toyota", "Camry")


"In Python, a class is a blueprint or template for creating objects. It defines the attributes (data) and methods (functions) that the objects created from that class will have. Classes are defined using the class keyword."

  • A class is a blueprint or template for producing particular types of things.

  • It specifies the attributes (data members) and methods (functions) that class objects will have.

  • A class can be thought of as a user-defined data type.

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def start_engine(self):
       print(f"{self.make} {self.model}'s engine is started.")

In OOP, an object is a basic unit that represents a real-world thing or notion.

We created a Dog class with attributes like name and breed and a bark method. We created two Dog objects, dog1 and dog2, representing different dogs.

class Dog:
    # Constructor to initialize attributes
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    # Method to bark
    def bark(self):
        return f"{self.name} says Woof!"

# Creating objects (instances) of the Dog class
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "Poodle")

# Accessing object attributes and calling methods
print(dog1.name)   # Output: Buddy
print(dog2.bark()) # Output: Max says Woof!
  • Mathematical Operations with Objects

The example demonstrates the creation of a Calculator class with methods for addition and subtraction, which is then utilized for performing arithmetic operations.

class Calculator:
    def __init__(self, value=0):
        self.value = value

    def add(self, num):
        self.value += num

    def subtract(self, num):
        self.value -= num

# Creating a Calculator object
calc = Calculator()

# Performing operations

# Accessing the result
print(calc.value)  # Output: 2

Object-oriented programming (OOP) involves classes with attributes and methods. Attributes hold data about the object, defining its characteristics.

Methods are associated functions that perform actions related to the object's state or behavior, such as retrieving a person's full name or updating their address.

class Person:
    def __init__(self, name, age, address):
        self.name = name    # Attribute
        self.age = age      # Attribute
        self.address = address  # Attribute

    def getFullName(self):  # Method
        return self.name

    def changeAddress(self, new_address):  # Method
        self.address = new_address

# Creating an instance of the Person class
person1 = Person("John Doe", 30, "123 Main St")

# Accessing attributes
print(person1.name)  # Output: John Doe
print(person1.age)   # Output: 30

# Calling methods
print(person1.getFullName())  # Output: John Doe

# Modifying an attribute
person1.changeAddress("456 Elm St")
print(person1.address)  # Output: 456 Elm St

The Person class, with attributes like name, age, and address, provides methods like getFullName and changeAddress for objects to interact with their data and behavior.


"Attributes are variables that store information about an object, and they represent an object's qualities or characteristics."

  • Attributes are variables that store information about an object.

  • They indicate an object's qualities or attributes.

  • Attributes in Python are declared within a class and accessed using dot notation.

Declared within a Class

Attributes are often defined within a class to specify the properties that objects produced from that class will have. They are defined in the class's body.

class MyClass:
  attribute1 = "some_value"
  attribute2 = 42

Accessed Using Dot Notation

Dot notation is used to access an object's attributes, which involves specifying the object's name, followed by a dot ('.'), and then the attribute's name.

obj = MyClass()
value1 = obj.attribute1  # Accessing attribute1
value2 = obj.attribute2  # Accessing attribute2

Instance and Class Attributes

In Python, there are two kinds of attributes: instance attributes and class attributes. Instance attributes are unique to a given instance (object) of a class, whereas class attributes are shared by all instances of the class.

class MyClass:
    class_attribute = "shared_value"  # This is a class attribute

    def __init__(self, instance_attribute):
        self.instance_attribute = instance_attribute  # This is an instance attribute

# Creating objects of MyClass
obj1 = MyClass("object1")
obj2 = MyClass("object2")

# Accessing class attribute (shared by all instances)
print("Class attribute for obj1:", obj1.class_attribute)  # "shared_value"
print("Class attribute for obj2:", obj2.class_attribute)  # "shared_value"

# Accessing instance attribute (unique to each instance)
print("Instance attribute for obj1:", obj1.instance_attribute)  # "object1"
print("Instance attribute for obj2:", obj2.instance_attribute)  # "object2"

# Modifying instance attribute for obj1
obj1.instance_attribute = "new_value"

# Now, obj1 has its own instance_attribute, separate from obj2
print("Updated instance attribute for obj1:", obj1.instance_attribute)  # "new_value"
print("Instance attribute for obj2:", obj2.instance_attribute)  # "object2"

Class attributes are shared across instances of a MyClass class, defining properties for all objects, while instance attributes allow each object to have its unique state, affecting only the instance to which it belongs.

Attributes are crucial in object-oriented programming in Python, enabling data storage, retrieval, and defining an object's state, which can be manipulated to alter its behavior or characteristics.


  • Methods are functions specified within a class that perform operations on the properties of class objects.

  • They encapsulate object-related activity.

  • The'self' argument refers to the object instance invoking the method.

person1 = Person("Alice", 30)
   greeting = person1.greet()  # Calling the 'greet' method

Methods in Classes

In Python, methods are functions that are specified within a class. These methods are related to and operate on class object properties (attributes). Methods specify the behavior or activities that class objects can take.

Methods encapsulate or include code related to the functionality of class objects. They aid in the organization and structure of a class's functionality, making it easier to manage and comprehend object behavior.

The self Argument

  • The self keyword is a convention in Python that is used as the first parameter in the declaration of instance methods.

  • It refers to the method-invoking object instance.

  • When you call a method on an object, Python automatically sends the object as the method's first parameter (i.e., self).

  • Within the method, you may access and alter the object's attributes.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"My name is {self.name} and I am {self.age} years old."

    def have_birthday(self):
        self.age += 1

# Creating a Person object
person1 = Person("Alice", 30)

# Calling methods on the object
print(person1.introduce())  # Output: "My name is Alice and I am 30 years old."

print(person1.introduce())  # Output: "My name is Alice and I am 31 years old."
Object-Oriented Programming (OOP) is a programming paradigm that organizes code by modeling real-world entities as objects with attributes and methods. Key OOP concepts include objects, which represent entities or concepts, classes, which define the structure and behavior of objects, attributes, which represent data or state, and methods, which define the behavior or actions of objects.

Today's blog discussed the basics of Object-Oriented Programming (OOP), including objects, classes, attributes, and methods. Future posts will cover encapsulation, abstraction, inheritance, and polymorphism.

We sincerely value your readership, and we don't want you to miss out on these insightful articles. So, please remain in touch and don't miss our forthcoming posts. Your continuing interest and support motivate us to present you with the greatest material available. Thank you for joining us on our quest to learn Object-Oriented Programming.

Thank you for reading our blog. Our top priority is your success and satisfaction. We are ready to assist with any questions or additional help.

Warm regards,

Kamilla Preeti Samuel,

Content Editor

ByteScrum Technologies Private Limited! 🙏

Did you find this article valuable?

Support ByteScrum Technologies by becoming a sponsor. Any amount is appreciated!