1. T r a n g 1 | 58
MỤC LỤC
Bài tập 1:..............................................................................................................................2
Bài tập 2:..............................................................................................................................4
Bài tập 3:..............................................................................................................................6
Bài tập 4:..............................................................................................................................8
Bài tập 5:............................................................................................................................10
Bài tập 6:............................................................................................................................12
Bài tập 7:............................................................................................................................14
Bài tập 8:............................................................................................................................15
Bài tập 9:............................................................................................................................19
Bài tập 10:..........................................................................................................................22
Bài tập 11:..........................................................................................................................26
Bài tập 12:..........................................................................................................................28
Bài tập 13:..........................................................................................................................31
Bài tập 14:..........................................................................................................................33
Bài tập 15:..........................................................................................................................34
Bài tập 16:..........................................................................................................................36
Bài tập 17:..........................................................................................................................39
Bài tập 18: Hệ thống quản lý sản phẩm.............................................................................41
Bài tập 19: Quản lý tài khoản ngân hàng ..........................................................................49
Bài tập 20: Quản lý số .......................................................................................................56

2. T r a n g 2 | 58
Bài tập 1:
Tạo class có tên SoHoc gồm có các thuộc tính và phương thức sau:
+ Thuộc tính: number1, number2
+ Phương thức:
- Phương thức tạo __init()__
- Các phương thức get, set cho tất cả các thuộc tính
- inputInfo(): dùng để nhập 2 số number1, number2
- printInfo(): dùng để hiển thị number1, number2
- addition(): dùng để cộng number1, number2
- subtract(): trừ number1, number2
- multi(): dùng để nhân number1, number2
- division(): dùng để chia number1, number2.
GIẢI:
class SoHoc:
def __init__(self):
self.number1 = 0
self.number2 = 0
def getNumber1(self):
return self.number1
def setNumber1(self, number):
self.number1 = number
def getNumber2(self):
return self.number2
def setNumber2(self, number):
self.number2 = number
def inputInfo(self):
self.number1 = float(input("Nhập số thứ nhất: "))
self.number2 = float(input("Nhập số thứ hai: "))
def printInfo(self):
print(f"Số thứ nhất: {self.number1}")
print(f"Số thứ hai: {self.number2}")

3. T r a n g 3 | 58
def addition(self):
return self.number1 + self.number2
def subtract(self):
return self.number1 - self.number2
def multi(self):
return self.number1 * self.number2
def division(self):
if self.number2 != 0:
return self.number1 / self.number2
else:
return "Không thể chia cho 0"
# Sử dụng lớp SoHoc
if __name__ == "__main__":
phep_tinh = SoHoc()
phep_tinh.inputInfo()
phep_tinh.printInfo()
print(f"Tổng: {phep_tinh.addition()}")
print(f"Hiệu: {phep_tinh.subtract()}")
print(f"Tích: {phep_tinh.multi()}")
print(f"Thương: {phep_tinh.division()}")
OUTPUT
Nhập số thứ nhất: 10
Nhập số thứ hai: 60
Số thứ nhất: 10.0
Số thứ hai: 60.0
Tổng: 70.0
Hiệu: -50.0
Tích: 600.0
Thương: 0.16666666666666666

4. T r a n g 4 | 58
Bài tập 2:
Viết class NhanVien gồm các thuộc tính:
+ Tên
+ Tuổi
+ Địa chỉ
+ Tiền lương
+ Tổng số giờ làm
Và các phương thức:
- Phương thức tạo
- inputInfo() : Nhập các thông tin cho nhân viên từ bàn phím
- printInfo() : In ra tất cả các thông tin của nhân viên
- tinhThuong(): Tính toán và trả về số tiền thưởng của nhân viên theo công thức sau:
Nếu tổng số giờ làm của nhân viên >=200 thì thưởng = lương * 20%
Nếu tổng số giờ làm của nhân viên <200 và >=100 thì thưởng = lương * 10%
Nếu tổng số giờ làm của nhân viên <100 thì thưởng = 0
GIẢI:
class NhanVien:
def __init__(self):
self.name = ""
self.age = 0
self.address = ""
self.salary = 0
self.total_hours_worked = 0
def inputInfo(self):
self.name = input("Nhập tên nhân viên: ")
self.age = int(input("Nhập tuổi: "))
self.address = input("Nhập địa chỉ: ")
self.salary = float(input("Nhập tiền lương: "))
self.total_hours_worked = int(input("Nhập tổng số giờ làm: "))
def printInfo(self):
print("Thông tin nhân viên:")
print(f"Tên: {self.name}")
print(f"Tuổi: {self.age}")
print(f"Địa chỉ: {self.address}")

5. T r a n g 5 | 58
print(f"Tiền lương: {self.salary}")
print(f"Tổng số giờ làm: {self.total_hours_worked}")
def tinhThuong(self):
if self.total_hours_worked >= 200:
return self.salary * 0.2
elif self.total_hours_worked >= 100:
return self.salary * 0.1
else:
return 0
# Sử dụng lớp NhanVien
if __name__ == "__main__":
nhanvien1 = NhanVien()
nhanvien1.inputInfo()
nhanvien1.printInfo()
thuong = nhanvien1.tinhThuong()
print(f"Số tiền thưởng: {thuong}")
OUTPUT:
Nhập tên nhân viên: Trung Lớn
Nhập tuổi: 99
Nhập địa chỉ: Bình Dương 1
Nhập tiền lương: 1000000000
Nhập tổng số giờ làm: 20
Thông tin nhân viên:
Tên: Trung Lớn
Tuổi: 99
Địa chỉ: Bình Dương 1
Tiền lương: 1000000000.0
Tổng số giờ làm: 20
Số tiền thưởng: 0

6. T r a n g 6 | 58
Bài tập 3:
Tạo lớp Student, lưu trữ các thông tin một sinh viên:
- Mã sinh viên: chứa 8 kí tự
- Điểm trung bình: từ 0.0 – 10.0
- Tuổi: Phải lớn hơn hoặc bằng 18
- Lớp: Phải bắt đầu bởi kí tự ‘A’ hoặc kí tự ‘C’
a. Phương thức tạo
b. Phương thức inputInfo(), nhập thông tin Student từ bàn phím
c. Phương thức showInfo(), hiển thị tất cả thông tin Student
d. Viết phương thức xét xem Student có được học bổng không? Điểm trung bình trên 8.0
là được học bổng
GIẢI:
class Student:
def __init__(self):
self.ma_sinh_vien = ""
self.diem_trung_binh = 0.0
self.tuoi = 0
self.lop = ""
def inputInfo(self):
self.ma_sinh_vien = input("Nhập mã sinh viên (8 kí tự): ")
self.diem_trung_binh = float(input("Nhập điểm trung bình (0.0 - 10.0): "))
self.tuoi = int(input("Nhập tuổi (lớn hơn hoặc bằng 18): "))
self.lop = input("Nhập lớp (bắt đầu bởi 'A' hoặc 'C'): ")
def showInfo(self):
print(f"Mã sinh viên: {self.ma_sinh_vien}")
print(f"Điểm trung bình: {self.diem_trung_binh}")
print(f"Tuổi: {self.tuoi}")
print(f"Lớp: {self.lop}")
def hocBong(self):
if self.diem_trung_binh >= 8.0:
return True
else:
return False

7. T r a n g 7 | 58
# Sử dụng lớp Student
if __name__ == "__main__":
student = Student()
student.inputInfo()
student.showInfo()
if student.hocBong():
print("Sinh viên này được học bổng.")
else:
print("Sinh viên này không được học bổng.")
OUTPUT:
Nhập mã sinh viên (8 kí tự): AN
Nhập điểm trung bình (0.0 - 10.0): 9
Nhập tuổi (lớn hơn hoặc bằng 18): 30
Nhập lớp (bắt đầu bởi 'A' hoặc 'C'): A
Mã sinh viên: AN
Điểm trung bình: 9.0
Tuổi: 30
Lớp: A
Sinh viên này được học bổng.

8. T r a n g 8 | 58
Bài tập 4:
Một học viện thực hiện trao học bổng cho các học viên xuất sắc và đáp ứng đủ các yêu cầu
sau:
a. Là học viên đăng ký khóa học HDSE
b. Có điểm tổng kết >= 75%
c. Không vi phạm nội quy của trung tâm
d. Các kì thi chỉ thi lần đầu tiên
Các dữ liệu a b c d của 1 học viên được nhập từ bàn phím.
Viết chương trình xem học viên đó có được học bổng không.
GIẢI:
class HocVien:
def __init__(self):
self.khoa_hoc = ""
self.diem_tong_ket = 0
self.vi_pham_noi_quy = False
self.thi_lan_dau = True
def nhapThongTin(self):
self.khoa_hoc = input("Nhập khóa học (HDSE hoặc khóa khác): ")
self.diem_tong_ket = float(input("Nhập điểm tổng kết (%): "))
self.vi_pham_noi_quy = input("Có vi phạm nội quy (yes/no): ").lower() == "yes"
self.thi_lan_dau = input("Các kì thi chỉ thi lần đầu (yes/no): ").lower() == "yes"
def coHocBong(self):
if (
self.khoa_hoc == "HDSE"
and self.diem_tong_ket >= 75
and not self.vi_pham_noi_quy
and self.thi_lan_dau
):
return True
else:
return False
# Sử dụng lớp HocVien
if __name__ == "__main__":

9. T r a n g 9 | 58
hoc_vien = HocVien()
hoc_vien.nhapThongTin()
if hoc_vien.coHocBong():
print("Học viên này được học bổng.")
else:
print("Học viên này không được học bổng.")
OUTPUT:
Nhập khóa học (HDSE hoặc khóa khác): HDSE
Nhập điểm tổng kết (%): 90
Có vi phạm nội quy (yes/no): no
Các kì thi chỉ thi lần đầu (yes/no): yes
Học viên này được học bổng.

10. T r a n g 10 | 58
Bài tập 5:
Tạo class SoNguyenTo gồm:
Thuộc tính a lưu trữ 1 số nguyên tố.
Constructor 1 tham số: __init__(x). Nếu x là số nguyên tố thì lưu x vào biến a. Nếu không
thì in ra màn hình: x không phải là số nguyên tố, không lưu trữ.
Phương thức isSoNguyenTo(x) kiểm tra số x có phải số nguyên tố không.
Phương thức timSoNguyenToTiepTheo() tìm và trả về số nguyên tố liền sau số nguyên tố
a.
Các phương thức get/set biến a. Nếu tham số truyền vào phương thức set là 1 số nguyên tố
thì mới lưu vào thuộc tính a. Nếu không thì hiển thị thông báo: Không set.
Khai báo 1 đối tượng thuộc class SoNguyenTo và test các phương thức đã viết.
GIẢI:
class SoNguyenTo:
def __init__(self, x):
if self.isSoNguyenTo(x):
self.a = x
else:
print(f"{x} không phải là số nguyên tố, không lưu trữ.")
def isSoNguyenTo(self, x):
if x < 2:
return False
for i in range(2, int(x**0.5) + 1):
if x % i == 0:
return False
return True
def timSoNguyenToTiepTheo(self):
if hasattr(self, 'a'):
current = self.a + 1
while True:
if self.isSoNguyenTo(current):
return current
current += 1
else:
print("Không có số nguyên tố để tìm tiếp theo.")

11. T r a n g 11 | 58
def get_a(self):
return self.a if hasattr(self, 'a') else None
def set_a(self, x):
if self.isSoNguyenTo(x):
self.a = x
else:
print("Không set.")
# Khởi tạo đối tượng SoNguyenTo và kiểm tra các phương thức
so_nguyen_to = SoNguyenTo(7) # Khởi tạo với số nguyên tố 7
print("Giá trị a:", so_nguyen_to.get_a()) # Output: 7
print("Số nguyên tố tiếp theo:", so_nguyen_to.timSoNguyenToTiepTheo()) # Output: 11
so_nguyen_to.set_a(4) # Set giá trị không phải số nguyên tố
print("Giá trị a:", so_nguyen_to.get_a()) # Output: None
so_nguyen_to.set_a(13) # Set giá trị là số nguyên tố
print("Giá trị a:", so_nguyen_to.get_a()) # Output: 13
print("Số nguyên tố tiếp theo:", so_nguyen_to.timSoNguyenToTiepTheo()) # Output: 17
OUTPUT:
Giá trị a: 7
Số nguyên tố tiếp theo: 11
Không set.
Giá trị a: 7
Giá trị a: 13
Số nguyên tố tiếp theo: 17

12. T r a n g 12 | 58
Bài tập 6:
Xây dựng lớp tam giác (Triangle) có các thành phần:
* Các thuộc tính: 3 cạnh a, b, c của tam giác.
* Các phương thức:
- Nhập độ dài 3 cạnh
- Xác định kiểu tam giác
- Tính chu vi tam giác
- Tính diện tích tam giác
GIẢI:
import math
class Triangle:
def __init__(self):
self.a = 0
self.b = 0
self.c = 0
def nhapCanh(self, a, b, c):
self.a = a
self.b = b
self.c = c
def xacDinhKieuTamGiac(self):
if self.a + self.b > self.c and self.a + self.c > self.b and self.b + self.c > self.a:
if self.a == self.b == self.c:
return "Tam giác đều"
elif self.a == self.b or self.a == self.c or self.b == self.c:
return "Tam giác cân"
else:
return "Tam giác thường"
else:
return "Không phải tam giác"
def tinhChuVi(self):
return self.a + self.b + self.c
def tinhDienTich(self):

13. T r a n g 13 | 58
if self.xacDinhKieuTamGiac() == "Không phải tam giác":
return "Không tính được diện tích"
s = self.tinhChuVi() / 2
dien_tich = math.sqrt(s * (s - self.a) * (s - self.b) * (s - self.c))
return dien_tich
# Sử dụng lớp Triangle
triangle = Triangle()
a = float(input("Nhập độ dài cạnh a: "))
b = float(input("Nhập độ dài cạnh b: "))
c = float(input("Nhập độ dài cạnh c: "))
triangle.nhapCanh(a, b, c)
print("Kiểu tam giác:", triangle.xacDinhKieuTamGiac())
print("Chu vi tam giác:", triangle.tinhChuVi())
print("Diện tích tam giác:", triangle.tinhDienTich())
OUTPUT:
Nhập độ dài cạnh a: 30
Nhập độ dài cạnh b: 50
Nhập độ dài cạnh c: 120
Kiểu tam giác: Không phải tam giác
Chu vi tam giác: 200.0
Diện tích tam giác: Không tính được diện tích

14. T r a n g 14 | 58
Bài tập 7:
Xây dựng lớp hình chữ nhật (Rectangle) có các thành phần sau:
* Các thuộc tính: chiều dài, chiều rộng.
* Các phương thức:
- Nhập chiều dài, chiều rộng
- Tính diện tích
- Tính chu vi
GIẢI:
class Rectangle:
def __init__(self):
self.chieu_dai = 0
self.chieu_rong = 0
def nhapChieuDaiChieuRong(self, chieu_dai, chieu_rong):
self.chieu_dai = chieu_dai
self.chieu_rong = chieu_rong
def tinhDienTich(self):
return self.chieu_dai * self.chieu_rong
def tinhChuVi(self):
return 2 * (self.chieu_dai + self.chieu_rong)
# Sử dụng lớp Rectangle
rectangle = Rectangle()
chieu_dai = float(input("Nhập chiều dài: "))
chieu_rong = float(input("Nhập chiều rộng: "))
rectangle.nhapChieuDaiChieuRong(chieu_dai, chieu_rong)
print("Diện tích hình chữ nhật:", rectangle.tinhDienTich())
print("Chu vi hình chữ nhật:", rectangle.tinhChuVi())
OUTPUT:
Nhập chiều dài: 20
Nhập chiều rộng: 15
Diện tích hình chữ nhật: 300.0
Chu vi hình chữ nhật: 70.0

15. T r a n g 15 | 58
Bài tập 8:
Xây dựng lớp Phân số (Fraction) có các thành phần sau:
* Các thuộc tính: Tử số, mẫu số.
* Phương thức tạo để khởi tạo giá trị cho tử số và mẫu số.
* Các phương thức setter và getter.
* Các phương thức:
- Nhập phân số
- In Phân số
- Rút gọn phân số
- Nghịch đảo phân số
- add(), sub(), mul(), div() tương ứng để thực hiện cộng, trừ, nhân, chia hai phân số cho
nhau.
GIẢI:
from math import gcd
class Fraction:
def __init__(self, numerator=0, denominator=1):
# Tử số và mẫu số được khởi tạo mặc định là 0/1
self.numerator = numerator
self.denominator = denominator
def setFraction(self, numerator, denominator):
# Phương thức setter để thiết lập giá trị của phân số
if denominator != 0:
self.numerator = numerator
self.denominator = denominator
else:
print("Mẫu số không thể bằng 0.")
def getNumerator(self):
# Phương thức getter để lấy giá trị của tử số
return self.numerator
def getDenominator(self):
# Phương thức getter để lấy giá trị của mẫu số
return self.denominator

16. T r a n g 16 | 58
def nhapPhanSo(self):
# Phương thức để nhập phân số từ người dùng
numerator = int(input("Nhập tử số: "))
denominator = int(input("Nhập mẫu số (khác 0): "))
self.setFraction(numerator, denominator)
def inPhanSo(self):
# Phương thức để in phân số
print(f"{self.numerator}/{self.denominator}")
def rutGon(self):
# Phương thức để rút gọn phân số bằng cách chia tử và mẫu số cho ước chung lớn
nhất
greatest_common_divisor = gcd(self.numerator, self.denominator)
self.numerator //= greatest_common_divisor
self.denominator //= greatest_common_divisor
def nghichDao(self):
# Phương thức để tạo phân số nghịch đảo (hoán đổi tử và mẫu số)
if self.numerator != 0:
self.numerator, self.denominator = self.denominator, self.numerator
else:
print("Không thể nghịch đảo phân số với tử số bằng 0.")
def add(self, other):
# Phương thức để cộng hai phân số
result_numerator = self.numerator * other.denominator + other.numerator *
self.denominator
result_denominator = self.denominator * other.denominator
result = Fraction(result_numerator, result_denominator)
result.rutGon()
return result
def sub(self, other):
# Phương thức để trừ hai phân số
result_numerator = self.numerator * other.denominator - other.numerator *
self.denominator
result_denominator = self.denominator * other.denominator
result = Fraction(result_numerator, result_denominator)
result.rutGon()
return result
def mul(self, other):

17. T r a n g 17 | 58
# Phương thức để nhân hai phân số
result_numerator = self.numerator * other.numerator
result_denominator = self.denominator * other.denominator
result = Fraction(result_numerator, result_denominator)
result.rutGon()
return result
def div(self, other):
# Phương thức để chia hai phân số
if other.numerator != 0:
result_numerator = self.numerator * other.denominator
result_denominator = self.denominator * other.numerator
result = Fraction(result_numerator, result_denominator)
result.rutGon()
return result
else:
print("Không thể chia cho phân số với tử số bằng 0.")
# Sử dụng lớp Fraction
frac1 = Fraction()
frac1.nhapPhanSo()
frac2 = Fraction()
frac2.nhapPhanSo()
print("Phân số 1:")
frac1.inPhanSo()
print("Phân số 2:")
frac2.inPhanSo()
# Thực hiện các phép toán
sum_result = frac1.add(frac2)
print("Tổng hai phân số:")
sum_result.inPhanSo()
difference_result = frac1.sub(frac2)
print("Hiệu hai phân số:")
difference_result.inPhanSo()
product_result = frac1.mul(frac2)
print("Tích hai phân số:")

18. T r a n g 18 | 58
product_result.inPhanSo()
division_result = frac1.div(frac2)
print("Thương hai phân số:")
division_result.inPhanSo()
OUTPUT:
Nhập tử số: 60
Nhập mẫu số (khác 0): 100
Nhập tử số: 35
Nhập mẫu số (khác 0): 78
Phân số 1:
60/100
Phân số 2:
35/78
Tổng hai phân số:
409/390
Hiệu hai phân số:
59/390
Tích hai phân số:
7/26
Thương hai phân số:
234/175

19. T r a n g 19 | 58
Bài tập 9:
Xây dựng lớp số phức có các thành phần sau:
+ Các thuộc tính:
- Phần thực
- Phần ảo
+ Các hàm thành phần:
- Cộng hai số phức
- Trừ hai số phức
- Nhân hai số phức
- Chia hai số phức
Nhập vào 2 số phức và thực hiện các phép toán trên hai số phức đó.
GIẢI:
class SoPhuc:
def __init__(self, phan_thuc, phan_ao):
self.phan_thuc = phan_thuc
self.phan_ao = phan_ao
def cong(self, other):
phan_thuc_moi = self.phan_thuc + other.phan_thuc
phan_ao_moi = self.phan_ao + other.phan_ao
return SoPhuc(phan_thuc_moi, phan_ao_moi)
def tru(self, other):
phan_thuc_moi = self.phan_thuc - other.phan_thuc
phan_ao_moi = self.phan_ao - other.phan_ao
return SoPhuc(phan_thuc_moi, phan_ao_moi)
def nhan(self, other):
phan_thuc_moi = self.phan_thuc * other.phan_thuc - self.phan_ao * other.phan_ao
phan_ao_moi = self.phan_thuc * other.phan_ao + self.phan_ao * other.phan_thuc
return SoPhuc(phan_thuc_moi, phan_ao_moi)
def chia(self, other):
mau_moi = other.phan_thuc**2 + other.phan_ao**2
phan_thuc_moi = (self.phan_thuc * other.phan_thuc + self.phan_ao * other.phan_ao)
/ mau_moi

20. T r a n g 20 | 58
phan_ao_moi = (self.phan_ao * other.phan_thuc - self.phan_thuc * other.phan_ao) /
mau_moi
return SoPhuc(phan_thuc_moi, phan_ao_moi)
def inSoPhuc(self):
if self.phan_ao >= 0:
print(f"{self.phan_thuc} + {self.phan_ao}i")
else:
print(f"{self.phan_thuc} - {-self.phan_ao}i")
# Nhập hai số phức từ người dùng
phan_thuc1 = float(input("Nhập phần thực của số phức thứ nhất: "))
phan_ao1 = float(input("Nhập phần ảo của số phức thứ nhất: "))
so_phuc1 = SoPhuc(phan_thuc1, phan_ao1)
phan_thuc2 = float(input("Nhập phần thực của số phức thứ hai: "))
phan_ao2 = float(input("Nhập phần ảo của số phức thứ hai: "))
so_phuc2 = SoPhuc(phan_thuc2, phan_ao2)
# Thực hiện các phép toán
tong = so_phuc1.cong(so_phuc2)
hieu = so_phuc1.tru(so_phuc2)
tich = so_phuc1.nhan(so_phuc2)
thuong = so_phuc1.chia(so_phuc2)
# In kết quả
print("Tổng hai số phức:")
tong.inSoPhuc()
print("Hiệu hai số phức:")
hieu.inSoPhuc()
print("Tích hai số phức:")
tich.inSoPhuc()
print("Thương hai số phức:")
thuong.inSoPhuc()
OUTPUT:
Nhập phần thực của số phức thứ nhất: 4
Nhập phần ảo của số phức thứ nhất: 1

21. T r a n g 21 | 58
Nhập phần thực của số phức thứ hai: 9
Nhập phần ảo của số phức thứ hai: 8
Tổng hai số phức:
13.0 + 9.0i
Hiệu hai số phức:
-5.0 - 7.0i
Tích hai số phức:
28.0 + 41.0i
Thương hai số phức:
0.30344827586206896 - 0.15862068965517243i

22. T r a n g 22 | 58
Bài tập 10:
Xây dựng lớp Vectơ có các thành phần sau:
+ Các thuộc tính:
- Hoành độ đầu
- Tung độ đầu
- Hoành đô cuối
- Tung độ cuối
+ Các phương thức:
- Kiểm tra hai vectơ có bằng nhau không?
- Tính góc giữa 2 vectơ
- Tính module của 2 vectơ
- Kiểm tra hai vectơ có cùng phương không?
- Cộng hai vectơ
- Trư hai vectơ
- Nhân hai vectơ
Nhập vào 2 vectơ và thực hiện các phép toán trên hai vectơ đó.
GIẢI:
import math
class Vector:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def are_equal(self, other):
return self.x1 == other.x1 and self.y1 == other.y1 and self.x2 == other.x2 and self.y2
== other.y2
def calculate_angle(self, other):
dot_product = self.x1 * other.x1 + self.y1 * other.y1
magnitude1 = math.sqrt(self.x1 ** 2 + self.y1 ** 2)
magnitude2 = math.sqrt(other.x1 ** 2 + other.y1 ** 2)

23. T r a n g 23 | 58
if magnitude1 * magnitude2 == 0:
return 0 # Tránh chia cho 0
else:
cos_theta = dot_product / (magnitude1 * magnitude2)
theta_rad = math.acos(cos_theta)
theta_deg = math.degrees(theta_rad)
return theta_deg
def calculate_magnitude(self):
return math.sqrt((self.x2 - self.x1) ** 2 + (self.y2 - self.y1) ** 2)
def are_parallel(self, other):
return self.x1 * other.y1 - self.y1 * other.x1 == 0
def add(self, other):
x_result = self.x1 + other.x1
y_result = self.y1 + other.y1
return Vector(x_result, y_result, self.x2, self.y2)
def subtract(self, other):
x_result = self.x1 - other.x1
y_result = self.y1 - other.y1
return Vector(x_result, y_result, self.x2, self.y2)
def multiply(self, scalar):
x_result = self.x1 * scalar
y_result = self.y1 * scalar
return Vector(x_result, y_result, self.x2, self.y2)
def main():
print("Nhập vectơ thứ nhất:")
x1 = float(input("Hoành độ đầu: "))
y1 = float(input("Tung độ đầu: "))
x2 = float(input("Hoành độ cuối: "))
y2 = float(input("Tung độ cuối: "))
vector1 = Vector(x1, y1, x2, y2)
print("Nhập vectơ thứ hai:")
x1 = float(input("Hoành độ đầu: "))
y1 = float(input("Tung độ đầu: "))
x2 = float(input("Hoành độ cuối: "))
y2 = float(input("Tung độ cuối: "))
vector2 = Vector(x1, y1, x2, y2)

24. T r a n g 24 | 58
# Kiểm tra hai vectơ có bằng nhau không
if vector1.are_equal(vector2):
print("Hai vectơ bằng nhau.")
else:
print("Hai vectơ không bằng nhau.")
# Tính góc giữa hai vectơ
angle = vector1.calculate_angle(vector2)
print(f"Góc giữa hai vectơ là {angle} độ.")
# Tính module của hai vectơ
magnitude1 = vector1.calculate_magnitude()
magnitude2 = vector2.calculate_magnitude()
print(f"Module của vectơ thứ nhất là {magnitude1}")
print(f"Module của vectơ thứ hai là {magnitude2}")
# Kiểm tra hai vectơ có cùng phương không
if vector1.are_parallel(vector2):
print("Hai vectơ cùng phương.")
else:
print("Hai vectơ không cùng phương.")
# Cộng hai vectơ
result_add = vector1.add(vector2)
print(f"Tổng hai vectơ là Hoành độ: {result_add.x1}, Tung độ: {result_add.y1} đến
Hoành độ: {result_add.x2}, Tung độ: {result_add.y2}")
# Trừ hai vectơ
result_subtract = vector1.subtract(vector2)
print(f"Hiệu hai vectơ là Hoành độ: {result_subtract.x1}, Tung độ: {result_subtract.y1}
đến Hoành độ: {result_subtract.x2}, Tung độ: {result_subtract.y2}")
# Nhân vectơ với một số
scalar = float(input("Nhập một số để nhân với vectơ: "))
result_multiply = vector1.multiply(scalar)
print(f"Nhân vectơ với {scalar} là Hoành độ: {result_multiply.x1}, Tung độ:
{result_multiply.y1} đến Hoành độ: {result_multiply.x2}, Tung độ:
{result_multiply.y2}")
if __name__ == "__main__":
main()

25. T r a n g 25 | 58
OUTPUT:
“ Nhập vectơ thứ nhất:
Hoành độ đầu: 1
Tung độ đầu: 2
Hoành độ cuối: 3
Tung độ cuối: 4
Nhập vectơ thứ hai:
Hoành độ đầu: 5
Tung độ đầu: 6
Hoành độ cuối: 7
Tung độ cuối: 8”

26. T r a n g 26 | 58
Bài tập 11:
Xây dựng lớp đa thức (polylomial) và các phép toán trên đa thức. Thực hiện nhập vào 2 đa
thức và tính tổng, tích của nó.
class Polynomial:
def __init__(self, coefficients):
self.coefficients = coefficients
def __str__(self):
terms = []
for i, coef in enumerate(self.coefficients):
if coef != 0:
if i == 0:
terms.append(str(coef))
else:
if coef > 0:
terms.append(f"+ {coef}x^{i}")
else:
terms.append(f"- {abs(coef)}x^{i}")
return " ".join(terms)
def __add__(self, other):
max_len = max(len(self.coefficients), len(other.coefficients))
result_coeffs = [0] * max_len
for i in range(len(self.coefficients)):
result_coeffs[i] += self.coefficients[i]
for i in range(len(other.coefficients)):
result_coeffs[i] += other.coefficients[i]
return Polynomial(result_coeffs)
def __mul__(self, other):
result_len = len(self.coefficients) + len(other.coefficients) - 1
result_coeffs = [0] * result_len
for i in range(len(self.coefficients)):
for j in range(len(other.coefficients)):
result_coeffs[i + j] += self.coefficients[i] * other.coefficients[j]
return Polynomial(result_coeffs)

27. T r a n g 27 | 58
def main():
print("Nhập đa thức A:")
coefficients_a = [float(x) for x in input("Nhập các hệ số của đa thức A (các hệ số
cách nhau bằng dấu cách): ").split()]
polynomial_a = Polynomial(coefficients_a)
print("Nhập đa thức B:")
coefficients_b = [float(x) for x in input("Nhập các hệ số của đa thức B (các hệ số
cách nhau bằng dấu cách): ").split()]
polynomial_b = Polynomial(coefficients_b)
print(f"Đa thức A: {polynomial_a}")
print(f"Đa thức B: {polynomial_b}")
# Tính tổng đa thức A và B
sum_result = polynomial_a + polynomial_b
print(f"Tổng của đa thức A và B: {sum_result}")
# Tính tích đa thức A và B
product_result = polynomial_a * polynomial_b
print(f"Tích của đa thức A và B: {product_result}")
if __name__ == "__main__":
main()
OUTPUT:
“Nhập đa thức A:
Nhập các hệ số của đa thức A (các hệ số cách nhau bằng dấu cách): 1 -2 3 0 4
Nhập đa thức B:
Nhập các hệ số của đa thức B (các hệ số cách nhau bằng dấu cách): -1 2 0 5 6
Đa thức A: 1.0 - 2.0x + 3.0x^2 + 0.0x^3 + 4.0x^4
Đa thức B: -1.0 + 2.0x + 0.0x^2 + 5.0x^3 + 6.0x^4
Tổng của đa thức A và B: 0.0 + 0.0x + 3.0x^2 + 5.0x^3 + 10.0x^4
Tích của đa thức A và B: -1.0 + 0.0x + 7.0x^2 + 4.0x^3 + 29.0x^4 + 16.0x^5 + 30.0x^6 +
24.0x^7 + 24.0x^8 + 24.0x^9”

28. T r a n g 28 | 58
Bài tập 12:
Xây dựng lớp ma trận và các phép toán trên ma trận. Thực hiện nhập vào 2 ma trận và tính
tổng, tích của nó.
class Matrix:
def __init__(self, rows, cols):
self.rows = rows
self.cols = cols
self.data = []
def input_data(self):
print(f"Nhập ma trận {self.rows}x{self.cols}:")
for i in range(self.rows):
row = []
for j in range(self.cols):
element = float(input(f"Nhập phần tử ({i+1}, {j+1}): "))
row.append(element)
self.data.append(row)
def display(self):
for i in range(self.rows):
for j in range(self.cols):
print(self.data[i][j], end="t")
print()
def __add__(self, other):
if self.rows == other.rows and self.cols == other.cols:
result = Matrix(self.rows, self.cols)
for i in range(self.rows):
row = []
for j in range(self.cols):
element = self.data[i][j] + other.data[i][j]
row.append(element)
result.data.append(row)
return result
else:
raise ValueError("Kích thước ma trận không phù hợp.")
def __mul__(self, other):
if self.cols == other.rows:
result = Matrix(self.rows, other.cols)
for i in range(self.rows):

29. T r a n g 29 | 58
row = []
for j in range(other.cols):
element = 0
for k in range(self.cols):
element += self.data[i][k] * other.data[k][j]
row.append(element)
result.data.append(row)
return result
else:
raise ValueError("Kích thước ma trận không phù hợp.")
def main():
# Nhập ma trận A
m = int(input("Nhập số hàng của ma trận A: "))
n = int(input("Nhập số cột của ma trận A: "))
matrix_a = Matrix(m, n)
matrix_a.input_data()
# Nhập ma trận B
p = int(input("Nhập số hàng của ma trận B: "))
q = int(input("Nhập số cột của ma trận B: "))
matrix_b = Matrix(p, q)
matrix_b.input_data()
# Hiển thị ma trận A và B
print("Ma trận A:")
matrix_a.display()
print("Ma trận B:")
matrix_b.display()
try:
# Tính tổng ma trận A và B
matrix_sum = matrix_a + matrix_b
print("Tổng của ma trận A và B:")
matrix_sum.display()
# Tính tích ma trận A và B
matrix_product = matrix_a * matrix_b
print("Tích của ma trận A và B:")
matrix_product.display()
except ValueError as e:
print(e)

30. T r a n g 30 | 58
if __name__ == "__main__":
main()
OUTPUT :
“Nhập số hàng của ma trận A: 2
Nhập số cột của ma trận A: 2
Nhập ma trận 2x2:
Nhập phần tử (1, 1): 1
Nhập phần tử (1, 2): 2
Nhập phần tử (2, 1): 3
Nhập phần tử (2, 2): 4
Nhập số hàng của ma trận B: 2
Nhập số cột của ma trận B: 2
Nhập ma trận 2x2:
Nhập phần tử (1, 1): 1
Nhập phần tử (1, 2): 2
Nhập phần tử (2, 1): 3
Nhập phần tử (2, 2): 4”

31. T r a n g 31 | 58
Bài tập 13:
Xây dựng lớp đa giác, hình bình hành thừa kế từ đa giác, hình chữ nhật thừa kế từ hình
bình hành và hình vuông thừa kế từ hình chữ nhật. Nhập vào các thuộc tính cần thiết của
mỗi hình và tính chu vi, diện tích của hình đó.
GIẢI:
import math
# Lớp cơ sở: Đa giác
class Polygon:
def __init__(self, num_sides):
self.num_sides = num_sides
self.sides = []
def input_sides(self):
for i in range(self.num_sides):
side = float(input(f"Nhập độ dài cạnh {i+1}: "))
self.sides.append(side)
def calculate_perimeter(self):
return sum(self.sides)
# Lớp thừa kế từ Đa giác: Hình bình hành
class Parallelogram(Polygon):
def __init__(self):
super().__init__(4)
def calculate_area(self):
if self.num_sides == 4:
base = self.sides[0]
height = float(input("Nhập chiều cao: "))
return base * height
# Lớp thừa kế từ Hình bình hành: Hình chữ nhật
class Rectangle(Parallelogram):
def __init__(self):
super().__init__()
# Lớp thừa kế từ Hình chữ nhật: Hình vuông
class Square(Rectangle):
def __init__(self):
super().__init()

32. T r a n g 32 | 58
# Hàm main
def main():
print("Tính chu vi và diện tích của các hình.")
choice = int(input("Chọn hình (1: Hình bình hành, 2: Hình chữ nhật, 3: Hình vuông): "))
if choice == 1:
parallelogram = Parallelogram()
parallelogram.input_sides()
print(f"Chu vi của hình bình hành: {parallelogram.calculate_perimeter()}")
print(f"Diện tích của hình bình hành: {parallelogram.calculate_area()}")
elif choice == 2:
rectangle = Rectangle()
rectangle.input_sides()
print(f"Chu vi của hình chữ nhật: {rectangle.calculate_perimeter()}")
print(f"Diện tích của hình chữ nhật: {rectangle.calculate_area()}")
elif choice == 3:
square = Square()
square.input_sides()
print(f"Chu vi của hình vuông: {square.calculate_perimeter()}")
print(f"Diện tích của hình vuông: {square.calculate_area()}")
else:
print("Lựa chọn không hợp lệ.")
if __name__ == "__main__":
main()

33. T r a n g 33 | 58
Bài tập 14:
Xây dựng lớp điểm, lớp elip thừa kế từ lớp điểm, lớp đường tròn thừa kế từ lớp elip. Nhập
vào các thuộc tính cần thiết của elip và tính diện tích.
import math
# Lớp điểm
class lopDiem:
def __init__(self, x, y):
self.x = x
self.y = y
# Lớp elip thừa kế từ lớp điểm
class lopElip(lopDiem):
def __init__(self, x, y, a, b):
super().__init__(x, y)
self.a = a # Bán kính trục lớn
self.b = b # Bán kính trục nhỏ
def tinh_Dientich(self):
return math.pi * self.a * self.b
# Lớp đường tròn thừa kế từ lớp elip
class duongTron(lopElip):
def __init__(self, x, y, r):
super().__init__(x, y, r, r) # Đường tròn có a = b = r
self.r = r # Bán kính
# Nhập các thuộc tính cần thiết của elip
x = float(input("Nhập điểm x của tâm elip: "))
y = float(input("Nhập điểm y của tâm elip: "))
a = float(input("Nhập bán kính trục lớn a: "))
b = float(input("Nhập bán kính trục nhỏ b: "))
# Tạo đối tượng elip
doiTuong_elip = lopElip(x, y, a, b)
# Tính diện tích elip và in kết quả
dienTich_elip = doiTuong_elip.tinh_Dientich()
print(f"Diện tích của elip là: {dienTich_elip}")
# Nhập bán kính của đường tròn
r = float(input("Nhập bán kính của đường tròn: "))
# Tạo đối tượng đường tròn
doiTuongduongTron = duongTron(x, y, r)
# Tính diện tích đường tròn và in kết quả
dienTich_duongTron = doiTuongduongTron.tinh_Dientich()
print(f"Diện tích của đường tròn là: {dienTich_duongTron}")

34. T r a n g 34 | 58
Bài tập 15:
Xây dựng lớp tam giác, lớp tam giác vuông, tam giác cân thừa kế từ lớp tam giác. Lớp tam
giác đều thừa kế từ lớp tam giác cân.
class Triangle:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def get_area(self):
s = (self.a + self.b + self.c) / 2
area = (s * (s - self.a) * (s - self.b) * (s - self.c)) ** 0.5
return area
def get_perimeter(self):
return self.a + self.b + self.c
class IsoscelesTriangle(Triangle):
def __init__(self, base, equal_side):
super().__init__(base, equal_side, equal_side)
class RightTriangle(Triangle):
def __init__(self, a, b, c):
super().__init__(a, b, c)
def is_right(self):
sides = sorted([self.a, self.b, self.c])
return sides[0]**2 + sides[1]**2 == sides[2]**2
class EquilateralTriangle(IsoscelesTriangle):
def __init__(self, side):
super().__init__(side, side)
def main():
a = float(input("Nhập độ dài cạnh a: "))
b = float(input("Nhập độ dài cạnh b: "))
c = float(input("Nhập độ dài cạnh c: "))
triangle = Triangle(a, b, c)
area = triangle.get_area()
perimeter = triangle.get_perimeter()

35. T r a n g 35 | 58
print(f"Diện tích tam giác: {area}")
print(f"Chu vi tam giác: {perimeter}")
isosceles_triangle = IsoscelesTriangle(a, b)
area = isosceles_triangle.get_area()
perimeter = isosceles_triangle.get_perimeter()
print(f"Diện tích tam giác cân: {area}")
print(f"Chu vi tam giác cân: {perimeter}")
right_triangle = RightTriangle(a, b, c)
area = right_triangle.get_area()
perimeter = right_triangle.get_perimeter()
is_right = right_triangle.is_right()
print(f"Diện tích tam giác vuông: {area}")
print(f"Chu vi tam giác vuông: {perimeter}")
if is_right:
print("Tam giác là tam giác vuông.")
else:
print("Tam giác không phải tam giác vuông.")
side = float(input("Nhập độ dài cạnh của tam giác đều: "))
equilateral_triangle = EquilateralTriangle(side)
area = equilateral_triangle.get_area()
perimeter = equilateral_triangle.get_perimeter()
print(f"Diện tích tam giác đều: {area}")
print(f"Chu vi tam giác đều: {perimeter}")
if __name__ == "__main__":
main()

36. T r a n g 36 | 58
Bài tập 16:
Mô phỏng sự hoạt dộng của một chiếc đèn pin. Với hai nhóm đối tượng cơ bản là Đèn
(FlashLamp) và Pin (Battery). Đối tượng pin mang trong mình thông tin về trạng thái năng
lượng, đối tượng đèn sữ sử dụng một đối tượng pin để cung cấp năng lượng cho hoạt động
chiếu sáng.
Mô tả chi tiết lớp các đối tượng pin và đèn như sau:
Đối tượng Đèn (FlashLamp):
- status: thuộc tính thể hiện trạng thái của đèn (bật hay tắt)
- battery: thuộc tính thể hiện pin của đèn
+ FlashLamp(): hàm tạo
+ setBattery(Battery): lắp pin cho đèn
+ getBatteryInfo(): lấy thông tin pin của đèn
+ turnOn(): bật đèn
+ turnOff(): tắt đèn
Đối tượng Pin (Battery):
- energy: thuộc tính thể hiện năng lượng của pin
+ Battery(): hàm tạo
+ setEnergy(): phương thức sạc pin
+ getEnergy(): phương thức lấy năng lượng pin
+ decreaseEnergy(): phương thức tiêu hao năng lượng pin
1. Xây dựng lớp Pin (Battery) với các thuộc tính và các phương thức đã cho như trong sơ
đồ trên. Trong đó:
- Thuộc tính energy: thể hiện năng lượng của Pin.
- Hàm tạo Battery(): khởi tạo mặc định giá trị năng lượng Pin (energy) là 10
- Các phương thức:
+ setEnergy(energy): Thiết đặt lại giá trị mới cho pin (thực hiện việc sạc pin)
+ getEnergy(): Trả về thông tin năng lượng pin đang có
+ decreaseEnergy(): mỗi lần Pin được sử dụng, năng lượng của Pin sẽ giảm đi 2 đơn vị.
2. Xây dựng lớp FlashLamp với các thuộc tính và phương thức như trong sơ đồ trên. Trong
đó:
- Các thuộc tính:
+ status: trạng thái của đèn, nếu status = true tức đèn được bật, ngược lại đèn tắt.

37. T r a n g 37 | 58
+ battery: đối tượng của Battery() là pin của đèn
- Hàm tạo:
FlashLamp(): khởi tạo trạng thái đèn tắt và chưa có pin.
- Các phương thức:
+ setBattery(b): nạp pin cho đèn, với b là đối tượng của lớp Battery()
+ getBatteryInfo(): lấy về năng lượng Pin của đèn
+ turnOn(): Chuyển trạng thái đèn là true. In ra thông tin đèn có sáng hay không (năng
lượng > 0 là sáng)
+ turnOff(): Chuyển trạng thái đèn là false. In ra thông tin: Đèn tắt.
3. Xây dựng lớp TestFlashLamp chứa phương thức main() với kịch bản như sau:
- Tạo một đối tượng Battery
- Tạo một đối tượng FlashLamp
- Lắp pin cho đèn
- Bật và tắt đèn pin 10 lần
- Hiển thị ra màn hình mức năng lượng còn lại trong pin.
class Battery:
def __init__(self, energy=10):
self.energy = energy
def setEnergy(self, energy):
self.energy = energy
def getEnergy(self):
return self.energy
def decreaseEnergy(self):
self.energy -= 2
class FlashLamp:
def __init__(self, status=False, battery=None):
self.status = status
self.battery = battery
def setBattery(self, b):
self.battery = b
def getBatteryInfo(self):

38. T r a n g 38 | 58
return self.battery.getEnergy()
def turnOn(self):
self.status = True
if self.getBatteryInfo() > 0:
print("Bật đèn => Đèn sáng!")
self.battery.decreaseEnergy()
else:
print("Bật đèn => Đèn không sáng!")
def turnOff(self):
self.status = False
print("Tắt đèn!")
class TestFlashLamp:
def main(self):
bat = Battery()
flash = FlashLamp()
flash.setBattery(bat)
for i in range(10):
flash.turnOn()
flash.turnOff()
print(f"Năng lượng cỏn lại trong pin: {flash.getBatteryInfo()}")
test = TestFlashLamp()
test.main()

39. T r a n g 39 | 58
Bài tập 17:
Một lớp gọi là MyPoint, thể hiện một mô hình điểm hai chiều (2D) gồm hai tọa độ x và y,
được thiết kế theo dạng sơ đồ lớp. Lớp
MyPoint bao gồm:
- Hai thuộc tính x và y.
- Hàm tạo dùng để khởi tạo một điểm có tọa độ (0,0).
- Các phương thức getter và setter cho các biến thể hiện x và y.
- Một phương thức setXY() để set giá trị cho cả x và y.
- Phương thức toString() trả về mộ mô tả chuỗi theo định dạng "(x, y)".
- Một phương thức gọi là distance(x, y) trả về khoảng cách từ điểm này tới điểm khác tại
các tọa độ (x, y) đã cho.
- Một phương thức tải chồng distance(point1) trả về khoảng cách từ điểm hiện thời tới điểm
point1, với point1 là đối tượng của lớp MyPoint.
Yêu cầu dành cho bạn: Viết mã lệnh xây dựng lớp MyPoint ở trên. Rồi viết một lớp có tên
TestMyPoint để kiểm thử chương trình của bạn.
class MyPoint:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def set_x(self, x):
self.x = x
def get_x(self):
return self.x
def set_y(self, y):
self.y = y
def get_y(self):
return self.y
def setXY(self, x, y):
self.x = x
self.y = y
def toString(self):
return f"({self.x}, {self.y})"
def distance(self, x, y):
xDiff = self.x - x
yDiff = self.y - y
return (xDiff**2 + yDiff**2)**0.5

40. T r a n g 40 | 58
def distance1(self, point1):
xDiff = self.x - point1.x
yDiff = self.y - point1.y
class TestMyPoint:
def main(self):
p1 = MyPoint(3, 0)
p2 = MyPoint(0, 1)
print(p1.distance1(p2))
print(p1.distance(5,6))
tmp = TestMyPoint()
tmp.main()

41. T r a n g 41 | 58
Bài tập 18: Hệ thống quản lý sản phẩm
1. Tạo một lớp có tên Product bao gồm các thuộc tính và phương thức sau:
· Name
· Description
· Price // 0 < Price <= 100
· list rate // lưu các đánh giá của người dùng cho sản phẩm, giá trị từ 1 - 5
· viewInfo() // hiển thị tên, giá và mô tả về sản phẩm
GIẢI:
class Product:
def __init__(self, name, description, price):
# Khởi tạo các thuộc tính của sản phẩm, bao gồm tên, mô tả và giá.
self.name = name
self.description = description
# Kiểm tra và đặt giá sản phẩm trong khoảng từ 1 đến 100.
if 0 < price <= 100:
self.price = price
else:
raise ValueError("Price must be between 1 and 100")
# Khởi tạo danh sách đánh giá của sản phẩm.
self.ratings = []
def viewInfo(self):
# Hiển thị thông tin cơ bản về sản phẩm, bao gồm tên, giá và mô tả.
print(f"Name: {self.name}")
print(f"Price: ${self.price}")
print(f"Description: {self.description}")
def addRating(self, rating):
# Thêm một đánh giá mới vào danh sách đánh giá của sản phẩm (từ 1 đến 5).
if 1 <= rating <= 5:
self.ratings.append(rating)
print(f"Added rating: {rating}")
else:
print("Invalid rating. Rating must be between 1 and 5.")
def getAverageRating(self):

42. T r a n g 42 | 58
# Tính và trả về điểm trung bình của các đánh giá của sản phẩm (hoặc None nếu chưa
có đánh giá nào).
if len(self.ratings) > 0:
average = sum(self.ratings) / len(self.ratings)
return average
else:
return None
# Sử dụng lớp Product
if __name__ == "__main__":
product1 = Product("Laptop", "A powerful laptop with high performance", 80)
product1.viewInfo()
product1.addRating(4)
product1.addRating(5)
product1.addRating(3)
average_rating = product1.getAverageRating()
if average_rating is not None:
print(f"Average Rating: {average_rating}")
else:
print("No ratings available.")
OUTPUT:
Name: Laptop
Price: $100
Description: A powerful laptop with high performance
Added rating: 4
Added rating: 5
Added rating: 3
Average Rating: 4.0
2. Tạo lớp Shop gồm các thuộc tính và phương thức sau:
· List ProductList // lưu danh sách các sản phẩm của shop
· addProduct() // yêu cầu người dùng nhập thông tin của sản phẩm rồi lưu vào ProductList
· removeProduct() // yêu cầu người dùng nhập vào tên sản phẩm sau đó tìm và xóa sản
phẩm có tên tương ứng trong ProductList

43. T r a n g 43 | 58
· iterateProductList() // hiển thị các sản phẩm trong ProductList, gọi phương thức
viewInfo() của lớp Product, tính trung bình cộng đánh giá cho từng sản phẩm và hiển thị
thông tin ra màn hình.
· searchProduct() // yêu cầu người dùng nhập vào 2 số, sau đó tìm và hiển thị thông tin của
những sản phẩm có giá nằm giữa hai số đó.
3. Tạo menu:
PRODUCT MANAGEMENT SYSTEM
1. Add new product
2. Remove product
3. Iterate product list
4. Search product
5. Exit
và thực thi các phương thức tương ứng trong lớp Shop với mỗi mục chọn.
GIẢI:
class Shop:
def __init__(self):
self.ProductList = []
def addProduct(self):
# Yêu cầu người dùng nhập thông tin sản phẩm và thêm vào danh sách sản phẩm của
cửa hàng.
name = input("Enter product name: ")
description = input("Enter product description: ")
price = float(input("Enter product price (between 1 and 100): "))
# Kiểm tra giá và đảm bảo rằng giá nằm trong khoảng từ 1 đến 100.
if 1 <= price <= 100:
product = Product(name, description, price)
self.ProductList.append(product)
print("Product added successfully.")
else:
print("Invalid price. Price must be between 1 and 100.")
def removeProduct(self):
# Yêu cầu người dùng nhập tên sản phẩm và xóa sản phẩm có tên tương ứng khỏi
danh sách.
name_to_remove = input("Enter the name of the product to remove: ")
removed = False

44. T r a n g 44 | 58
for product in self.ProductList:
if product.name == name_to_remove:
self.ProductList.remove(product)
print(f"Product '{name_to_remove}' removed successfully.")
removed = True
break
if not removed:
print(f"Product '{name_to_remove}' not found in the shop.")
def iterateProductList(self):
# Hiển thị thông tin, tính trung bình đánh giá và hiển thị danh sách sản phẩm.
for product in self.ProductList:
product.viewInfo()
average_rating = product.getAverageRating()
if average_rating is not None:
print(f"Average Rating: {average_rating}")
else:
print("No ratings available.")
print()
def searchProduct(self):
# Yêu cầu người dùng nhập 2 số và hiển thị thông tin các sản phẩm có giá nằm giữa
hai số đó.
low_price = float(input("Enter the lower price limit: "))
high_price = float(input("Enter the higher price limit: "))
print(f"Products with prices between {low_price} and {high_price}:")
for product in self.ProductList:
if low_price <= product.price <= high_price:
product.viewInfo()
average_rating = product.getAverageRating()
if average_rating is not None:
print(f"Average Rating: {average_rating}")
else:
print("No ratings available.")
print()
# Sử dụng lớp Shop và lớp Product
if __name__ == "__main__":
myShop = Shop()

45. T r a n g 45 | 58
while True:
print("nOptions:")
print("1. Add Product")
print("2. Remove Product")
print("3. List Products")
print("4. Search Products by Price")
print("5. Sort Products by Price")
print("6. Quit")
choice = input("Enter your choice: ")
if choice == "1":
myShop.addProduct()
elif choice == "2":
myShop.removeProduct()
elif choice == "3":
myShop.iterateProductList()
elif choice == "4":
myShop.searchProduct()
elif choice == "5":
break
elif choice == "6": break
else:
print("Invalid choice. Please choose a valid option.")
OUTPUT:
Options:
1. Add Product
2. Remove Product
3. List Products
4. Search Products by Price
5. Quit
Enter your choice: 1
Enter product name: Nón lá
Enter product description: Nón là việt nam
Enter product price (between 1 and 100): 30
Product added successfully.

46. T r a n g 46 | 58
Options:
1. Add Product
2. Remove Product
3. List Products
4. Search Products by Price
5. Quit
Enter your choice: 1
Enter product name: Giày Thái Bình
Enter product description: Giày sản xuất công ty Thái bình -VN
Enter product price (between 1 and 100): 20
Product added successfully.
Options:
1. Add Product
2. Remove Product
3. List Products
4. Search Products by Price
5. Quit
Enter your choice: 3
Name: Nón lá
Price: $30.0
Description: Nón là việt nam
No ratings available.
Name: Giày Thái Bình
Price: $20.0
Description: Giày sản xuất công ty Thái bình -VN
No ratings available.

47. T r a n g 47 | 58
Options:
1. Add Product
2. Remove Product
3. List Products
4. Search Products by Price
5. Quit
Enter your choice: 1
Enter product name: 4
Enter product description: 1
Enter product price (between 1 and 100): 20
Product added successfully.
Options:
1. Add Product
2. Remove Product
3. List Products
4. Search Products by Price
5. Quit
Enter your choice:
Câu hỏi thêm:
Tạo thêm một mục trong Menu ứng với phương thức gọi là sortProduct() đặt trong lớp
Shop để sắp xếp các sản phẩm trong ProductList theo giá.
class Shop:
# ... Các phần khác của lớp Shop
def sortProduct(self):
# Sắp xếp danh sách sản phẩm theo giá tăng dần.
self.ProductList.sort(key=lambda product: product.price)
# Sử dụng lớp Shop và lớp Product
if __name__ == "__main__":
myShop = Shop()
while True:

48. T r a n g 48 | 58
print("nOptions:")
print("1. Add Product")
print("2. Remove Product")
print("3. List Products")
print("4. Search Products by Price")
print("5. Sort Products by Price")
print("6. Quit")
choice = input("Enter your choice: ")
if choice == "1":
myShop.addProduct()
elif choice == "2":
myShop.removeProduct()
elif choice == "3":
myShop.iterateProductList()
elif choice == "4":
myShop.searchProduct()
elif choice == "5":
myShop.sortProduct()
print("Products sorted by price.")
elif choice == "6":
break
else:
print("Invalid choice. Please choose a valid option.")

49. T r a n g 49 | 58
Bài tập 19: Quản lý tài khoản ngân hàng
Hãy cài đặt lớp BankAcount theo mô tả như dưới đây:
- accountNumber : Số tài khoản ngân hàng
- accountName : Tên chủ tài khoản
- balance : Số tiền có trong tài khoản
+ BankAccount(accountName, accountNumber): Phương thức thiết lập để tạo tài khoản
với số tiền =0; tên tài khoản và số tài
khoản là tham số truyền vào.
+ getAccountNumber() : Lấy về thông tin số tài khoản
+ getAccountName() : Trả về tên chủ tài khoản
+ getBalance() : Trả về số tiền hiện có trong tài khoản
+ deposit(money): Nạp tiền vào tài khoản
+ withdraw(money) : Chuyển khoản/rút tiền với số tiền được truyền vào là tham số; hàm
trả về true nếu số tiền cần rút <= số tiền
trong tài khoản; cập nhật lại số tiền trong tài khoản nếu rút thành công; ngược lại hàm trả
về false.
GIẢI:
class BankAccount:
def __init__(self, accountName, accountNumber):
self.accountNumber = accountNumber
self.accountName = accountName
self.balance = 0 # Ban đầu, tài khoản có số tiền bằng 0
def getAccountNumber(self):
return self.accountNumber
def getAccountName(self):
return self.accountName
def getBalance(self):
return self.balance
def deposit(self, money):
if money > 0:
self.balance += money

50. T r a n g 50 | 58
return True
else:
return False
def withdraw(self, money):
if 0 < money <= self.balance:
self.balance -= money
return True
else:
return False
if __name__ == "__main__":
account1 = BankAccount("John Doe", "12345")
print(f"Account Number: {account1.getAccountNumber()}")
print(f"Account Name: {account1.getAccountName()}")
print(f"Balance: ${account1.getBalance()}")
account1.deposit(500)
print(f"Deposited $500. New balance: ${account1.getBalance()}")
if account1.withdraw(200):
print(f"Withdrew $200. New balance: ${account1.getBalance()}")
else:
print("Withdrawal failed. Insufficient balance.")
if account1.withdraw(1000):
print(f"Withdrew $1000. New balance: ${account1.getBalance()}")
else:
print("Withdrawal failed. Insufficient balance.")
OUTPUT:
Account Number: 12345
Account Name: John Doe
Balance: $0 Deposited $500.
New balance: $500 Withdrew $200.
New balance: $300 Withdrawal failed.
Insufficient balance.
Cho lớp Bank có quan hệ với lớp BankAccount như sau:

51. T r a n g 51 | 58
Hãy cài đặt lớp Bank như mô tả dưới đây
+ list BankAccount
Chứa danh sách các tài khoản hiện có tại ngân hàng.
Có 7 phương thức được mô tả như dưới đây:
+ search(accountNumber)
Phương thức này trả về chỉ số của tài khoản ngân hàng có số tài khoản là tham số trong
list; nếu không tồn tại tài khoản nào có số tài khoản như tham số thì hàm trả về -1.
+ getTotal()
Phương thức này trả về số lượng tài khoản hiện có tại ngân hàng.
+ getItem(accountNumber)
Phương thức này nhận tham số đầu vào là số tài khoản ngân hàng, và trả về đối tượng
BankAccount có số tài khoản là tham số truyền vào; nếu số tài khoản không hợp lệ hàm sẽ
trả về giá trị null.
+ addAccount(accountNumber, accountName)
Phương thức này nhận 2 xâu ký tự lần lượt là số tài khoản và tên chủ tài khoản. Nếu số tài
khoản đã tồn tại trong hệ thống thì hàm sẽ trả về giá trị false; ngược lại hàm sẽ thêm một
tài khoản mới có thông tin là tham số truyền vào và trả về giá trị true.
+ depositMoney(accountNumber, money)
Thực hiện nạp tiền vào tài khoản; nếu tồn tại số tài khoản trong hệ thống thì cập nhật lại số
tiền của tài khoản và trả về giá trị true, ngược lại trả về false
+ withdrawMoney(accountNumber, money)
Thực hiện rút tiền từ tài khoản; nếu tồn tại số tài khoản trong hệ thống và số tiền trong tài
khoản >= số tiền cần rút thì cập nhật lại số tiền của tài khoản và trả về giá trị true, ngược
lại trả về false.
+ removeAccount(accountNumber)

52. T r a n g 52 | 58
Loại bỏ tài khoản có số tài khoản được truyền vào khỏi danh sách; nếu không tồn tại tài
khoản nào có số tài khoản đó thì trả về false; ngược lại trả về true.
Bạn hãy xây dựng chương trình quản lý ngân hàng với các chức năng sau:
Nhập một danh sách các tài khoản hiện có của ngân hàng
Sinh ngẫu nhiên số tiền trong tài khoản cho các tài khoản hiện có trong hệ thống
Hiển thị ra màn hình thông tin các tài khoản cho ngân hàng
Nạp thêm 500 triệu đồng cho số tài khoản 1050008855
Thực hiện rút 30 triệu đồng từ tài khoản 1050008854
Hiển thị in ra màn hình thông báo số dư và tình trạng giao dịch sau khi thực hiện nạp và
rút tiền tại các tài khoản ở trên.
import random
class BankAccount:
def __init__(self, accountName, accountNumber):
self.accountNumber = accountNumber
self.accountName = accountName
self.balance = random.randint(1000000, 50000000) # Số tiền ban đầu được sinh ngẫu
nhiên
def getAccountNumber(self):
return self.accountNumber
def getAccountName(self):
return self.accountName
def getBalance(self):
return self.balance
def deposit(self, money):
if money > 0:
self.balance += money
return True
else:
return False

53. T r a n g 53 | 58
def withdraw(self, money):
if 0 < money <= self.balance:
self.balance -= money
return True
else:
return False
class Bank:
def __init__(self):
self.accounts = []
def search(self, accountNumber):
for index, account in enumerate(self.accounts):
if account.getAccountNumber() == accountNumber:
return index
return -1
def getTotal(self):
return len(self.accounts)
def getItem(self, accountNumber):
index = self.search(accountNumber)
if index != -1:
return self.accounts[index]
else:
return None
def addAccount(self, accountNumber, accountName):
if self.search(accountNumber) == -1:
new_account = BankAccount(accountName, accountNumber)
self.accounts.append(new_account)
return True
else:
return False
def depositMoney(self, accountNumber, money):
account = self.getItem(accountNumber)
if account is not None:
return account.deposit(money)
else:
return False

54. T r a n g 54 | 58
def withdrawMoney(self, accountNumber, money):
account = self.getItem(accountNumber)
if account is not None:
return account.withdraw(money)
else:
return False
def removeAccount(self, accountNumber):
index = self.search(accountNumber)
if index != -1:
self.accounts.pop(index)
return True
else:
return False
# Tạo đối tượng ngân hàng
bank = Bank()
# Nhập danh sách tài khoản và sinh ngẫu nhiên số tiền trong tài khoản
bank.addAccount("1050008854", "John Doe")
bank.addAccount("1050008855", "Jane Smith")
bank.addAccount("1050008856", "Alice Johnson")
# Hiển thị thông tin tài khoản
for account in bank.accounts:
print(f"Account Number: {account.getAccountNumber()}")
print(f"Account Name: {account.getAccountName()}")
print(f"Balance: ${account.getBalance()}")
print()
# Nạp thêm 500 triệu đồng cho số tài khoản 1050008855
if bank.depositMoney("1050008855", 500000000):
print("Deposited $500,000,000 into account 1050008855")
else:
print("Deposit failed. Account not found.")
# Thực hiện rút 30 triệu đồng từ tài khoản 1050008854
if bank.withdrawMoney("1050008854", 30000000):
print("Withdrew $30,000,000 from account 1050008854")
else:
print("Withdrawal failed. Insufficient balance or account not found.")

55. T r a n g 55 | 58
# Hiển thị thông báo số dư và tình trạng giao dịch
for account in bank.accounts:
print(f"Account Number: {account.getAccountNumber()}")
print(f"Account Name: {account.getAccountName()}")
print(f"Balance: ${account.getBalance()}")
print()
OUTPUT
Account Number: 1050008854
Account Name: John Doe
Balance: $37673952
Account Number: 1050008855
Account Name: Jane Smith
Balance: $20169308
Account Number: 1050008856
Account Name: Alice Johnson
Balance: $12289292
Deposited $500,000,000 into account 1050008855
Withdrew $30,000,000 from account 1050008854
Account Number: 1050008854
Account Name: John Doe
Balance: $7673952
Account Number: 1050008855
Account Name: Jane Smith
Balance: $520169308
Account Number: 1050008856
Account Name: Alice Johnson
Balance: $12289292

56. T r a n g 56 | 58
Bài tập 20: Quản lý số
Xây dựng một lớp có tên So gồm các thuộc tính và phương thức sau:
+ Các thuộc tính: number
+ Các phương thức:
Các phương thức tạo không tham số, đầy đủ tham số
Các phương thức getter, setter
inputNumber() để nhập liệu
showNumber() để hiển thị
kiemTraNguyen() để kiểm tra number có phải số nguyên không
kiemTraChanLe()
kiemTraAmDuong()
kiemTraChanDuong()
kiemTraLeAm()
kiemTraChinhPhuong()
kiemTraNguyenTo()
kiemTraHoanHao()
kiemTraDacBiet()
GIẢI:
import math
class So:
def __init__(self, number=0):
self.__number = number
# Phương thức getter cho thuộc tính number
def getNumber(self):
return self.__number
# Phương thức setter cho thuộc tính number
def setNumber(self, number):
self.__number = number
# Phương thức để nhập liệu
def inputNumber(self):
self.__number = float(input("Nhập số: "))

57. T r a n g 57 | 58
# Phương thức để hiển thị
def showNumber(self):
print("Số hiện tại:", self.__number)
# Phương thức kiểm tra số nguyên
def kiemTraNguyen(self):
return self.__number.is_integer()
# Phương thức kiểm tra số chẵn/lẻ
def kiemTraChanLe(self):
return self.__number % 2 == 0
# Phương thức kiểm tra số âm/dương
def kiemTraAmDuong(self):
return self.__number >= 0
# Phương thức kiểm tra số chẵn dương
def kiemTraChanDuong(self):
return self.__number % 2 == 0 and self.__number > 0
# Phương thức kiểm tra số lẻ âm
def kiemTraLeAm(self):
return self.__number % 2 != 0 and self.__number < 0
# Phương thức kiểm tra số chính phương
def kiemTraChinhPhuong(self):
if self.__number < 0:
return False
sqrt_int = int(math.sqrt(self.__number))
return sqrt_int * sqrt_int == self.__number
# Phương thức kiểm tra số nguyên tố
def kiemTraNguyenTo(self):
if self.__number <= 1:
return False
if self.__number <= 3:
return True
if self.__number % 2 == 0 or self.__number % 3 == 0:
return False
i = 5
while i * i <= self.__number:
if self.__number % i == 0 or self.__number % (i + 2) == 0:

58. T r a n g 58 | 58
return False
i += 6
return True
# Phương thức kiểm tra số hoàn hảo
def kiemTraHoanHao(self):
if self.__number <= 0:
return False
sum_divisors = 1
for i in range(2, int(math.sqrt(self.__number)) + 1):
if self.__number % i == 0:
sum_divisors += i
if i != self.__number // i:
sum_divisors += self.__number // i
return sum_divisors == self.__number
# Phương thức kiểm tra số đặc biệt (ví dụ: số Armstrong)
def kiemTraDacBiet(self):
num_str = str(int(self.__number))
n = len(num_str)
sum_digits_power_n = sum(int(digit) ** n for digit in num_str)
return sum_digits_power_n == int(self.__number)
# Sử dụng lớp So
so1 = So()
so1.inputNumber()
so1.showNumber()
print("Số nguyên:", so1.kiemTraNguyen())
print("Số chẵn/lẻ:", "Chẵn" if so1.kiemTraChanLe() else "Lẻ")
print("Số âm/dương:", "Dương" if so1.kiemTraAmDuong() else "Âm")
print("Số chẵn dương:", so1.kiemTraChanDuong())
print("Số lẻ âm:", so1.kiemTraLeAm())
print("Số chính phương:", so1.kiemTraChinhPhuong())
print("Số nguyên tố:", so1.kiemTraNguyenTo())
print("Số hoàn hảo:", so1.kiemTraHoanHao())
print("Số đặc biệt:", so1.kiemTraDacBiet())