Dự án tài khoản ngân hàng Python: class và kế thừa
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
Trong bài này · 9
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:
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:
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:
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():
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Ả
8000000Phé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:
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ềnMộ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:
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.
# 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__trongTaiKhoanTietKiemđể dòng in của Minh có thêm chữ(tiết kiệm), bằngsuper().__str__().Cho mỗi tài khoản một list
lich_sutạ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
NganHangchứ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ủ đề
Bài này có hữu ích?
Hỏi đáp
Tham vấn chuyên môn
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.