Python Classes and Objects

names = ["Rahul", "Amit"]
ages = [20, 25]
marks = [70, 90]

The above written code is good at the beginning.

Once you start adding more names, updating marks, or passing data between functions, this code will become fragile.

Lists can go out of sync easily and silently. Bugs will start appearing. Overall, it would be difficult to manage the code.

In fact, this is a very common problem in beginner Python programs without classes and objects.

3. What Is a Class? (With Example)

class Student:
    name = "Amit"
    marks = 80

    def display(self):
        print("Name:", self.name)
        print("Marks:", self.marks)

Explanation

In the above program, we have created a Student class that acts as a blueprint.

This class contains data and a function (method).

Next, we have defined two attributes: name and marks that hold information.

After that, we have defined a method display() that prints these two attributes.

Here, self represents the current object created from the class.

It allows a method to access data and print the data of that same object.

Please note that a class can have multiple attributes and methods as well.

4. What Is an Object in Python? (Simple Explanation for Beginners)

An object is the real instance created from a class.

Example

class Student:
    name = "Amit"
    marks = 80

    def display(self):
        print("Name:", self.name)
        print("Marks:", self.marks)

s1 = Student()
s1.display()

Explanation

In the above example, Student is a class (blueprint).

The below line of code creates a real object from the Student class:

s1 = Student()

Please note that s1 is an object that contains:

• data (name and marks)

• behavior (display)

In the last line, s1.display() is used to call the display method using the s1 object for that specific object.

If you want, you can create multiple objects from the same class like:

s1 = Student()

s2 = Student()

Please note that here s1 and s2 objects are created from the same Student class, but s1 and s2 are different objects.

Each object can hold its own data and methods differently.

5. What Is __init__() Method in Python?

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

s1 = Student("Amit", 25)

Explanation

In the above program, first the s1 object is created with the below line of code:

s1 = Student("Amit", 25)

Then, the __init__() method is called automatically.

The __init__() method receives values (Amit and 25), and these values are assigned to the object’s data.

In this way, Python ensures that the object is created in a valid and usable state (with required data).

6. Why Use self in Python Classes? (Beginner Explanation)

In Python language, self refers to the current object created from a class.

It is also used to store and access data inside that specific object.

Example:

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

s1 = Student("Rocky", 22)

Explanation:

In the above program, when we write the following statement:

self.name = name

The name on the right-hand side (RHS) is the value passed to the function as a parameter.

This value exists only inside the function (constructor), and self.name on the left-hand side (LHS) is an attribute of the object.

In simple words, the value received (Rocky), which is passed as a function parameter (name), is assigned to an object attribute (self.name).

Note: At runtime, the attribute name is created automatically inside the object when the following statement is executed:

self.name = name

In Python, you don’t need to declare attributes in advance.

Call-flow Illustration:

When Python runs the following line:

s1 = Student("Rocky", 22)

Internally, Python does the following:

Student.__init__(s1, "Rocky", 22)

Explanation:

Object s1 is automatically passed as self.

In simple words, self contains the s1 object reference.

This is how self connects methods to an object, and it also prevents data from mixing between multiple objects.

Now, you have clarity about self in Python.

7. Default Values in __init__()

In real projects, sometimes we don’t have every piece of information available, or we don’t provide all the values to the __init__() method.

Some values are optional, and Python allows this using default values in __init__().

Example:

class User:
    def __init__(self, name, role="guest"):
        self.name = name
        self.role = role

u1 = User("Admin")
u2 = User("Amit", "manager")

Explanation:

In the above example, we have set a default value using role="guest".

When we create the u1 object and don’t pass any role, then Python uses the default value "guest" for role.

In the next line, when we create the u2 object and pass role value as "manager", then the default value (guest) is overridden.

Why This Is Useful?

Default values inside the __init__() method give you these benefits:

• Flexibility: Objects can be created even when partial information is available.

• Readability: Objects are created in a clean way, and it becomes easy to understand code.

• Safety: Objects are created with sensible values, so you never miss important data.

8. Multiple Parameters in __init__() (Normal in Real Projects)

class Product:
    def __init__(self, id, name, price, stock, category):
        self.id = id
        self.name = name
        self.price = price
        self.stock = stock
        self.category = category

Explanation:

In the above code, this class represents a Product with all its important details (like id, name, price, stock, etc.).

Each parameter passed to the __init__() method becomes data stored inside the object.

In real applications, these multiple values can come from multiple sources like databases, APIs, or user input.

When you pass multiple parameters, it ensures that the object is created with complete data.

9. Instance Variables vs Class Variables in Python

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

Explanation:

In the above shown code, self.name is an instance variable.

When you create an object of the Student class, then each object gets its own copy of name.

If you change one object’s data, then it won’t affect others.

b) Class Variables (Shared by All Objects)

class Student:
    school_name = "XYZ School"

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

Explanation:

In the above shown code, school_name is a class variable, and it is shared by all student objects.

Production Example: E-commerce Order System

class Order:
    tax_rate = 0.18

    def __init__(self, order_id, amount):
        self.order_id = order_id
        self.amount = amount

    def total_amount(self):
        return self.amount + (self.amount * Order.tax_rate)

o1 = Order(201, 1000)
o2 = Order(202, 1500)

print(o1.total_amount())
print(o2.total_amount())

Output:

1180.0

1770.0

Explanation:

In the above program, tax_rate is a class variable because it is shared by all orders.

Also, self.order_id and self.amount are instance variables because each order stores its own order id and amount.

The total_amount() method calculates and returns the final amount (including tax) using the shared tax rate.

10. Methods in a Class

A method in a class is a function, and it defines what an object can do.

In simple words, it represents the behavior or actions of an object.

Example: Student Class with Multiple Methods

class Student:
    def display(self):
        print("Student details")

    def is_passed(self):
        return True

s1 = Student()
s1.display()
print(s1.is_passed())

Output:

Student details

True

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

    def __str__(self):
        return f"Student Name: {self.name}"

print(Student("Raj"))

Output:

Student Name: Raj

class Student:
    def __init__(self, name, marks):
        self.name = name        # public variable
        self.__marks = marks   # private variable

    def get_marks(self):
        return self.__marks

s = Student("Andy", 75)

print(s.name)
print(s.__marks)

Output:

Andy

AttributeError

from datetime import datetime

class UserLogger:
    def __init__(self, username):
        self.username = username

    def log(self, action):
        time = datetime.now().isoformat()
        print(f"{time} | {self.username} | {action}")

Explanation:

In the above code, firstly we have imported the datetime class from the datetime module so that the current date and time can be captured.

After that, we have defined a class UserLogger that handles logging user actions.

Next, we have initialized the logger with a specific user inside the constructor method.

After that, we have defined a method log() to log a user action. Inside the log() method, we are capturing the current time in a standard and readable format.

Finally, the log message is printed showing when, who, and what.

Important Points:

Normally, the log() method is called in the following scenarios:

• After a user logs in or logs out

• When a file is uploaded or downloaded

• When an error or warning occurs

• When an API request is received

And a production developer places the logging call inside business logic so that every important event gets recorded.

14. Object Lifecycle: Creation → Use → Cleanup

class FileTracker:
    def __init__(self, filename):
        self.filename = filename
        print("Opened:", filename)

    def process(self):
        print("Processing file")

    def __del__(self):
        print("Closed:", self.filename)
# object creation
tracker = FileTracker("data.txt")

# object usage
tracker.process()

# object deletion
del tracker

Output:

Opened: data.txt

Processing file

Closed: data.txt

Explanation:

In the above program, when FileTracker object is created, it runs the __init__() method and prints "Opened: data.txt".

After that, the process() method is called, then Python executes the body inside process() method and prints "Processing file".

Please note that the process() method represents using the object while it is active.

Finally, when del tracker is executed, Python removes the reference to the object, and if no reference remains, then Python invokes the __del__() method for cleanup tasks (during garbage collection) and prints "Closed: data.txt".

Normally, a __del__() method is used for the following cleanup tasks:

• Closing a file

• Releasing a network connection

• If you want to free an external resource (not Python memory)

• If you want to print a message (for learning perspective)

Golden Lines:

• del only removes references of an object

• __del__() method is used for cleanup tasks

• Python garbage collector releases the object from memory

15. Deleting Objects in Python

del obj

Important Points:

• It only removes the reference, not the object

• There is no immediate guarantee about destruction of the object

• The object is cleaned up only when Python garbage collector decides it is safe

17. Why This Matters for AI, ML, and Cloud Development:

1. PyTorch models are classes:

2. ML pipelines manage state using objects:

3. Cloud services use class-based SDKs: