Build a Simple Bank Account System Using Python OOP

Python is one of the easiest programming languages for beginners, but it is also powerful enough to build practical software projects. One excellent way to improve your Python skills is by learning Object-Oriented Programming (OOP) through a real-world project.

In this tutorial, we will build a simple bank account system using Python OOP. The project will demonstrate how classes and objects can represent customers and bank accounts while also teaching important concepts such as constructors, methods, encapsulation, inheritance, and validation.

Note: This is an educational project. It is not suitable for handling real banking transactions or sensitive financial information.

What Is Object-Oriented Programming?

Object-Oriented Programming is a programming approach where software is organized around objects.

An object contains:

Data, known as attributes
Behavior, represented by methods

For example, a bank account has information such as an account holder's name and balance. It also performs actions such as depositing money, withdrawing money, and displaying account information.

Instead of writing separate functions for every account, OOP allows us to create a reusable BankAccount class.

What We Will Build

Our simple system will support several operations:

Create a bank account
Display account information
Deposit money
Withdraw money
Check the balance
Transfer money
Prevent invalid transactions

The project will use Python classes and objects to keep the code organized.

Step 1: Creating the Bank Account Class

Let's start by creating a basic class.

class BankAccount:

    def __init__(self, account_number, account_holder, balance=0):
        self.account_number = account_number
        self.account_holder = account_holder
        self.balance = balance

The BankAccount class represents a bank account.

The __init__() method is called automatically when a new object is created.

The self keyword refers to the current object.

For example:

account1 = BankAccount("1001", "Rahul", 5000)

Here, account1 is an object created from the BankAccount class.

Its initial balance is ₹5,000.

Step 2: Adding a Deposit Method

A bank account should allow customers to deposit money.

We can create a method for this:

def deposit(self, amount):
    if amount <= 0:
        print("Deposit amount must be greater than zero.")
        return

    self.balance += amount
    print(f"₹{amount} deposited successfully.")

The method first checks whether the amount is valid.

If the amount is positive, it is added to the account balance.

For example:

account1.deposit(2000)

The balance will become ₹7,000.

Step 3: Adding a Withdrawal Method

Now we can create a method for withdrawing money.

def withdraw(self, amount):
    if amount <= 0:
        print("Withdrawal amount must be greater than zero.")
        return

    if amount > self.balance:
        print("Insufficient balance.")
        return

    self.balance -= amount
    print(f"₹{amount} withdrawn successfully.")

This method performs two important checks.

First, the withdrawal amount must be greater than zero.

Second, the customer cannot withdraw more money than the available balance.

For example:

account1.withdraw(1000)

The account balance will decrease by ₹1,000.

Step 4: Checking the Balance

We can add a method that displays the current balance.

def check_balance(self):
    print(f"Current balance: ₹{self.balance}")

Now we can write:

account1.check_balance()

and the program will display the current balance.

Step 5: Displaying Account Information

It is also useful to have a method for displaying basic account details.

def display_account(self):
    print("\n--- Account Details ---")
    print(f"Account Number: {self.account_number}")
    print(f"Account Holder: {self.account_holder}")
    print(f"Balance: ₹{self.balance}")

This keeps account information organized and easy to read.

Step 6: Adding Money Transfer

We can make the project more interesting by allowing one account to transfer money to another.

def transfer(self, other_account, amount):
    if amount <= 0:
        print("Transfer amount must be greater than zero.")
        return

    if amount > self.balance:
        print("Insufficient balance.")
        return

    self.balance -= amount
    other_account.balance += amount

    print(f"₹{amount} transferred successfully.")

The method accepts another BankAccount object as other_account.

For example:

account1 = BankAccount("1001", "Rahul", 5000)
account2 = BankAccount("1002", "Amit", 3000)

account1.transfer(account2, 1500)

After the transaction, Rahul's balance becomes ₹3,500, while Amit's balance becomes ₹4,500.

The Complete Bank Account Class

We can now combine everything into one class.

class BankAccount:

    def __init__(self, account_number, account_holder, balance=0):
        self.account_number = account_number
        self.account_holder = account_holder
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            print("Deposit amount must be greater than zero.")
            return

        self.balance += amount
        print(f"₹{amount} deposited successfully.")

    def withdraw(self, amount):
        if amount <= 0:
            print("Withdrawal amount must be greater than zero.")
            return

        if amount > self.balance:
            print("Insufficient balance.")
            return

        self.balance -= amount
        print(f"₹{amount} withdrawn successfully.")

    def check_balance(self):
        print(f"Current balance: ₹{self.balance}")

    def display_account(self):
        print("\n--- Account Details ---")
        print(f"Account Number: {self.account_number}")
        print(f"Account Holder: {self.account_holder}")
        print(f"Balance: ₹{self.balance}")

    def transfer(self, other_account, amount):
        if amount <= 0:
            print("Transfer amount must be greater than zero.")
            return

        if amount > self.balance:
            print("Insufficient balance.")
            return

        self.balance -= amount
        other_account.balance += amount

        print(f"₹{amount} transferred successfully.")

Creating and Using Accounts

Now let's create two accounts.

account1 = BankAccount("1001", "Rahul", 5000)
account2 = BankAccount("1002", "Amit", 3000)

account1.display_account()
account2.display_account()

account1.deposit(2000)
account1.withdraw(1000)

account1.transfer(account2, 1500)

account1.check_balance()
account2.check_balance()

This demonstrates how multiple objects can be created from the same class.

Each object maintains its own data.

Understanding Encapsulation

One important OOP concept demonstrated by this project is encapsulation.

Encapsulation means keeping data and the operations that work on that data together inside a class.

For a more advanced version, we could make the balance private:

self.__balance = balance

Python's double underscore provides name mangling, making accidental direct access more difficult.

A production-quality banking application would require much stronger security and data protection, but this example helps demonstrate the underlying OOP concept.

Adding Inheritance

Python OOP also supports inheritance.

For example, we could create a specialized savings account:

class SavingsAccount(BankAccount):

    def add_interest(self, rate):
        interest = self.balance * rate / 100
        self.balance += interest
        print(f"Interest added: ₹{interest}")

Now SavingsAccount inherits the deposit, withdrawal, transfer, and other methods from BankAccount.

We can create one like this:

savings = SavingsAccount("2001", "Priya", 10000)

savings.deposit(2000)
savings.add_interest(5)
savings.check_balance()

This shows how inheritance can help us extend existing functionality without rewriting the entire class.

What You Learn From This Project

Although the program is relatively small, it introduces several important programming concepts:

Classes and objects
Constructors
Instance attributes
Methods
Encapsulation
Inheritance
Object interaction
Conditional statements
Input validation
Basic transaction logic

These concepts appear in much larger applications as well.

Ideas for Improving the Project

Once the basic system works, you can expand it into a complete command-line banking application.

Possible improvements include:

User login and authentication
Multiple customer accounts
Transaction history
Account creation menu
Account deletion
Interest calculation
PIN verification
Saving data to a JSON or database file
SQLite database integration
Monthly statements
Administrative functions
Exception handling

You could eventually turn the project into a graphical application using a Python GUI framework or build a web-based banking demonstration using a Python web framework.

Conclusion

Building a simple bank account system is an excellent way to learn Python Object-Oriented Programming because it connects programming concepts with a familiar real-world example.

Instead of treating every transaction as an unrelated function, OOP allows us to model a bank account as an object containing both its information and behavior.

Once you understand this small project, you can start experimenting with more advanced ideas such as inheritance, abstraction, databases, authentication, and transaction management.

The most important lesson is not simply learning how to write a BankAccount class. It is learning how to break a real-world problem into objects, responsibilities, and reusable pieces of code. That skill will become increasingly valuable as your Python projects grow in complexity.

TechnologiesInternetz

Monday, August 17, 2026