Python Constructors

Learning Objectives

In the previous lesson, you learned that classes act as blueprints and objects are instances created from those classes.

Now we will learn how to automatically give newly created objects their initial data.

What Is a Constructor?

A constructor is a special method that runs automatically when an object is created.

In Python, the method commonly used for initializing objects is called __init__().

Its main purpose is to initialize the object's attributes with appropriate starting values.

Why Use Constructors?

Consider the approach from the previous lesson:

class Student:
    pass


student = Student()

student.name = "Ali"
student.age = 22
student.course = "Python"

This works, but there is a better and more structured approach.

class Student:

    def __init__(self, name, age, course):
        self.name = name
        self.age = age
        self.course = course


student = Student("Ali", 22, "Python")

The __init__() Method

The double underscores around init are important.

The method is written as:

def __init__(self):
    # initialization code
    pass

When you create an object like this:

student = Student()

Python automatically calls the class's __init__() method as part of creating and initializing that object.

Creating a Basic Constructor

Let's create a simple Student class.

class Student:

    def __init__(self):
        self.name = "Unknown"
        self.age = 0


student = Student()

print(student.name)
print(student.age)

Unknown
0

The attributes were created automatically when the object was initialized.

Understanding self

The first parameter of an instance constructor is normally self.

It represents the current object.

class Student:

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


student = Student("Ali")

print(student.name)

Ali

Here:

• name is the constructor parameter.
• self.name is the object's attribute.
• "Ali" is passed into the constructor.

Constructor Parameters

Constructors become especially useful when they accept parameters.

class Student:

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


student = Student("Sara", 21)

print(student.name)
print(student.age)

Sara
21

The values supplied during object creation are passed to __init__().

Student("Sara", 21)
        ↓
__init__(self, "Sara", 21)
        ↓
self.name = "Sara"
self.age = 21

Initializing Multiple Attributes

A constructor can initialize as many related attributes as your class requires.

class Product:

    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock


product = Product("Laptop", 85000, 10)

print(product.name)
print(product.price)
print(product.stock)

Laptop
85000
10

This pattern is extremely common in real-world applications such as ecommerce systems, inventory software, CRM systems, and business applications.

Creating Multiple Objects

Once a constructor is defined, we can easily create many objects with different values.

class Product:

    def __init__(self, name, price):
        self.name = name
        self.price = price


product1 = Product("Laptop", 85000)
product2 = Product("Phone", 50000)
product3 = Product("Headphones", 8000)

print(product1.name, product1.price)
print(product2.name, product2.price)
print(product3.name, product3.price)

Laptop 85000
Phone 50000
Headphones 8000

Default Constructor Values

Constructor parameters can have default values, just like normal Python function parameters.

class Student:

    def __init__(self, name, course="Python"):
        self.name = name
        self.course = course


student1 = Student("Ali")
student2 = Student("Sara", "Data Analytics")

print(student1.name, student1.course)
print(student2.name, student2.course)

Ali Python
Sara Data Analytics

If a value is not supplied, Python uses the default value.

Using Keyword Arguments

Constructor arguments can also be passed by name.

class Employee:

    def __init__(self, name, department, salary):
        self.name = name
        self.department = department
        self.salary = salary


employee = Employee(
    name="Ahmed",
    department="Sales",
    salary=75000
)

print(employee.name)
print(employee.department)
print(employee.salary)

Ahmed
Sales
75000

Keyword arguments can make object creation easier to read, especially when a class has several parameters.

Validation Inside a Constructor

A constructor can also validate data before storing it inside an object.

class Product:

    def __init__(self, name, price):
        if price < 0:
            raise ValueError("Price cannot be negative.")

        self.name = name
        self.price = price


product = Product("Laptop", 85000)

print(product.name)
print(product.price)

Laptop
85000

If an invalid price is supplied, the constructor can reject it before the object is fully initialized.

Required vs Optional Data

A constructor can contain both required and optional parameters.

class Customer:

    def __init__(self, name, email, country="Pakistan"):
        self.name = name
        self.email = email
        self.country = country


customer1 = Customer(
    "Ali",
    "ali@example.com"
)

customer2 = Customer(
    "Sara",
    "sara@example.com",
    "UAE"
)

print(customer1.country)
print(customer2.country)

Pakistan
UAE

Constructors and Class Attributes

A class can contain both class attributes and instance attributes initialized through a constructor.

class Student:

    school = "PyLearn Academy"

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


student1 = Student("Ali")
student2 = Student("Sara")

print(student1.name)
print(student2.name)

print(student1.school)
print(student2.school)

Ali
Sara
PyLearn Academy
PyLearn Academy

Constructors + Methods

A class becomes much more useful when its constructor initializes data and its methods operate on that data.

class Product:

    def __init__(self, name, price):
        self.name = name
        self.price = price

    def show_details(self):
        print("Product:", self.name)
        print("Price:", self.price)


product = Product("Laptop", 85000)

product.show_details()

Product: Laptop
Price: 85000

This is a pattern you will use repeatedly throughout object-oriented programming:

Real-World Examples

Constructors are heavily used in real applications. Let's examine some practical examples.

Example 1 — Bank Account

class BankAccount:

    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    def show_balance(self):
        print(self.owner)
        print("Balance:", self.balance)


account = BankAccount("Ali", 50000)

account.show_balance()

Ali
Balance: 50000

Example 2 — Employee

class Employee:

    def __init__(self, name, department, salary):
        self.name = name
        self.department = department
        self.salary = salary

    def show_details(self):
        print(self.name)
        print(self.department)
        print(self.salary)


employee = Employee(
    "Sara",
    "Marketing",
    90000
)

employee.show_details()

Example 3 — Ecommerce Product

class Product:

    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    def is_available(self):
        return self.stock > 0


product = Product(
    "Wireless Mouse",
    2500,
    15
)

print(product.name)
print(product.is_available())

Wireless Mouse
True

Common Constructor Mistakes

1. Forgetting self

# Wrong
class Student:

    def __init__(name):
        self.name = name

The correct version is:

class Student:

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

2. Forgetting to use self when storing attributes

# Wrong
class Student:

    def __init__(self, name):
        name = name

The parameter does not become a persistent object attribute simply by assigning it to itself.

# Correct
class Student:

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

3. Passing the wrong number of arguments

class Student:

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


student = Student("Ali")

This produces a TypeError because the required age argument is missing.

4. Confusing self.name with name

5. Incorrect capitalization of __init__

# Wrong
def __Init__(self):
    pass

# Correct
def __init__(self):
    pass

Python's special method name is exactly __init__.

Practice Exercises

Mini Challenge — Ecommerce Product Manager

Let's combine classes, constructors, attributes, methods, and validation into one practical exercise.

Requirements

• Create a Product class.
• Use a constructor.
• Accept name, price, and stock.
• Store them as instance attributes.
• Reject negative prices.
• Reject negative stock values.
• Create a show_details() method.
• Create at least three product objects.

Starter Code

class Product:

    def __init__(self, name, price, stock):

        if price < 0:
            raise ValueError("Price cannot be negative.")

        if stock < 0:
            raise ValueError("Stock cannot be negative.")

        self.name = name
        self.price = price
        self.stock = stock

    def show_details(self):
        print("Name:", self.name)
        print("Price:", self.price)
        print("Stock:", self.stock)


product1 = Product(
    "Laptop",
    85000,
    10
)

product1.show_details()

Extension Challenge

Add a method called is_available() that returns True when stock is greater than zero and False otherwise.

Quick Knowledge Check

Test your understanding of Python constructors.

Lesson Summary

Constructors make Python classes much more practical by allowing objects to be initialized with their required information at creation time.