How to Build a Simple OOP Project in Python

I remember when I first started coding in Python over a decade ago. Everything was a mess of global variables and long, confusing functions.

Then I discovered Object-Oriented Programming (OOP), and it changed how I built tools. It was like moving from a messy desk to a perfectly organized filing cabinet.

In this tutorial, I will show you how to build a real-world project from scratch. We aren’t doing “Hello World” today; we are building a functional banking system.

Table of Contents

Why Use OOP for Your Python Projects?

When I build software for clients in the US, they care about scalability. OOP allows you to treat pieces of your code like real-world objects.

If you are building a banking app, you don’t just want “data.” You want an “Account” object that knows its own balance and how to handle a deposit.

Method 1: Build a Simple US Bank Account System

I’ve found that the best way to learn OOP is to model something you use daily. In this example, we will create a system that handles standard US checking accounts.

We will define a class that manages the account holder’s name and their balance. It will also include methods to deposit and withdraw funds safely.

Step 1: Define the Account Class

First, I always start by defining the blueprint for our object. The __init__ method is where we set up the initial state of the account.

class BankAccount:
    def __init__(self, owner, balance=0.0):
        self.owner = owner
        self.balance = balance

    def __str__(self):
        return f"Account Owner: {self.owner}\nAccount Balance: ${self.balance:,.2f}"

In the code above, I used a default balance of zero. I also added a __str__ method to make the output look professional.

Step 2: Add Functionality

Now, we need to let the user actually do something with their money. I like to add simple logic to prevent people from withdrawing more than they have.

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"Added ${amount:,.2f} to the balance.")
        else:
            print("Deposit amount must be positive.")

    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            print(f"Withdrawal of ${amount:,.2f} successful.")
        else:
            print("Insufficient funds or invalid amount.")

Notice how I used f-strings with a comma separator. This is standard in the US to make large dollar amounts easier to read.

Method 2: Create a Modern Tech Inventory Tracker

Sometimes, I need to track assets instead of money. Another great OOP project is a simplified Inventory Management system.

This is perfect for a small startup in San Francisco or a tech hub. We will track “Tech Gadgets” and their stock levels.

class TechInventory:
    def __init__(self, item_name, price, stock):
        self.item_name = item_name
        self.price = price
        self.stock = stock

    def update_stock(self, quantity):
        self.stock += quantity
        print(f"Stock updated for {self.item_name}. New total: {self.stock}")

    def apply_discount(self, percentage):
        self.price -= (self.price * (percentage / 100))
        print(f"New price for {self.item_name} after {percentage}% discount: ${self.price:,.2f}")

I used this logic recently for a local electronics shop’s internal tool. It’s simple, but it handles the core logic of a business effectively.

The Complete Python OOP Project Code

I have combined the logic into a single, runnable script for you. You can copy this into your IDE (like VS Code or PyCharm) and run it immediately.

# Simple Python OOP Project: US Banking System
# Author: Senior Python Developer

class BankAccount:
    """A simple class to represent a US Bank Account."""
    
    def __init__(self, owner, balance=0.0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        """Add money to the account."""
        if amount > 0:
            self.balance += amount
            print(f"--- SUCCESS: ${amount:,.2f} deposited into {self.owner}'s account.")
        else:
            print("--- ERROR: Deposit must be a positive number.")

    def withdraw(self, amount):
        """Subtract money if funds are available."""
        if amount > self.balance:
            print(f"--- REJECTED: Insufficient funds. Available: ${self.balance:,.2f}")
        elif amount <= 0:
            print("--- ERROR: Withdrawal must be a positive number.")
        else:
            self.balance -= amount
            print(f"--- SUCCESS: ${amount:,.2f} withdrawn from {self.owner}'s account.")

    def display_balance(self):
        """Show the current status of the account."""
        print(f"\n[ACCOUNT SUMMARY]")
        print(f"Owner:   {self.owner}")
        print(f"Balance: ${self.balance:,.2f}\n")


# Main execution block
if __name__ == "__main__":
    # 1. Create a new account for a customer in New York
    my_account = BankAccount("John Doe", 1500.00)
    
    # 2. Check initial status
    my_account.display_balance()
    
    # 3. Perform some transactions
    my_account.deposit(500.50)
    my_account.withdraw(200.00)
    
    # 4. Try to overdraw
    my_account.withdraw(3000.00)
    
    # 5. Show final balance
    my_account.display_balance()

You can refer to the screenshot below to see the output.

When you run this, you will see a clean, formatted output in your terminal. It handles the logic, formatting, and errors just like a real application would.

Building projects like this helped me land my first senior dev role. It shows you understand how to structure data and behavior together.

I hope you found this tutorial helpful and easy to follow. OOP can be intimidating at first, but it is just about organizing your thoughts.

You may read:

Bijay Kumar

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.

enjoysharepoint.com/