Bỏ qua đến nội dung chính
Mục lục

Dự án tài khoản ngân hàng Python: class và kế thừa

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 17/17 · Chương 13

Lập trình hướng đối tượng

  • 8 phút
  • Trung cấp
  • Python 3.14
  • Cập nhật

Dự án này viết một chương trình tài khoản ngân hàng bằng Python: class TaiKhoan có nạp, rút và kiểm tra số dư, rồi class TaiKhoanTietKiem kế thừa nó để tính lãi và giới hạn mỗi lần rút. Bạn dựng nó qua năm bước, mỗi bước chạy được ngay, ghép thành chương trình hoàn chỉnh ở bước sáu, rồi tự viết hàm chuyển khoản ở cuối trang.

Cần biết trước: __init__ và self, kế thừa và ngoại lệ tự định nghĩa.

Chương trình sẽ làm gì

Chương trình có hai tài khoản: tài khoản thường của Lan với 2.000.000 đ, và tài khoản tiết kiệm của Minh với 10.000.000 đ, lãi 6% một năm. Nó nhận một list lệnh rút viết sẵn, mỗi lệnh là một cặp tài khoản và số tiền. Tài khoản thường từ chối lệnh rút nhiều hơn số dư. Tài khoản tiết kiệm còn từ chối lệnh rút hơn một nửa số dư. Lệnh bị từ chối thì in lý do, rồi chương trình chạy tiếp lệnh sau. Cuối cùng chương trình cộng lãi cho tài khoản tiết kiệm và in số dư của hai tài khoản.

Lý do từ chối đi bằng ngoại lệ: phương thức rút raise lỗi, vòng lặp bắt lỗi bằng try và except. Chương trình có rẽ nhánh và một vòng lặp, dựng theo thứ tự: tài khoản thường, lỗi số dư không đủ, lãi của tài khoản tiết kiệm, luật rút của nó, vòng lặp bắt lỗi, rồi ghép lại. Các số dư trong bài là số giả định.

Bước 1: Class tài khoản với nạp tiền và số dư

Một tài khoản có chủ và số dư. Phương thức nap() cộng tiền vào số dư, còn __str__ cho print() một dòng dễ đọc:

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def nap(self, so_tien):
        self.so_du += so_tien
    def __str__(self):
        return f"{self.chu}: {self.so_du:,} đ"

lan = TaiKhoan("Lan", 2000000)
lan.nap(500000)
print(lan)

KẾT QUẢ

Lan: 2,500,000 đ

print(lan) gọi __str__, nên in ra tên chủ và số dư có dấu phẩy ngăn hàng nghìn thay cho dòng <__main__.TaiKhoan object at ...>. Số dư mặc định là 0, nên TaiKhoan("Huy") mở một tài khoản trống. Đổi lan.nap(500000) thành lan.nap(1250000) rồi chạy lại: dòng in Lan: 3,250,000 đ.

Bước 2: Lỗi riêng khi số dư không đủ

Rút nhiều hơn số dư thì phương thức rut() không trừ tiền mà raise một lỗi riêng, SoDuKhongDu. Lỗi mang tên chủ và số tiền còn thiếu trong câu thông báo:

python
class SoDuKhongDu(Exception):
    def __init__(self, chu, thieu):
        super().__init__(f"{chu} thiếu {thieu:,} đ")
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def rut(self, so_tien):
        if so_tien > self.so_du:
            raise SoDuKhongDu(self.chu, so_tien - self.so_du)
        self.so_du -= so_tien
try:
    TaiKhoan("Lan", 2000000).rut(3000000)
except SoDuKhongDu as e:
    print("Từ chối:", e)

KẾT QUẢ

Từ chối: Lan thiếu 1,000,000 đ

Phép kiểm đứng trước phép trừ, nên lần rút bị từ chối không làm số dư thay đổi. Nơi gọi chọn cách xử lý: ở đây in lý do. Một lỗi riêng thay cho ValueError cho phép nơi gọi bắt đúng lỗi "thiếu tiền" mà không nuốt nhầm lỗi khác. Đổi rut(3000000) thành rut(2500000) rồi chạy lại: dòng in Từ chối: Lan thiếu 500,000 đ.

Bước 3: Tài khoản tiết kiệm kế thừa và tính lãi

Tài khoản tiết kiệm là một tài khoản, nên nó kế thừa TaiKhoan và chỉ viết phần riêng. Lãi suất là thuộc tính của class, chung cho mọi tài khoản tiết kiệm:

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def nap(self, so_tien):
        self.so_du += so_tien
    def __str__(self):
        return f"{self.chu}: {self.so_du:,} đ"
class TaiKhoanTietKiem(TaiKhoan):
    lai_suat = 6
    def tinh_lai(self):
        self.nap(self.so_du * self.lai_suat // 100)
minh = TaiKhoanTietKiem("Minh", 10000000)
minh.tinh_lai()
print(minh)

KẾT QUẢ

Minh: 10,600,000 đ

TaiKhoanTietKiem không có __init__ hay __str__ riêng: Python tìm thấy chúng ở class cha. tinh_lai() gọi lại nap() có sẵn thay cho tự cộng vào số dư, nên mọi việc nạp tiền đi qua một chỗ. Phép chia nguyên // 100 giữ số dư là số nguyên. Đổi lai_suat = 6 thành lai_suat = 7 rồi chạy lại: dòng in Minh: 10,700,000 đ.

Bước 4: Ghi đè phương thức rút với super()

Tài khoản tiết kiệm chỉ cho rút tối đa một nửa số dư mỗi lần. Class con ghi đè rut(): kiểm luật riêng trước, rồi giao phần còn lại cho bản của class cha bằng super().rut():

python
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def rut(self, so_tien):
        self.so_du -= so_tien
class TaiKhoanTietKiem(TaiKhoan):
    def rut(self, so_tien):
        if so_tien * 2 > self.so_du:
            raise ValueError(f"{self.chu} chỉ rút tối đa 50%")
        super().rut(so_tien)

minh = TaiKhoanTietKiem("Minh", 10000000)
minh.rut(2000000)
print(minh.so_du)

KẾT QUẢ

8000000

Phép so so_tien * 2 > self.so_du tránh phép chia, và rút đúng một nửa vẫn được. Lỗi ở đây là ValueError có sẵn, vì luật 50% là giới hạn của số tiền xin rút. Trong chương trình hoàn chỉnh, super().rut() gọi bản có phép kiểm số dư của bước 2. Đổi minh.rut(2000000) thành minh.rut(5000000) rồi chạy lại: dòng in 5000000.

Bước 5: Chạy list lệnh rút và bắt cả hai lỗi

Chương trình chạy một list lệnh rút, và một lệnh bị từ chối không được làm dừng các lệnh sau. Để khối ngắn, TaiKhoan dưới đây chỉ giữ phép kiểm số dư của bước 2, và mọi lệnh là của Lan:

python
class SoDuKhongDu(Exception): pass
class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu, self.so_du = chu, so_du
    def rut(self, so_tien):
        if so_tien > self.so_du:
            raise SoDuKhongDu(f"{self.chu} thiếu tiền")
        self.so_du -= so_tien
lan = TaiKhoan("Lan", 2000000)
cac_lenh = [(lan, 3000000), (lan, 500000), (lan, 2000000)]
for tk, so_tien in cac_lenh:
    try:
        tk.rut(so_tien)
    except (SoDuKhongDu, ValueError) as e:
        print("Từ chối:", e)

KẾT QUẢ

Từ chối: Lan thiếu tiền
Từ chối: Lan thiếu tiền

Một except với tuple (SoDuKhongDu, ValueError) bắt cả hai loại lỗi, và as e cho câu thông báo của lỗi vừa bắt. ValueError là luật 50% của bước 4: Lan có tài khoản thường nên ở đây nó chưa xảy ra, tới bước 6 nó mới bắt một lệnh của Minh. Khối try nằm trong thân vòng lặp, nên sau một lệnh bị từ chối vòng lặp vẫn sang lệnh kế. Đổi (lan, 2000000) thành (lan, 1500000) rồi chạy lại: chương trình chỉ in Từ chối: Lan thiếu tiền một lần.

Bước 6: Ghép thành chương trình hoàn chỉnh

Ghép năm bước lại: lỗi riêng, class TaiKhoan đủ ba phương thức, class tiết kiệm có lãi và luật rút, rồi vòng lặp của bước 5 chạy các lệnh trong list cac_lenh qua rut() của từng tài khoản:

python
class SoDuKhongDu(Exception):
    def __init__(self, chu, thieu):
        super().__init__(f"{chu} thiếu {thieu:,} đ")

class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def nap(self, so_tien):
        self.so_du += so_tien
    def rut(self, so_tien):
        if so_tien > self.so_du:
            raise SoDuKhongDu(self.chu, so_tien - self.so_du)
        self.so_du -= so_tien
    def __str__(self):
        return f"{self.chu}: {self.so_du:,} đ"

class TaiKhoanTietKiem(TaiKhoan):
    lai_suat = 6
    def tinh_lai(self):
        self.nap(self.so_du * self.lai_suat // 100)
    def rut(self, so_tien):
        if so_tien * 2 > self.so_du:
            raise ValueError(f"{self.chu} chỉ rút tối đa 50%")
        super().rut(so_tien)

lan = TaiKhoan("Lan", 2000000)
minh = TaiKhoanTietKiem("Minh", 10000000)
cac_lenh = [(lan, 3000000), (lan, 500000),
            (minh, 8000000), (minh, 2000000)]
for tk, so_tien in cac_lenh:
    try:
        tk.rut(so_tien)
    except (SoDuKhongDu, ValueError) as e:
        print("Từ chối:", e)
minh.tinh_lai()
print(lan)
print(minh)

KẾT QUẢ

Từ chối: Lan thiếu 1,000,000 đ
Từ chối: Minh chỉ rút tối đa 50%
Lan: 1,500,000 đ
Minh: 8,480,000 đ

Lan rút 3.000.000 đ bị từ chối vì thiếu tiền, Minh rút 8.000.000 đ bị từ chối vì quá một nửa số dư; hai lệnh còn lại thành công. Lãi 6% được tính trên 8.000.000 đ còn lại. Đổi (minh, 8000000) thành (minh, 5000000) rồi chạy lại: lệnh đó thành công và dòng cuối in Minh: 3,180,000 đ.

Bài tập

Thêm hàm chuyển khoản giữa hai tài khoản

Mở rộng chương trình hoàn chỉnh trong ô: viết thân hàm chuyen_khoan(tu, den, so_tien). Hàm rút so_tien khỏi tài khoản tu bằng phương thức rut() của chính nó, rồi nạp số tiền đó vào den. Nếu rut() báo SoDuKhongDu hoặc ValueError thì bắt lỗi, không nạp gì, và trả về False; thành công thì trả về True. Gọi rut() của tài khoản để tài khoản tiết kiệm giữ luật 50% của nó. Dòng in "Chuyển cho Minh" đã gọi sẵn hàm.

Trả về: một bool. Ôn lại: ngoại lệ tự định nghĩa.

python
# Viết thân hàm chuyen_khoan
class SoDuKhongDu(Exception):
    def __init__(self, chu, thieu):
        super().__init__(f"{chu} thiếu {thieu:,} đ")

class TaiKhoan:
    def __init__(self, chu, so_du=0):
        self.chu = chu
        self.so_du = so_du
    def nap(self, so_tien):
        self.so_du += so_tien
    def rut(self, so_tien):
        if so_tien > self.so_du:
            raise SoDuKhongDu(self.chu, so_tien - self.so_du)
        self.so_du -= so_tien
    def __str__(self):
        return f"{self.chu}: {self.so_du:,} đ"

class TaiKhoanTietKiem(TaiKhoan):
    lai_suat = 6
    def tinh_lai(self):
        self.nap(self.so_du * self.lai_suat // 100)
    def rut(self, so_tien):
        if so_tien * 2 > self.so_du:
            raise ValueError(f"{self.chu} chỉ rút tối đa 50%")
        super().rut(so_tien)

def chuyen_khoan(tu, den, so_tien):
    pass  # Viết thân hàm thay cho dòng này

lan = TaiKhoan("Lan", 2000000)
minh = TaiKhoanTietKiem("Minh", 10000000)
cac_lenh = [(lan, 3000000), (lan, 500000),
            (minh, 8000000), (minh, 2000000)]
for tk, so_tien in cac_lenh:
    try:
        tk.rut(so_tien)
    except (SoDuKhongDu, ValueError) as e:
        print("Từ chối:", e)
print("Chuyển cho Minh:", chuyen_khoan(lan, minh, 1000000))
minh.tinh_lai()
print(lan)
print(minh)

Thử mở rộng

Hai hướng đầu làm được ngay với những gì bạn đã học:

  • Ghi đè __str__ trong TaiKhoanTietKiem để dòng in của Minh có thêm chữ (tiết kiệm), bằng super().__str__().

  • Cho mỗi tài khoản một list lich_su tạo trong __init__, và ghi một dòng vào đó ở mỗi lần nạp hay rút thành công.

  • Viết class NganHang chứa các tài khoản trong một dict theo tên chủ, có phương thức cộng tổng tiền của cả ngân hàng, theo cách bài composition dạy.

  • Không cho bên ngoài gán thẳng so_du: bài property chỉ cách giữ số dư trong thuộc tính nội bộ mà vẫn đọc được như thuộc tính.

Chủ đề

dự án tài khoản ngân hàng python

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập