Project on Banking: Building a Bank Management System Using Python With Complete Source Code

Creating projects is one of the best ways to master a programming language, and a bank management system project in python is a fantastic choice for beginners and intermediate developers alike. It covers fundamental concepts like object-oriented programming, data handling, and user interaction, all within a real-world context. This project serves as a solid foundation, helping you understand how software applications are structured to solve practical problems. 

In this detailed blog, we will walk you through building a functional banking application from the ground up. You will get a complete, step-by-step tutorial, the full source code to work with, and ideas on how to enhance your project further. Whether you're a student looking for a college project or a self-learner aiming to strengthen your Python skills, this blog has everything you need to succeed. 

Build the future with code! Explore our diverse Software Engineering Courses and kickstart your journey to becoming a tech expert. 

Bank Management System Project in Python: Core Features 

Our command-line-based system will focus on the essential functionalities every bank needs. Here's a quick look at what our application will do: 

This set of features provides a complete, functional core for our banking system project. 

Coding Your Bank Management System Project in Python: Step-by-Step 

Let's get our hands dirty and start coding. We'll build this project step-by-step, explaining the purpose of each code block as we go. 

Prerequisites 

Before we begin, make sure you have a basic understanding of Python's core concepts: 

• Variables and Data Types (strings, integers) 
• User Input (input() function) 
• Conditional Statements (if, elif, else) 
• Loops (while, for) 
• Functions 
• Object-Oriented Programming (Classes and Objects) 

You will also need Python installed on your computer. If you don't have it, you can download it from the official Python website. 

You may Read: How to Install Python in Windows (Even If You're a Beginner!) 

Step 1: Designing the Account Class 

The best way to structure a project like this is using Object-Oriented Programming (OOP). We will create an Account class to act as a blueprint for every bank account. Each account we create will be an "object" of this class, containing its own specific data (like name and balance). 

This class will hold all the information and actions related to a single bank account. 

Python 
import random 
 
class Account: 
    def __init__(self, name, initial_deposit): 
        self.name = name 
        self.balance = initial_deposit 
        self.account_number = self.generate_account_number() 
        print(f"Account for {self.name} created successfully.") 
        print(f"Your Account Number is: {self.account_number}") 
 
    def generate_account_number(self): 
        # A simple way to generate a 10-digit account number 
        return ''.join([str(random.randint(0, 9)) for _ in range(10)]) 
 
    def deposit(self, amount): 
        if amount > 0: 
            self.balance += amount 
            print(f"Deposited ${amount}. New balance: ${self.balance}") 
        else: 
            print("Invalid deposit amount.") 
 
    def withdraw(self, amount): 
        if amount > 0 and amount <= self.balance: 
            self.balance -= amount 
            print(f"Withdrew ${amount}. New balance: ${self.balance}") 
        else: 
            print("Invalid withdrawal amount or insufficient funds.") 
 
    def check_balance(self): 
        print(f"Current balance for account {self.account_number}: ${self.balance}") 
 
    def display_details(self): 
        print("\n--- Account Details ---") 
        print(f"Account Holder: {self.name}") 
        print(f"Account Number: {self.account_number}") 
        print(f"Balance: ${self.balance}") 
        print("-----------------------") 
 
 

Code Breakdown: 

• __init__(self, name, initial_deposit): This is the constructor. It runs every time a new Account object is created. It takes the account holder's name and their first deposit as input and initializes the account's properties. 
• generate_account_number(): We create a simple function to generate a random 10-digit number for each new account to make it unique. 
• deposit(self, amount): This method adds the specified amount to the balance. 
• withdraw(self, amount): This method subtracts the amount from the balance but first checks if the funds are sufficient. 
• check_balance(self): This simply prints the current balance. 
• display_details(self): This method prints a formatted summary of the account. 

Also Read: Python Built-in Modules: Supercharge Your Coding Today! 

Step 2: Creating the Main Bank Class 

Now we need a way to manage all the different accounts. For this, we'll create a Bank class. This class will handle operations like creating new accounts, finding existing accounts, and closing them. It will essentially be the main controller for our entire banking system project. 

We'll use a Python dictionary to store all the accounts, where the account number is the key and the Account object is the value. This makes looking up an account very fast and efficient. 

Python 
class Bank:def __init__(self): 
        self.accounts = {} # A dictionary to store accounts 
 
    def create_account(self): 
        name = input("Enter account holder's name: ") 
        try: 
            initial_deposit = float(input("Enter initial deposit amount: $")) 
            if initial_deposit < 0: 
                print("Initial deposit cannot be negative.") 
                return 
            new_account = Account(name, initial_deposit) 
            self.accounts[new_account.account_number] = new_account 
        except ValueError: 
            print("Invalid input for deposit. Please enter a number.") 
 
    def find_account(self, account_number): 
        return self.accounts.get(account_number) 
 
    def close_account(self): 
        account_number = input("Enter the account number to close: ") 
        account = self.find_account(account_number) 
        if account: 
            print(f"Closing account for {account.name}.") 
            del self.accounts[account_number] 
            print("Account closed successfully.") 
        else: 
            print("Account not found.") 
 
    def perform_transaction(self): 
        account_number = input("Enter your account number: ") 
        account = self.find_account(account_number) 
 
        if not account: 
            print("Account not found.") 
            return 
 
        while True: 
            print("\nTransaction Menu:") 
            print("1. Deposit") 
            print("2. Withdraw") 
            print("3. Check Balance") 
            print("4. View Account Details") 
            print("5. Exit Transaction Menu") 
             
            try: 
                choice = int(input("Enter your choice (1-5): ")) 
 
                if choice == 1: 
                    amount = float(input("Enter amount to deposit: $")) 
                    account.deposit(amount) 
                elif choice == 2: 
                    amount = float(input("Enter amount to withdraw: $")) 
                    account.withdraw(amount) 
                elif choice == 3: 
                    account.check_balance() 
                elif choice == 4: 
                    account.display_details() 
                elif choice == 5: 
                    break 
                else: 
                    print("Invalid choice. Please enter a number between 1 and 5.") 
            except ValueError: 
                print("Invalid input. Please enter a number.") 
 

Code Breakdown: 

• __init__(self): The constructor initializes an empty dictionary called accounts to store all the account objects. 
• create_account(): This method prompts the user for a name and initial deposit, creates a new Account object, and adds it to our accounts dictionary. 
• find_account(self, account_number): A helper function that searches the dictionary for an account number and returns the corresponding Account object if found. 
• close_account(): This method asks for an account number, finds it, and removes it from the accounts dictionary. 
• perform_transaction(): This is for existing customers. It finds their account and then presents a sub-menu for depositing, withdrawing, or checking the balance. 

Also Read: Class in Python 

Future-proof your tech career with industry-led programs in Cloud Computing, DevOps, and Full Stack Development. Gain hands-on experience, master in-demand tools, and earn certifications that set you apart in today’s AI-powered digital economy. 

• AI-Powered Full Stack Development Course by IIITB 
• Professional Certificate Program in Cloud Computing and DevOps 
• AI-Driven Full-Stack Development by upGrad 

Step 3: Building the Main Menu and Running the Application 

Finally, we need a user interface to interact with our Bank class. We will create a simple command-line menu that runs in a loop, allowing the user to choose what they want to do. This is the entry point of our application. 

Python 
def main(): 
    my_bank = Bank() 
 
    while True: 
        print("\n===== Welcome to Python Bank =====") 
        print("1. Create New Account") 
        print("2. Access Existing Account") 
        print("3. Close an Account") 
        print("4. Exit") 
         
        try: 
            choice = int(input("Enter your choice (1-4): ")) 
 
            if choice == 1: 
                my_bank.create_account() 
            elif choice == 2: 
                my_bank.perform_transaction() 
            elif choice == 3: 
                my_bank.close_account() 
            elif choice == 4: 
                print("Thank you for using Python Bank. Goodbye!") 
                break 
            else: 
                print("Invalid choice. Please select a valid option.") 
        except ValueError: 
            print("Invalid input. Please enter a number.") 
 
if __name__ == "__main__": 
    main() 
 

Code Breakdown: 

• main(): This function creates an instance of our Bank class. 
• while True: This creates an infinite loop to keep the program running until the user decides to exit. 
• The menu presents the main options. Based on the user's choice, it calls the appropriate method from our my_bank object. 
• if __name__ == "__main__":: This is standard Python practice. It ensures that the main() function is called only when the script is executed directly. 

This completes the basic structure of our bank management system project in python. 

Also Read: Top 50 Python Project Ideas with Source Code in 2025 

The Complete Source Code for Your Banking System Project 

For your convenience, here is the complete, consolidated source code for the project. You can copy and paste this into a single Python file (e.g., bank_app.py) and run it. 

Python 
import random 
 
#-------------------------------- 
# Class for a single bank account 
#-------------------------------- 
class Account: 
    """ 
    Represents a single bank account with basic functionalities like 
    deposit, withdraw, and balance check. 
    """ 
    def __init__(self, name, initial_deposit): 
        self.name = name 
        self.balance = initial_deposit 
        self.account_number = self.generate_account_number() 
        print(f"Account for '{self.name}' created successfully.") 
        print(f"Your Account Number is: {self.account_number}") 
 
    def generate_account_number(self): 
        """Generates a random 10-digit account number.""" 
        return ''.join([str(random.randint(0, 9)) for _ in range(10)]) 
 
    def deposit(self, amount): 
        """Deposits a specified amount into the account.""" 
        if amount > 0: 
            self.balance += amount 
            print(f"Successfully deposited ${amount:.2f}. New balance: ${self.balance:.2f}") 
        else: 
            print("Invalid deposit amount. Please enter a positive number.") 
 
    def withdraw(self, amount): 
        """Withdraws a specified amount from the account if funds are sufficient.""" 
        if 0 < amount <= self.balance: 
            self.balance -= amount 
            print(f"Successfully withdrew ${amount:.2f}. New balance: ${self.balance:.2f}") 
        else: 
            print("Invalid withdrawal amount or insufficient funds.") 
 
    def check_balance(self): 
        """Prints the current balance of the account.""" 
        print(f"Current balance for account {self.account_number}: ${self.balance:.2f}") 
 
    def display_details(self): 
        """Displays the full details of the account.""" 
        print("\n--- Account Details ---") 
        print(f"Account Holder: {self.name}") 
        print(f"Account Number: {self.account_number}") 
        print(f"Balance: ${self.balance:.2f}") 
        print("-----------------------") 
 
#-------------------------------- 
# Class for managing the entire bank 
#-------------------------------- 
class Bank: 
    """ 
    Manages all bank accounts and top-level operations like creating, 
    closing, and accessing accounts. 
    """ 
    def __init__(self): 
        self.accounts = {}  # Dictionary to store account_number: Account_object 
 
    def create_account(self): 
        """Guides the user through creating a new account.""" 
        name = input("Enter account holder's name: ") 
        if not name.strip(): 
            print("Name cannot be empty.") 
            return 
             
        try: 
            initial_deposit = float(input("Enter initial deposit amount: $")) 
            if initial_deposit < 0: 
                print("Initial deposit cannot be negative.") 
                return 
            new_account = Account(name, initial_deposit) 
            self.accounts[new_account.account_number] = new_account 
        except ValueError: 
            print("Invalid input for deposit. Please enter a valid number.") 
 
    def find_account(self, account_number): 
        """Finds and returns an account object based on the account number.""" 
        return self.accounts.get(account_number) 
 
    def close_account(self): 
        """Closes an account after confirming with the user.""" 
        account_number = input("Enter the account number to close: ") 
        account = self.find_account(account_number) 
        if account: 
            confirm = input(f"Are you sure you want to close the account for {account.name}? (yes/no): ").lower() 
            if confirm == 'yes': 
                del self.accounts[account_number] 
                print("Account closed successfully.") 
            else: 
                print("Account closure cancelled.") 
        else: 
            print("Account not found.") 
 
    def perform_transaction(self): 
        """Handles transactions for an existing customer.""" 
        account_number = input("Enter your account number: ") 
        account = self.find_account(account_number) 
 
        if not account: 
            print("Account not found. Please check the account number and try again.") 
            return 
 
        print(f"\nWelcome, {account.name}!") 
        while True: 
            print("\nTransaction Menu:") 
            print("1. Deposit") 
            print("2. Withdraw") 
            print("3. Check Balance") 
            print("4. View Account Details") 
            print("5. Return to Main Menu") 
             
            try: 
                choice = int(input("Enter your choice (1-5): ")) 
 
                if choice == 1: 
                    amount = float(input("Enter amount to deposit: $")) 
                    account.deposit(amount) 
                elif choice == 2: 
                    amount = float(input("Enter amount to withdraw: $")) 
                    account.withdraw(amount) 
                elif choice == 3: 
                    account.check_balance() 
                elif choice == 4: 
                    account.display_details() 
                elif choice == 5: 
                    break 
                else: 
                    print("Invalid choice. Please enter a number between 1 and 5.") 
            except ValueError: 
                print("Invalid input. Please enter a number.") 
 
#-------------------------------- 
# Main execution block 
#-------------------------------- 
def main(): 
    """The main function to run the bank application.""" 
    my_bank = Bank() 
 
    while True: 
        print("\n===== Welcome to Python Bank =====") 
        print("1. Create New Account") 
        print("2. Access Existing Account") 
        print("3. Close an Account") 
        print("4. Exit") 
         
        try: 
            choice = int(input("Enter your choice (1-4): ")) 
 
            if choice == 1: 
                my_bank.create_account() 
            elif choice == 2: 
                my_bank.perform_transaction() 
            elif choice == 3: 
                my_bank.close_account() 
            elif choice == 4: 
                print("Thank you for using Python Bank. Goodbye!") 
                break 
            else: 
                print("Invalid choice. Please select a valid option.") 
        except ValueError: 
            print("Invalid input. Please enter a number.") 
 
if __name__ == "__main__": 
    main() 
 
 

 Also Read: How to Run Python Program 

Taking Your Project to the Next Level 

Congratulations on building a functional command-line banking application! This is a great achievement. However, the current project has one major limitation: all the data is lost when you close the program. Here are some ways you can enhance your bank management system project in python with code examples to make it more robust. 

1. Data Persistence with JSON Files 

To save account data, you can write it to a file. The json module is great for this. You'd need functions to save data when the app closes and load it when it starts. 

Example Code: First, import json at the top of your file. Then, you could add a save_data method to your Bank class. 

Python 
# Inside the Bank class 
def save_data(self, filename="bank_data.json"): 
    # We can't save the Account objects directly, so we create a dictionary of their data 
    data_to_save = {} 
    for acc_num, account_obj in self.accounts.items(): 
        data_to_save[acc_num] = { 
            'name': account_obj.name, 
            'balance': account_obj.balance 
        } 
     
    with open(filename, 'w') as f: 
        json.dump(data_to_save, f, indent=4) 
    print("Data saved successfully.") 
 

You would call my_bank.save_data() before the program exits. You'd also need a corresponding load_data function to run when the program starts. 

Also Read: How to Open a JSON File? A Complete Guide on Creating and Reading JSON 

2. Add a Graphical User Interface (GUI) 

Command-line interfaces are functional, but GUIs are much more user-friendly. You can use Python's built-in Tkinter library to create a simple visual interface. 

Example Code: This is a very basic example of what a Tkinter window looks like. 

Python 
import tkinter as tk 
 
def create_gui(): 
    window = tk.Tk() 
    window.title("Python Bank") 
    window.geometry("400x300") 
 
    greeting_label = tk.Label(window, text="Welcome to Python Bank!", font=("Arial", 16)) 
    greeting_label.pack(pady=20) 
 
    create_account_btn = tk.Button(window, text="Create Account") 
    create_account_btn.pack(pady=10) 
     
    # You would link buttons to your bank functions here 
 
    window.mainloop() 
 
# You could call create_gui() instead of the command-line main() 
# create_gui() 
 

3. Implement Transaction History 

A real banking system keeps a record of all transactions. You can add this by creating a list within your Account class to store a log of every deposit and withdrawal. 

#Inside the Account class's init method, add: 
self.transactions = [] 
#Modify the deposit method: 
def deposit(self, amount): if amount > 0: self.balance += amount self.transactions.append(f"Deposit: +${amount:.2f}") # Log the transaction print(f"Deposited ${amount:.2f}. New balance: ${self.balance:.2f}") # ... rest of the method 
#Add a new method to display the history: 
def display_transactions(self): print("\n--- Transaction History ---") if not self.transactions: print("No transactions found.") else: for transaction in self.transactions: print(transaction) print("--------------------------") 

4. Improve Error Handling and Input Validation 

Our current project has some error handling, but you can make it more specific. For instance, what if a user tries to withdraw a non-numeric value? Using a try-except block for every input is good practice. 

Example Code: Here is a more robust way to handle numeric input. 

Python 
# In the perform_transaction method, when asking for amount: 
try: 
    amount_str = input("Enter amount to deposit: $") 
    amount = float(amount_str) 
    account.deposit(amount) 
except ValueError: 
    print("Invalid amount. Please enter a valid number (e.g., 50.75).") 
 
This try-except block specifically catches the ValueError that occurs if the user types letters instead of numbers, providing a clearer error message. 

By implementing these enhancements, you can transform this simple program into a much more comprehensive and impressive banking system project. 

Also Read: Python Tkinter Projects [Step-by-Step Explanation] 

What is a Bank Management System? 

A Bank Management System is a software application that digitizes and manages all the core operations of a bank. Think of it as the backbone that allows customers to open accounts, deposit money, withdraw cash, and check their balances without manual paperwork. It ensures that all transactions are recorded accurately and that customer data is stored securely and can be accessed easily. 

For developers, building a bank management system project in python is an excellent exercise. Python's simple syntax and powerful features make it an ideal language for this task. This project doesn't just teach you how to write code; it teaches you how to think logically and structure an application. 

Conclusion 

Building a bank management system project in python is a rewarding experience that reinforces many core programming principles. You have successfully created an application that handles essential banking operations using object-oriented principles. You started by designing an Account class, managed multiple accounts with a Bank class, and tied it all together with an interactive command-line menu. 

The real learning begins when you start extending this project. We encourage you to try implementing the enhancements suggested above, such as adding data persistence or a graphical user interface. Every new feature you add will deepen your understanding and make your portfolio stronger. Keep experimenting, keep coding, and continue building your skills. 

upGrad’s Exclusive Data Science Webinar for you –

ODE Thought Leadership Presentation

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles