Adventures in Machine Learning

Mastering Python OOPs for Efficient Programming

Introduction to Python Constructor and OOPs

As technology continues to advance, it has become necessary to look for better ways of coding to accommodate these advancements. One such way is by embracing the Object-Oriented Programming (OOP) paradigm.

OOP is a style of programming that seeks to organize code into objects that interact with each other to achieve an end goal. Python is one of the programming languages that has embraced this paradigm in a big way.

This article will introduce you to the concepts of Python Constructor and OOPs. We will start with simple definitions of objects and classes, then delve into the basics of Constructors and the init() method. Finally, we will create a simple class in Python and illustrate how to use the Constructor and the init() method.

What are Objects and Classes in OOP?

In OOP, an object is a self-contained entity that encapsulates data and behavior.

It may interact with other objects via calls to methods, or by exchanging messages. An object can be thought of as a real-life entity that we interact with on a daily basis, such as a car or a phone.

On the other hand, a class is a blueprint for creating objects. It defines a set of properties and methods that are common to all objects of that class.

You can think of a class as a generalization of an object, a template from which objects are derived. For instance, if we consider the object ‘motorbike’ in real life, it has characteristics such as; color, make, model, year of manufacture, and many others.

In OOP, a class would define these attributes. Later on, we can use the class to create actual objects i.e bikes.

Constructors and the init() method

In Python, a constructor is a special method that is called automatically when an object is created.

It has the responsibility of initializing the state of an object. The init() method is one such constructor.

The init() method is a special method used to initialize an instance of a class. It is called automatically whenever you create a new object.

This method may take arguments that help to initialize the object’s attributes. For instance, consider the ‘motorbike’ object as earlier defined, with attributes such as color, make, model, and year of manufacture.

The constructor would be the init() method, which is responsible for initializing the properties of the motorbike object.

Creating a Class in Python

Now that we understand the basics of objects, classes, Constructors, and the init() method, let us create a simple class in Python- Cartesian Point.

A Cartesian point represents a location on a two-dimensional coordinate plane.

It has two coordinates, an x-coordinate, and a y-coordinate. The following code creates the Cartesian Point class:

class CartesianPoint:
    def __init__(self,x,y):
    def coords(self):
        print(f"Coords: ({self.x},{self.y}")

In the code above, we define the class, CartesianPoint, which has two parameters, x and y.

In the init() method, we initialize the x and y attributes to the values passed as parameters. The self parameter refers to the instance of the class and is necessary for methods to access the instance variables.

The coords() method is then defined to display the values of x and y. Here’s a sample use of the code:

p1 = CartesianPoint(4,5)
p2 = CartesianPoint(-3,2)
p1.coords() #output: Coords: (4, 5)
p2.coords() #output: Coords: (-3, 2)


In conclusion, we have introduced you to the basics of Python Constructor and OOPs. We have defined objects and classes, mentioned the init() method, and used an example to illustrate how to create a class in Python. This information can come in handy when you need to create a more complex class or when troubleshooting code.

3) Default Parameters for init() Method

Python’s init() method is a special method designed to initialize instances of a given class. The method is called when an instance of a class is created.

It can also accept parameters that help initialize the class instance. In some cases, you might want to specify default parameters to the init() method so that if no value is explicitly provided by the user, the default value is used.

Default values in Python are used to specify a value for a parameter in case the caller doesn’t pass a value. They take the form parameter_name=value in the function signature.

If a parameter is not passed by the caller, the function uses the default value specified in the function signature. Here’s an example of how default parameters can be used in the init() method:

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

In the Person class, we give the age parameter a default value of 30.

That means that if the age parameter isn’t specified in the class constructor, the default value 30 will be used. Now, let’s create an instance of the Person class without adding the age argument:

person1 = Person("John")
print(person1.age) # Output: 30

As you can see, the default age value of 30 was applied because we didn’t specify any value for the age parameter.

Defining another class Point1 to initialize with (0,0) if no data point is specified

Let’s create another Python class, Point1 that accepts no argument yet initializes the x and y co-ordinates to (0, 0). We can specify default parameters of 0 for x and y in the init() method.

Here’s the code for the Point1 class:

class Point1:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

In the Point1 class, the default values for x and y are both 0.

Now, we can create an instance of the Point1 class without specifying the values of x and y.

This is because we have set default values of 0 in the class definition. Here’s an example:

point1 = Point1()
print(point1.x) # Output: 0
print(point1.y) # Output: 0

We can also create an instance of the Point1 class by specifying the values of x and y, as shown below:

point2 = Point1(5, 6)
print(point2.x) # Output: 5
print(point2.y) # Output: 6

As you can see, it is possible to specify values for x and y, which overrides the default values of 0.

4) Alternative methods for class initialization in Python

Apart from using default parameters in the init() method, Python offers alternative ways to initialize classes. These methods help to specify initial values without necessarily using the init() method.

Here are two alternative methods for class initialization in Python:

  1. @classmethod: This is a special Python method that is used to define a method that can be called on a class instead of an instance. The class method is called using the class name, as opposed to an instance of the class.

    Here’s an example:

    class Person2:
        def from_year_birth(cls, name, birth_year):
            age = - birth_year
            return cls(name, age)
        def __init__(self, name, age):
   = name
            self.age = age

    In this Person2 class, we define a class method, from_year_birth() that calculates age based on the year of birth and returns an instance of the Person2 class. We can then create an instance of the Person2 class using this class method, as shown below:

    person2 = Person2.from_year_birth("John", 1990)
    print( # Output: John
    print(person2.age) # Output: 31
  2. @staticmethod: This is another special method in Python that is defined with the @staticmethod decorator.

    It is similar to a static method in other programming languages and is used to define methods that are specific to a class but do not require access to the instance. Here’s an example:

    class Math:
        def add_numbers(x, y):
            return x + y

    In this Math class, we define a static method add_numbers() that adds two numbers.

    We can then call this method using the class name, as shown below:

    answer = Math.add_numbers(5, 6)
    print(answer) # Output: 11


In this article, we have discussed the concept of default parameters for the Python init() method and how they can make class initialization more flexible. We also created a simple class, Point1, to illustrate how to set default parameters to the init() method.

Finally, we looked at alternative methods for class initialization, including @classmethod and @staticmethod. With these alternatives, we can further customize class initialization to meet our specific needs.

In this article, we explored the concept of Python Constructor and OOPs. We learned that objects are self-contained entities that encapsulate data and behavior, while classes are blueprints for creating objects. We also discussed the init() method and how it initializes instances of a given class, with default parameters being applicable where no value is explicitly provided.

Finally, we looked at alternative methods for class initialization in Python, including the @classmethod and @staticmethod methods. By embracing Python’s OOP paradigm and effectively using default parameters and alternative initialization methods, developers can create more robust, flexible, and efficient programs.

Ultimately, mastering these techniques is critical to achieving success as a Python programmer.

Popular Posts