Datasets:
Tasks:
Question Answering
Modalities:
Text
Formats:
csv
Sub-tasks:
open-domain-qa
Languages:
Vietnamese
Size:
< 1K
License:
Download test.csv from hung678/hung8386: direct link, hf CLI and curl.
- Browser
- Download file 24.3 kB
-
https://huggingface.co/datasets/hung678/hung8386/resolve/main/test.csv
- Command line
-
hf download hf://datasets/hung678/hung8386/test.csv
-
curl -L -o test.csv https://huggingface.co/datasets/hung678/hung8386/resolve/main/test.csv
24.3 kB
| input,output,instruction | |
| Dấu chấm phẩy (;) có bắt buộc ở cuối câu lệnh trong Python không và khi nào nó được dùng?,"Trong Python, dấu chấm phẩy (`;`) hoàn toàn KHÔNG bắt buộc ở cuối câu lệnh. Trình thông dịch tự động nhận diện kết thúc dòng là kết thúc một câu lệnh. | |
| Tuy nhiên, dấu chấm phẩy có thể được dùng để viết nhiều câu lệnh ngắn trên cùng một dòng đơn, dù chuẩn PEP 8 khuyến cáo không nên lạm dụng để giữ mã nguồn sáng sủa. | |
| Ví dụ: | |
| ```python | |
| # Cách viết thông thường, chuẩn mực (khuyên dùng): | |
| x = 10 | |
| y = 20 | |
| z = x + y | |
| print(z) | |
| # Viết nhiều lệnh trên 1 dòng bằng dấu chấm phẩy (chỉ nên dùng khi rất ngắn gọn): | |
| a = 5; b = 15; c = a * b; print(c) | |
| ``` | |
| Kết quả: | |
| ```text | |
| 30 | |
| 75 | |
| ```","Hãy viết lại một đoạn mã nhiều dòng thành một dòng duy nhất bằng dấu chấm phẩy, sau đó đánh giá xem cách nào dễ đọc hơn cho người khác." | |
| Lỗi cú pháp SyntaxError là gì và những nguyên nhân phổ biến nào gây ra lỗi này đối với người mới học?,"`SyntaxError` (lỗi cú pháp) xảy ra khi mã nguồn vi phạm các quy tắc ngữ pháp của ngôn ngữ Python. Trình thông dịch sẽ phát hiện lỗi này trước khi chương trình được chạy thực sự. | |
| Các nguyên nhân phổ biến nhất: | |
| 1. Quên dấu hai chấm `:` ở cuối các câu lệnh điều kiện, vòng lặp hoặc định nghĩa hàm (`if`, `for`, `while`, `def`). | |
| 2. Thiếu hoặc thừa dấu ngoặc đơn `()`, ngoặc vuông `[]`, ngoặc nhọn `{}`. | |
| 3. Không đóng dấu nháy đơn hoặc nháy kép khi khai báo chuỗi ký tự. | |
| 4. Dùng nhầm toán tử gán `=` thay vì toán tử so sánh `==` trong biểu thức `if`. | |
| Ví dụ sửa lỗi: | |
| ```python | |
| # SAI: if x == 10 print(""Bang 10"") -> Thiếu dấu hai chấm ':' | |
| # ĐÚNG: | |
| x = 10 | |
| if x == 10: | |
| print(""x đúng bằng 10"") | |
| ``` | |
| Kết quả: | |
| ```text | |
| x đúng bằng 10 | |
| ```",Hãy thử gõ câu lệnh `if 5 > 3` mà không có dấu `:` và chạy thử để xem thông báo lỗi hiển thị chỉ rõ vị trí mũi tên lỗi cú pháp. | |
| "Các toán tử gán kết hợp (+=, -=, *=, /=) hoạt động như thế nào trong Python?","Toán tử gán kết hợp (Augmented Assignment Operators) cho phép bạn thực hiện một phép toán số học và gán lại kết quả vào chính biến đó một cách ngắn gọn. | |
| Bảng quy đổi tương đương: | |
| - `x += 5` tương đương `x = x + 5` | |
| - `x -= 3` tương đương `x = x - 3` | |
| - `x *= 2` tương đương `x = x * 2` | |
| - `x /= 4` tương đương `x = x / 4` (lưu ý kết quả phép chia luôn là float) | |
| - `x //= 2` tương đương `x = x // 2` (chia lấy nguyên) | |
| - `x %= 3` tương đương `x = x % 3` (chia lấy dư) | |
| Ví dụ: | |
| ```python | |
| diem = 10 | |
| diem += 5 # diem = 15 | |
| diem -= 2 # diem = 13 | |
| diem *= 2 # diem = 26 | |
| diem /= 4 # diem = 6.5 | |
| print(""Điểm cuối cùng:"", diem) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Điểm cuối cùng: 6.5 | |
| ```","Hãy khởi tạo một biến `tong_tien = 1000` và dùng các toán tử gán kết hợp để lần lượt cộng thêm 200, trừ đi 50 và nhân đôi số tiền." | |
| Tại sao việc cộng trực tiếp một số nguyên với một chuỗi ký tự lại gây ra lỗi TypeError và cách sửa?,"Python là ngôn ngữ định kiểu mạnh (strongly typed), nghĩa là nó không tự động ép kiểu giữa kiểu số và kiểu chuỗi khi thực hiện phép cộng `+`. | |
| Nếu bạn thực hiện `10 + ""20""`, Python không biết bạn muốn cộng số học (cho ra `30`) hay nối chuỗi (cho ra `""1020""`), vì vậy nó sẽ ném ra lỗi `TypeError: unsupported operand type(s) for +: 'int' and 'str'`. | |
| Cách khắc phục: | |
| 1. Nếu muốn tính toán số học: Ép chuỗi sang số bằng `int()` hoặc `float()`. | |
| 2. Nếu muốn nối chuỗi: Ép số sang chuỗi bằng `str()` hoặc sử dụng f-string. | |
| Ví dụ: | |
| ```python | |
| so_luong = 5 | |
| don_gia_chuoi = ""20000"" | |
| # Cách 1: Tính toán số học (ép chuỗi thành int) | |
| thanh_tien = so_luong * int(don_gia_chuoi) | |
| print(""Thành tiền:"", thanh_tien) | |
| # Cách 2: Nối chuỗi để hiển thị thông báo | |
| thong_bao = ""Số lượng đã mua: "" + str(so_luong) + "" sản phẩm"" | |
| print(thong_bao) | |
| # Cách 3: Dùng f-string hiện đại và sạch sẽ nhất | |
| print(f""Số lượng: {so_luong}, Tổng tiền: {thanh_tien} VNĐ"") | |
| ``` | |
| Kết quả: | |
| ```text | |
| Thành tiền: 100000 | |
| Số lượng đã mua: 5 sản phẩm | |
| Số lượng: 5, Tổng tiền: 100000 VNĐ | |
| ```","Hãy viết chương trình nhận hai biến `a = '15'` và `b = 25`, tính tổng của chúng dưới dạng số rồi in ra kết quả." | |
| Biểu thức điều kiện ba ngôi (ternary operator) trong Python được viết gọn như thế nào?,"Biểu thức điều kiện ba ngôi cho phép bạn viết câu lệnh `if-else` đơn giản thành một dòng duy nhất để gán giá trị hoặc trả về kết quả. | |
| Cú pháp: | |
| `gia_tri_dung if dieu_kien else gia_tri_sai` | |
| Ví dụ so sánh cách viết dài và ngắn: | |
| ```python | |
| diem = 7.5 | |
| # Cách viết if-else truyền thống: | |
| if diem >= 5.0: | |
| ket_qua = ""Đỗ"" | |
| else: | |
| ket_qua = ""Trượt"" | |
| # Cách viết gọn bằng toán tử ba ngôi: | |
| ket_qua_gon = ""Đỗ"" if diem >= 5.0 else ""Trượt"" | |
| so = 10 | |
| trang_thai = ""Chẵn"" if so % 2 == 0 else ""Lẻ"" | |
| print(""Kết quả thi:"", ket_qua_gon) | |
| print(f""Số {so} là số:"", trang_thai) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Kết quả thi: Đỗ | |
| Số 10 là số: Chẵn | |
| ```","Hãy dùng toán tử ba ngôi để gán giá trị cho biến `loai_ve` là `'Vé trẻ em'` nếu `tuoi < 12`, ngược lại là `'Vé người lớn'`." | |
| Cơ chế đánh giá ngắn mạch (short-circuit evaluation) của toán tử and và or trong Python hoạt động ra sao?,"Cơ chế đánh giá ngắn mạch (Short-circuit Evaluation) nghĩa là Python chỉ tính toán biểu thức phía sau khi kết quả của biểu thức phía trước chưa đủ để quyết định kết quả toàn bộ: | |
| 1. Với `A and B`: Nếu `A` là `False`, Python dừng lại ngay lập tức và trả về giá trị của `A` mà không thèm tính `B` (vì chắc chắn kết quả là False). | |
| 2. Với `A or B`: Nếu `A` là `True`, Python dừng lại ngay lập tức và trả về giá trị của `A` mà không tính `B` (vì chắc chắn kết quả là True). | |
| Đặc biệt, `and` và `or` trong Python không chỉ trả về bool mà trả về chính giá trị của toán hạng quyết định kết quả. | |
| Ví dụ: | |
| ```python | |
| # Tránh lỗi chia cho 0 nhờ ngắn mạch | |
| mau_so = 0 | |
| # Do mau_so != 0 là False nên Python không chạy vế sau (10 / mau_so > 1), tránh lỗi ZeroDivisionError! | |
| if mau_so != 0 and (10 / mau_so > 1): | |
| print(""Chia hợp lệ"") | |
| else: | |
| print(""Mẫu số bằng 0, đã chặn lỗi an toàn!"") | |
| # Giá trị trả về của toán tử or | |
| ten_nguoi_dung = """" | |
| ten_hien_thi = ten_nguoi_dung or ""Khách ẩn danh"" | |
| print(""Chào mừng:"", ten_hien_thi) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Mẫu số bằng 0, đã chặn lỗi an toàn! | |
| Chào mừng: Khách ẩn danh | |
| ```",Hãy thử đổi `ten_nguoi_dung = 'Nam'` và quan sát xem `ten_hien_thi` bằng bao nhiêu khi áp dụng `ten_nguoi_dung or 'Khách ẩn danh'`. | |
| Tại sao câu lệnh if x = 5: lại báo lỗi cú pháp trong Python?,"Trong Python, dấu một dấu bằng `=` là toán tử GÁN giá trị, chứ không phải toán tử SO SÁNH. | |
| Toán tử so sánh bằng trong Python bắt buộc phải là hai dấu bằng liên tiếp `==`. | |
| Để tránh lỗi ngớ ngẩn thường gặp trong ngôn ngữ C (nơi phép gán trả về giá trị và vô tình luôn đúng), cú pháp Python cấm tuyệt đối việc dùng phép gán `=` đơn lẻ bên trong điều kiện `if`, và sẽ ném lỗi `SyntaxError: invalid syntax`. | |
| Cách sửa: | |
| ```python | |
| x = 5 | |
| # SAI: if x = 5: | |
| # ĐÚNG: | |
| if x == 5: | |
| print(""x có giá trị bằng 5"") | |
| ``` | |
| Kết quả: | |
| ```text | |
| x có giá trị bằng 5 | |
| ```",Hãy kiểm tra xem một biến `mat_khau` có bằng đúng chuỗi `'python123'` hay không bằng toán tử `==`. | |
| Làm thế nào để kết hợp nhiều điều kiện phức tạp bằng dấu ngoặc đơn trong lệnh if?,"Khi điều kiện trong câu lệnh `if` kết hợp cả toán tử `and` và `or`, bạn nên sử dụng dấu ngoặc đơn `()` để nhóm rõ ràng các mệnh đề. Điều này giúp tránh hiểu lầm về thứ tự ưu tiên (vì `and` được tính trước `or`) và làm cho mã nguồn trở nên sáng tỏ. | |
| Ví dụ xét tuyển học bổng: | |
| Điều kiện: (Điểm rèn luyện >= 80 VÀ Điểm học tập >= 8.5) HOẶC có giải Nhất nghiên cứu khoa học. | |
| ```python | |
| diem_ren_luyen = 85 | |
| diem_hoc_tap = 8.7 | |
| giai_nhat_nckh = False | |
| if (diem_ren_luyen >= 80 and diem_hoc_tap >= 8.5) or giai_nhat_nckh: | |
| print(""Sinh viên đủ điều kiện nhận học bổng xuất sắc!"") | |
| else: | |
| print(""Chưa đủ tiêu chuẩn nhận học bổng."") | |
| ``` | |
| Kết quả: | |
| ```text | |
| Sinh viên đủ điều kiện nhận học bổng xuất sắc! | |
| ```","Hãy viết điều kiện kiểm tra một năm là năm nhuận: `(nam % 4 == 0 and nam % 100 != 0) or (nam % 400 == 0)` và thử với các năm 2000, 2024, 2100." | |
| Vòng lặp lồng nhau (nested loop) trong Python là gì và cho ví dụ in bảng cửu chương?,"Vòng lặp lồng nhau là việc đặt một vòng lặp bên trong một vòng lặp khác. Với mỗi một lần lặp của vòng lặp bên ngoài (outer loop), vòng lặp bên trong (inner loop) sẽ chạy toàn bộ các lượt lặp của nó. | |
| Ví dụ in bảng cửu chương 2 và 3: | |
| ```python | |
| for i in range(2, 4): | |
| print(f""--- BẢNG CỬU CHƯƠNG {i} ---"") | |
| for j in range(1, 6): | |
| print(f""{i} x {j} = {i * j}"") | |
| ``` | |
| Kết quả: | |
| ```text | |
| --- BẢNG CỬU CHƯƠNG 2 --- | |
| 2 x 1 = 2 | |
| 2 x 2 = 4 | |
| 2 x 3 = 6 | |
| 2 x 4 = 8 | |
| 2 x 5 = 10 | |
| --- BẢNG CỬU CHƯƠNG 3 --- | |
| 3 x 1 = 3 | |
| 3 x 2 = 6 | |
| 3 x 3 = 9 | |
| 3 x 4 = 12 | |
| 3 x 5 = 15 | |
| ```",Hãy viết vòng lặp lồng nhau để in ra một hình chữ nhật đặc bằng dấu sao `*` kích thước 3 hàng x 5 cột. | |
| Cách duyệt ngược một danh sách hoặc một dãy số trong vòng lặp for như thế nào?,"Để duyệt ngược trong Python, có hai cách thông dụng và hiệu quả: | |
| 1. Dùng hàm `reversed(iterable)`: Trả về một iterator duyệt từ cuối về đầu mà không làm biến đổi danh sách gốc. | |
| 2. Dùng hàm `range(start, stop, step)` với bước nhảy âm (`step = -1`). | |
| 3. Cắt danh sách đảo ngược bằng cú pháp `danh_sach[::-1]`. | |
| Ví dụ: | |
| ```python | |
| ds = [""Đầu"", ""Giữa"", ""Cuối""] | |
| # Cách 1: Dùng hàm reversed() | |
| print(""Dùng reversed():"") | |
| for item in reversed(ds): | |
| print(item, end="" "") | |
| print() | |
| # Cách 2: Dùng range với bước nhảy âm đếm ngược | |
| print(""Đếm ngược từ 5 về 1:"") | |
| for i in range(5, 0, -1): | |
| print(i, end="" "") | |
| print() | |
| ``` | |
| Kết quả: | |
| ```text | |
| Dùng reversed(): | |
| Cuối Giữa Đầu | |
| Đếm ngược từ 5 về 1: | |
| 5 4 3 2 1 | |
| ```","Hãy viết chương trình đếm ngược thời gian từ 10 về 0 bằng `range(10, -1, -1)` và sau đó in ra thông báo `'Phóng tên lửa!'`." | |
| Docstring trong Python là gì và cách viết tài liệu hướng dẫn cho hàm như thế nào?,"Docstring (Documentation String) là chuỗi ký tự đặt ngay dòng đầu tiên bên trong định nghĩa hàm, lớp hoặc mô-đun để giải thích mục đích, các tham số và giá trị trả về của hàm. | |
| Docstring thường được đặt trong cặp ba dấu nháy kép `""""""...""""""`. | |
| Bạn có thể đọc docstring bằng thuộc tính `ten_ham.__doc__` hoặc hàm `help(ten_ham)`. | |
| Ví dụ: | |
| ```python | |
| def tinh_chu_vi_hinh_tron(ban_kinh): | |
| """""" | |
| Tính chu vi của hình tròn dựa vào bán kính. | |
| Tham số: | |
| ban_kinh (float): Bán kính hình tròn (phải > 0). | |
| Trả về: | |
| float: Chu vi hình tròn. | |
| """""" | |
| PI = 3.14159 | |
| return 2 * PI * ban_kinh | |
| # Đọc tài liệu hướng dẫn của hàm | |
| print(tinh_chu_vi_hinh_tron.__doc__) | |
| ``` | |
| Kết quả hiển thị chính xác khối tài liệu đã viết bên trong hàm.",Hãy viết docstring chuẩn cho một hàm giải phương trình bậc nhất $ax + b = 0$ và dùng lệnh `help()` để xem kết quả. | |
| Một hàm trong Python có thể trả về nhiều giá trị cùng lúc không và cơ chế hoạt động thực sự là gì?,"Có! Trong Python, một hàm có thể trả về nhiều giá trị cùng một lúc ngăn cách nhau bằng dấu phẩy sau từ khóa `return`. | |
| Thực chất, Python tự động đóng gói (pack) các giá trị đó vào MỘT đối tượng duy nhất kiểu `tuple`. Khi nhận kết quả, bạn có thể giải nén (unpack) trực tiếp vào nhiều biến. | |
| Ví dụ hàm tính cả chu vi và diện tích: | |
| ```python | |
| def tinh_toan_hinh_vuong(canh): | |
| chu_vi = canh * 4 | |
| dien_tich = canh * canh | |
| return chu_vi, dien_tich # Trả về 2 giá trị cùng lúc | |
| # Giải nén kết quả vào 2 biến riêng biệt | |
| cv, dt = tinh_toan_hinh_vuong(5) | |
| print(f""Hình vuông cạnh 5: Chu vi = {cv}, Diện tích = {dt}"") | |
| # Nếu nhận bằng 1 biến duy nhất, kết quả sẽ là một tuple | |
| ket_qua_tuple = tinh_toan_hinh_vuong(5) | |
| print(""Kết quả dạng tuple:"", ket_qua_tuple) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Hình vuông cạnh 5: Chu vi = 20, Diện tích = 25 | |
| Kết quả dạng tuple: (20, 25) | |
| ```","Hãy viết một hàm nhận vào danh sách các số và trả về cùng lúc: giá trị nhỏ nhất, giá trị lớn nhất và giá trị trung bình." | |
| "Làm thế nào để tìm độ dài, giá trị lớn nhất, nhỏ nhất và tổng của một danh sách các số trong Python?","Python cung cấp các hàm tích hợp sẵn (built-in functions) rất mạnh mẽ để xử lý danh sách số học: | |
| - `len(ds)`: Đếm tổng số phần tử. | |
| - `max(ds)`: Tìm phần tử có giá trị lớn nhất. | |
| - `min(ds)`: Tìm phần tử có giá trị nhỏ nhất. | |
| - `sum(ds)`: Tính tổng tất cả các phần tử số. | |
| Ví dụ tính điểm trung bình môn học: | |
| ```python | |
| diem_so = [8.0, 9.5, 7.0, 8.5, 10.0] | |
| so_mon = len(diem_so) | |
| diem_cao_nhat = max(diem_so) | |
| diem_thap_nhat = min(diem_so) | |
| tong_diem = sum(diem_so) | |
| diem_trung_binh = tong_diem / so_mon | |
| print(f""Số môn thi: {so_mon}"") | |
| print(f""Điểm cao nhất: {diem_cao_nhat}"") | |
| print(f""Điểm thấp nhất: {diem_thap_nhat}"") | |
| print(f""Điểm trung bình: {diem_trung_binh:.2f}"") | |
| ``` | |
| Kết quả: | |
| ```text | |
| Số môn thi: 5 | |
| Điểm cao nhất: 10.0 | |
| Điểm thấp nhất: 7.0 | |
| Điểm trung bình: 8.60 | |
| ```","Hãy tạo danh sách doanh thu của 7 ngày trong tuần và dùng các hàm trên để in ra doanh thu cao nhất, thấp nhất và trung bình mỗi ngày." | |
| Tại sao phép gán list2 = list1 không tạo ra bản sao độc lập và cách sao chép danh sách đúng là gì?,"Trong Python, danh sách là kiểu dữ liệu có thể biến đổi (mutable). Khi bạn viết `list2 = list1`, Python KHÔNG sao chép dữ liệu mà chỉ tạo một tham chiếu (reference) mới trỏ tới CÙNG VÙNG NHỚ của `list1`. Do đó, khi bạn sửa đổi `list2`, `list1` cũng sẽ bị thay đổi theo! | |
| Các cách sao chép (copy) danh sách độc lập đúng cách: | |
| 1. Dùng phương thức `.copy()`: `list2 = list1.copy()` | |
| 2. Dùng kỹ thuật slicing: `list2 = list1[:]` | |
| 3. Dùng hàm `list()`: `list2 = list(list1)` | |
| 4. Nếu có danh sách lồng nhau, dùng `copy.deepcopy()`. | |
| Ví dụ: | |
| ```python | |
| goc = [1, 2, 3] | |
| # Sai lầm: Gán tham chiếu | |
| tham_chieu = goc | |
| tham_chieu.append(99) | |
| print(""Gốc bị thay đổi ngoài ý muốn:"", goc) | |
| # Đúng đắn: Dùng .copy() | |
| ban_sao = goc.copy() | |
| ban_sao.append(1000) | |
| print(""Bản sao:"", ban_sao) | |
| print(""Gốc vẫn an toàn:"", goc) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Gốc bị thay đổi ngoài ý muốn: [1, 2, 3, 99] | |
| Bản sao: [1, 2, 3, 99, 1000] | |
| Gốc vẫn an toàn: [1, 2, 3, 99] | |
| ```","Hãy thử tạo một danh sách điểm số ban đầu, sao chép bằng `.copy()` rồi cộng thêm 1 điểm khuyến khích vào bản sao để kiểm chứng danh sách gốc không bị ảnh hưởng." | |
| Những kiểu dữ liệu nào có thể làm khóa (key) cho Dictionary hoặc phần tử của Set?,"Quy tắc bất biến: Chỉ các kiểu dữ liệu có thể băm (Hashable) và BẤT BIẾN (Immutable) mới được phép làm khóa của Dictionary hoặc phần tử của Set. | |
| Các kiểu dữ liệu HỢP LỆ: | |
| - Số nguyên (`int`), số thực (`float`), luận lý (`bool`) | |
| - Chuỗi ký tự (`str`) | |
| - `tuple` (chỉ khi tuple đó chứa toàn các phần tử bất biến) | |
| - `frozenset` (tập hợp bất biến) | |
| Các kiểu dữ liệu KHÔNG HỢP LỆ (sẽ báo lỗi `TypeError: unhashable type`): | |
| - `list` (vì có thể thay đổi thêm sửa xóa) | |
| - `dict` | |
| - `set` | |
| Ví dụ: | |
| ```python | |
| # Hợp lệ: Dùng tuple làm tọa độ khóa | |
| ban_do = {} | |
| ban_do[(10, 20)] = ""Cửa hàng trà sữa"" | |
| print(""Vị trí (10, 20):"", ban_do[(10, 20)]) | |
| # SAI: ban_do[[10, 20]] = ""Lỗi"" -> TypeError: unhashable type: 'list' | |
| ``` | |
| Kết quả: | |
| ```text | |
| Vị trí (10, 20): Cửa hàng trà sữa | |
| ```","Hãy thử tạo một set chứa một danh sách `{[1, 2], 3}` và quan sát thông báo lỗi `TypeError: unhashable type: 'list'`." | |
| Dictionary Comprehension trong Python là gì và cho ví dụ minh họa cách dùng?,"Tương tự List Comprehension, Dictionary Comprehension cho phép bạn tạo ra một từ điển mới một cách nhanh chóng và ngắn gọn từ một tập hợp có sẵn. | |
| Cú pháp: | |
| `{khoa: gia_tri for phan_tu in iterable if dieu_kien}` | |
| Ví dụ tạo từ điển bình phương của các số chẵn: | |
| ```python | |
| # Tạo từ điển {x: x^2} cho các số chẵn từ 1 đến 8 | |
| binh_phuong = {x: x ** 2 for x in range(1, 9) if x % 2 == 0} | |
| print(""Từ điển bình phương:"", binh_phuong) | |
| # Chuyển đổi đơn vị giá tiền từ USD sang VNĐ (tỉ giá 25000) | |
| gia_usd = {""sach"": 10, ""ao"": 20, ""tai_nghe"": 50} | |
| gia_vnd = {sp: gia * 25000 for sp, gia in gia_usd.items()} | |
| print(""Bảng giá VNĐ:"", gia_vnd) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Từ điển bình phương: {2: 4, 4: 16, 6: 36, 8: 64} | |
| Bảng giá VNĐ: {'sach': 250000, 'ao': 500000, 'tai_nghe': 1250000} | |
| ```",Hãy dùng Dictionary Comprehension để lọc ra các học sinh có điểm >= 8.0 từ một từ điển điểm số lớp học. | |
| Cách kiểm tra chuỗi chỉ chứa chữ cái (isalpha) hoặc chỉ chứa chữ số (isdigit)?,"Python có các phương thức kiểm tra định dạng ký tự (trả về `True` hoặc `False`): | |
| - `str.isalpha()`: Trả về `True` nếu tất cả ký tự trong chuỗi đều là chữ cái và chuỗi có ít nhất 1 ký tự. | |
| - `str.isdigit()`: Trả về `True` nếu tất cả ký tự đều là chữ số (0-9). | |
| - `str.isalnum()`: Trả về `True` nếu chuỗi chỉ gồm chữ cái hoặc chữ số. | |
| Ví dụ kiểm tra dữ liệu đầu vào: | |
| ```python | |
| tuoi_nhap = ""25"" | |
| ten_nhap = ""NguyenVanA"" | |
| ma_pin = ""12a4"" | |
| print(f""'{tuoi_nhap}' có phải số không?"", tuoi_nhap.isdigit()) | |
| print(f""'{ten_nhap}' chỉ chứa chữ cái?"", ten_nhap.isalpha()) | |
| print(f""'{ma_pin}' chỉ chứa số?"", ma_pin.isdigit()) | |
| ``` | |
| Kết quả: | |
| ```text | |
| '25' có phải số không? True | |
| 'NguyenVanA' chỉ chứa chữ cái? True | |
| '12a4' chỉ chứa số? False | |
| ```",Hãy viết chương trình yêu cầu nhập số điện thoại và dùng `.isdigit()` để kiểm tra xem chuỗi nhập vào có hoàn toàn là số hay không. | |
| "Ký tự thoát (escape characters) như \n, \t, \\ trong chuỗi Python hoạt động ra sao?","Ký tự thoát (Escape Sequence) bắt đầu bằng dấu gạch chéo ngược `\`, dùng để biểu diễn các ký tự đặc biệt khó gõ trực tiếp trong chuỗi: | |
| - `\n`: Xuống dòng mới (newline). | |
| - `\t`: Thụt đầu dòng một khoảng Tab. | |
| - `\'`: Dấu nháy đơn bên trong chuỗi nháy đơn. | |
| - `\""`: Dấu nháy kép bên trong chuỗi nháy kép. | |
| - `\\`: In ra chính dấu gạch chéo ngược. | |
| - Chuỗi thô (Raw string) `r""...""`: Vô hiệu hóa ký tự thoát, coi mọi dấu `\` là ký tự bình thường. | |
| Ví dụ: | |
| ```python | |
| print(""Dòng 1\nDòng 2\nDòng 3"") | |
| print(""Cột 1\tCột 2\tCột 3"") | |
| print(""Cô ấy nói: \""Python thật thú vị!\"""") | |
| # Đường dẫn tệp trong Windows nên dùng raw string (r""..."") | |
| duong_dan = r""C:\Users\Admin\Documents\test.py"" | |
| print(""Đường dẫn:"", duong_dan) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Dòng 1 | |
| Dòng 2 | |
| Dòng 3 | |
| Cột 1 Cột 2 Cột 3 | |
| Cô ấy nói: ""Python thật thú vị!"" | |
| Đường dẫn: C:\Users\Admin\Documents\test.py | |
| ```",Hãy in ra một đoạn thơ gồm 4 câu thơ trên 4 dòng khác nhau chỉ bằng một lệnh `print` duy nhất có sử dụng ký tự `\n`. | |
| Lệnh assert trong Python dùng để làm gì trong quá trình gỡ lỗi (debugging)?,"Lệnh `assert` (khẳng định) được dùng trong quá trình kiểm thử và gỡ lỗi (debugging). Nó kiểm tra một điều kiện logic xem có đúng không: | |
| - Nếu điều kiện là `True`, chương trình tiếp tục chạy bình thường. | |
| - Nếu điều kiện là `False`, Python sẽ ném ra lỗi ngoại lệ `AssertionError` kèm thông báo chỉ định. | |
| Cú pháp: | |
| `assert dieu_kien, ""Thông điệp lỗi nếu điều kiện sai""` | |
| Ví dụ: | |
| ```python | |
| def tinh_tong_tien(gia, so_luong): | |
| # Khẳng định giá và số lượng phải luôn là số không âm | |
| assert gia >= 0, ""Giá sản phẩm không được nhỏ hơn 0!"" | |
| assert so_luong > 0, ""Số lượng mua phải lớn hơn 0!"" | |
| return gia * so_luong | |
| print(""Tổng tiền:"", tinh_tong_tien(50000, 3)) | |
| # Nếu truyền số lượng âm: | |
| # tinh_tong_tien(50000, -2) -> AssertionError: Số lượng mua phải lớn hơn 0! | |
| ``` | |
| Kết quả: | |
| ```text | |
| Tổng tiền: 150000 | |
| ```",Hãy viết một câu lệnh `assert` kiểm tra xem danh sách điểm thi có rỗng hay không trước khi tiến hành tính toán. | |
| Làm thế nào để mở và đọc/ghi file an toàn bằng cấu trúc with open() trong Python?,"Khi làm việc với tệp tin (File I/O), lập trình viên rất dễ quên gọi phương thức `file.close()`, dẫn đến việc rò rỉ tài nguyên hệ thống hoặc mất dữ liệu chưa kịp ghi ra ổ đĩa. | |
| Giải pháp chuẩn mực của Python là dùng cấu trúc `with open(...) as f:` (Context Manager). Cấu trúc này đảm bảo tệp tin sẽ LUÔN ĐƯỢC ĐÓNG TỰ ĐỘNG ngay sau khi kết thúc khối lệnh thụt lề, kể cả khi có lỗi ngoại lệ xảy ra bên trong. | |
| Các chế độ mở file thông dụng: | |
| - `'r'`: Mở để đọc (read - mặc định). | |
| - `'w'`: Mở để ghi mới (write - sẽ ghi đè xóa nội dung cũ). | |
| - `'a'`: Mở để ghi thêm vào cuối (append). | |
| - `encoding='utf-8'`: Bắt buộc chỉ định để hiển thị tiếng Việt có dấu chuẩn xác. | |
| Ví dụ ghi và đọc file an toàn: | |
| ```python | |
| ten_tep = ""ghi_chu.txt"" | |
| # 1. Ghi file với mã hóa utf-8 | |
| with open(ten_tep, ""w"", encoding=""utf-8"") as f: | |
| f.write(""Xin chào! Đây là file thực hành Python.\n"") | |
| f.write(""Học Python mỗi ngày cùng nhau nhé!\n"") | |
| # 2. Đọc lại nội dung file | |
| with open(ten_tep, ""r"", encoding=""utf-8"") as f: | |
| noi_dung = f.read() | |
| print(""Nội dung tệp vừa đọc:"") | |
| print(noi_dung) | |
| ``` | |
| Kết quả: | |
| ```text | |
| Nội dung tệp vừa đọc: | |
| Xin chào! Đây là file thực hành Python. | |
| Học Python mỗi ngày cùng nhau nhé! | |
| ```","Hãy viết chương trình tạo một file `nhat_ky.txt`, dùng chế độ `'a'` (append) để thêm một dòng nhật ký mới kèm thời gian hiện tại." | |