Python Class Definition Tutorial (With Examples)

Introduction to Python Classes

In object-oriented programming (OOP), a class is a blueprint for creating objects. Objects are instances of a class, and they can have attributes (variables) and methods (functions) associated with them. Python is an object-oriented programming language, which means it supports the creation and use of classes and objects.

Defining classes in Python allows you to create custom data types that can have their own attributes and behaviors. This tutorial will walk you through the process of defining classes in Python, along with detailed examples to help you understand the concepts better.

Creating a Class

To define a class in Python, you use the class keyword followed by the class name. The class name should start with an uppercase letter by convention. Let’s start by creating a simple class called Person.

class Person:
    pass

In the example above, we’ve defined a basic class named Person using the class keyword. The pass statement is used as a placeholder since the class is currently empty. Now, let’s add attributes and methods to our Person class.

Adding Attributes and Methods to a Class

Attributes

Attributes are variables that store data associated with an object. They define the properties or characteristics of the object. You can define attributes in the class’s constructor method using the __init__ method. This method is called when an object is created from the class.

Let’s add attributes name and age to the Person class.

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

In this example, the __init__ method takes three parameters: self, name, and age. The self parameter refers to the instance of the object being created. Inside the method, we use self.name and self.age to store the values passed as arguments.

Methods

Methods are functions defined within a class and can perform actions or operations related to the class. Let’s add a method named greet to the Person class.

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.")

In this example, we’ve defined a method named greet that uses the self.name and self.age attributes to display a greeting message.

Creating Objects from the Class

Once the class is defined with its attributes and methods, you can create objects (instances) from the class. To create an object, call the class name as if it were a function, passing any required arguments to the constructor.

Let’s create two Person objects and call the greet method on each of them.

# Creating Person objects
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

# Calling the greet method
person1.greet()
person2.greet()

When you run the code above, you’ll see the following output:

Hello, my name is Alice and I am 30 years old.
Hello, my name is Bob and I am 25 years old.

Example 1: Creating a Bank Account Class

Let’s work through a more comprehensive example by creating a BankAccount class. This class will have attributes for account number, account holder name, balance, and methods to deposit and withdraw money.

class BankAccount:
    def __init__(self, account_number, account_holder, initial_balance):
        self.account_number = account_number
        self.account_holder = account_holder
        self.balance = initial_balance

    def deposit(self, amount):
        self.balance += amount
        print(f"Deposited {amount} units. Current balance: {self.balance}")

    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            print(f"Withdrew {amount} units. Current balance: {self.balance}")
        else:
            print("Insufficient funds.")

    def get_balance(self):
        return self.balance

In this example, we’ve defined a BankAccount class with attributes account_number, account_holder, and balance. The methods deposit, withdraw, and get_balance allow us to perform actions on the account.

Let’s create a BankAccount object and perform some actions on it.

# Creating a BankAccount object
account1 = BankAccount("12345", "Alice", 1000)

# Depositing and withdrawing money
account1.deposit(500)
account1.withdraw(200)
account1.withdraw(800)  # This will result in insufficient funds

# Getting the current balance
balance = account1.get_balance()
print(f"Current balance: {balance}")

The output will be:

Deposited 500 units. Current balance: 1500
Withdrew 200 units. Current balance: 1300
Insufficient funds.
Current balance: 1300

Example 2: Creating a Rectangle Class

Let’s explore another example by creating a Rectangle class. This class will have attributes for width and height, and methods to calculate area and perimeter.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

    def calculate_perimeter(self):
        return 2 * (self.width + self.height)

In this example, the Rectangle class has attributes width and height, along with methods calculate_area and calculate_perimeter.

Let’s create a Rectangle object and calculate its area and perimeter.

# Creating a Rectangle object
rectangle1 = Rectangle(5, 8)

# Calculating area and perimeter
area = rectangle1.calculate_area()
perimeter = rectangle1.calculate_perimeter()

print(f"Rectangle area: {area}")
print(f"Rectangle perimeter: {perimeter}")