Man_Ebook

1. NHAØ XUAÁT BAÛN
ÑAÏI HOÏC QUOÁC GIA TP. HOÀ CHÍ MINH
GIÁO TRÌNH
TRẦN NHẬT QUANG
PHẠM VĂN KHOA
LẬP TRÌNH PYTHON CĂN BẢN

2. TS. TRẦN NHẬT QUANG, TS. PHẠM VĂN KHOA
GIÁO TRÌNH
LẬP TRÌNH
PYTHON CĂN BẢN
NHÀ XUẤT BẢN ĐẠI HỌC QUỐC GIA
THÀNH PHỐ HỒ CHÍ MINH – 2023

3. 2

4. 3
LỜI NÓI ĐẦU
Python hiện là ngôn ngữ lập trình phổ biến nhất thế giới1
. Ưu điểm nổi bật
của Python là dễ học, dễ viết. Không những thế, Python còn có một cộng
đồng người dùng lớn và hệ thống thư viện mã nguồn mở đồ sộ giúp bạn
hoàn thành các dự án của mình nhanh chóng và hiệu quả. Cho dù đó là một
dự án về phân tích dữ liệu, học máy, xử lý ảnh, game, điều khiển thiết bị,
hoặc chỉ đơn giản là tự động hóa các tác vụ trên máy tính của bạn, thì gần
như bạn đều có thể tìm thấy các thư viện Python hỗ trợ.
Quyển giáo trình này được biên soạn với mong muốn hỗ trợ hiệu quả cho
các bạn sinh viên học lập trình Python. Tiêu chí thứ nhất của nhóm biên
soạn là giúp người học lập trình lần đầu cũng có thể dễ dàng nắm bắt
được các khái niệm và kỹ thuật lập trình với Python. Tiêu chí thứ hai là cố
gắng trình bày nội dung một cách súc tích, nhưng vẫn đầy đủ, để những
bạn đã học qua lập trình có thể nhanh chóng làm quen và sử dụng được
Python khi học xong giáo trình.
Rất mong quyển giáo trình này sẽ hữu ích với các bạn! Nhóm biên soạn
cũng mong nhận được góp ý của độc giả để cải thiện giáo trình này ngày
càng tốt hơn. Xin cảm ơn các bạn!
1
Theo xếp hạng của TIOBE Index và PYPL Index cập nhật vào tháng 3 năm 2022.

5. 4

6. 5
MỤC LỤC
LỜI NÓI ĐẦU .......................................................................................... 3
MỤC LỤC ................................................................................................ 5
DANH MỤC HÌNH ẢNH.........................................................................8
Chương 1 GIỚI THIỆU VÀ CÀI ĐẶT PYTHON..................................9
1.1 Đôi nét về ngôn ngữ lập trình Python............................................9
1.2 Lịch sử phát triển Python.............................................................10
1.3 Cài đặt Python..............................................................................11
1.4 Một số lời khuyên hữu ích cho những người mới ......................16
Chương 2 PHÉP TOÁN CƠ BẢN, BIẾN VÀ NHẬP XUẤT TRONG
PYTHON ..............................................................................................18
2.1 Sử dụng VS Code như một máy tính cầm tay..............................18
2.2 Các phép toán...............................................................................19
2.3 Biến..............................................................................................21
2.4 Nhập xuất cơ bản .........................................................................23
2.5 Lệnh if..........................................................................................26
Bài tập có lời giải.................................................................................32
Bài tập thực hành.................................................................................33
Chương 3 VÒNG LẶP VÀ CẤU TRÚC DỮ LIỆU MẢNG................35
3.1 Vòng lặp while.............................................................................35
3.2 Cấu trúc dữ liệu mảng..................................................................41
3.3 Vòng lặp for.................................................................................46
3.4 Break, continue và pass................................................................49
Bài tập có lời giải.................................................................................50
Bài tập thực hành.................................................................................51
Chương 4 NUMPY................................................................................54
4.1 Giới thiệu về Numpy....................................................................54
4.2 Cài đặt thư viện numpy................................................................54
4.3 Numpy arrays...............................................................................55

7. 6
Bài tập thực hành.................................................................................58
Chương 5 SETS VÀ DICTIONARIES .................................................60
5.1 Sets...............................................................................................60
5.2 Dictionaries..................................................................................62
Bài tập có lời giải.................................................................................67
Bài tập thực hành.................................................................................68
Chương 6 STRINGS..............................................................................69
6.1 Khái niệm và khởi tạo strings ......................................................69
6.2 Hàm xử lý strings.........................................................................71
Bài tập thực hành.................................................................................73
Chương 7 HÀM .....................................................................................74
7.1 Khái niệm và cú pháp ..................................................................74
7.2 Một số ví dụ .....................................................................................74
7.3 Biến đoạn code bất kỳ thành hàm................................................81
Bài tập có lời giải.................................................................................83
Bài tập thực hành.................................................................................84
Chương 8 LỖI VÀ SỬA LỖI................................................................86
8.1 Các dạng lỗi trong lập trình .........................................................86
8.2 Xử lý lỗi runtime..........................................................................87
8.3 Xử lý lỗi logic ..............................................................................90
8.4 Các lưu ý khi viết code để hạn chế lỗi.........................................95
Bài tập thực hành.................................................................................97
Chương 9 VẼ VỚI MATPLOTLIB.......................................................99
9.1 Cách thức vẽ trên màn hình kỹ thuật số.......................................99
9.2 Vẽ với thư viện matplotlib.........................................................100
9.3 Vẽ đồ thị trong tọa độ cực..........................................................106
9.4 Tùy chỉnh hình vẽ ......................................................................108
9.5 Vẽ trên nhiều phân vùng với subplotlib.....................................116
Bài tập thực hành...............................................................................120

8. 7
PHỤ LỤC ..............................................................................................122
Mã nguồn bài tập có lời giải chương 2..............................................122
Mã nguồn bài tập có lời giải chương 3..............................................127
Mã nguồn bài tập có lời giải chương 5..............................................131
Mã nguồn bài tập có lời giải chương 7..............................................135
Keywords của Python........................................................................142
Cài đặt các thuật toán sắp xếp bằng Python ......................................145
Cài đặt các thuật toán tìm kiếm trên mảng bằng Python...................151
Cài đặt các thuật toán tìm kiếm trên chuỗi bằng Python...................158
INDEX...................................................................................................161
TÀI LIỆU THAM KHẢO .....................................................................163

9. 8
DANH MỤC HÌNH ẢNH
Hình 1-1 Logo của Python. Nguồn: Python Software Foundation............9
Hình 1-2 Cài đặt Python bằng cách tick vào ô Add Python... to PATH ở
cửa sổ cài đặt đầu tiên..............................................................................12
Hình 1-3 Giao diện của Visual Studio Code. ..........................................12
Hình 1-4 Giao diện trang OnlineGDB.....................................................16
Hình 1-5 Ứng dụng Pydroid 3 trên Google Play. ....................................16
Hình 2-1 Lưu đồ của khối lệnh if. ...........................................................28
Hình 3-1 Lưu đồ hoạt động của vòng lặp while. .....................................35
Hình 3-2 Lưu đồ hoạt động của vòng lặp for. .........................................47

10. 9
Chương 1
GIỚI THIỆU VÀ CÀI ĐẶT PYTHON
1.1 Đôi nét về ngôn ngữ lập trình Python
Python là một ngôn ngữ lập trình cấp cao và đa dụng (general-
purpose) được phát triển bởi Guido van Rossum. Phiên bản đầu tiên của
nó được phát hành vào năm 1991. Tên của nó được đặt theo chương trình
hài Monty Python1
của Anh như một cách phản ánh triết lý thiết kế của
Python: một ngôn ngữ lập trình thú vị khi sử dụng.
Hình 1-1 Logo của Python.
Nguồn: Python Software Foundation
Triết lý của ngôn ngữ lập trình Python được mô tả bằng những cách
ngôn trong tài liệu The Zen of Python (PEP 20) như:
▪ Simple is better than complex (tạm dịch: Đơn giản tốt hơn phức
tạp).
▪ Complex is better than complicated (tạm dịch: Phức hợp tốt hơn
phức tạp).
▪ Explicit is better than implicit (tạm dịch: Tường minh tốt hơn là
ngầm định).
▪ Readability counts (tạm dịch: Lưu tâm đến sự dễ đọc hiểu).
Với những triết lý đó, Python hướng tới sự đơn giản, ngắn gọn
trong mã lệnh của mình. Bạn sẽ cảm nhận được điều này khi bắt đầu lập
trình với Python và so sánh nó với các ngôn ngữ như C/C++, Java.
Đến nay, Python đã được phát triển qua nhiều phiên bản. Hai nhóm
phiên bản được sử dụng hiện nay là Python 2.x và Python 3.x. Tuy nhiên,
1
Theo General Python FAQ, docs.python.org

11. 10
các phiên bản 2.x đã không còn được hỗ trợ đầy đủ từ ngày 1/1/20201
.
Phiên bản mới nhất của Python là 3.10 (phát hành ngày 4/10/2021)2
.
1.2 Lịch sử phát triển Python3
Python được bắt đầu phát triển vào cuối những năm 1980 bởi
Guido van Rossum tại Centrum Wiskunde & Informatica (CWI), Hà Lan
như một ngôn ngữ kế thừa của ngôn ngữ lập trình ABC có khả năng xử lý
ngoại lệ và giao tiếp với hệ điều hành Amoeba.
Python được bắt đầu phát triển vào tháng 12 năm 1989. Vào thời
điểm đó, van Rossum là tác giả duy nhất của dự án, với tư cách là nhà phát
triển chính, cho đến ngày 12 tháng 7 năm 2018. Vào tháng 1 năm 2019,
các nhà phát triển cốt lõi Python đã bầu ra một Hội đồng chỉ đạo gồm năm
thành viên để lãnh đạo dự án.
Python 2.0 được phát hành vào ngày 16 tháng 10 năm 2000, với
nhiều tính năng mới. Python 3.0, được phát hành vào ngày 3 tháng 12 năm
2008, với nhiều tính năng chính vẫn hỗ trợ ngược Python 2.6.x và 2.7.x.
Các bản phát hành của Python 3 tích hợp tiện ích 2to3 giúp dịch mã tự
động từ Python 2 sang Python 3.
Python 2.7 ban đầu được chỉ định sẽ chấm dứt hoạt động vào
năm 2015, nhưng sau đó bị hoãn lại đến năm 2020 vì những lo ngại về
việc chuyển đổi các code Python 2 hiện có sang Python 3. Từ thời điểm
đó, Python 2 không nhận được thêm bất kỳ bản vá bảo mật hoặc cải tiến
nào nữa.
Sau khi Python 2 bị ngừng hỗ trợ, chỉ còn Python 3.6.x và các phiên
bản mới hơn được hỗ trợ. Một thời gian sau, Python 3.6 cũng bị ngừng hỗ
trợ. Đến năm 2021, Python 3.9.2 và 3.8.8 được phát triển vì tất cả các phiên
bản Python trước (bao gồm 2.7) đều có vấn đề bảo mật có thể khiến máy
tính bị thực thi mã từ xa và nhiễm độc bộ nhớ web cache.
Vào năm 2022, Python 3.10.4 và 3.9.12 được phát triển và các bản
cũ hơn bao gồm 3.8.13 và 3.7.13 được cập nhật vì nhiều vấn đề bảo mật.
1
Theo PEP 373 -- Python 2.7 Release Schedule
2
Theo PEP 619 -- Python 3.10 Release Schedule
3
Theo https://en.wikipedia.org/wiki/Python_(programming_language)

12. 11
1.3 Cài đặt Python
Có nhiều cách khác nhau để lập trình với Python. Phần này mô
tả ba cách phù hợp với các nhóm người dùng với điều kiện về thiết bị
khác nhau.
Cách 1. Lập trình Python trên máy tính sử dụng VS Code
Nếu bạn sở hữu một máy tính cá nhân thì nên dùng cách này để
tận dụng được đầy đủ chức năng của Python một cách thuận tiện.
Trước tiên, bạn cần cài đặt trình biên dịch Python (Python
interpreter). Nên chọn phiên bản Python 3.7 hoặc mới hơn.1
Một lưu ý
khi cài đặt Python intepreter là bạn nên tick vào ô “Add Python ... to
PATH” ở cửa sổ cài đặt đầu tiên (xem Hình 1-2).
Sau khi đã cài đặt xong trình biên dịch Python, bạn nên cài đặt một
editor (trình soạn thảo) hoặc một IDE (Integrated Development
Environment) để lập trình Python được dễ dàng hơn. Có nhiều editor,
IDE khác nhau hỗ trợ lập trình Python. Trong giáo trình này, chúng tôi
khuyến nghị sử dụng Visual Studio Code2
(VS Code). Editor này có các
ưu điểm như:
▪ Miễn phí, mã nguồn mở, hỗ trợ nhiều nền tảng (Windows, Linux,
Mac).
▪ IntelliSense: giúp viết code nhanh chóng hơn bằng cách đưa ra các
lựa chọn tự động hoàn thành code cho bạn.
▪ Hỗ trợ tìm và sửa lỗi (debug) hiệu quả.
▪ Nhiều extension hữu ích: như kết nối với Git, đọc file Jupyter
Notebook (.ipynb), hỗ trợ Docker.
1
Download Python phiên bản mới nhất tại https://www.python.org/downloads/. Với
những phiên bản cũ, download tại https://www.python.org/ftp/python/.
2
Download bản cài đặt VS Code tại https://code.visualstudio.com/download.

13. 12
Hình 1-2 Lưu ý: Khi cài đặt Python nên tick vào ô Add Python ... to PATH để
thuận tiện chạy các Scripts Python về sau..
Hình 1-3 Giao diện của Visual Studio Code.
Sau khi cài đặt VS Code xong, bạn nên thực hiện các bước sau để tạo một
file code Python đầu tiên và cũng để VS Code hoàn tất cài đặt các extension
hỗ trợ lập trình Python.

14. 13
1. Chọn File > Open Folder…
2. Tạo mới hoặc chọn một thư mục rồi nhấn Select Folder.
Lưu ý: đối với máy tính sử dụng Windows, bạn nên chọn một thư
mục trong ổ D: hoặc một ổ đĩa mà bạn có đầy đủ quyền chạy các
mã lệnh. Không dùng các thư mục có tên “python” hoặc “code”
vì có thể gây lỗi về sau. Tên và đường dẫn thư mục tốt nhất là
không chứa khoảng trắng và không chứa dấu tiếng Việt.

15. 14
3. Nhấn vào biểu tượng và nhập tên file.
Lưu ý: Tên file phải có phần mở rộng .py. Không nên dùng tên file
python.py hoặc code.py để tránh bị lỗi khi chạy. Tên file tốt nhất là
không chứa khoảng trắng và không chứa dấu tiếng Việt.
4. Sau khi tạo file xong, VS Code có thể hỏi bạn có muốn cài đặt
extension cho Python không. Hãy chọn Install.
5. Nhập nội dung sau đây vào file vừa tạo:
#%%
print("Xin chao!")
6. Nhấn Shift-Enter để chạy.
Lưu ý: Lúc này VS Code có thể hỏi bạn muốn cài đặt các
extension hỗ trợ không, hãy chọn Install.
7. Nếu kết quả hiện ra như hình sau tức là bạn đã hoàn thành cài đặt
và chạy thành công đoạn lệnh Python đầu tiên.
8. Chọn File > Auto Save để VS Code tự động lưu code.
Lưu ý: Nếu không dùng Auto Save thì phải lưu (Save) file code
thủ công bằng cách nhấn Ctrl-S mỗi khi muốn lưu.

16. 15
Cách 2. Lập trình Python trên máy tính sử dụng trình duyệt web
Nếu bạn sử dụng máy tính công cộng hoặc một máy tính không thể
cài đặt Python thì bạn có thể sử dụng trình duyệt web có kết nối internet
và truy cập vào địa chỉ sau để lập trình Python:
https://www.onlinegdb.com/online_python_compiler.
Lưu ý: Cách này không đảm bảo hỗ trợ đầy đủ chức năng của
Python. Chỉ nên dùng khi không thể cài đặt Python và VS Code như
cách 1.

17. 16
Hình 1-4. Giao diện trang OnlineGDB.
Cách 3. Lập trình Python sử dụng smartphone
Trong trường hợp không có máy tính, bạn vẫn có thể lập trình
Python bằng cách sử dụng smartphone và cài đặt ứng dụng Pydroid 3
(hoặc một ứng dụng tương tự).
Lưu ý: cách này không được khuyến khích sử dụng vì không hỗ trợ
đủ tính năng của Python. Chỉ nên sử dụng tạm thời cách này trong một thời
gian ngắn khi không thể dùng máy tính.
Hình 1-5 Ứng dụng Pydroid 3 trên Google Play.
1.4 Một số lời khuyên hữu ích cho những người mới
Lập trình là một kỹ năng. Vì vậy nếu muốn lập trình tốt không có
cách nào khác ngoài thực hành. Tự mình thực hành càng nhiều càng tốt!
Một số kinh nghiệm khi luyện lập trình:

18. 17
▪ Cảm thấy không hiểu rõ khi lần đầu học về một khái niệm, kỹ năng
lập trình. Điều này là hoàn toàn bình thường! Bạn chỉ cần bỏ thêm
chút thời gian xem lại một vài lần, rồi tự mình ngồi code lại nội
dung được học thì sẽ dần dần hiểu rõ.
Thậm chí đôi khi bạn đã rất cố gắng mà vẫn cảm thấy không hiểu rõ
hết. Không sao cả! Có một hiện tượng là: dường như não của chúng
ta tự động tổng hợp kiến thức mà nó từng biết qua. Sau một học kỳ,
hoặc vài tháng, thậm chí một năm sau, bạn sẽ ngạc nhiên khi gặp lại
kiến thức lúc trước bạn thấy bế tắc: lúc này bạn hiểu nó rất rõ ràng!
Vì vậy, đừng ngại khi học qua một lần mà chưa hiểu rõ.
Keep learning!
▪ Những lần đầu lập trình đôi khi giống học thuộc lòng, sao chép code.
Tức là bạn xem code mẫu rồi gõ lại giống như vậy. Điều này cũng
hoàn toàn bình thường! Học thuộc luôn luôn là một phần của việc thu
nạp kiến thức.
▪ Đừng ngại ngồi gõ lại code mẫu. Tự mình gõ lại code khác xa với
việc ngồi nhìn code và nghĩ rằng mình hiểu. Gõ lại code giúp bạn trải
nghiệm lập trình. Khi bạn gõ và chạy code, bạn sẽ tự nhiên ghi nhớ,
tư duy và phát hiện các lỗi, các vấn đề trong đoạn lệnh. Bạn sẽ hiểu
nó cặn kẽ và từ từ sẽ tự viết được các đoạn code theo ý mình.
▪ Internet có thể rất hữu ích. Nếu gặp những lỗi khó hiểu khi lập
trình, hoặc nghĩ mãi chưa ra cách lập trình cho một vấn đề, bạn có
thể thử google. Nhiều khả năng bạn sẽ tìm được lời giải từ các diễn
đàn, các bài viết về lập trình.
Tuy nhiên, đừng lạm dụng! Lúc nào cũng tra google trước khi tự
mình tìm cách giải quyết, hoặc chỉ copy code mà không hiểu, chắc
chắn sẽ có hại cho bạn!
Ngoài ra, bạn cũng nên cẩn thận với vấn đề đạo văn (plagiarism).
Nên tìm hiểu về quy định bản quyền của đoạn code mà bạn định sử
dụng và nhớ phải ghi nguồn.
▪ Thực hành càng nhiều càng tốt!

19. 18
Chương 2
PHÉP TOÁN CƠ BẢN, BIẾN
VÀ NHẬP XUẤT TRONG PYTHON
Chương này giúp bạn làm quen với các phép toán cơ bản, khái niệm
biến (variables) trong lập trình và các hàm cơ bản để nhập xuất dữ liệu
trong Python.
2.1 Sử dụng VS Code như một máy tính cầm tay
Phần này demo một số cách thực thi lệnh Python với VS Code. Bạn
có thể tận dụng những cách này để biến VS Code với Python thành một
công cụ tính toán như máy tính cầm tay (calculator).
Lưu ý: Trước khi có thể chạy code Python trong VS Code, bạn cần
Cài đặt Python (xem mục 1.3 Cài đặt Python).
Sau đây giới thiệu ba cách thực thi lệnh Python trong VS Code.
Cách 1. Tạo và thực thi cell
Để tạo một cell, bạn dùng cú pháp #%% Tên gợi nhớ cho cell
như ví dụ sau:
Để chạy cell, bạn đặt con nháy vào 1 dòng bất kỳ trong cell (nằm giữa 2
đường kẻ màu xanh như trong hình trên), và nhấn Run Cell (nằm ở ngay
phía trên dòng #%%) hoặc sử dụng tổ hợp phím tắt Shift-Enter.
Khi bạn chạy cell lần đầu tiên, VS Code sẽ load Python interpreter rồi mới
thực thi code nên mất thời gian một chút. Từ lần chạy thứ 2, code sẽ được
thực thi ngay vì Python interpreter đã được load vào bộ nhớ rồi.
Cách 2. Thực thi code trong cửa sổ interactive
Để sử dụng cách này trước tiên bạn phải chạy ít nhất một cell theo
cách 1 để VS Code load Python interpreter và khởi tạo cửa sổ interactive
(như hình dưới).

20. 19
Trong cửa sổ interactive, bạn có thể nhập code vào dòng lệnh (nằm
dưới cùng cửa sổ interactive, tại vị trí có ghi dòng chữ Type ‘python’ code
here and press Shift+Enter to run (như hình dưới). Khi nhập xong, nhấn
Shift+Enter để thực thi.
2.2 Các phép toán
Python hỗ trợ các phép toán cơ bản như mô tả trong bảng sau.
Phép toán Cú pháp Code mẫu Kết quả
Trị tuyệt đối abs() abs(-2) 2
Cộng + 2 + 5 7
Trừ - 3 - 1 2
Nhân * 3 * 2 6

21. 20
Chia / 5 / 2 2.5
Chia lấy dư % 7 % 2 1
Lũy thừa ** 3**2 9
Lũy thừa 10 e 4e3 4*103
= 4000
Số phức j 2 + 5j 2 + 5i
Nếu bạn muốn tính những hàm toán học khác như khai căn, lượng giác, thì
cần sử dụng package math. Cú pháp như sau:
import math
math.cos(3.14)
Một số hàm toán học được liệt kê trong bảng bên dưới1
:
Phép toán Cú pháp Code mẫu Kết quả
Số π math.pi math.pi 3.1415…
Số e math.e math.e 2.7182
Vô cùng math.inf math.inf inf
Cosine math.cos() math.cos(3.14) -0.9999
Sine math.sin() math.sin(2*3.14) -0.0031
Arc cosine math.acos() math.acos(1) 0
Arc sine math.asin() math.asin(-1) -1.5707
Tangent math.tan() math.tan(5) -3.3805
Trị tuyệt đối math.fabs() math.fabs(-5.6) 5.6
Ước chung lớn nhất math.gcd() math.gcd(20, 90) 10
Hàm mũ math.exp() math.exp(5) 148.4131
Hàm log math.log()
math.log(8)
math.log(8, 2)
2.0794
3
Căn bậc 2 math.sqrt() math.sqrt(9) 3
Ghi chú: Khi cần tra cứu thông tin của một hàm, bạn có thể dùng cú pháp
với dấu chấm hỏi, ví dụ: lệnh math.log? sẽ hiện thông tin về hàm log.
1
Xem bảng liệt kê đầy đủ tại https://docs.python.org/3/library/math.html

22. 21
2.3 Biến
Biến (variables) là một trong những khái niệm căn bản nhất trong
lập trình. Một biến có thể xem như một nơi chứa dữ liệu đơn giản, phục vụ
cho các tác vụ được lập trình. Ví dụ, khi viết chương trình vẽ đồ thị của
một hàm số bậc 2 có dạng y = ax2
+ bx + c, ta có thể tạo ra các biến để lưu
giá trị của các hệ số a, b và c.
Để tạo ra một biến, bạn cần tuân theo các quy định cú pháp (syntax)
tạo biến. Trong Python các quy định về biến như sau:
1. Để tạo biến trong Python, bạn chỉ cần ghi tên biến và gán giá trị
cho nó, ví dụ các dòng sau lệnh (chú ý mỗi dòng lệnh phải nằm
trên một hàng riêng, dùng phím Enter để xuống dòng):
so1 = 4
so2 = 15
đã tạo ra 2 biến có tên so1, so2 với các giá trị là 4, 15 tương ứng.
Ghi chú: [Dành cho bạn nào đã biết ngôn ngữ lập trình như C,
C++] Python không yêu cầu khai báo biến hoặc khai báo kiểu dữ
liệu cho biến. Khi bạn gán giá trị cho biến, Python sẽ tự động xác
định kiểu dữ liệu cho biến đó.
2. Tên biến phải bắt đầu bằng chữ cái hoặc dấu _ (dấu dash tạo ra
bằng cách nhấn tổ hợp phím Shift -)
Ví dụ: các biến so1, _so1 và _1so là hợp lệ, nhưng biến 1so là
không hợp lệ vì bắt đầu bằng chữ số 1.
3. Tên biến không được chứa khoảng trắng hoặc ký tự đặc biệt
(ký tự đặc biệt là các ký tự không phải chữ cái và chữ số (ngoại trừ
dấu dash _), ví dụ @, &, ! là một số ký tự đặc biệt).

23. 22
Ví dụ: các biến phuongtrinh1 và phuong_trinh_1 là hợp lệ,
nhưng biến phuong trinh1, phuongtrinh-1,
phuongtrinh#1 là không hợp lệ.
4. Tên biến phải khác keywords của Python. Trong Python, cũng như
các ngôn ngữ lập trình khác, một số từ đã được dành riêng cho các
chức năng của ngôn ngữ, ví dụ if, for, while. Vì vậy bạn
không được dùng nhũng từ này đặt tên biến.
Ví dụ: các biến có tên if, for, break, import là không hợp
lệ vì chúng là các keywords, nhưng các biến if1, for_,
break_A một thì hợp lệ vì có chứa thêm các ký tự khác nên không
còn là keywords.
Ghi chú: để nhận biến một từ có phải keyword không, bạn quan sát
màu sắc của nó trong VS Code (VS Code tự chuyển từ thành màu
xanh da trời nếu là keyword). Xem danh sách các keywords trong
phần Phụ lục.
5. Tên biến có phân biệt chữ hoa và chữ thường.
Ví dụ: biến so1 và So1 là 2 biến khác nhau.
Ghi chú: mặc dù bạn có thể tạo ra 2 biến so1 và So1 trong một
chương trình, tuy nhiên, một kinh nghiệm viết code tốt là bạn nên
tránh tạo ra những biến quá giống nhau vì chúng dễ gây nhầm
lẫn và dễ dẫn tới lỗi khi lập trình.
Ngoài các quy định cú pháp bắt buộc ở trên, khi lập trình bạn cũng
nên tuân theo các kinh nghiệm đặt tên biến sau đây sẽ giúp code của bạn
được chuyên nghiệp hơn, khó bị mắc lỗi hơn.
1. Tránh đặt tên biến trùng với tên hàm cài sẵn (built-in
functions). Hàm cài sẵn là các hàm được cung cấp mặc định trong
Python hoặc các packages (xem mục 4.2), ví dụ hàm print,
input. Việc đặt tên biến trùng với tên hàm cài sẵn sẽ làm chương
trình có thể gặp lỗi khi bạn gọi các hàm này sau khi đã tạo biến.
Bạn có thể chạy thử dòng code sau:
print("Xin chao")
Sau đó, chạy đoạn code sau:
print = 5
print("Xin chao")

24. 23
Để ý rằng lần chạy dòng lệnh print thì hàm sẽ hoạt động bình
thường. Nhưng khi chạy đoạn code có dòng print = 5 (tức là ta
tạo ra biến tên print và gán giá trị 5 cho nó) thì hàm sẽ báo lỗi.
Để xử lý lỗi này, bạn chạy lệnh del print để xóa biến print trong
bộ nhớ, khi đó hàm print sẽ hoạt động trở lại.
Ghi chú: Trong VS Code, để kiểm tra xem một từ có trùng tên hàm
cài sẵn không, bạn nhấn tổ hợp phím Ctrl-Space (thanh cách). Nếu
là hàm cài sẵn thì sẽ xuất hiện bảng thông tin như hình dưới:
2. Đặt tên biến có ý nghĩa. Kinh nghiệm đơn giản này đã được chứng
minh trong thực tế có thể giúp cải thiện đáng kể code của bạn: dễ
đọc, dễ bảo trì, sửa lỗi và dễ phát triển hơn. Điều này đặc biệt cần
thiết khi bạn viết những chương trình phức tạp và code được viết
bởi một nhóm nhiều người. Đừng ngại các tên dài, chỉ ngại các tên
khó hiểu!
Ví dụ: Thay vì đặt tên biến là a, N, f, g, bạn hãy đặt: he_so_a,
so_thiet_bi, ham_loc_du_lieu, ham_phan_tich sẽ giúp
chương trình của bạn dễ đọc hơn rất nhiều.
Ghi chú: Để liệt kê các tên bạn đã tạo, dùng lệnh whos. Để xóa một biến,
dùng lệnh del ten_bien, ví dụ del he_so_a.
2.4 Nhập xuất cơ bản
Dữ liệu đưa vào chương trình có thể thông qua việc gán trực tiếp
vào biến (như mục trên), hoặc nhập từ bàn phím, từ các thiết bị chuyên
dụng (cảm biến, camera), hoặc từ file dữ liệu. Bên dưới giới thiệu cách
nhập dữ liệu cơ bản từ bàn phím.
Để nhập dữ liệu từ bàn phím bạn có thể dùng hàm input(), như
các ví dụ sau:
#%% Ví dụ 1: nhập chữ
ho_ten = input('Xin nhap ho ten:')

25. 24
#%% Ví dụ 2: nhập số nguyên
so_thiet_bi = int(input('Nhap so thiet bi:'))
#%% Ví dụ 3: nhập số thực
diem_trung_binh = int(input('Nhap diem trung binh:'))
Trong ví dụ 1, khi chạy dòng lệnh nhập sẽ xuất hiện ô đợi người
dùng nhập tên như sau (trong VS Code ô này xuất hiện ở trên cùng của cửa
sổ VS Code):
Sau khi người dùng nhập tên và nhấn Enter thì tên được nhập sẽ
được lưu vào biến ho_ten.
Trong ví dụ 2, để ý trong dòng lệnh nhập có hàm int(), hàm này
có công dụng kiểm tra và chuyển đổi dữ liệu được nhập thành kiểu số
nguyên. Khi chạy ví dụ này bạn cũng sẽ thấy xuất hiện ô nhập tương tự
như trên, nhưng lưu ý rằng, bạn cần nhập số nguyên, nếu không chương
trình sẽ báo lỗi.
Trong ví dụ 3, đoạn lệnh nhập tương tự ví dụ 2, chỉ khác ở hàm
float() thay cho hàm int(). Hàm float() đổi dữ liệu được nhập về kiểu
số thực.
Lưu ý: Khi không dùng hàm chuyển đổi kiểu dữ liệu (type casting)
như hàm int(), float(), thì dữ liệu trả về từ hàm input() sẽ có kiểu chữ
(string) và không thể thực hiện các phép toán.
Tương tự như việc nhập dữ liệu, việc xuất dữ liệu cũng có nhiều
cách khác nhau như gán trực tiếp vào biến (để sử dụng tiếp tục trong
chương trình), hoặc in chữ, vẽ hình lên màn hình, hoặc truyền tới các thiết
bị xuất (loa, máy in, thiết bị điều khiển), hoặc lưu xuống file. Bên dưới
giới thiệu cách in dữ liệu đơn giản ra màn hình.
Để in text lên màn hình, bạn có thể dụng hàm print() của Python
như các ví dụ bên dưới:
#%% Ví dụ 1: in trực tiếp văn bản
print("Xin chao")

26. 25
#%% Ví dụ 2: in nội dung 1 biến
ho_ten = "Tran An"
print(ho_ten)
#%% Ví dụ 3: in nội dung 1 biến kèm thông báo
print("Ho ten cua ban:", ho_ten)
#%% Ví dụ 4: in nội dung nhiều biến
x1 = 15.3456
x2 = 26.1234
print("Nghiem 1:", x1, " Nghiem 2:", x2)
#%% Ví dụ 5: định dạng biến kiểu số thực
print("Nghiem 1: %.2f Nghiem 2: %.2f" % (x1,x2)) # chỉ
lấy 2 chữ số thập phân
Khi thực thi ví dụ 1, dòng chữ Xin chao! sẽ được in ra màn hình.
Khi thực thi ví dụ 2, dòng chữ Tran An (nội dung của biến
ho_ten) sẽ được in ra màn hình.
Khi thực thi ví dụ 3, dòng chữ Ho ten cua ban: Tran An sẽ
được in ra màn hình.
Khi thực thi ví dụ 4, dòng chữ Nghiem 1: 15.3456 Nghiem
2: 26.1234 sẽ được in ra màn hình.
Khi thực thi ví dụ 5, dòng chữ Nghiem 1: 15.35 Nghiem 2:
26.12 sẽ được in ra màn hình (để ý giá trị của x1, x2 chỉ in ra 2 chữ số
thập phân). Chúng ta xem chi tiết dòng lệnh trong ví dụ này:
print("Nghiem 1: %.2f Nghiem 2: %.2f" % (x1,x2))
Đoạn code %.2f có nghĩa là sẽ in ra số thực với 2 số thập phân.
Để in 3 số thập phân bạn sẽ code thành: %.3f (con số nằm trước chữ f
chính là số lượng chữ số thập phân sẽ in ra).

27. 26
Các biến cần in được đặt trong đoạn code % ( ). Ví dụ: %
(x1,x2) sẽ in ra giá trị của các biến x1, x2. Lưu ý các biến được in ra
theo đúng thứ tự bạn liệt kê trong đoạn code này.
Lưu ý: Trong ví dụ 5, dấu # trong đánh dấu đoạn ghi chú
(comments). Mọi nội dung đặt sau dấu # sẽ được trình dịch Python bỏ
qua, không thực thi. Thông thường trong lập trình, comments được sử dụng
để ghi chú cho những đoạn lệnh quan trọng, hoặc để giải thích cho công
dụng các hàm hoặc các đoạn lệnh phức tạp. Khi viết comments nên viết rõ
ràng nhưng ngắn gọn. Tránh ghi quá nhiều comments cho những đoạn code
đơn giản, vì có thể làm code rườm rà, khó đọc hơn.
2.5 Lệnh if
Lệnh if là cấu trúc rẽ nhánh trong Python. Nói một cách đơn giản,
cấu trúc rẽ nhánh là lựa chọn chạy lệnh này hoặc lệnh khác. Ví dụ khi giải
phương trình bậc 2, nếu giá trị biệt số delta ≥ 0 thì ta sẽ chạy lệnh tính
nghiệm, còn nếu giá trị biệt số delta < 0 thì ta chạy lệnh in ra thông báo
phương trình vô nghiệm. Lệnh if chính là sự diễn đạt “nếu” trong lập trình.
Để sử dụng được lệnh if, trước tiên ta cần biết quy tắc cú pháp của
nó. Trong Python, lệnh if được quy định cú pháp như sau:
if dieu_kien_1:
khoi_lenh_1
elif dieu_kien_2:
khoi_lenh_2:
elif dieu_kien_3:
khoi_lenh_3:
else:
khoi_lenh_N
khoi_lenh_sau_if
Luồng hoạt động của khối lệnh if trên được mô tả trong lưu đồ ở Hình 2-1.
Một cách cụ thể, trong cú pháp if trên,
▪ if, elif, else là các từ khóa (bắt buộc viết chính xác như vậy).
Lưu ý: Chỉ khối if là bắt buộc có, còn khối elif và else có thể
xuất hiện tùy ý. Cụ thể, khối elif có thể không xuất hiện hoặc xuất hiện

28. 27
1 lần hoặc nhiều lần, còn khối else có thể không xuất hiện hoặc xuất hiện
1 lần. Ví dụ, chúng ta có thể viết lệnh if như sau:
if dieu_kien_1:
khoi_lenh_1
khoi_lenh_sau_if
hoặc viết như sau:
if dieu_kien_1:
khoi_lenh_1
else:
khoi_lenh_N
khoi_lenh_sau_if
hoặc viết như sau:
if dieu_kien_1:
khoi_lenh_1
elif dieu_kien_2:
khoi_lenh_2:
khoi_lenh_sau_if
▪ dieu_kien_1, dieu_kien_2, dieu_kien_3,
dieu_kien_N là các mệnh đề logic: có giá trị True hoặc False
(đúng hoặc sai) khi chạy code. Ví dụ: 1>2 là một mệnh đề sai (giá
trị False), 5<6 là mệnh đề đúng (True), N<10: mệnh đề này đúng
hoặc sai tùy thuộc vào giá trị của biến N khi chạy code, ví dụ nếu
N = 9 thì mệnh đề đúng (9<10). Bảng sau đây liệt kê các toán tử so
sánh và toán tử kết hợp có thể dùng trong khối điều kiện.
Toán tử Cú pháp Code mẫu Kết quả
So sánh lớn hơn > 5>2 True
So sánh nhỏ hơn < 5<2 False
So sánh bằng == 5==2 False
So sánh khác != 5!=2 True

29. 28
So sánh lớn hơn
hoặc bằng
>= 5>=2 True
So sánh nhỏ hơn
hoặc bằng
<= 5<=5 True
Và and (5<2) and (2<4) False
Hoặc or (5<2) or (2<4) True
Phủ định not not (5>=2) False
Hình 2-1 Lưu đồ của khối lệnh if.
Khi được viết đúng cú pháp, lệnh if sẽ hoạt động theo nguyên tắc:
điều kiện nào đúng thì chỉ chạy duy nhất khối lệnh ngay dưới điều
kiện đó (các khối lệnh khác sẽ bị bỏ qua). Các điều kiện sẽ được kiểm tra

30. 29
lần lượt từ trên xuống: dieu_kien_1 được kiểm tra trước, sau đó đến
dieu_kien_2, rồi dieu_kien_3… Ví dụ:
▪ Nếu dieu_kien_1 đúng (giá trị True) thì khối lệnh
khoi_lenh_1 sẽ được chạy. Sau khi chạy xong khoi_lenh_1
thì chương trình sẽ nhảy đến khoi_lenh_sau_if, tức là toàn
bộ các dòng code còn lại trong lệnh if sẽ bị bỏ qua.
▪ Nếu dieu_kien_1 sai (giá trị False) thì khối lệnh
khoi_lenh_1 sẽ bị bỏ qua. Lúc này trình biên dịch Python sẽ
kiểm tra dieu_kien_2. Nếu dieu_kien_2 đúng thì sẽ chạy
khoi_lenh_2. Sau khi chạy xong khoi_lenh_2 thì chạy đến
khoi_lenh_sau_if. Nếu dieu_kien_2 sai thì kiểm tra
dieu_kien_3 và thực hiện tương tự như trên.
▪ Khi tất cả các điều kiện đều sai, nếu có khối else thì lệnh trong
khối else sẽ được chạy (tức lệnh khoi_lenh_N sẽ chạy). Nếu
không có khối else thì sẽ chạy khoi_lenh_sau_if.
Lưu ý:
▪ Một khối lệnh có thể bao gồm nhiều dòng lệnh.
▪ Mỗi dòng lệnh Python được đặt trên 1 dòng. Nghĩa là bạn phải
xuống dòng (enter) khi viết xong 1 câu lệnh.
▪ Các câu lệnh trong một khối lệnh phải có thụt đầu dòng
(indentation) bằng nhau. Tức là nếu dòng lệnh 1 được thụt đầu
dòng bằng 3 khoảng trắng (space) thì dòng lệnh 2 (trong khối đó)
cũng phải như vậy. Nếu bạn thụt đầu dòng 4 khoảng trắng, hoặc 2
khoảng trắng khi viết dòng lệnh 2 thì sẽ bị lỗi. Đây là quy định cú
pháp của Python nhằm đảm bảo chương trình ngăn nắp, dễ đọc.
Ví dụ 2.1: Nhập 1 số nguyên và xác định số được nhập là chẵn hay lẻ.
#%% Xác định chẵn lẻ
N = int(input('Xin nhap 1 so nguyen:'))
if N % 2 == 0:
print(N, 'la so chan.')
else:
print(N, 'la so le.')

31. 30
Trong đoạn lệnh trên, phép toán % là phép chia lấy dư (xem mục 2.2). Nếu
số được nhập chia lấy dư cho 2 bằng 0 (tức là nó chia hết cho 2) thì đây là
số chẵn.
Thực hành: Bạn hãy gõ lại đoạn code trên và thực thi (Shift-Enter) rồi
nhập vào các số nguyên khác nhau để xem kết quả được in ra.
Ví dụ 2.2: Nhập 2 số thực và xác định xem chúng cùng dấu hay trái dấu.
#%% Xác định cùng dấu, trái dấu
so1 = float(input('Xin nhap so thu nhat:'))
so2 = float(input('Xin nhap so thu hai:'))
if so1*so2 < 0:
print('Hai so duoc nhap trai dau.')
elif so1*so2 > 0:
print('Hai so duoc nhap trai dau.')
else:
print('Co mot so bang khong.')
Thực hành: Bạn hãy gõ lại đoạn code trên và thực thi (Shift-Enter) rồi
nhập vào các cặp số thực khác nhau để xem kết quả được in ra. Lý giải
hoạt động của chương trình dựa vào các điều kiện so1*so2 < 0 và
so1*so2 > 0.
Ví dụ 2.3: Nhập 3 số thực và tìm số lớn nhất trong 3 số này.
#%% Tìm số lớn nhất trong 3 số
so1 = float(input('Nhap so thu nhat:'))
so2 = float(input('Nhap so thu hai:'))
so3 = float(input('Nhap so thu ba:'))
so_lon_nhat = so1
if so_lon_nhat < so2:
so_lon_nhat = so2
if so_lon_nhat < so3:

32. 31
so_lon_nhat = so3
print('So lon nhat:', so_lon_nhat)
Thực hành: Bạn hãy gõ lại đoạn code trên và thực thi (Shift-Enter) rồi
nhập vào các bộ số thực khác nhau để xem kết quả được in ra. Lý giải hoạt
động của chương trình (để ý rằng đoạn code trên sử dụng 2 khối if liên tiếp
nhau).
Thực hành: Nhập đoạn mã sau và đặt tên file là if_else_demo.py. Sau đó
hãy thực thi đoạn mã và cho biết kết quả in ra màn hình.
# if-else
a = 10
b = 30
print('demo if-elif-else')
if (a > 10) or (b > 10):
# do something
print('(a > 10) or (b > 10)')
elif (a != 5) and (b <= 7):
# do something
print('(a != 5) and (b <= 7)')
else:
# do something
print('else')
# nested if
if (a == 0) or (b > 20):
if b < 50:
print('nested-if')
else:
print('else-nested-if')
else:
print('if-else')

33. 32
Bài tập có lời giải1
1. Viết chương trình đọc một ký tự từ bàn phím. Nếu ký tự được nhập
là nguyên âm gồm các điểm chữ thành điểm số như cách tính điểm
ở một số trường đại học trên thế giới. Bảng ánh xạ có thể được thể
hiện như sau
Chương trình sẽ đọc ký tự từ người sử dụng. Sau đó, chương trình
sẽ tính toán và hiển thị con số điểm tương ứng. Ngoài ra, chương
trình có thể đưa ra thông báo “yêu cầu nhập lại” trong trường hợp
người dùng nhập vào một ký tự không tồn tại trong bảng trên.
2. Viết chương trình đánh giá hiệu quả làm việc của nhân viên. Một
công ty muốn đánh giá hiệu quả làm việc của nhân viên công ty
theo mỗi năm. Thang đo hiệu quả làm việc sẽ được đánh giá từ 0.0
và giá trị càng cao thì thể hiện năng lực làm việc càng tốt của nhân
viên. Giá trị đánh giá n có thể là 0.0, 0.4 hoặc 0.6 hoặc lớn hơn.
Trong đó, các giá trị giữa 0.0 và 0.4 hoặc 0.4 và 0.6 thì không được
sử dụng. Chi tiết được thể hiện trong bảng sau. Giá trị thưởng cho
1
Các bài tập có lời giải trong giáo trình này đa số được trích từ sách Stephenson, B.
(2019). The Python Workbook 2nd
. Springer. Lời giải được trình bày trong phần Phụ lục.

34. 33
mỗi nhân viên sau khi đánh giá sẽ tương ứng với công thức
$2400*n. Hãy viết chương trình đọc vào giá trị n từ người dùng và
hãy chỉ ra rằng hiệu quả làm việc tương ứng của nhân viên có giá
trị n cho hiệu quả công việc là unacceptable, acceptable và
meritorious. Nếu giá trị n không thể hiện đúng như trong bảng thì
đưa ra thông báo “vui lòng nhập lại”.
3. Viết chương trình kiểm tra năm nhuận. Thông thường mỗi năm có
khoảng 365 ngày. Tuy nhiên, thời gian này phụ thuộc vào thời gian
Trái đất hoàn thành một vòng xoay quanh Mặt trời. Điều này dẫn
đến có thể có thêm 1 ngày là ngày 29 tháng 2. Những năm có thêm
ngày này được xem là năm nhuận. Cách tính năm nhuận sẽ được
quyết định bởi một số điều sau:
• Số năm chia hết cho 400 là năm nhuận
• Các năm còn lại:
▪ nếu chia hết cho 100 thì không là năm nhuận
▪ nếu chia hết cho 4 thì là năm nhuận
• Các trường hợp còn lại thì không là năm nhuận
Hãy viết một chương trình đọc vào số năm từ người dùng và hiển
thị thông báo chỉ ra rằng năm vừa nhập có phải là năm nhuận
không.
Bài tập thực hành
1. Viết code tính diện tích tam giác có cạnh đáy dài 10 cm và cao 6
cm.
2. Viết code cho người dùng nhập vào đường kính của 1 hình tròn tùy
ý và tính diện tích hình tròn đó.
3. Viết code kiểm tra biểu thức sau đúng không (True or False).
Kiểm tra với x = 𝜋,
𝜋
2
,
4𝜋
3
.
sin2(𝑥) + cos2(𝑥) = 1

35. 34
4. Viết code cho nhập 3 số thực a, b, c (sử dụng hàm input()), và giải
phương trình bậc hai ax2
+ bx + c = 0. In nghiệm tìm được bằng
hàm print().
5. Viết chương trình cho người dùng nhập 3 số thực rồi tìm in ra các
số có trị tuyệt đối nhỏ hơn 10.
6. Viết chương trình cho người dùng nhập 5 số thực rồi tìm max/min
của chúng.
7. Viết chương trình xác định thứ trong tuần của ngày 1 tháng 1.
Thứ trong tuần của ngày 1 tháng 1 đối với một năm được tính theo
công thức sau:
Kết quả của công thức trên là một số nguyên thể hiện thứ trong
tuần. Việc mã hóa thứ sẽ bắt đầu với ngày Chủ nhật với số mã
hóa là 0. Tương tự, ngày thứ Bảy sẽ có giá trị mã hóa là 6. Hãy
sử dụng công thức trên và viết một chương trình đọc số năm từ
người sử dụng. Chương trình sẽ tính toán và in ra thứ tương ứng
với đối ngày 1 tháng 1 của năm mà người dùng nhập.

36. 35
Chương 3
VÒNG LẶP VÀ
CẤU TRÚC DỮ LIỆU MẢNG
Trong chương trước bạn đã được giới thiệu về lệnh if giúp điều
khiển chương trình chạy rẽ nhánh vào các đoạn lệnh khác nhau theo điều
kiện. Trong chương này, bạn sẽ được tìm hiểu về vòng lặp – cấu trúc tự
động thực thi nhiều lần các đoạn lệnh theo kịch bản bạn muốn. Có hai dạng
vòng lặp được hỗ trợ trong Python là vòng lặp while và vòng lặp for.
3.1 Vòng lặp while
Cú pháp của vòng lặp while như sau:
while dieu_kien:
khoi_lenh_lap
khoi_lenh_sau_while
Luồng hoạt động của vòng lặp while được mô tả trong lưu đồ ở
Hình 3-1.
Hình 3-1 Lưu đồ hoạt động của vòng lặp while.

37. 36
Nhìn qua khối lệnh while có cú pháp giống với khối if tối giản.
Hoạt động của khối while như sau: khi dieu_kien còn đúng (True) thì
còn thực thi khoi_lenh_lap (tức là khoi_lenh_lap sẽ được chạy
nhiều lần), khi dieu_kien sai (False) thì sẽ chạy
khoi_lenh_sau_while. Để dễ hiểu hơn, chúng ta xem ví dụ sau.
Ví dụ 3.1: Viết code yêu cầu nhập số N dương. Nếu nhập sai thì cho nhập
lại đến khi đúng.
#%% Nhập số dương
N = -1
while N<=0:
N = int(input('Xin nhap so nguyen duong:'))
print('So duoc nhap N =', N)
Lưu ý: Để vòng lặp while hoạt động được cần thỏa mãn hai điểm sau:
1. Điều kiện dieu_kien phải được khởi tạo trước. Tức là mọi
biến trong dieu_kien phải được gán giá trị sẵn. Thông
thường ta sẽ khởi tạo biến sao cho dieu_kien có giá trị True
ở lần chạy đầu tiên.
2. Khối lệnh khoi_lenh_lap phải có ít nhất 1 dòng lệnh làm thay
đổi điều kiện dieu_kien. Nếu không vòng lặp sẽ chạy không bao
giờ dừng (do dieu_kien không bị thay đổi, nó sẽ đúng (True) mãi
mãi nên vòng lặp sẽ lặp mãi mãi).
Trong ví dụ ở trên, lệnh N = -1 đã khởi tạo giá trị cho biến N. Nếu không
có lệnh này thì điều kiện N<=0 chưa được khởi tạo, sẽ báo lỗi khi chạy.
Ngoài ra, để ý rằng lệnh N = int(input(…)) là câu lệnh có thể làm
thay đổi điều kiện bởi vì nó gán giá trị cho biến N. Khi giá trị của N thay
đổi thì điều kiện N<=0 có thể thay đổi (từ True thành False).
Thực hành: Bạn hãy gõ lại đoạn code trên và thực thi (Shift-Enter) rồi
nhập vào các số nguyên âm, sau đó nhập 1 số nguyên dương và xem kết
quả được in ra.

38. 37
Ví dụ 3.2: Viết code yêu cầu nhập số N dương và tính N!
#%% Tính giai thừa
N = -1
while N<=0:
N = int(input('Xin nhap so nguyen duong:'))
print('So duoc nhap N =', N)
giai_thua = 1
i = 1
while i<=N:
giai_thua *= i # = giai_thua*i
i += 1
print('N! =', giai_thua)
Nhắc lại lưu ý viết lệnh trong Python:
▪ Mỗi dòng lệnh Python được đặt trên 1 dòng. Nghĩa là bạn phải
xuống dòng (enter) khi viết xong 1 câu lệnh.
▪ Các câu lệnh trong một khối lệnh phải có thụt đầu dòng
(indentation) bằng nhau. Tức là nếu dòng lệnh 1 được thụt
đầu dòng bằng 3 khoảng trắng (space) thì dòng lệnh 2 (trong
khối đó) cũng phải như vậy. Nếu bạn thụt đầu dòng 4 khoảng
trắng, hoặc 2 khoảng trắng khi viết dòng lệnh 2 thì sẽ bị lỗi.
Đây là quy định cú pháp của Python nhằm đảm bảo chương
trình ngăn nắp, dễ đọc.
Trong ví dụ trên, các lệnh N = int(input(…)) và i = 1 giúp khởi tạo
điều kiện i<=N. Lệnh i += 1 giúp thay đổi điều kiện. Dòng lệnh
giai_thua *= i tương đương với lệnh giai_thua = giai_thua*i.
Đây là một cách viết tắt phép tính và gán trong Python, ví dụ:
a += 2, tương đương a = a + 2
b /= 3, tương đương b = b / 3
Thực hành: Bạn hãy gõ lại đoạn code trên và thực thi (Shift-Enter) rồi
nhập vào các số nguyên dương N khác nhau và xem kết quả được in ra.

39. 38
Ví dụ 3.3: Viết code yêu cầu nhập số N dương và tính tổng 1+2+…+N.
#%% Tính tổng 1+2+…+N
N = -1
while N<=0:
N = int(input('Xin nhap so nguyen duong:'))
print('So duoc nhap N =', N)
tong = 0
i = 1
while i<=N:
tong += i
i += 1
print('1+2+...+N =', tong)
Trong code trên, để ý lệnh tong = 0. Ở đây chúng ta khởi tạo giá trị cho
tổng là 0 (so với ví dụ 2 ở trên, ta khởi tạo giai thừa bằng 1 vì phép tính
nhân dồn).
Thực hành: Bạn hãy gõ lại đoạn code trên và thực thi (Shift-Enter) rồi
nhập vào các số nguyên dương N khác nhau và xem kết quả được in ra.
Ví dụ 3.4: Viết code tìm max trong 3 số thực nhập bởi người dùng. Sau khi
chạy xong thì hỏi người dùng có muốn chạy lại không. Nếu người dùng
nhấn phím ‘y’ thì chạy lại, nhấn phím khác thì dừng.
#%% Tìm max và lặp lại
chay_tiep = 'y'
while chay_tiep == 'y' or chay_tiep == 'Y':
so1 = float(input('Nhap so thu nhat'))
so2 = float(input('Nhap so thu hai'))
so3 = float(input('Nhap so thu ba'))
so_lon_nhat = so1
if so_lon_nhat<so2:
so_lon_nhat=so2
if so_lon_nhat<so3:

40. 39
so_lon_nhat=so3
print('So lon nhat: ', so_lon_nhat)
chay_tiep = input('Nhan "y" de chay lai, nhan phim
khac de thoat:')
print('Da hoan thanh.')
Trong đoạn code trên, bạn hãy để ý cách biến chay_tiep được khởi tạo
cũng như gán lại giá trị chay_tiep = input(…) để đảm bảo điều kiện
sẽ có lúc sai (False) và vòng lặp có thể dừng.
Thực hành: Bạn hãy gõ lại đoạn code trên và thực thi (Shift-Enter) rồi
nhập vào các số thực, sau đó nhập “y” hoặc “Y” để chạy lại. Nếu nhập
phím khác “y” và “Y” thì chương trình sẽ dừng.
Ví dụ 3.5: Viết code tính ln(1+x) bằng khai triển Taylor1
với |x|<1. Cho
công thức khai triển Taylor của ln(1+x) (với |x|<1) như sau:
#%% Tính ln(1+x) bằng khai triển Taylor
x = float(input('Nhap x (-1<x<1):'))
i = 1
tu_so = x
mau_so = i
so_hang = tu_so/mau_so
tong = so_hang
while abs(so_hang)>1e-10:
i += 1
tu_so *= -x
mau_so = i
so_hang = tu_so/mau_so
tong += so_hang
print('ln( 1 +',x,') =',tong)
1
https://en.wikipedia.org/wiki/Taylor_series

41. 40
Trong code trên, đoạn lệnh x = float(input(…) giả định rằng người
dùng sẽ nhập x đúng yêu cầu (|x|<1).
Để viết code trên, ta cần phân tích biểu thức của khai triển Taylor:
Để ý rằng biểu thức tổng này có các số hạng có tính chất lặp: tử số của số
hạng sau bằng tử số của số hạng trước đó nhân với -x. Còn mẫu số của các
số hạng thì tăng dần từ 1, 2, 3…
Các lệnh:
i = 1
tu_so = x
mau_so = i
so_hang = tu_so/mau_so
tong = so_hang
là các lệnh khởi tạo cho số hạng và tổng. Khi khởi tạo xong, ta có thể tính
số hạng sau bằng theo phân tích lặp ở trên.
Ngoài ra, bởi vì khai triển Taylor của ln(1+x) là một dãy hội tụ (khi
|x|<1), hay nói cách khác, các số hạng trong dãy càng về sau càng có giá
trị tuyệt đối nhỏ (tiến về 0). Vì vậy ta có thể thiết lập điều kiện dừng của
vòng lặp khi giá trị của số hạng đã trở nên rất nhỏ, ví dụ 10-10
như trong
điều kiện trên code: abs(so_hang)>1e-10.
Thực hành: Viết thêm đoạn code bắt buộc người dùng nhập x đúng yêu
cầu (|x|<1).
Bạn cũng có thể kiểm tra độ chính xác của code được viết bằng
cách tính giá trị của ln(1+x) và đối chiếu. Ví dụ đoạn code sau có thể dùng
để tính giá trị cho ln(1+x):
import math
print('ln( 1 +',x,') =',math.log(1+x))
Thực hành: Nhập đoạn mã sau và đặt tên là while_demo.py, sau đó hãy
thực thi đoạn mã và cho biết kết quả in ra màn hình.

42. 41
print('demo - iteration while')
i = 0
while i < 10:
print(i)
i += 1
3.2 Cấu trúc dữ liệu mảng
Trước khi giới thiệu vòng lặp for, chúng ta xem về một dạng cấu
trúc dữ liệu cơ bản rất phổ biến trong Python cũng như các ngôn ngữ lập
trình khác: mảng.
Nói một cách đơn giản, một biến có kiểu mảng thì có thể lưu trữ
đồng thời nhiều giá trị. Biến mà bạn được giới thiệu trong chương trước
chỉ có thể lưu 1 giá trị. Khi bạn gán giá trị mới thì giá trị cũ sẽ mất. Mảng
thì không như vậy, nó có thể chứa một lúc nhiều giá trị.
Ví dụ, bạn sẽ cần dùng mảng nếu muốn lưu danh sách tên của các
sinh viên trong 1 lớp. Nếu không dùng mảng, bạn sẽ phải tạo nhiều biến
bình thường để lưu các tên sinh viên, vì mỗi biến chỉ chứa được 1 tên. Cách
làm này vừa bất tiện vừa khó phát triển chương trình, vì khi cần thêm một
sinh viên, bạn phải thêm 1 biến nữa trong code.
Một ví dụ khác là khi bạn cần lưu giá trị nhiệt độ trả về từ một cảm
biến nhiệt mà bạn dùng để theo dõi một thiết bị nào đó (ví dụ bình đun
nước, bình giữ nhiệt). Giả sử mỗi phút cảm biến này sẽ trả về 1 nhiệt độ.
Như vậy, nếu không dùng mảng thì cứ mỗi phút nhiệt độ cũ sẽ bị mất (bị
thay thế bởi nhiệt độ mới). Để lưu lại tất cả các giá trị nhiệt độ sử dụng cho
phân tích về sau (ví dụ để vẽ biểu đồ thay đổi nhiệt độ của thiết bị) thì ta
cần lưu lại tất cả nhiệt độ này. Mảng sẽ giúp bạn lưu lại tất cả nhiệt độ này.
Trong Python, có nhiều cách khác nhau để tạo ra các biến có kiểu
mảng. Trong phần này chúng ta sẽ sử dụng list. Để tạo một list, bạn dùng
dấu ngoặc vuông để đánh dấu bắt đầu và kết thúc list như các ví dụ sau:
#%% Tạo list
list1 = [-2, 3, 5.27, -19, 10]
list2 = ['Tam', 'Thien', 'Hoa', 'Binh']
list3 = ['Tam', 10, 'Thien', 7.3, 'Hoa', 8, 'Binh', 9.2]

43. 42
Có thể thấy mảng tạo bằng cú pháp list chứa được các phần tử có
kiểu dữ liệu khác nhau (số nguyên, số thực, chữ). Các phần tử trong list
được ngăn cách bởi dấu phẩy. Phần tử kiểu chữ phải được đặt trong dấu
nháy đơn ' hoặc nháy kép ''.
Bạn cũng có thể tạo list bằng cách ghép 2 list đã có với nhau:
list4 = list1 + list2
Để xem nội dung của list bạn có thể dùng lệnh print():
print(list4)
Để truy xuất các phần tử trong list, ta cần biết các phần tử của list
đều được đánh số, gọi là index. Có 2 dạng indexing trong list: index không
âm và index âm. Ví dụ, xét
list1 = [-2, 3, 5.27, -19, 10]
Các phần tử trong list này có index như sau:
Phần tử -2 3 5.27 -19 10
Index không âm 0 1 2 3 4
Index âm -5 -4 -3 -2 -1
Index không âm là các số nguyên không âm được đánh từ trái sang phải
(phần tử đầu tiên của list có index 0). Index âm là các số nguyên âm được
đánh từ phải sang trái (phần tử cuối cùng của list có index -1).
Để truy xuất phần tử trong list, ta dùng cú pháp sau:
ten_list[index]
ví dụ, để truy xuất phần tử 5.27 trong list1 ta dùng code sau:
list1[2]
hoặc
list1[-3]
Bạn có thể kết hợp với lệnh print để xem giá trị truy xuất được:
print(list1[2])
Ngoài ra, Python còn hỗ trợ truy xuất nhiều phần tử một lúc sử
dụng cú pháp sau (thường được gọi là cú pháp slicing):
ten_list[start_index : stop_index : step]

44. 43
Trong đó start_index và stop_index là index phần tử đầu và index
phần tử cuối bạn muốn truy xuất, còn step là bước nhảy của index khi
chạy từ start_index đến stop_index. Các giá trị cho start_index,
stop_index, và step đều phải là số nguyên.
Lưu ý: Truy xuất slicing stop_index không bao gồm phần tử tại
stop_index. Do đó, để lấy được phần tử có index i ta cần phải dùng stop
index bằng i+1.
Ví dụ 3.6: Để lấy 3 phần tử đầu tiên của list1 ta dùng code sau:
list1[0:3:1]
hoặc dùng index âm:
list1[-5:-2:1]
Để lấy 3 phần tử cuối cùng của list1:
list1[2:5:1]
Trường hợp này nếu dùng index âm bạn sẽ không thể thu được kết
quả như mong muốn: list1[-3:0:1]. Lý do là index 0 là phần tử đầu
tiên của mảng, trong khi với step bằng 1 thì phép slicing sẽ lấy các phần
tử với index tăng dần, tức là lấy các phần tử theo chiều từ trái sang phải.
Quan sát list1 chúng ta có thể thấy không có cách nào đi từ trái sang
phải xuất phát từ phần tử có index -3 mà đến được phần tử có index 0.
Đối với trường hợp này, ta cần sử dụng giá trị mặc định của
start_index, stop_index, và step. Giá trị mặc định của các thành
phần sẽ được trình biên dịch Python sử dụng khi bạn để khuyết các thành
phần này trong lệnh slicing (xem ví dụ bên dưới).
▪ Giá trị mặc định của start_index là: 0
▪ Giá trị mặc định của stop_index sẽ lấy hết các phần tử đến cuối
mảng (nếu step có giá trị dương), hoặc lấy hết các phần tử đến đầu
mảng (nếu step có giá trị âm).
▪ Giá trị mặc định của step là: 1
Ví dụ, để lấy 3 phần tử cuối cùng của list1 ta có thể dùng slicing
với index âm như sau:
list1[-3::1]
do stop_index bị khuyết nên trình dịch Python sẽ lấy đến hết mảng theo
giá trị mặc định (để ý step bằng 1 là số dương). Ngoài ra, ta cũng có thể

45. 44
bỏ step bằng 1 vì đây là giá trị mặc định. Code sau đây cho kết quả giống
với lệnh trên:
list1[-3:]
Tương tự, bạn có thể dùng code sau để lấy 3 phần tử đầu tiên của mảng:
list1[:3]
code trên bỏ qua start_index và step
Bên cạnh việc truy xuất các phần tử của list, Python cung cấp các
hàm sau để thao tác với list:
▪ Hàm append(): thêm phần tử vào cuối mảng. Ví dụ, để thêm phần
tử 48 vào list1 ta dùng code: list1.append(48).
▪ Hàm insert(): chèn phần tử vào mảng. Hàm này yêu cầu 2 tham số
(arguments) là vị trí chèn (index chèn) và giá trị chèn. Ví dụ, để
thêm phần tử 90 vào list1 ở vị trí có index 2 ta dùng code:
list1.insert(2, 90).
▪ Lệnh del: xóa phần tử hoặc xóa mảng. Ví dụ, để xóa phần tử ở vị
trí có index 5 ta dùng code: del list1[5]. Để xóa toàn bộ list1:
del list1.
Thực hành: Sử dụng các hàm trên với các list của bạn và in ra kết quả sau
khi thực thi. Tìm hiểu thêm hàm pop() với công dụng tương tự lệnh del.
Lưu ý: Trong Python còn cung cấp một dạng mảng tương tự như
list có tên là tuple. List và tuple có công năng và cách sử dụng giống nhau,
ngoại trừ việc tuple là một mảng hằng số, có nghĩa là khi tạo ra tuple, bạn
không thể thay đổi các phần tử của nó. Để tạo tuple ta dùng cú pháp sử
dụng dấu ngoặc đơn (thay cho ngoặc vuông của list):
tuple1 = (5, 3.14, -6, 7)
Thực hành: Nhập đoạn mã sau và đặt tên là list_demo.py Sau đó hãy thực
thi đoạn mã và cho biết kết quả in ra màn hình.
# declare lists
print('----declare lists')
numbers = []
a = [2, 7, 10, 8]
cities = ['Berlin', 'Seattle', 'Tokyo', 'Moscow']

46. 45
b = [10, 3, 'Apple', 6, 'Strawberry']
c = range(1, 10, 2)
# print(lists
print('----print(lists')
print(a)
for city in cities:
print(city)
print(b)
print(c)
# get length of lists
print('----get length of lists')
print(len(a))
print(len(cities))
# add item into list
print('----add item')
numbers.append(10)
numbers.append(5)
cities.append('London')
for i in numbers:
print(i)
for city in cities:
print(city)
# get specific item
print('----get item')
print(cities[2])
print(a[3])

47. 46
# sorting
print(a.sort())
# edit item
print('----edit item')
cities[2] = 'new city'
for city in cities:
print(city)
# remove item
print('----remove item')
a.remove(8) # by value
del cities[2] # by index
for city in cities:
print(city)
3.3 Vòng lặp for
Tương tự như vòng lặp while, vòng lặp for cũng có công dụng thực
thi lặp lại nhiều lần một khối lệnh. Tuy nhiên, trong Python, vòng lặp for
được thiết kế chủ yếu để làm việc với mảng hoặc các cấu trúc tương tự
mảng. Do đó, có thể nói vòng lặp while là vòng lặp đa dụng (mọi tác vụ
lặp đều có thể dùng vòng lặp này), còn vòng lặp for mang tính chuyên
dụng cho mảng.
Cú pháp của vòng lặp for:
for bien_chay in mang:
khoi_lenh_lap
khoi_lap_sau_for
Luồng hoạt động của vòng lặp for được mô tả trong lưu đồ ở Hình 3-2.
Trong cú pháp trên, for và in là các từ khóa, bien_chay là một biến
chứa các phần tử trong biến mang. Khi vòng lặp được thực thi, bien_chay

48. 47
sẽ lần lượt chứa các phần tử trong mang. Ví dụ, nếu mang là một list có
các phần tử [2, 4, -6, 50] thì khối lệnh lặp sẽ được chạy 4 lần, mỗi lần chạy
thì bien_chay sẽ lần lượt có các giá trị 2, 4, -6 và 50. Sau khi chạy lặp 4
lần thì khoi_lap_sau_for sẽ được thực thi.
Hình 3-2 Lưu đồ hoạt động của vòng lặp for.
Ví dụ 3.7: Cho một list chứa các nhiệt độ tại nhiều thời điểm của một thiết
bị. Viết code để truy xuất các nhiệt độ âm chứa trong mảng.
#%% Xuất nhiệt độ âm
list_nhiet_do = [-2, -5, -8, 3, -1, 6, 0]
list_am = []
for phan_tu in list_nhiet_do:
if phan_tu<0:
list_am.append(phan_tu)
print(list_am)

49. 48
Trong code trên, chúng ta khởi tạo list_am bằng một list rỗng (không
chứa phần tử nào). Khi chạy vòng lặp, các phần tử thỏa điều kiện (giá trị
âm) sẽ lần lược được thêm (append) vào list_am.
Thực hành: Thay đổi code trên để truy xuất các nhiệt độ nằm trong khoảng
từ 0 đến 10 độ.
Ví dụ 3.8: Cho một list chứa các nhiệt độ tại nhiều thời điểm của một thiết
bị. Viết code để xác định index của các nhiệt độ âm trong mảng.
#%% In index các phần tử âm
print('Indices cac phan tu am:')
for i in range(len(list_nhiet_do)):
if list_nhiet_do[i]<0:
print(i)
Để ý trong code trên chúng ta sử dụng hàm
range(len(list_nhiet_do)). Hàm này có công dụng tạo ra một
mảng chứa các index của list_nhiet_do, tức là list
[0,1,2,3,4,5,6] (vì list_nhiet_do có 7 phần tử). Khi thực thi,
biến i sẽ lần lượt chứa các phần tử của list index, tức là trong mỗi lần lặp,
biến i sẽ là index của một phần tử trong list_nhiet_do (lần lượt từ
trái sang phải).
Thực hành: Thay đổi code để lưu các phần tử âm vào một mảng (tương
tự ví dụ bên trên) và lưu index của các phần tử âm vào một mảng khác.
Thực hành: Nhập đoạn mã sau và đặt tên là for_demo.py. Sau đó hãy
thực thi đoạn mã và cho biết kết quả in ra màn hình.
# iteration - for
print('demo - iteration for')
for i in range(1, 5):
print(i)
# nested - for
print('demo - nested for')

50. 49
for i in range(1, 3):
for j in range(5, 10):
print(str(i) + '-' + str(j))
3.4 Break, continue và pass
Từ khóa break có thể được sử dụng để dừng đoạn mã hoặc thoát
ra khỏi vòng lặp đang chứa break.
Ngược lại, từ khóa continue có thể được sử dụng để bỏ qua một
số phần mã phía sau continue để tiếp tục thực hiện vòng lặp mới.
Còn từ khóa pass đơn giản là một câu lệnh giả (câu lệnh không
làm gì cả). Pass có thể được dùng tại những vị trí mà cú pháp yêu cầu
phải có câu lệnh nhưng chương trình của chúng ta không có lệnh nào cần
làm ở đó.
Để minh họa, giả sử có đoạn mã sau, bằng cách sử dụng lệnh break
vòng lặp sẽ dừng khi giá trị value=7. Một trường hợp khác, vòng lặp có
thể tiếp tục thực hiện vòng lặp mới và có thể bỏ qua một số thành phần
trong thân vòng lặp khi sử dụng lệnh continue.
Thực hành: Nhập đoạn mã sau và đặt tên là break_continue_demo.py.
Sau đó hãy thực thi đoạn mã và cho biết kết quả in ra màn hình.
print('demo - break, continue and pass')
for i in range(1, 10):
if i == 4:
continue
if i == 7:
break
print(i)
pass # do nothing
print('This is the end of program')

51. 50
Bài tập có lời giải
1. Viết chương trình tính chu vi của một đa giác. Chương trình sẽ đọc
các tọa độ x, y của các điểm trong một đa giác. Các tọa độ được
đọc liên tục cho đến khi người sử dụng nhập khoảng trắng ( ) đối
với tọa độ x. Mỗi khi đọc 1 tọa độ mới, chương trình sẽ tính toán
khoảng cách của điểm mới nhập so với điểm trước đó. Khi nhập
khoảng trắng vào trong tọa độ x thì chương trình sẽ thêm khoảng
cách từ điểm cuối đến điểm đầu để tính chu vi. Khi tính toán và
hiển thị chu vi thì các tọa độ của mỗi điểm đã nhập cũng được hiển
thị trên màn hình. Ví dụ có dạng như sau
2. Parity bit là một cơ chế đơn giản để phát hiện các lỗi trong việc
truyền dữ liệu thông qua một đường truyền không đáng tin cậy như
đường dây điện thoại. Ý tưởng rất đơn giản đó là một bit sẽ được
thêm vào và truyền đi sau mỗi một nhóm 8-bit dữ liệu. Vì thế một
bit lỗi trên đường truyền có thể được phát hiện dễ dàng. Bit parity
có thể được tính toán cho cả trường hợp parity là chẵn hoặc lẻ. Nếu
là parity chẵn thì tổng số bit 1 được truyền, gồm 8 bit dữ liệu và 1
bit parity phải là số chẵn. Ngược lại, khi chọn bit parity lẻ thì tổng
số bit 1 truyền đi sẽ là lẻ.
Viết chương trình tính bit parity của một nhóm 8 bit nhị phân được
nhập bởi người dùng sử dụng parity chẵn. Chương trình sẽ đọc
chuỗi nhị phân gồm 8 bit cho đến khi nhập khoảng trắng. Sau mỗi
chuỗi được nhập vào bởi người dùng, chương trình cần hiển thị một
thông điệp chỉ ra rằng người dùng muốn tính parity chẵn hay lẻ.
Một thông điệp cảnh báo sẽ được hiển thị nếu người dùng nhập
một chuỗi nhị phân có hơn 8 bit.
3. Viết chương trình thực hiện chuyển đổi số thập phân thành nhị
phân. Với số nguyên thập phân do người dùng nhập vào từ bàn

52. 51
phím hãy sử dụng pháp chia được minh họa sau đây để thực hiện
việc chuyển đổi. Khi chương trình chuyển đổi được hoàn tất, kết
quả in ra màn hình sẽ chứa một chuỗi các bit nhị phân tương ứng
với số thập phân mà người dùng nhập.
Ban đầu cho chuỗi rỗng result
Cho q là thể hiện của số cần chuyển đổi
Repeat
Cho r bằng với phần dư của phép chia q với 2
Chuyển r thành chuối và cộng r với phần bắt đầu của result
Thực hiện chia q với 2, loại bỏ phần dư, và lưu phần nguyên của
phép chia vào chính q
Until q bằng 0
Bài tập thực hành
1. Sử dụng vòng lặp while tính các tổng sau, với n là một số nguyên
dương nhập bởi người dùng:
𝑆(𝑛) = 1 +
1
1 + 2
+
1
1 + 2 + 3
+ ⋯ +
1
1 + 2 + ⋯ + 𝑛
𝑆(𝑛) =
1
1 × 2
+
1
2 × 3
+ ⋯ +
1
𝑛 × (𝑛 + 1)
𝑆(𝑛) =
1
2
+
2
3
+
3
4
+ ⋯ +
𝑛
𝑛 + 1
𝑆(𝑛) =
1
2
+
3
4
+
5
6
… +
2𝑛 + 1
2𝑛 + 2
2. Cho người dùng nhập số nguyên dương N. Nếu nhập sai thì cho
nhập lại đến khi đúng. Sau đó cho người dùng nhập N số nguyên
và in ra số lẻ lớn nhất trong những số được nhập. Cuối cùng, hỏi
người dùng có muốn tiếp tục không, nếu người dùng nhấn ‘c’ thì
tiếp tục, nhấn phím khác thì thoát chương trình.
3. In ra tất cả ước số của một số nguyên N nhập bởi người dùng.
4. Tính tổng các chữ số của số nguyên dương N nhập bởi người
dùng. Ví dụ: số N = 205 có tổng các chữ số là 2+0+5 = 8.
Gợi ý: với N = 257, ta có
257 % 10 = 7
int(257/10) = 25

53. 52
5. Dùng vòng lặp for tính các tổng sau, với n nguyên dương nhập
bởi người dùng.
𝑆(𝑛) =
1
1 × 2
+
1
2 × 3
+ ⋯ +
1
𝑛 × (𝑛 + 1)
𝑆(𝑛) =
1
2
+
3
4
+
5
6
… +
2𝑛 + 1
2𝑛 + 2
6. Tạo một list có độ dài tùy ý chứa các phần tử tùy ý. Dùng vòng lặp
for tìm phần tử chia hết cho 5 lớn nhất trong list.
7. Tạo một list có độ dài tùy ý chứa các phần tử tùy ý. Dùng vòng lặp
for xóa các phần tử lớn hơn A trong list, với A là một số thực nhập
bởi người dùng.
Gợi ý: Có thể tạo list mới chứa phần tử không bị xóa. Nếu muốn
xóa bằng lệnh del thì cần dùng vòng lặp while.
8. Tạo một list có độ dài tùy ý chứa các phần tử đã sắp tăng dần.
Dùng vòng lặp for chèn một số B vào list sao cho list vẫn tăng dần,
với B là một số thực nhập bởi người dùng.
Gợi ý: dùng vòng lặp tìm ra vị trí (index) thích hợp cần chèn, sau
đó dùng hàm insert() để chèn B vào list. Có thể tìm hiểu từ khóa
break trong vòng lặp để sử dụng.
9. Tìm N số nguyên tố đầu tiên và lưu vào 1 list. N là một số nguyên
dương nhập bởi người dùng.
Yêu cầu: dùng vòng lặp for kết hợp với vòng lặp while.
10. Viết chương trình tính căn bậc hai của một số x. Sử dụng phương
pháp Newton để tính toán và hiển thị căn bậc hai của một số x được
nhập bởi người dùng. Thuật toán Newton như sau:
Đọc số x từ bàn phím
Khởi tạo guess bằng x/2
While guess không thỏa điều kiện do
Cập nhật giá trị guess bằng với trung bình của guess và x/guess.
Khi thuật toán chạy hoàn chỉnh thì guess chứa một giá trị xấp xỉ
với căn bậc hai của x, giá trị của phép xấp xỉ sẽ phụ thuộc vào điều
kiện thỏa mãn mà người dùng đặt. Trong bài tập này thì guess được
xem là thỏa mãn khi giá trị tuyệt đối của guess*guess so với x nhỏ
hơn hoặc bằng 10-12
.

54. 53
11. Viết chương trình thực hiện chuyển đổi một số nhị phân (binary)
sang hệ thập phân (decimal). Chương trình sẽ đọc một chuỗi các số
nhị phân. Sau đó, chương trình sẽ tính toán một số hệ thập phân
tương đương. Cuối cùng, chương trình sẽ hiển thị số thập phân
tương ứng lên màn hình.

55. 54
Chương 4
NUMPY
Trong chương trước chúng ta đã tìm hiểu về list – một cấu trúc dữ
liệu cho phép lưu trữ mảng. List đơn giản và có đầy đủ chức năng cơ bản
của mảng. Tuy nhiên, khi chứa mảng số với nhiều phần tử, list có tốc độ
thực thi và hỗ trợ tính toán không bằng numpy arrays – một cấu trúc dữ
liệu dạng mảng của thư viện numpy.
4.1 Giới thiệu về Numpy1
NumPy (phát âm là /ˈnʌmpaɪ/) là một thư viện cho Python, hỗ trợ
làm việc với các mảng lớn, nhiều chiều, và cung cấp các hàm toán học cấp
cao hoạt động trên các mảng này. Phiên bản “tổ tiên” của NumPy:
Numeric, được tạo bởi Jim Hugunin và có sự đóng góp của một số nhà
phát triển khác. Năm 2005, Travis Oliphant tạo ra NumPy bằng cách kết
hợp các tính năng của Numarray vào Numeric với nhiều sửa đổi sâu rộng.
Hiện nay, NumPy là phần mềm mã nguồn mở và có nhiều người đóng góp
phát triển. NumPy là một dự án được tài trợ về mặt tài chính bởi
NumFOCUS.
4.2 Cài đặt thư viện numpy
Một trong những thế mạnh nổi trội của Python là hệ thống thư viện
(packages) mở đồ sộ của nó. Nếu biết cách sử dụng packages, việc lập
trình với Python sẽ trở nên dễ dàng hơn rất nhiều, vì các packages đã cài
đặt sẵn rất nhiều chức năng phục vụ đủ loại tác vụ mà chúng ta có thể làm
với máy tính.
Để sử dụng một package, trước tiên cần cài đặt nó. Đa số các thư
viện trong Python có thể cài đặt đơn giản như sau:
1
Nguồn: https://en.wikipedia.org/wiki/NumPy

56. 55
1. Mở command prompt với quyền admin (nếu sử dụng hệ điều hành
Windows) hoặc terminal (nếu sử dụng Linux, MacOS).
2. Chạy lệnh:
pip install package_name
Trong đó package_name là tên của package bạn muốn cài đặt.
Ví dụ, để cài đặt numpy:
pip install numpy
Lưu ý: Lệnh này yêu cầu kết nối internet để tải thư viện về máy.
Để xem danh sách các thư viện đã được cài đặt trên máy tính, trong
cửa sổ command prompt hoặc terminal, bạn dùng lệnh: pip list.
Sau khi cài đặt thư viện xong, cần khai báo thư viện trước khi sử
dụng. Cú pháp như sau:
import ten_package as ten_viet_tat
Trong đó ten_package là tên thư viện cần dùng, còn ten_viet_tat là
một tên tùy ý được đặt để gọi thư viện cho tiện. Ví dụ:
import numpy as np
import matplotlib as mpl
Lưu ý: Cần phải cài đặt thư viện trước khi sử dụng, nếu không khi
chạy lệnh import sẽ báo lỗi không tìm thấy thư viện.
4.3 Numpy arrays
Numpy là một package chuyên hỗ trợ các tác vụ số học. Numpy
arrays là cấu trúc hỗ trợ mảng của thư viện numpy. Nó có nhiều tính năng
giống với list, như index, truy xuất phần tử, slicing. Trong phần này, chúng
ta sẽ nói về những điểm khác biệt của numpy arrays và lists.
Để tạo một numpy array ta dùng cú pháp sau:
ten_array = np.array(list)
Trong đó, list là tên một list hoặc một list tường minh. Xem ví dụ sau:
array1 = np.array([1, 4, 3, -6, 2, 4])
Lệnh trên tạo tra một numpy array có tên là array1 với các phần tử 1, 4,
3, -6, 2, 4.
Ví dụ khác:
list1 = [1, 4, 3, -6, 2, 4]

57. 56
array2 = np.array(list1)
Code trên tạo tra một numpy array có tên là array2 với các phần tử của
list list1.
Lưu ý: Khác với list, numpy array các phần tử của numpy array chỉ
có 1 kiểu dữ liệu duy nhất. Ví dụ nếu trong array có các phần tử là kiểu số
nguyên và số thực thì tất cả các phần tử sẽ được tự động chuyển đổi thành
kiểu số thực. Điều này giúp các phép tính toán trên numpy array nhanh
hơn list vì dữ liệu có kiểu đồng nhất. Bạn cũng không cần quan tâm về
việc chuyển đổi kiểu dữ liệu, vì nó được numpy thực hiện một cách tự
động. Chúng ta chỉ cần biết sử dụng numpy array sẽ có tốc độ tính toán cải
hiện so với list đối với dữ liệu số và kích thước mảng lớn.
Việc truy xuất phần tử trong numpy array giống với list, tức là bạn
có thể dùng index không âm, index âm, slicing, ví dụ:
array1[2]
array1[-1]
array1[:3]
Để thêm, xóa các phần tử vào numpy array, ta dùng các hàm sau:
▪ append(): thêm phần tử vào cuối mảng. Cách gọi hàm này hơi
khác với append() trong list đôi chút.
Ví dụ: array1 = np.append(array1, 48)
(đối với list (xem mục 3.2) thì hàm append() được gọi đơn giản
hơn: list1.append(48))
▪ insert(): chèn phần tử.
Ví dụ: array1 = np. insert(array1, 2, 90)
(code đối với list: list1.insert(2, 90))
▪ delete(): xóa phần tử.
Ví dụ: array1 = np. delete(array1, 5)
(code đối với list: del list1[5])
Thư viện numpy cũng hỗ trợ các phép toán tương tự thư viện math,
nhưng phong phú và tốc độ thực thi nhanh hơn. Một số hàm tính toán của
numpy bao gồm1
:
1
Xem danh sách đầy đủ tại https://numpy.org/doc/stable/reference/routines.math.html

58. 57
▪ Các hàm tính toán: np.sqrt(), np.exp(), np.log(), np.cos(), …
▪ Các hàm làm tròn: np.round(), np.floor(), np.ceil(), …
▪ Các hàm tạo số ngẫu nhiên: np.random.randint(), np.random.rand()
Ngoài ra, numpy còn có các hàm hỗ trợ tạo mảng với các phần tử cách đều,
như np.arange(), np.linspace(). Ví dụ, code sau tạo ra một numpy array
chứa các số nguyên từ 2 đến 9:
np.arange(2,10,1)
Trong đó, tham số đầu tiên (số 2) là giá trị phần tử đầu tiên cần tạo, tham
số kế tiếp (số 10) là giá trị stop (phần tử cuối cùng được tạo luôn luôn nhỏ
hơn giá trị stop này), tham số cuối cùng (số 1) là bước nhảy.
Một ví dụ khác: để tạo ra một numpy array chứa các số lẻ từ 3 đến 15 ta
dùng code sau:
np.arange(3,16,2)
Để ý rằng step là 2, khi đó hàm arange sẽ tạo các số cách nhau 2 giá trị.
Hàm linspace() cũng có công dụng tương tự hàm arange() (tạo
mảng với các phần tử cách đều), tuy nhiên thay vì chỉ định bước nhảy, ta
chỉ định số lượng phần tử cần tạo. Ví dụ, lệnh sau sẽ tạo ra mảng bao gồm
4 phần tử cách đều nhau có giá trị từ 1 đến 20: [1, 5.75, 10.5, 15.25, 20]
np.linspace(1,20,5)
Ưu điểm của numpy array so với list là bên cạnh tốc độ thực thi nhanh,
numpy array còn hỗ trợ phép toán trên từng phần tử (element-wise
operations). Dạng phép toán không chỉ tăng tốc độ thực thi trên mảng kích
thước lớn mà còn cho phép viết code rất gọn gàng. Xem ví dụ sau.
Ví dụ 4.1: Cho mảng chứa cân nặng và mảng chứa chiều cao của một số
sinh viên. Hãy tính Body mass index (BMI) của các sinh viên này.
# Cách 1: sử dụng list
list_can_nang = [50, 62, 71, 55, 80]
list_chieu_cao = [1.65, 1.67, 1.8, 1.53, 1.7]
list_BMI = []
for i in range(0, len(list_can_nang)):
bmi = list_can_nang[i]/list_chieu_cao[i]**2
list_BMI.append(round(bmi,2))

59. 58
print(list_BMI)
# Cách 2: sử dụng numpy array
arr_can_nang = np.array([50, 62, 71, 55, 80])
arr_chieu_cao = np.array([1.65, 1.67, 1.8, 1.53, 1.7])
arr_BMI = arr_can_nang/arr_chieu_cao**2
print(arr_BMI.round(2))
Có thể thấy code với numpy array ngắn gọn và trực quan hơn nhiều vì bạn
có thể viết code tính toán sử dụng trực tiếp tên mảng (không cần viết rõ
từng phần tử mảng). Ngoài ra, việc loại bỏ được vòng lặp giúp code thực
thi nhanh hơn.
Lưu ý: Để có thể sử dụng các pháp toán trên từng phần tử thì các
numpy array phải có kích thước giống nhau.

60. 59
Bài tập thực hành
1. Tạo numpy array chứa các số lẻ từ 1 đến N, với N là số nguyên
dương nhập bởi người dùng.
Gợi ý: dùng hàm numpy.arange() (tương tự hàm range() của
Python. Sinh viên có thể dùng cú pháp ? hoặc google để biết thêm
thông tin về hàm).
2. Tạo numpy array chứa 20 số thực cách đều nhau thuộc khoảng
(a, b) với a, b nhập bởi người dùng.
Gợi ý: dùng hàm numpy.linspace() (có thể google cách dùng).
3. Tạo numpy array chứa 10 số thực ngẫu nhiên trong khoảng (a, b)
với a, b nhập bởi người dùng.
Gợi ý: dùng random.rand() (tạo số thực ngẫu nhiên trong [0,1)) và
cộng/trừ/nhân/chia với a, b để ra khoảng mong muốn.
4. Cho số lượng hàng hóa bán ra trong tuần của một cửa hàng được
lưu trong một mảng 2D có shape (2, 7), với mỗi dòng tương ứng
với buổi (sáng, chiều), và mỗi cột tương ứng với ngày trong tuần.
Sinh viên tự cho giá trị các phần tử (có thể dùng random.randint()).
Hãy viết chương trình cho biết:
a. Ngày bán được nhiều nhất tuần (theo tổng số hàng của cả 2
buổi). Gợi ý: dùng for trên cột.
b. Thời điểm bán được nhiều nhất (buổi nào, ngày nào). Gợi ý:
dùng for lồng nhau.
c. Buổi nào có khuynh hướng bán được nhiều hàng hơn. Ví dụ:
buổi sáng bán nhiều hơn buổi chiều trong 4 ngày thì kết luận buổi
sáng. Còn nếu buổi sáng bán nhiều buổi chiều trong 3 ngày, 1 ngày
bán bằng nhau, thì kết luận cả 2 buổi như nhau. Gợi ý: dùng for
lồng nhau.

61. 60
Chương 5
SETS VÀ DICTIONARIES
Trong các chương trước, chúng ta đã được giới thiệu về cấu trúc
mảng (cài đặt bằng lists hoặc numpy arrays). Trong chương này, chúng ta
tìm hiểu về 2 cấu khác: sets (tập hợp) và dictionaries (cấu trúc dạng từ
điển). Các cấu trúc này cho phép tổ chức dữ liệu khác biệt hơn so với mảng.
Sets thì các phần tử không có thứ tự, không có index. Còn dictionaries thì
cho phép thiết lập index không phải số nguyên.
5.1 Sets
Cấu trúc dữ liệu sets (tập hợp) có thể chứa nhiều phần tử tương tự
như mảng. Nhưng khác với mảng, các phần tử của sets không có thứ tự
(tức là không thể đánh index). Cấu trúc này có thể coi là cài đặt của khái
niệm tập hợp trong toán học.
Để tạo ra một set, ta dùng cú pháp với dấu ngoặc nhọn như các ví
dụ sau:
set_1 = {3,3,2,2,4,5,6,2}
set_ho_ten = {'Tam', 'An', 'Hoa', 'Binh'}
set_diem = {'Tam', 10, 'An', 8, 'Hoa', 9.1, 'Binh',
5.4}
Tập hợp có 2 đặc tính: các phần tử không có thứ tự và không trùng lặp.
Thứ nhất, tập hợp không có thứ tự, vì vậy các phần tử không thể được đánh
index. Nói cách khác, bạn không thể truy xuất các phần tử trong tập hợp
bằng index như mảng.
Thực hành: Truy xuất phần tử trong set sử dụng index, ví dụ set_1[2].
Để lấy một phần tử ra khỏi tập hợp, ta làm cách gián tiếp như sau:
1. Kiểm tra xem phần tử có trong set không sử dụng từ khóa in.
2. Nếu có phần tử, thì dùng hàm remove() để xóa phần tử ra khỏi
set.

62. 61
Code sau đây thực hiện 2 bước vừa mô tả:
phan_tu = 3
if phan_tu in set_1:
print('set_1 co chua phan tu',phan_tu)
set_1.remove(phan_tu)
else:
print(('set_1 khong chua phan tu',phan_tu))
Thực hành: Gọi hàm remove() với một phần tử không có trong set_1.
Thử in set_1 sau khi đã gọi hàm remove().
Đặc tính thứ hai của tập hợp là các phần tử không trùng lặp. Điều
này có nghĩa là nếu bạn đưa vào mảng nhiều phần tử giống nhau thì chỉ có
duy nhất một phần tử trong đó được giữ lại. Xem ví dụ sau:
set_1 = {3,3,2,2,4,5,6,2}
print(set_1)
Kết quả in ra của lệnh print(set_1) như sau: {2, 3, 4, 5, 6}.
Tức là chỉ có 1 phần tử 3, 1 phần tử 2 được giữ lại trong set_1.
Chúng ta có thể sử dụng đặc tính này của tập hợp để lọc lại các
phần tử khác nhau của một tập nào đó như các ví dụ sau.
Ví dụ 5.1: Cho một đoạn văn bản. Hãy xác định các chữ cái có trong đó.
text = "Mississippi river"
print(set(text))
Khi chạy đoạn code trên, bạn sẽ thấy các chữ cái cấu thành đoạn text bao
gồm: 'p', 'i', 'M', 'e', 's', 'v', ' ', 'r'. Để ý rằng
khoảng trắng cũng là một phần tử của tập hợp kết quả, ta có thể loại bỏ
nó ra bằng cách xử lý chuỗi (xem chương sau).
Ví dụ 5.2: Cho một danh sách người thực hiện một công việc nào đó. Danh
sách này lưu dưới dạng mảng: mỗi phần tử của mảng là tên của người thực
hiện trong một ngày (mỗi ngày có 1 người thực hiện). Hãy xác định số
người đã tham gia vào công việc này.

63. 62
nhat_ky_cong_viec = ['Tam', 'An', 'Tam', 'Hoa', 'An',
'Binh', 'Tam', 'An', 'Tam']
nguoi_tham_gia = set(nhat_ky_cong_viec)
print('So luong nguoi tham gia:',len(nguoi_tham_gia))
Thực hành: Hãy xác định danh sách người tham gia trong 4 ngày đầu và
3 ngày cuối. Gợi ý: dùng slicing trên mảng danh sách người thực hiện.
Để thao tác với tập hợp, ta có thể dùng các hàm sau:
▪ add(): thêm một phần tử vào tập hợp. Ví dụ, set_1.add(9)
▪ union(): tìm hợp 2 tập hợp. Ví dụ,
nhom1 = {'Tam', 'An'}
nhom2 = {'Hoa', 'Binh', 'Tam'}
danh_sach_tong_hop = nhom1.union(nhom2)
print(danh_sach_tong_hop)
▪ intersection(): tìm giao của 2 tập hợp. Ví dụ,
ds_tham_gia_ca_2_nhom =
nhom1.intersection(nhom2)
print(ds_tham_gia_ca_2_nhom)
Thực hành: Sử dụng các hàm này trên tập hợp tùy ý và in kết quả sau khi
thực hiện. Tìm hiểu (google) và sử dụng hàm issubset() cũng như các hàm
khác của tập hợp.
5.2 Dictionaries
Dictionaries (cấu trúc dữ liệu dạng từ điển) là cấu trúc cho phép
chứa nhiều phần tử tương tự như mảng. Điểm khác biệt của dictionaries là
cho phép tạo index tùy ý. Đối với mảng, index luôn là số nguyên (số
nguyên âm hoặc không âm). Đối với dictionaries, bạn có thể tạo index
bằng số hoặc bằng chữ đều được, miễn là chúng phải khác biệt nhau cho
các phần tử (xem các ví dụ bên dưới).
Để tạo một dictionary ta dùng cú pháp với dấu ngoặc nhọn:
ten_dictinary = {index1: giatri1, index2: giatri2,
index3: giatri3}
Mỗi phần tử trong một dictionary là một bộ gồm hai phần: index
và giá trị, ngăn cách nhau bởi dấu hai chấm. Trong cú pháp trên chúng ta

64. 63
tạo ra một dictionary có ba phần tử. Trong thực tế, số lượng phần tử là tùy
ý.
Ví dụ 5.3: Tạo một dictionary chứa tên các dụng cụ và số lượng tồn kho
của chúng.
#%% Tạo dictionary
kho_dung_cu = {'Vit': 3, 'May khoan': 2, 'Kem': 4,
'Bua': 1, 'May khoan': 1}
# Truy xuất phần tử:
print(kho_dung_cu['Kem'])
# Thay đổi giá trị phần tử:
kho_dung_cu['Kem'] = 3
# Thêm phần tử:
kho_dung_cu['Thang'] = 1
kho_dung_cu['Keo'] = 3
Trong ví dụ trên, biến kho_dung_cu là một dictionaries chứa 5 phần tử
tương ứng với tên dụng cụ (index) và số lượng của chúng (giá trị), ví dụ:
Vít có 3 cái, Máy khoan có 2 cái.
Để truy xuất một phần tử trong một dictionary chúng ta đặt index
trong dấu ngoặc vuông tương tự như với mảng, chỉ khác mảng ở chỗ index
của dictionary không nhất thiết là số nguyên. Ví dụ để truy xuất giá trị của
phần tử 'Kem' chúng ta dùng code: kho_dung_cu['Kem']. Để chỉnh
sửa giá trị cho phần tử, chúng ta đơn giản dừng phép gán sau khi truy xuất
phần tử, ví dụ lệnh sau đây sẽ thay đổi giá trị của phần tử 'Kem' thành
3: kho_dung_cu['Kem'] = 3.
Để thêm phần tử vào một dictionary, bạn viết code giống như truy
xuất một phần tử trong dictionary, nhưng sẽ đưa vào index mới chưa tồn
tại trong dictionary. Ví dụ, trong dictionary kho_dung_cu chưa có phần
tử với index 'Thang', khi đó bạn dùng lệnh sau để thêm phần tử 'Thang'
với số lượng 1 vào dictionary kho_dung_cu: kho_dung_cu['Thang']
= 1. Lưu ý rằng bạn phải gán giá trị cho phần tử mới, tức là bạn không thể
tạo ra một phần tử khuyết giá trị.

65. 64
Lưu ý: Các index trong một dictionary không được trùng nhau,
tức là bạn không thể tạo một dictionary với nhiều phần tử có index giống
nhau. Lý do là index được sử dụng để truy xuất phần tử, nếu có nhiều
index giống nhau thì lệnh truy xuất phần tử sẽ không thể trả về một giá
trị duy nhất được.
Một lưu ý nữa là không chỉ index của các phần tử trong dictionary
có thể có kiểu dữ liệu là chữ hoặc số tùy ý, mà giá trị của các phần tử cũng
có thể có kiểu dữ liệu là chữ hoặc số tùy ý. Ví dụ:
thoi_khoa_bieu = {'Thu 2': 'Toan, Ve ky thuat', 'Thu
4': 'Xac suat thong ke', 'Thu 5:': 'Tin hoc, The chat'}
Code trên tạo ra một dictionary với index và giá trị đều có kiểu chữ (string).
Bạn cũng có thể tạo ra giá trị có cấu trúc mảng như ví dụ sau:
thoi_khoa_bieu = {'Thu 2': ['Toan', 'Ve ky thuat'],
'Thu 4': ['Xac suat thong ke'], 'Thu 5:': ['Tin hoc',
'The chat']}
Bên cạnh việc truy xuất phần tử bằng index, Python còn cung cấp một số
hàm giúp bạn làm việc với dictionary thuận tiện hơn.
▪ Hàm keys(): trả về các index trong dictionary.
Ví dụ: kho_dung_cu.keys()
▪ Hàm values(): trả về các giá trị trong dictionary.
Ví dụ: kho_dung_cu.values()
▪ Hàm items(): trả về các phần tử (bao gồm cả index và giá trị)
trong dictionary.
Ví dụ: kho_dung_cu.items()
Ví dụ sau sử dụng các hàm trên để lấy ra danh sách các dụng cụ có số
lượng từ 2 cái trở lên:
# Cách 1: dùng hàm keys()
ds_dung_cu_hon_2_cai = []
for ten in kho_dung_cu.keys():
if kho_dung_cu[ten]>=2:
ds_dung_cu_hon_2_cai.append(ten)

66. 65
# Cách 2: dùng hàm items()
ds_dung_cu_hon_2_cai = []
for ten, so_luong in kho_dung_cu.items():
if so_luong>=2:
ds_dung_cu_hon_2_cai.append(ten)
Điểm khác biệt của hai cách trên là nếu dùng hàm keys() thì ta phải truy
xuất số lượng dụng cụ sử dụng index kho_dung_cu[ten]. Còn khi dùng
hàm items() thì số lượng dụng cụ đã được lấy sẵn đi kèm với index rồi.
Ví dụ 5.4: Cho một dictionary chứa bảng điểm của sinh viên, trong đó
index là tên sinh viên còn giá trị là một list chứa điểm các môn học của
sinh viên đó (xem code bên dưới). Hãy viết code thực hiện các chức năng
sau:
1. Thêm một cột điểm cho các sinh viên.
2. Tính điểm trung bình cho các sinh viên.
# Bảng điểm:
bang_diem = {'An': [9.5, 7.2, 8.6],
'Binh': [8.2, 9.1],
'Long': [5.4, 7.2, 8.3],
'Hoa': [6.1, 5.6, 7.7, 7.9]}
# 1. Thêm một cột điểm cho các sinh viên:
for ten in bang_diem.keys():
diem = float(input('Nhap diem cua '+ten))
bang_diem[ten].append(diem)
# 2. Tính điểm trung bình cho các sinh viên:
diem_tb = {}
for ten, list_diem in bang_diem.items():
diem_tb_1_sv = sum(list_diem)/len(list_diem)
diem_tb[ten] = round(diem_tb_1_sv,2)
Thực hành: Viết code tìm tên sinh viên có điểm trung bình lớn nhất (để
nhà trường trao học bổng chẳng hạn).

67. 66
Thực hành: Nhập đoạn mã sau và đặt tên là dictionaries_demo.py Sau
đó hãy thực thi đoạn mã và cho biết kết quả in ra màn hình.
# declare
a = {}
b = {2: 'Sea', 3: 'River', 8: 'Mountain'}
c = {2: {4: 'abcd', 5: 'hjkl'}, 3: 'vbnm'}
d = dict(name='elena', age=30, roles=('manager',
'consultant'))
# print
print(a)
print(b)
print(c)
print(d)
# keys values
print(b.keys())
print(b.values())
print(b.items())
# add item
a.setdefault(2, 'car')
a.setdefault(5, 'train')
a.setdefault(7, 'plane')
print(a)
# check key
print(3 in b)
print(5 in b)

68. 67
Bài tập có lời giải
1. Mã Morse là một sơ đồ mã hóa sử dụng dấu – và dấu . để thể hiện
các số và ký tự. Viết chương trình sử dụng dictionary để lưu trữ
bảng ánh xạ các ký tự này sang mã Morse. Bảng ánh xạ được thể
hiện dưới đây. Chương trình sẽ đọc một chuỗi từ người dùng sau
đó sẽ dịch chuỗi gồm các ký tự và số thành mã Morse, đặt thêm
các khoảng trắng giữa chuỗi các dấu gạch ngang – và dấu chấm .
Chương trình sẽ bỏ qua bất cứ ký tự nào không được liệt kê ở bảng dưới
đây. Dưới đây là mã Morse cho chuỗi Hello, World!

69. 68
Bài tập thực hành
1. Đếm số lần xuất hiện của các chữ cái (không kể dấu câu, ví dụ: .
–) được dùng trong một câu, ví dụ:
“An eye for an eye makes the whole world blind. – Mahatma
Gandhi”1
Câu này có số lần xuất hiện của ‘A’: 1 lần, ‘a’: 6 lần, ‘b’: 1 lần...
Gợi ý: Có thể dùng set và dictionary kết hợp với vòng lặp để đếm
(dictionary dùng để lưu kết quả).
2. Tạo một chương trình quản lý thời gian trong ngày sử dụng
dictionary với keys là các loại hoạt động (ví dụ: Học, Ngủ, Thể
dục, Chơi, Di chuyển...) và values là thời gian (tính theo phút) của
hoạt động tương ứng. Chương trình cần thực hiện các chức năng
sau:
a. Nhập thêm thời gian: Hỏi người dùng nhập key hoạt động và số
phút rồi cộng dồn vào số phút đang có.
b. Thống kê thời gian các hoạt động (tính theo giờ), ví dụ: Học 8.4
giờ, Ngủ 7.2 giờ, Di chuyển 0.8 giờ...
c. Cho biết 2 hoạt động được làm nhiều nhất và 2 hoạt động làm ít
nhất trong ngày.
1
Mahatma Gandhi (1869 – 1948) là một lãnh tụ của Ấn Độ đã dẫn dắt đất nước với hơn
350 triệu dân (vào những năm 1940) thoát khỏi chế độ thực dân của Đế quốc Anh. Ông
nổi tiếng với phương pháp bất bạo lực (nonviolence) đã giúp Ấn Độ tránh được cuộc
chiến tranh thương vong lớn mà vẫn giành được độc lập. Ông là một trong những biểu
tượng toàn cầu của phong trào bất bạo lực.
Câu nói “An eye for an eye makes the whole world blind” (tạm dịch: Một con mắt đổi
một con mắt chỉ làm cả thế giới mù lòa) được cho là của ông Gandhi đã nói khi thuyết
phục nội các chính phủ Ấn Độ chọn con đường bất bạo lực để đối phó với Đế quốc Anh.
Trong bộ phim điện ảnh Gandhi (thắng 8 giải Oscars) kể về cuộc đời ông, câu nói này
nằm trong lời thoại: “An eye for an eye only ends up making the whole world blind”.

70. 69
Chương 6
STRINGS
Các chương trước đã giới thiệu các các cấu trúc dữ liệu như mảng,
dictionaries với các phần tử chủ yếu có kiểu dữ liệu dạng số (số nguyên,
số thực). Trong chương này, chúng ta tìm hiểu về kiểu dữ liệu chuỗi
(strings) dành cho chữ (text).
6.1 Khái niệm và khởi tạo strings
Kiểu dữ liệu string (thường được dịch là chuỗi) là kiểu dữ liệu phục
vụ lưu trữ chữ (text). Một cách đơn giản, một chuỗi là một tuple (xem mục
3.2) của các ký tự (characters).
Để tạo 1 string bạn dùng cú pháp với dấu nháy đơn hoặc nháy kép:
ten_string = 'noi dung string'
ten_string = "noi dung string"
Cả hai cú pháp trên hoàn toàn tương đương nhau. Lưu ý rằng các
strings tạo bởi cú pháp trên chỉ chứa text nằm trên một dòng. Để tạo string
có nội dung nằm trên nhiều dòng các bạn dùng cú pháp với 3 dấu nháy đơn
liên tiếp:
ten_string = '''Dong 1.
Dong 2. '''
Ví dụ 6.1:
str1 = 'Hom nay la thu ba.'
ho_ten = 'Tran Nhan Tong'
bai_tho = '''Công cha như núi Thái Sơn,
Nghĩa mẹ như nước trong nguồn chảy ra.
Một lòng thờ mẹ kính cha,
Cho tròn chữ hiếu mới là đạo con.'''
Bởi vì string là một tuple của các ký tự nên bạn có thể truy xuất các ký tự
của nó giống như cách truy xuất các phần tử của tuple. Ví dụ: