How to Build an Online Banking System – Python Object-Oriented Programming Tutorial

Object-Oriented Programming (OOP) is a basic idea in software program engineering that permits software program engineers to construction code in a extra organized and modular approach.

Python, with its clear and concise syntax, is a wonderful language for studying and implementing OOP ideas.

In this text, we’ll  have a look at the fundamentals of OOP in Python by constructing a easy on-line banking system.

An Overview of OOP Concepts

Before we begin coding, let’s perceive the important thing ideas of OOP:

• Classes: Classes are blueprints for creating objects. They outline the attributes (information) and strategies (capabilities) that objects of that class could have.
• Objects: Objects are situations of courses. They signify real-world entities and encapsulate information and habits.
• Inheritance: Inheritance permits a category (subclass) to inherit attributes and strategies from one other class (superclass). It promotes code reuse and helps hierarchical relationships between courses.
• Constructor: A constructor ( __init__() ) is a particular sort of technique that’s routinely known as when an object of a category is created. Its main goal is to initialize the newly created object, setting preliminary values for its attributes or performing any vital setup duties.

How to Build An Online Banking System

Let’s begin by creating the essential construction for our on-line banking system utilizing OOP ideas.

How to Create A Class and Constructor

Let’s create a category and provoke the category with the constructor:

class Account:
    def __init__(self, title, account_number, steadiness):
        self.title = title
        self.account_number = account_number
        self.steadiness = steadiness

In the instance above:

• The class key phrase declares an Account class.
• The __init__() technique is the constructor, outlined with the particular double underscore notation initially and finish.
• self is a reference to the occasion of the category. It is the primary parameter of all occasion strategies in Python.
• title is the title of the account holder.
• account_number  is a singular identifier for the financial savings account, and steadiness are parameters handed to the constructor.
• Inside the constructor self.title, self.account_number, and self.steadiness are attributes of the category Account which might be initialized with the values of title, account_number and steadiness, respectively.

Constructors can carry out numerous duties resembling initializing attributes, opening connections, loading information, and extra. They are important for making certain that objects are correctly arrange and prepared to be used as quickly as they’re created.

How to Create Methods (capabilities)

The subsequent factor to do is to write down the completely different strategies for our Account class. Users ought to have the ability to deposit and withdraw.

How to create a deposit technique

    def deposit(self, quantity):
        self.steadiness += quantity
        print(f"{self.title} Deposited {quantity} $. Current steadiness is: {self.steadiness}")

In the instance above:

• The deposit technique permits customers so as to add funds to their account.
• The technique takes an extra parameter quantity, which is the quantity to be deposited.
• Inside the tactic, the quantity is added to the present steadiness utilizing self.steadiness += quantity.
• A message is printed exhibiting the depositor title and the quantity deposited and the steadiness is up to date.

How to create a withdraw technique

    def withdraw(self, quantity):
        if self.steadiness >= quantity:
            self.steadiness -= quantity
            print(f"{self.title} Withdrew {quantity} $. Current steadiness is: {self.steadiness}")
        else:
            print("You do not have sufficient funds to withdraw.")

In the instance above:

• The withdraw technique permits customers to withdraw funds from their account.
• The technique additionally takes an quantity parameter which is the quantity our person desires to withdraw.
• The technique checks if the account steadiness (self.steadiness) is larger than or equal to the quantity our person desires to withdraw.
• If the steadiness is sufficient, the withdrawal quantity is faraway from the steadiness utilizing self.steadiness -= quantity.
• If the steadiness is just not sufficient, a message stating “You do not have sufficient funds to withdraw.” is printed to the person.

How Inheritance Works

Having defined inheritance above, let’s have a look at the way it works in code. We are going to create a category that inherits the Account class.

Note that the Account class is the supper class, whereas the Savings_Account class is a subclass, also referred to as a toddler class.

class Savings_Account(Account):
    def __init__(self, title, account_number, steadiness, interest_rate):
        tremendous().__init__(title, account_number, steadiness)
        self.interest_rate = interest_rate

In the above code:

• The __init__ technique is the constructor for the Savings_Account class.
• It accepts 4 parameters: title which is the title of the account holder,  account_number, which is a singular identifier for the financial savings account, steadiness, which is the preliminary steadiness of the account, and interest_rate, which is the annual rate of interest (expressed as a decimal) for the account.
• The tremendous().__init__(title, account_number, steadiness) line calls the constructor of the father or mother class (Account) to initialize the account quantity and steadiness.
• The self.interest_rate = interest_rate line units the rate of interest particular to the financial savings account. it isn’t inherited

How to Create An add_interest  Method

def add_interest(self):
    curiosity = self.steadiness * self.interest_rate
    self.deposit(curiosity)

In the instance above:

• The add_interest technique calculates and provides curiosity to the account steadiness.
• The technique calculates the curiosity by multiplying the present steadiness (self.steadiness) with the rate of interest (self.interest_rate).
• The result’s saved within the curiosity variable.
• Finally, the self.deposit(curiosity) line calls the deposit technique (outlined within the father or mother Account class) so as to add the curiosity quantity to the account steadiness.

How to Create and Use Objects

Your class is only a template. You must create an object to your class to work.

Now, let’s create objects from our courses and work together with them.

account1 = Account("John Doe", "123456", 1000)
account1.deposit(500)
account1.withdraw(200)
print()

savings_account = Savings_Account("John Doe", "789012", 2000, 0.05)
savings_account.deposit(1000)
savings_account.add_interest()
savings_account.withdraw(500)
savings_account.withdraw(1000)

In the above code:

• We created an occasion account1 of the Account class and carried out deposit and withdrawal operations.
• Similarly, we created an occasion savings_account of the Savings_Account class and demonstrated deposit, curiosity addition, and withdrawal operations.

Conclusion

Object-Oriented Programming is a robust paradigm that permits software program engineers to write down code that’s reusable, maintainable, and might scale.

Python’s simplicity makes it a superb selection for studying and implementing OOP ideas.

By constructing a easy on-line banking system, I’ve present you the essential ideas of courses, objects, and inheritance in Python.

Happy coding!