ಪ್ರಾಜೆಕ್ಟ್ 15: ಬ್ಯಾಂಕ್ ಖಾತೆ ವ್ಯವಸ್ಥೆ (Bank Account System)

ಈ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ, ನಾವು ಒಂದು ಸರಳ ಬ್ಯಾಂಕಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ. ಇದು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (OOP) ಮತ್ತು ವಿವಿಧ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳ ಬಳಕೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಬಳಕೆದಾರರು ಖಾತೆಗಳನ್ನು ರಚಿಸಬಹುದು, ಹಣವನ್ನು ಠೇವಣಿ ಮಾಡಬಹುದು ( deposit), ಹಿಂಪಡೆಯಬಹುದು (withdraw), ಮತ್ತು ಬ್ಯಾಲೆನ್ಸ್ ಪರಿಶೀಲಿಸಬಹುದು. ಎಲ್ಲಾ ಡೇಟಾವನ್ನು JSON ಫೈಲ್‌ನಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ.

ಕಲಿಕೆಯ ಪರಿಕಲ್ಪನೆಗಳು

• ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (OOP): Account ಕ್ಲಾಸ್ ರಚಿಸುವುದು.
• ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್: ಖಾತೆಯ ಬ್ಯಾಲೆನ್ಸ್ ಅನ್ನು ಪ್ರೈವೇಟ್ ಅಟ್ರಿಬ್ಯೂಟ್ (__balance) ಆಗಿ ಇಡುವುದು.
• ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು:
  • ಡಿಕ್ಷನರಿ: ಎಲ್ಲಾ ಬ್ಯಾಂಕ್ ಖಾತೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು (ಖಾತೆ ಸಂಖ್ಯೆ ಕೀ ಆಗಿರುತ್ತದೆ).
  • ಲಿಸ್ಟ್: ಪ್ರತಿ ಖಾತೆಯ ವಹಿವಾಟುಗಳ (transactions) ಇತಿಹಾಸವನ್ನು ಸಂಗ್ರಹಿಸಲು.
• json ಮಾಡ್ಯೂಲ್: ಡೇಟಾವನ್ನು ಫೈಲ್‌ನಲ್ಲಿ ಉಳಿಸಲು.
• datetime ಮಾಡ್ಯೂಲ್: ವಹಿವಾಟುಗಳಿಗೆ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಸೇರಿಸಲು.

ಕೋಡ್

import json
import datetime
import random

ACCOUNTS_FILE = "bank_accounts.json"


class Account:
    """ಒಂದು ಬ್ಯಾಂಕ್ ಖಾತೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕ್ಲಾಸ್."""

    def __init__(self, account_number, owner_name, balance=0.0):
        self.account_number = account_number
        self.owner_name = owner_name
        self.__balance = float(balance)  # ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್‌ಗಾಗಿ ಪ್ರೈವೇಟ್ ಅಟ್ರಿಬ್ಯೂಟ್
        self.transactions = []  # ವಹಿವಾಟುಗಳಿಗಾಗಿ ಲಿಸ್ಟ್

    def deposit(self, amount):
        """ಖಾತೆಗೆ ಹಣವನ್ನು ಠೇವಣಿ ಮಾಡುತ್ತದೆ."""
        if amount > 0:
            self.__balance += amount
            self._add_transaction("Deposit", amount)
            print(f"ರೂ. {amount:.2f} ಯಶಸ್ವಿಯಾಗಿ ಠೇವಣಿ ಮಾಡಲಾಗಿದೆ.")
            return True
        print("ಠೇವಣಿ ಮೊತ್ತವು ಧನಾತ್ಮಕವಾಗಿರಬೇಕು.")
        return False

    def withdraw(self, amount):
        """ಖಾತೆಯಿಂದ ಹಣವನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ."""
        if amount <= 0:
            print("ಹಿಂಪಡೆಯುವ ಮೊತ್ತವು ಧನಾತ್ಮಕವಾಗಿರಬೇಕು.")
            return False
        if self.__balance >= amount:
            self.__balance -= amount
            self._add_transaction("Withdrawal", amount)
            print(f"ರೂ. {amount:.2f} ಯಶಸ್ವಿಯಾಗಿ ಹಿಂಪಡೆಯಲಾಗಿದೆ.")
            return True
        else:
            print("ನಿಮ್ಮ ಖಾತೆಯಲ್ಲಿ ಸಾಕಷ್ಟು ಬ್ಯಾಲೆನ್ಸ್ ಇಲ್ಲ.")
            return False

    def get_balance(self):
        """ಪ್ರಸ್ತುತ ಬ್ಯಾಲೆನ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ."""
        return self.__balance

    def _add_transaction(self, trans_type, amount):
        """ವಹಿವಾಟಿನ ಇತಿಹಾಸವನ್ನು ದಾಖಲಿಸುತ್ತದೆ."""
        transaction = {
            "timestamp": datetime.datetime.now().isoformat(),
            "type": trans_type,
            "amount": amount
        }
        self.transactions.append(transaction)

    def display_transactions(self):
        """ಖಾತೆಯ ಎಲ್ಲಾ ವಹಿವಾಟುಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ."""
        print(f"\n--- {self.owner_name} ({self.account_number}) ಖಾತೆಯ ವಹಿವಾಟುಗಳು ---")
        if not self.transactions:
            print("ಯಾವುದೇ ವಹಿವಾಟುಗಳಿಲ್ಲ.")
        else:
            for trans in self.transactions:
                print(f"{trans['timestamp']} - {trans['type']}: ರೂ. {trans['amount']:.2f}")
        print("-------------------------------------------------")


def load_accounts():
    """ಫೈಲ್‌ನಿಂದ ಎಲ್ಲಾ ಖಾತೆಗಳನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ."""
    try:
        with open(ACCOUNTS_FILE, 'r') as file:
            accounts_data = json.load(file)
            accounts = {}
            for acc_num, data in accounts_data.items():
                acc = Account(acc_num, data['owner_name'], data['balance'])
                acc.transactions = data.get('transactions', [])
                accounts[acc_num] = acc
            return accounts
    except (FileNotFoundError, json.JSONDecodeError):
        return {}


def save_accounts(accounts):
    """ಎಲ್ಲಾ ಖಾತೆಗಳನ್ನು ಫೈಲ್‌ಗೆ ಉಳಿಸುತ್ತದೆ."""
    accounts_data = {}
    for acc_num, acc_obj in accounts.items():
        accounts_data[acc_num] = {
            'owner_name': acc_obj.owner_name,
            'balance': acc_obj.get_balance(),
            'transactions': acc_obj.transactions
        }
    with open(ACCOUNTS_FILE, 'w') as file:
        json.dump(accounts_data, file, indent=4)


def create_account(accounts):
    """ಹೊಸ ಬ್ಯಾಂಕ್ ಖಾತೆಯನ್ನು ರಚಿಸುತ್ತದೆ."""
    owner_name = input("ಖಾತೆದಾರರ ಹೆಸರನ್ನು ನಮೂದಿಸಿ: ")
    # ಯಾದೃಚ್ಛಿಕ 10-ಅಂಕಿಯ ಖಾತೆ ಸಂಖ್ಯೆಯನ್ನು ರಚಿಸುವುದು
    account_number = str(random.randint(1000000000, 9999999999))

    new_account = Account(account_number, owner_name)
    accounts[account_number] = new_account
    save_accounts(accounts)
    print(f"ಖಾತೆ ಯಶಸ್ವಿಯಾಗಿ ರಚಿಸಲಾಗಿ���ೆ! ನಿಮ್ಮ ಖಾತೆ ಸಂಖ್ಯೆ: {account_number}")


def main():
    """ಮುಖ್ಯ ಅಪ್ಲಿಕೇಶನ್ ಲೂಪ್."""
    accounts = load_accounts()

    while True:
        print("\n--- ಬ್ಯಾಂಕಿಂಗ್ ವ್ಯವಸ್ಥೆ ಮೆನು ---")
        print("1. ಹೊಸ ಖಾತೆ ರಚಿಸಿ")
        print("2. ಠೇವಣಿ ಮಾಡಿ (Deposit)")
        print("3. ಹಣ ಹಿಂಪಡೆಯಿರಿ (Withdraw)")
        print("4. ಬ್ಯಾಲೆನ್ಸ್ ಪರಿಶೀಲಿಸಿ")
        print("5. ವಹಿವಾಟುಗಳನ್ನು ವೀಕ್ಷಿಸಿ")
        print("6. ನಿರ್ಗಮಿಸಿ")

        choice = input("ನಿಮ್ಮ ಆಯ್ಕೆಯನ್ನು ನಮೂದಿಸಿ: ")

        if choice == '1':
            create_account(accounts)
        elif choice in ['2', '3', '4', '5']:
            acc_num = input("ನಿಮ್ಮ ಖಾತೆ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ: ")
            account = accounts.get(acc_num)
            if not account:
                print("ಖಾತೆ ಸಂಖ್ಯೆ ಕಂಡುಬಂದಿಲ್ಲ.")
                continue

            if choice == '2':
                amount = float(input("ಠೇವಣಿ ಮಾಡಬೇಕಾದ ಮೊತ್ತವನ್ನು ನಮೂದಿಸಿ: "))
                account.deposit(amount)
            elif choice == '3':
                amount = float(input("ಹಿಂಪಡೆಯಬೇಕಾದ ಮೊತ್ತವನ್ನು ನಮೂದಿಸಿ: "))
                account.withdraw(amount)
            elif choice == '4':
                print(f"ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಬ್ಯಾಲೆನ್ಸ್: ರೂ. {account.get_balance():.2f}")
            elif choice == '5':
                account.display_transactions()
            save_accounts(accounts)  # ಪ್ರತಿ ಕಾರ್ಯಾಚರಣೆಯ ನಂತರ ಉಳಿಸುವುದು
        elif choice == '6':
            print("ಧನ್ಯವಾದಗಳು!")
            break
        else:
            print("ತಪ್ಪಾದ ಆಯ್ಕೆ.")


if __name__ == "__main__":
    main()

ವಿವರಣೆ

1. Account ಕ್ಲಾಸ್ (OOP):
   • ಇದು ಒಂದು ಬ್ಯಾಂಕ್ ಖಾತೆಯ ಬ್ಲೂಪ್ರಿಂಟ್. ಪ್ರತಿಯೊಂದು Account ಆಬ್ಜೆಕ್ಟ್ ತನ್ನದೇ ಆದ account_number, owner_name, __balance, ಮತ್ತು transactions ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.
   • __balance: ಇದನ್ನು ಪ್ರೈವೇಟ್ (__) ಮಾಡಲಾಗಿದೆ (ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್). ಅಂದರೆ, ಇದನ್ನು ನೇರವಾಗಿ ಕ್ಲಾಸ್‌ನ ಹೊರಗಿನಿಂದ acc.__balance ಎಂದು ಆಕ್ಸೆಸ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಬದಲಾಗಿ, deposit, withdraw, ಮತ್ತು get_balance ನಂತಹ ಮೆಥಡ್‌ಗಳ ಮೂಲಕ ಮಾತ್ರ ಇದನ್ನು ನಿರ್ವಹಿಸಬೇಕು.
2. transactions ಲಿಸ್ಟ್ (ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್):
   • ಪ್ರತಿ ಖಾತೆಯು ತನ್ನ ವಹಿವಾಟುಗಳ ಇತಿಹಾಸವನ್ನು ಸಂಗ್ರಹಿಸಲು ಒಂದು ಲಿಸ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
   • ಪ್ರತಿ ವಹಿವಾಟು ಒಂದು ಡಿಕ್ಷನರಿಯಾಗಿದ್ದು, ಅದು ಸಮಯ, ಪ್ರಕಾರ, ಮತ್ತು ಮೊತ್ತವನ್ನು ಹೊಂದಿರುತ್ತದೆ.
3. accounts ಡಿಕ್ಷನರಿ (ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್):
   • ಪ್ರೋಗ್ರ���ಂನಲ್ಲಿರುವ ಎಲ್ಲಾ ಖಾತೆಗಳನ್ನು ನಾವು ಒಂದು ದೊಡ್ಡ ಡಿಕ್ಷನರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ.
   • ಇಲ್ಲಿ, ಕೀ ಯು account_number ಮತ್ತು ವ್ಯಾಲ್ಯೂ ಯು Account ಆಬ್ಜೆಕ್ಟ್ ಆಗಿರುತ್ತದೆ. ಇದು ಖಾತೆ ಸಂಖ್ಯೆಯ ಮೂಲಕ ಯಾವುದೇ ಖಾತೆಯನ್ನು ವೇಗವಾಗಿ ಹುಡುಕಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
4. load_accounts ಮತ್ತು save_accounts (JSON Persistence):
   • save_accounts: ಈ ಫಂಕ್ಷನ್ accounts ಡಿಕ್ಷನರಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ Account ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಂಡು, ಅವುಗಳನ್ನು JSON-ಹೊಂದಾಣಿಕೆಯ ಡಿಕ್ಷನರಿಯಾಗಿ ಪರಿವರ್ತಿಸಿ, bank_accounts.json ಫೈಲ್‌ಗೆ ಉಳಿಸುತ್ತದೆ.
   • load_accounts: ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಾರಂಭವಾದಾಗ, ಈ ಫಂಕ್ಷನ್ JSON ಫೈಲ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಓದಿ, ಅದನ್ನು ಮತ್ತೆ Account ಆಬ್ಜೆಕ್ಟ್‌ಗಳಾ��ಿ ಪರಿವರ್ತಿಸಿ, ಪ್ರೋಗ್ರಾಂಗೆ ಲೋಡ್ ಮಾಡುತ್ತದೆ.
5. main() ಫ��ಕ್ಷನ್: ಇದು ಬಳಕೆದಾರರ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಮತ್ತು ಸೂಕ್ತವಾದ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್ ಮೆಥಡ್‌ಗಳನ್ನು ಕಾಲ್ ಮಾಡುತ್ತದೆ.