rysasahrialIn Python, classes and objects are essential concepts in Object-Oriented Programming (OOP). They allow you to structure your code efficiently, reuse logic, and model real-world entities. Understanding classes and objects is crucial if you want to write scalable, maintainable, and organized Python applications.
In this tutorial, you will learn the basics of Python classes and objects — including how to create a class, instantiate objects, define attributes and methods, and understand the relationship between classes and instances. By the end of this article, you will be able to build and manage your own class-based programs in Python with ease.
What is a Class in Python?
A class is a blueprint for creating objects. Think of a class as a template that defines what an object should look like and what it can do. For example, a class Car might define attributes like color, brand, and year, and methods like start() or stop().
class Car:
def __init__(self, brand, color, year):
self.brand = brand
self.color = color
self.year = year
def start(self):
print(f"The {self.brand} car has started.")
def stop(self):
print(f"The {self.brand} car has stopped.")
In this example, we defined a class Car that has an initializer method (__init__) and two other methods (start and stop). The __init__ method runs automatically whenever we create a new object from this class.
Creating an Object (Instance) from a Class
An object is an instance of a class. When you create an object, you are essentially creating a unique version of the class with specific attribute values.
# Creating objects from the Car class
car1 = Car("Toyota", "Red", 2020)
car2 = Car("Honda", "Blue", 2022)
# Using class methods
car1.start()
car2.stop()
Output:
The Toyota car has started. The Honda car has stopped.
Here, car1 and car2 are two different objects created from the same class Car. Each object contains its own values for brand, color, and year.
Understanding the self Keyword
The self keyword in Python refers to the current instance of the class. It allows access to the class attributes and methods. Every method inside a class must have self as its first parameter (except for static methods).
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print(f"Hello, my name is {self.name} and I am {self.age} years old.")
person1 = Person("Alice", 25)
person1.greet()
Output:
Hello, my name is Alice and I am 25 years old.
Notice that self.name and self.age refer to the attributes of the current object, which in this case is person1.
Class Attributes vs Instance Attributes
Python allows you to define two types of attributes in a class:
- Class attributes — shared by all objects of the class.
- Instance attributes — unique to each object.
class Dog:
species = "Canis familiaris" # class attribute
def __init__(self, name, breed):
self.name = name # instance attribute
self.breed = breed # instance attribute
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "Bulldog")
print(dog1.species) # Shared attribute
print(dog2.name) # Unique attribute
Output:
Canis familiaris Max
In this example, both dog1 and dog2 share the same class attribute species, but each has its own name and breed.
Adding Methods to a Class
Methods are functions defined inside a class. They allow the object to perform actions or return information about its data. You can define as many methods as needed inside a class.
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * (self.radius ** 2)
def circumference(self):
return 2 * 3.14 * self.radius
circle1 = Circle(5)
print("Area:", circle1.area())
print("Circumference:", circle1.circumference())
Output:
Area: 78.5 Circumference: 31.400000000000002
Inheritance in Python Classes
Inheritance allows a class to derive attributes and methods from another class. It’s a powerful feature of OOP that promotes code reuse and extensibility.
# Base class
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return "Some sound"
# Derived class
class Cat(Animal):
def speak(self):
return "Meow!"
# Derived class
class Dog(Animal):
def speak(self):
return "Woof!"
cat = Cat("Milo")
dog = Dog("Buddy")
print(cat.name, "says", cat.speak())
print(dog.name, "says", dog.speak())
Output:
Milo says Meow! Buddy says Woof!
Here, both Cat and Dog inherit from the Animal class and override the speak() method to provide their own implementation.
Practical Example: Student Management System
Let’s combine everything we’ve learned into a real-world example. Suppose we’re building a small student management system that can store student information and calculate their average scores.
class Student:
def __init__(self, name, scores):
self.name = name
self.scores = scores
def average(self):
return sum(self.scores) / len(self.scores)
def show_info(self):
print(f"Name: {self.name}")
print(f"Scores: {self.scores}")
print(f"Average: {self.average():.2f}")
# Creating students
student1 = Student("John", [80, 90, 85])
student2 = Student("Lisa", [95, 88, 92])
# Displaying info
student1.show_info()
student2.show_info()
Output:
Name: John Scores: [80, 90, 85] Average: 85.00 Name: Lisa Scores: [95, 88, 92] Average: 91.67
Conclusion
Understanding Python classes and objects basics is a key step toward mastering Object-Oriented Programming. With classes, you can structure your programs logically, represent real-world objects, and make your code modular and reusable. You’ve now learned how to create classes, instantiate objects, define attributes and methods, and even use inheritance to extend functionality.
Start practicing by creating your own classes to represent everyday objects — such as a BankAccount, Book, or Employee — and explore how Python’s OOP principles can simplify your programming journey.
