GT Python Final

BỘ GIÁO DỤC VÀ ĐÀO TẠO
LẬP TRÌNH PYTHON
Biên soạn: TS. Phạm Quốc Thiện

ThS. Phạm Quốc Phương
Tài Liệu Lưu Hành Tại HUTECH www.hutech.edu.vn

LẬP TRÌNH PYTHON
MỤC LỤC I
MỤC LỤC
MỤC LỤC ............................................................................ ERROR! BOOKMARK NOT DEFINED.
HƯỚNG DẪN ....................................................................... ERROR! BOOKMARK NOT DEFINED.
BÀI 1: PYTHON LÀ GÌ? ................................................ ERROR! BOOKMARK NOT DEFINED.
1.1 GIỚI THIỆU ..................................................................... ERROR! BOOKMARK NOT DEFINED.
1.1.1 Trình biên dịch và trình thông dịch ............................... Error! Bookmark not defined.
1.1.2 Ví dụ về biên dịch và thông dịch .................................. Error! Bookmark not defined.
1.2 ANACONDA VÀ TRÌNH SOẠN THẢO PYTHON ................................. ERROR! BOOKMARK NOT DEFINED.
1.2.1 Python IDLE .............................................................. Error! Bookmark not defined.
1.2.2 Visual Studio Code ..................................................... Error! Bookmark not defined.
1.2.3 Spyder ..................................................................... Error! Bookmark not defined.
1.2.4 Visual Studio ............................................................. Error! Bookmark not defined.
1.2.5 PyCharm .................................................................. Error! Bookmark not defined.
1.2.6 Wing Python IDE ....................................................... Error! Bookmark not defined.
1.2.7 Jupyter Notebook ...................................................... Error! Bookmark not defined.
1.3 CÀI ĐẶT PYTHON VÀ THIẾT LẬP MÔI TRƯỜNG ............................... ERROR! BOOKMARK NOT DEFINED.
1.3.1 Cài đặt Anaconda trên Windows .................................. Error! Bookmark not defined.
1.3.2 Thiết lập môi trường ảo cho Python bằng Anaconda ....... Error! Bookmark not defined.
1.4 CÀI ĐẶT GÓI PYTHON TRONG ANACONDA ................................... ERROR! BOOKMARK NOT DEFINED.
1.4.1 Các gói Python .......................................................... Error! Bookmark not defined.
1.4.2 Anaconda Navigator ................................................... Error! Bookmark not defined.
1.4.3 Lệnh conda ............................................................... Error! Bookmark not defined.
1.4.4 Lệnh pip ................................................................... Error! Bookmark not defined.
1.4.5 Cài đặt Python Spyder IDE và chạy tập lệnh ................. Error! Bookmark not defined.
TÓM TẮT ............................................................................ ERROR! BOOKMARK NOT DEFINED.
CÂU HỎI ÔN TẬP ................................................................. ERROR! BOOKMARK NOT DEFINED.
BÀI 2: KIỂU DỮ LIỆU ................................................... ERROR! BOOKMARK NOT DEFINED.
2.1 PYTHON – BIẾN................................................................. ERROR! BOOKMARK NOT DEFINED.
2.1.1 Tạo biến Python ........................................................ Error! Bookmark not defined.
2.1.2 Print biến Python ....................................................... Error! Bookmark not defined.
2.1.3 Xoá biến ................................................................... Error! Bookmark not defined.
2.1.4 Gán nhiều biến .......................................................... Error! Bookmark not defined.
2.1.5 Tên biến Python ........................................................ Error! Bookmark not defined.
2.1.6 Biến cục bộ - Local variable ........................................ Error! Bookmark not defined.
2.1.7 Biến toàn cục - Global variable .................................... Error! Bookmark not defined.
2.2 CÁC KIỂU DỮ LIỆU TIÊU CHUẨN............................................... ERROR! BOOKMARK NOT DEFINED.
2.2.1 Số - number ............................................................. Error! Bookmark not defined.
II MỤC LỤC
2.2.2 Chuỗi - string .............................................................Error! Bookmark not defined.

2.2.3 List ...........................................................................Error! Bookmark not defined.
2.2.4 Tuple ........................................................................Error! Bookmark not defined.
2.2.5 Dictionary ..................................................................Error! Bookmark not defined.
BÀI 3: SỬ DỤNG TOÁN TỬ VÀ TOÁN HẠNG .................. ERROR! BOOKMARK NOT DEFINED.
3.1 CÁC LOẠI TOÁN TỬ ............................................................. ERROR! BOOKMARK NOT DEFINED.
3.2 TOÁN TỬ SỐ HỌC............................................................... ERROR! BOOKMARK NOT DEFINED.
3.3 TOÁN TỬ SO SÁNH ............................................................. ERROR! BOOKMARK NOT DEFINED.
3.4 TOÁN TỬ GÁN ................................................................... ERROR! BOOKMARK NOT DEFINED.
3.5 TOÁN TỬ BITWISE .............................................................. ERROR! BOOKMARK NOT DEFINED.
3.6 TOÁN TỬ LOGIC ................................................................ ERROR! BOOKMARK NOT DEFINED.
3.7 TOÁN TỬ MENBERSHIP ........................................................ ERROR! BOOKMARK NOT DEFINED.
3.8 TOÁN TỬ NHẬN DẠNG .......................................................... ERROR! BOOKMARK NOT DEFINED.
3.9 MỨC ĐỘ ƯU TIÊN GIỮA CÁC TOÁN TỬ ........................................ ERROR! BOOKMARK NOT DEFINED.
BÀI 4: CÂU LỆNH ĐIỀU KIỆN VÀ VÒNG LẶP ................. ERROR! BOOKMARK NOT DEFINED.
4.1 CÂU LỆNH ĐIỀU KIỆN – RA QUYẾT ĐỊNH .................................... ERROR! BOOKMARK NOT DEFINED.
4.1.1 Câu lệnh IF ................................................................Error! Bookmark not defined.
4.1.2 Câu lệnh if…else .........................................................Error! Bookmark not defined.
4.1.3 Câu lệnh if…elif…else ...................................................Error! Bookmark not defined.
4.1.4 Câu lệnh if lồng nhau - Nested if ..................................Error! Bookmark not defined.
4.1.5 Câu lệnh if viết tắt - Shorthand if .................................Error! Bookmark not defined.
4.1.6 Câu lệnh if…else viết tắt - Shorthand if…else ..................Error! Bookmark not defined.
4.2 VÒNG LẶP ....................................................................... ERROR! BOOKMARK NOT DEFINED.
4.2.1 Vòng lặp for ...............................................................Error! Bookmark not defined.
4.2.2 Vòng lặp while ...........................................................Error! Bookmark not defined.
BÀI TẬP ............................................................................. ERROR! BOOKMARK NOT DEFINED.
BÀI 5: LẬP TRÌNH PYTHON ......................................... ERROR! BOOKMARK NOT DEFINED.
5.1 HÀM ............................................................................. ERROR! BOOKMARK NOT DEFINED.
5.1.1 Định nghĩa hàm ..........................................................Error! Bookmark not defined.
5.1.2 Cú pháp ....................................................................Error! Bookmark not defined.
5.1.3 Gọi hàm ....................................................................Error! Bookmark not defined.
5.1.4 Chuyển theo tham chiếu so với giá trị ...........................Error! Bookmark not defined.
MỤC LỤC III
5.1.5 Đối số của hàm ......................................................... Error! Bookmark not defined.
5.1.6 Hàm ẩn danh ............................................................ Error! Bookmark not defined.
5.1.7 Câu lệnh return ......................................................... Error! Bookmark not defined.
5.1.8 Phạm vi biến ............................................................. Error! Bookmark not defined.
5.2 MODULE ......................................................................... ERROR! BOOKMARK NOT DEFINED.
5.2.1 Lệnh import .............................................................. Error! Bookmark not defined.
5.2.2 Lệnh from…import ..................................................... Error! Bookmark not defined.
5.2.3 Lệnh from…import *................................................... Error! Bookmark not defined.
5.2.4 Định vị module .......................................................... Error! Bookmark not defined.
5.2.5 Biến PYTHONPATH ..................................................... Error! Bookmark not defined.
5.2.6 Namespace và phạm vi .............................................. Error! Bookmark not defined.
5.2.7 Hàm dir() ................................................................. Error! Bookmark not defined.
5.2.8 Hàm reload() ............................................................ Error! Bookmark not defined.
5.3 FILE I/O ........................................................................ ERROR! BOOKMARK NOT DEFINED.
5.3.1 Xuất ra màn hình....................................................... Error! Bookmark not defined.
5.3.2 Đọc bàn phím ............................................................ Error! Bookmark not defined.
5.3.3 Mở và đóng file .......................................................... Error! Bookmark not defined.
5.3.4 Đọc và viết file .......................................................... Error! Bookmark not defined.
5.3.5 Vị trí file ................................................................... Error! Bookmark not defined.
5.3.6 Đổi tên và xóa file ..................................................... Error! Bookmark not defined.
5.3.7 Thư mục trong Python ................................................ Error! Bookmark not defined.
5.4 PYTHON - XỬ LÝ NGOẠI LỆ VÀ XÁC NHẬN ................................... ERROR! BOOKMARK NOT DEFINED.
5.4.2 Ngoại lệ là gì? ........................................................... Error! Bookmark not defined.
5.4.3 Xử lý một ngoại lệ ..................................................... Error! Bookmark not defined.
5.5 PYTHON - HƯỚNG ĐỐI TƯỢNG ............................................... ERROR! BOOKMARK NOT DEFINED.
5.5.1 Tổng quan về thuật ngữ OOP ...................................... Error! Bookmark not defined.
5.5.2 Tạo class .................................................................. Error! Bookmark not defined.
5.5.3 Tạo đối tượng instance ............................................... Error! Bookmark not defined.
5.5.4 Truy cập thuộc tính .................................................... Error! Bookmark not defined.
5.5.5 Thuộc tính class tích hợp ............................................ Error! Bookmark not defined.
5.5.6 Huỷ đối tượng ........................................................... Error! Bookmark not defined.
5.5.7 Class kế thừa ............................................................ Error! Bookmark not defined.
5.5.8 Phương thức ghi đè .................................................... Error! Bookmark not defined.
5.5.9 Nạp chồng toán tử - Overloading Operator .................... Error! Bookmark not defined.
5.5.10 Ẩn dữ liệu ............................................................... Error! Bookmark not defined.
BÀI TẬP ............................................................................. ERROR! BOOKMARK NOT DEFINED.
IV MỤC LỤC
TÀI LIỆU THAM KHẢO .......................................................... ERROR! BOOKMARK NOT DEFINED.

HƯỚNG DẪN V
HƯỚNG DẪN
MÔ TẢ MÔN HỌC
Vi điều khiển nâng cao là một trong những môn học tiên quyết nhằm cung cấp kiến
thức cho những người học muốn nghiên cứu chuyên sâu về lập trình và áp dụng những
thuật toán điều khiển hiện đại cũng như cổ điển. Môn học trang bị những kiến thức từ
cơ bản đến nâng cao của dòng vi điều khiển mạnh nhất hiện nay đó là ARM .
NỘI DUNG MÔN HỌC

− Bài 1. Tổng quan về ARM: Bài này cung cấp cho học viên một số khái niệm về ARM.
Ngoài ra, học viên còn có thể phân biệt kiến trúc RISC và CISC, so sánh giữa các
dòng vi điều khiển ARM Cortex M0 của Nuvoton. Nắm được các tính năng chính của
dòng NUC130/140.
− Bài 2. Họ NuMicroTM NUC140: Bài này giúp học viên nắm vững tổ chức bộ nhớ Vi
điều khiển họ NUC140 và có thể phân biệt bộ nhớ chương trình và bộ nhớ dữ liệu.
Ngoài ra, còn hiểu rõ địa chỉ, chức năng các bit trong các thanh ghi đặc biệt.
− Bài 3: Input - Output: Bài này trình bày về cấu trúc các thanh ghi điều khiển I-O.
Hướng dẫn cách tạo 1 project sử dụng phần mềm Keil C. Học xong bài này học viên
có thể viết 1 số chương trình ứng dụng.
− Bài 4: Timer – Watchdog Timer – Real Time Clock: Trong bài này trình bày các sơ
đồ khối và các thanh ghi liên quan đến các bộ Timer. Hướng dẫn cách khởi tạo và
cấu hình Timer, tính toán giá trị cho Timer và Counter. Học viên có thể viết 1 số
chương trình ứng dụng Timer.
− Bài 5: ADC: Bài này giúp học viên phân biệt tín hiệu digital và analog, trình bày sơ
đồ khối và các thanh ghi liên quan đến ADC. Hướng dẫn cách khởi tạo và cấu hình
ADC. Học viên có thể viết 1 số chương trình ứng dụng ADC.
− Bài 6: PWM – Capture: Bài này giúp học viên phân biệt giữa mode Capture – PWM.
Ngoài ra, còn trình bày cấu trúc và các thanh ghi liên quan đến PWM. Hướng dẫn
cách khai báo và viết chương trình dùng Keil C. Viết 1 số chương trìnhứng dụng
trong thực tế.
VI HƯỚNG DẪN
− Bài 7: Truyền thông UART – I2C – SPI: Bài này giúp học viên nắm được các khái
niệm về truyền thông UART, I2C, SPI. Cách khởi tạo và cấu hình các giao thức truyền
thông. Giao tiếp giữa PC và MCU, MCU-MCU và viết 1 số chương trình ứng dụng.
KIẾN THỨC TIỀN ĐỀ

Các môn học tiên quyết (những môn phải học trước môn này): Môn học được bố
trí vào giai đoạn lựa chọn chuyên ngành, sau khi kết thúc các môn cơ bản của ngành.
Các môn học kế tiếp (những môn học ngay sau môn này): Kỹ thuật lập trình nâng cao,
hệ thống nhúng.
YÊU CẦU MÔN HỌC

Người học phải dự học đầy đủ các buổi lên lớp và làm bài tập đầy đủ ở nhà.
CÁCH TIẾP NHẬN NỘI DUNG MÔN HỌC

Để học tốt môn này, người học cần ôn tập các bài đã học, trả lời các câu hỏi và làm
đầy đủ bài tập; đọc trước bài mới và tìm thêm các thông tin liên quan đến bài học.
Đối với mỗi bài học, người học đọc trước mục tiêu và tóm tắt bài học, sau đó đọc nội
dung bài học. Kết thúc mỗi ý của bài học, người đọc trả lời câu hỏi ôn tập và kết thúc
toàn bộ bài học, người đọc làm các bài tập.
PHƯƠNG PHÁP ĐÁNH GIÁ MÔN HỌC

1. Kiểm tra – đánh giá quá trình: Có trọng số chung là 30%, bao gồm các điểm
đánh giá như sau:
− Điểm chuyên cần: Cấm thi nếu vắng hơn 20% tiết lên lớp.
− Điểm đánh giá nhận thức và thái độ tham gia thảo luận, Seminar: 20%
− Điểm thi giữa kỳ: 10%
− Điểm thi cuối kỳ: 70%
− Điểm đánh giá khối lượng tự học, tự nghiên cứu của sinh viên (hoàn thành tốt nội
dung, nhiệm vụ mà giảng viên giao cho cá nhân/ tuần; bài tập nhóm/ tháng; bài
tập cá nhân/ học kì,…).
2. Kiểm tra - đánh giá cuối kỳ: Điểm thi kết thúc học phần có trọng số 70%
− Hình thức thi: tự luận
HƯỚNG DẪN VII
− Thời lượng thi: 90 phút
− Sinh viên được tham khảo tài liệu hay không khi thi: được tham khảo tài liệu
BÀI 1: PYTHON LÀ GÌ? 1
BÀI 1: PYTHON LÀ GÌ?
Sau khi học xong bài này, học viên có thể:
▪ Phân biệt trình biên dịch và trình thông dịch
▪ Trình bày được các trình soạn thảo phổ biến cho Python
▪ Thực hiện được cài đặt Anaconda, các gói cho Python và thiết lập được môi trường
ảo
▪ Nắm được các tính năng chính của Spyder
1.1 Giới thiệu

Python là một ngôn ngữ lập trình mã nguồn mở và đa nền tảng, ngày càng trở nên
phổ biến trong hơn mười năm qua. Nó được phát hành lần đầu tiên vào năm 1991,
CPython là triển khai tham chiếu của ngôn ngữ lập trình Python. Được viết bằng C,
CPython là triển khai ngôn ngữ mặc định và được sử dụng rộng rãi nhất.
Python là ngôn ngữ lập trình đa mục đích (do có nhiều phần mở rộng), ví dụ như
tính toán khoa học, mô phỏng, phát triển web (YouTube và Dropbox), v.v.
Trang chủ Python: https://www.python.org
Ngôn ngữ lập trình được duy trì và có sẵn từ (Python Software Foundation):
https://www.python.org. Các tính năng cơ bản của Python có thể được tải xuống , bao
gồm trình thông dịch ngôn ngữ lập trình Python và trình soạn thảo code cơ bản hoặc
môi trường phát triển tích hợp, được gọi là IDLE (integrated development environment),
như thể hiện trong hình 1.1. Tuy nhiên, đây chỉ là phần cốt lõi của Python, tức là trình
thông dịch, một trình soạn thảo rất cơ bản và là phần tối thiểu cần thiết để tạo các
chương trình Python cơ bản.
Thông thường, một chương trình của dự án sẽ cần nhiều tính năng hơn để giải quyết
các yêu cầu. Sau đó, các gói Python riêng có thể được cài đặt và sử dụng do bên thứ
2 BÀI 1: PYTHON LÀ GÌ?
ba tạo ra. Các gói này cần phải được tải xuống và cài đặt riêng (thông thường sử dụng
PIP) hoặc các gói phân phối từ Anaconda.
Python là ngôn ngữ lập trình hướng đối tượng (OOP - object-oriented programming),
nhưng Python có thể được sử dụng trong ứng dụng cơ bản mà không cần phải biết hoặc
sử dụng các tính năng hướng đối tượng trong Python. Python là ngôn ngữ lập trình được
thông dịch, code được viết trong file Python (.py) trong trình soạn thảo , sau đó đưa
file này vào trong trình thông dịch Python để thực thi. Tuỳ thuộc vàp trình soạn thảo
đang sử dụng, công việc này được thực hiện tự động hoặc thủ công.
Hình 1.1. IDLE – trình soạn thảo Python cơ bản.
1.1.1 Trình biên dịch và trình thông dịch

Sự khác biệt giữa ngôn ngữ lập trình được thông dịch và ngôn ngữ lập trình được
biên dịch là gì? Nên chọn loại nào, và tại sao phải quan tâm?
Các ngôn ngữ lập trình thường thuộc một trong hai loại: biên dịch (Compiled) hoặc
thông dịch (Interpreted).
Các ngôn ngữ đã biên dịch được chuyển đổi trực tiếp thành mã máy (nhị phân) mà
bộ xử lý có thể thực thi. Kết quả là, chúng có xu hướng thực thi nhanh hơn và hiệu quả
hơn so với các ngôn ngữ thông dịch. Chúng cũng cung cấp cho nhà phát triển nhiều
quyền kiểm soát hơn đối với các khía cạnh phần cứng, như quản lý bộ nhớ và sử dụng
CPU. Các ngôn ngữ được biên dịch cần một bước biên soạn code (build) chúng cần được
biên dịch thủ công trước và cần xây dựng lại chương trình mỗi khi cần thực hiện thay
đổi. Ví dụ về các loại ngôn ngữ biên dịch – C, C++, C#, CLEO, COBOL, v.v.
Trình thông dịch chạy qua từng dòng chương trình và thực hiện từng lệnh, nghĩa là
mỗi lệnh được dịch sang mã nhị phân của mã máy và thực thi. Không giống như trình
biên dịch, trình thông dịch không tạo file thực thi nhị phân. Đó là lý do tại sao nó phải
có mặt trong RAM của máy tính bất cứ khi nào chạy một chương trình. Phạm vi ngôn
ngữ được thông dịch – JavaScript, Perl, Python, BASIC, v.v.
1.1.2 Ví dụ về biên dịch và thông dịch

Cho một đoạn code như sau:
Một trình biên dịch sẽ dịch đoạn code trên sang mã nhị phân, có thể thực thi như
trong hình 1.2. Tất cả các chỉ thị nhị phân đó là các lệnh dành cho máy tính. Chúng chỉ
thị máy tính thiết lập thanh ghi CPU thích hợp thành 1. Sau đó, chúng chọn một địa chỉ
trống trong RAM để ghi nội dung của thanh ghi. Đó là cách trình biên dịch dịch a = 1;
sang mã nhị phân. Các chỉ thị nhị phân khác là bản dịch phần còn lại của code sang
ngôn ngữ nhị phân của máy. Khi mã nhị phân được chạy, nó sẽ được tải vào RAM và
CPU sẽ thực thi nó.
Hình 1.2. Nguyên tắc hoạt động của trình biên dịch.
Mặt khác, trước tiên, một trình thông dịch sẽ đọc lệnh a = 1. Nó sẽ được tải vào
RAM của máy tính, dịch nó thành mã nhị phân và để (các) CPU thực thi nó. Sau đó,
trình thông dịch sẽ làm tương tự với lệnh b = 2. Sau lệnh thứ hai, nó sẽ chuyển sang
lệnh thứ ba và cho đến lệnh cuối cùng, như thể hiện trong hình 1.3.
Hình 1.3. Nguyên tắc hoạt động của trình thông dịch.
Tổng hợp sự khác biệt giữa trình biên dịch và trình thông dịch:
Lưu ý rằng hầu hết các ngôn ngữ lập trình có thể có cả triển khai được biên dịch và
thông dịch. Bản thân ngôn ngữ không nhất thiết phải được biên dịch hoặc thông dịch.
Tuy nhiên, để đơn giản, chúng thường được gọi như vậy. Ví dụ, Python có thể được
thực thi dưới dạng chương trình đã biên dịch hoặc dưới dạng ngôn ngữ được thông dịch
trong chế độ tương tác. Mặt khác, hầu hết các công cụ dòng lệnh (CLI - command line
tool) và Shell về mặt lý thuyết có thể được phân loại là ngôn ngữ được thông dịch.
1.2 Anaconda và trình soạn thảo Python

Anaconda là một gói phân phối bao gồm trình biên dịch Python, trình soạn thảo
Spyder, Jupyter Notebook và các gói thường được sử dụng khác cho máy tính khoa học
và khoa học dữ liệu.
Anaconda gồm hai phiên bản: miễn phí (Anaconda Distribution) và trả phí
(Enterprise) có sẵn cho Windows, macOS và Linux. Web: https://www.anaconda.com
Trình soạn thảo là chương trình để tạo code đồng thời có thể chạy và kiểm tra code.
Hầu hết các trình soạn thảo cũng có các tính năng để gỡ lỗi (Debugging). Đối với các
chương trình Python đơn giản, có thể sử dụng trình soạn thảo IDLE, nhưng đối với các
chương trình nâng cao hơn, nên sử dụng trình soạn thảo tốt hơn.
Một số trình soạn thảo phổ biến dành cho Python:
▪ Python IDLE
▪ Visual Studio Code
▪ Spyder
▪ Visual Studio
▪ PyCharm
▪ Wing Python IDE
▪ Jupyter Notebook
Người lập trình nên sử dụng trình soạn thảo nào tuỳ thuộc vào nền tảng, loại trình
soạn thảo nào đã sử dụng trước đây, kỹ năng lập trình, những gì sẽ phát triển trong
Python, v.v.
Một số nguồn Python hữu ích:
▪ Hướng dẫn Python chính: https://docs.python.org/3.7/tutorial/index.html
▪ Tài liệu Python: https://docs.python.org/3.7/index.html
▪ Hướng dẫn Python: https://www.w3schools.com/python/
1.2.1 Python IDLE

Ngôn ngữ lập trình được tải và có sẵn từ (Python Software Foundation):
https://www.python.org
Tại đây, các tính năng cơ bản Python có thể được tải trong một gói, bao gồm trình
thông dịch ngôn ngữ lập trình Python, và một trình soạn thảo code cơ bản, hoặc một
môi trường phát triển tích hợp, được gọi là IDLE.
1.2.2 Visual Studio Code

Visual Studio Code là trình soạn thảo mã nguồn do Microsoft phát triển cho Windows,
Linux và macOS.
Web: https://code.visualstudio.com
Resources: Getting Started with Python in Visual Studio Code
1.2.3 Spyder
Spyder là một môi trường phát triển tích hợp (IDE - integrated development
environment) đa nền tảng nguồn mở dành cho lập trình khoa học bằng ngôn ngữ
Python.
Web: https://www.spyder-ide.org
Spyder được bao gồm trong Anaconda Distribution.
1.2.4 Visual Studio

Microsoft Visual Studio là một môi trường phát triển tích hợp (IDE) của Microsoft.
Nó được sử dụng để phát triển các chương trình máy tính, cũng như các trang web, ứng
dụng web, dịch vụ web và ứng dụng di động.
Ngôn ngữ lập trình (chính) mặc định trong Visual studio là C, nhưng nhiều ngôn
ngữ lập trình khác được hỗ trợ.
Visual studio có sẵn cho Windows và macOS. Visual Studio (từ 2017), có hỗ trợ tích
hợp cho Python, nó được gọi là Python Support in Visual Studio.
Web: https://visualstudio.microsoft.com
1.2.5 PyCharm
PyCharm đa nền tảng, có các phiên bản Windows, macOS và Linux. Community
Edition là phiên bản được sử dụng miễn phí, trong khi Professional Edition (phiên bản
trả phí) có một số tính năng bổ sung.
Web: https://www.jetbrains.com/pycharm/
1.2.6 Wing Python IDE

Wing Python IDE từ Wingware được tạo riêng cho ngôn ngữ lập trình Python. Có 3
phiên bản Wing khác nhau:
▪ Wing 101 - một phiên bản miễn phí rất đơn giản, dành cho những người mới bắt đầu
dạy lập trình
▪ Wing Personal - phiên bản miễn phí lược bỏ một số tính năng, dành cho sinh viên
và người có sở thích lập trình
▪ Wing Pro - bản thương mại (trả phí) đầy đủ tính năng, dành cho lập trình viên chuyên
nghiệp
1.2.7 Jupyter Notebook

Jupyter Notebook là một ứng dụng web mã nguồn mở cho phép tạo và chia sẻ các
tài liệu có chứa code trực tiếp, phương trình, trực quan hóa và văn bản.
Web: http://jupyter.org
1.3 Cài đặt python và thiết lập môi trường

Anaconda là một phần mềm nguồn mở có chứa Jupyter, spyder, v.v. được sử dụng
để xử lý dữ liệu lớn, phân tích dữ liệu, tính toán khoa học. Anaconda hoạt động cho
ngôn ngữ lập trình R và python. Spyder (ứng dụng phụ của Anaconda) được sử dụng
cho python. Opencv cho python sẽ hoạt động trong spyder. Các phiên bản gói được
quản lý bởi hệ thống quản lý gói có tên là conda.
Để bắt đầu làm việc với Anaconda, trước tiên phải cài đặt nó. Thực hiện theo các
hướng dẫn bên dưới để tải xuống và cài đặt Anaconda trên hệ thống máy tính.
1.3.1 Cài đặt Anaconda trên Windows

Bước 1: tải và cài đặt Anaconda
Truy cập anaconda.com và cài đặt phiên bản Anaconda mới nhất hoặc phiên bản
phù hợp với dự án/đề tài cần sử dụng, như thể hiện trong hình 1.4. Anaconda có hỗ trợ
cho ba nền tảng Windows, Mac và Linux. Tuỳ thuộc vào mực đích sử dụng, người dùng
có thể chọn nền tảng phù hợp. Trong nội dung tài liệu này tập trung hướng dẫn sử dụng
Anaconda trên nền tảng của Windows và sẽ là tương tự cho Mac và Linux.
Hình 1.4. Giao diện chính khi thực hiện tải Anaconda.
Bước 2: bắt đầu quá trình cài đặt
▪ Để bắt đầu cài đặt Anaconda trên hệ điều hành, click đúp vào file cài đặt trong thư
mục Download trên máy tính và click Next
Hình 1.5. Giao diện chính sau khi click đúp vào file cài đặt.
▪ Click I Agree với License Agreement
Hình 1.6. Giao diện của License Agreement.

▪ Select Installation Type: phần này sẽ hỏi người dùng muốn cài đặt Anaconda chỉ cho
cá nhân hay cho tất cả người dùng sử dụng PC này. Click Just Me hoặc All Users,
tùy thuộc vào mục đích sử dụng. Cả hai tùy chọn đều được nhưng để chọn All Users,
người dùng sẽ cần có đặc quyền của quản trị viên và sau đó click Next
Hình 1.7. Giao diện của Select Installation Type.

▪ Choose Installation Location: nếu người dùng đã chọn Just Me, theo mặc định,
Anaconda sẽ được cài đặt trong thư mục C:\ProgramData\Anaconda3. Vì vậy, hãy
đảm bảo rằng có ít nhất dung lượng phù hợp để cài đặt thư mục con so với dung
lượng cần thiết
Hình 1.8. Giao diện của Choose Installation Location.

▪ Advanced Installation Option: tùy thuộc vào việc người dùng đã cài đặt bất kỳ phiên
bản Python nào trên hệ điều hành của mình hay chưa, để thực hiện các thiết lập
khác nhau
✓ Nếu người dùng đang cài đặt Python lần đầu tiên: chọn Add Anaconda to my PATH
environment variable. Điều này cho phép người dùng sử dụng Anaconda trong
Command Prompt
✓ Nếu người dùng đã cài đặt Python: không chọn Add Anaconda to my PATH
environment variable, có nghĩa là người dùng sẽ phải sử dụng Anaconda
Command Prompt để dùng Anaconda.
Hình 1.9. Giao diện của Advanced Installation Option.

Vì vậy, trừ khi người dùng thêm PATH sau đó, nếu không sẽ không thể sử dụng
Python từ Command Prompt. Python thường không được bao gồm theo mặc định trên
Windows, tuy nhiên có thể kiểm tra xem có phiên bản nào tồn tại trên hệ thống hay
không.
▪ Kiểm tra đã cài đặt Python trên máy tính chưa?
✓ Vào Start Menu và gõ Command Prompt để mở nó
✓ Nhập lệnh >python -- và Enter
✓ Nếu không có gì xảy ra, người dùng chưa cài đặt Python. Ngược lại, người dùng sẽ
nhận được kết quả này
Hình 1.10. Công cụ Command Prompt.

▪ Quá trình cài đặt
Hình 1.11. Giao diện của quá trình cài đặt.

▪ Khuyến nghị cài đặt Pycharm
Hình 1.12. Giao diện của việc khuyến nghị cài đặt Pycharm.
▪ Kết thúc cài đặt
Hình 1.13. Giao diện của hoàn thành quá trình cài đặt.
Bước 3: làm việc với Anaconda
Khi quá trình cài đặt hoàn tất, Anaconda có thể được sử dụng để thực hiện nhiều
thao tác. Để bắt đầu sử dụng Anaconda, hãy tìm kiếm Anaconda Navigator từ Start
Menu trong Windows
Hình 1.14. Giao diện chính của Anaconda Navigator.
1.3.2 Thiết lập môi trường ảo cho Python bằng Anaconda

Giống như nhiều ngôn ngữ khác, Python yêu cầu một phiên bản khác cho các loại
ứng dụng khác nhau. Ứng dụng cần chạy trên một phiên bản cụ thể của ngôn ngữ vì
nó yêu cầu một phụ thuộc nhất định có trong các phiên bản cũ hơn nhưng thay đổi
trong các phiên bản mới hơn. Môi trường ảo giúp dễ dàng phân tách các ứng dụng khác
nhau một cách lý tưởng và tránh các sự cố với các phần phụ thuộc khác nhau. Sử dụng
môi trường ảo, có thể dễ dàng chuyển đổi giữa cả hai ứng dụng và thực thi chúng.
Có nhiều cách để tạo môi trường bằng virtualenv, venv và conda. Lệnh conda
được sử dụng phổ biến để quản lý cài đặt và môi trường ảo với bản Anaconda
Distribution. Các bước tạo môi trường ảo bằng conda:
Bước 1: kiểm tra xem conda đã được cài đặt trong đường dẫn của máy tính chưa
▪ Mở Anaconda Prompt
▪ Nhập lệnh conda -V và Enter
▪ Nếu conda được cài đặt thành công trong hệ thống máy tính, sẽ xuất hiện một kết
quả tương tự
Hình 1.15. Công cụ Anaconda Prompt.

Bước 2: cập nhật môi trường conda
conda update conda
Bước 3: thiết lập môi trường ảo
▪ Nhập lệnh conda serach “^python$” để xem danh sách các phiên bản Python có sẵn
▪ Thay envname bằng tên muốn đặt cho môi trường ảo, thay x.x bằng phiên bản
Python muốn sử dụng với lệnh
conda create -n envname python=x.x anaconda
▪ Tất cả các gói cần thiết cho phiên bản Python x.x và yêu cầu Processd ([y]/n)? sẽ
xuất hiện. Nếu người dùng nhập y và Enter, quá trình thiết lập môi trường ảo sẽ bắt
đầu. Ngược lại, quá trình thiết lập này sẽ bị huỷ
Ví dụ: muốn thiết lập môi trường ảo có tên là ROBOT và phiên bản Python là 3.10.
Hình 1.16. Thiết lập môi trường ảo trên Anaconda Prompt.

Bước 4: kích hoạt môi trường ảo
▪ Để xem danh sách tất cả các môi trường đã được thiết lập trong hệ thống bằng cách
nhập lệnh
conda info –envs
Hoặc
conda env list
▪ Để kích hoạt môi trường ảo, hãy nhập lệnh đã cho và thay thế tên môi trường đã
cho của người dùng bằng envname. Khi môi trường conda được kích hoạt, nó sẽ
sửa đổi PATH và các biến shell trỏ cụ thể đến thiết lập Python biệt lập mà người
dùng đã tạo
conda activate envname
Bước 5: cài đặt các gói cần thiết vào môi trường ảo
▪ Nhập lệnh sau để cài đặt các gói bổ sung vào môi trường và thay thế envname
bằng tên môi trường của người dùng
conda install -n envname package
Bước 6: vô hiệu hóa môi trường ảo
▪ Để thoát khỏi môi trường cụ thể, hãy gõ lệnh sau. Các cài đặt của môi trường sẽ
vẫn được giữ nguyên
conda deactivate
Bước 7: xóa môi trường ảo
▪ Nếu người dùng không còn muốn sử dụng một môi trường ảo nào đó. Xóa nó bằng
lệnh sau và thay thế tên môi trường của người dùng bằng envname
conda remove -n envname -all
1.4 Cài đặt gói Python trong Anaconda

Một trong những cách phổ biến nhất để quản lý và phân phối các gói Python là thông
qua Anaconda Distribution, đây là một bản phân phối mã nguồn mở và miễn phí của
Python.
Cài đặt các gói Python trong Anaconda là một quy trình đơn giản có thể được thực
hiện thông qua nhiều phương pháp khác nhau, chẳng hạn như sử dụng lệnh conda, pip
hoặc Anaconda Navigator.
Trong phần này, các phương pháp khác nhau để cài đặt các gói Python trong
Anaconda và giải thích cách sử dụng cho từng phương pháp.
1.4.1 Các gói Python

Việc sử dụng Python cần cài đặt các gói hỗ trợ khác nhau cho các dự án/đề tài khác
nhau, thay vì tích hợp tất cả các chức năng vào lõi của nó.
Cách tiếp cận này có ưu điểm và nhược điểm. Một nhược điểm là cần cài đặt các gói
này một cách riêng biệt và sau đó import các mô-đun này vào code. Đây cũng là cách
tiếp cận điển hình cho phần mềm nguồn mở, bởi vì mọi người đều có thể tạo các gói
Python của riêng mình và phân phối chúng. Theo cách này, các gói Python cũng được
tìm thấy cho hầu hết mọi thứ, từ khoa học máy tính đến phát triển Web.
Các gói này cần được tải xuống và cài đặt riêng, ví dụ: gói phân phối như Anaconda,
thường nhận các gói cần thiết cho tính toán khoa học. Với Anaconda, thường nhận được
các tính năng tương tự như với Matlab.
Có rất nhiều gói Python, tùy thuộc vào những gì sẽ giải quyết trong các dự án/đề
tài, ví dụ: các gói phát triển GUI trên máy tính, phát triển cơ sở dữ liệu, phát triển Web,
phát triển phần mềm, v.v.
Xem tổng quan về Các ứng dụng dành cho Python:
https://www.python.org/about/apps/
Xem thêm trang web Python Package Index (PyPI):
https://pypi.org
Tại đây, có thể tìm kiếm, tải xuống và cài đặt hàng trăm gói Python trong các dự
án/đề tài và ứng dụng khác nhau. Chúng ta cũng có thể tạo các gói Python của riêng
mình và phân phối chúng tại đây.
1.4.1.1 Gói Python cho khoa học và tính toán số

Một số gói Python quan trọng cho khoa học và tính toán số bao gồm:
▪ NumPy - gói cơ bản cho tính toán khoa học với Python.
▪ SciPy - một thư viện Python mã nguồn mở và miễn phí được sử dụng cho tính toán
khoa học và tính toán kỹ thuật. SciPy chứa các mô-đun để tối ưu hóa, đại số tuyến
tính, tích phân, nội suy, các hàm đặc biệt, biến đổi Fourier, xử lý tín hiệu và hình
ảnh, giải phương trình vi phân và các nhiệm vụ phổ biến khác trong khoa học và kỹ
thuật.
▪ Matplotlib - thư viện vẽ đồ thị Python 2D.
▪ Pandas - thư viện phân tích dữ liệu
1.4.2 Anaconda Navigator

Để thêm các gói Python vào môi trường Anaconda bằng Navigator, hãy làm theo các
bước bên dưới:
▪ Mở Anaconda Navigator và chọn tab Environments
▪ Chọn môi trường muốn thêm các gói. Nếu người dùng muốn tạo một môi trường
mới, có thể nhấp vào nút Create
Hình 1.17. Giao diện của Anaconda Navigator tại tab Environments.
▪ Click vào thẻ Not Installed. Thao tác này sẽ hiển thị danh sách tất cả các gói hiện
chưa được cài đặt trong môi trường đã chọn
Hình 1.18. Giao diện của Anaconda Navigator, kiểm tra các gói chưa cài đặt.
▪ Tìm kiếm (các) gói muốn cài đặt bằng cách nhập tên gói vào thanh tìm kiếm
Hình 1.19. Giao diện của Anaconda Navigator, tìm kiếm gói cài đặt.
▪ Chọn (các) gói muốn cài đặt bằng cách click vào checkbox bên cạnh tên gói
Hình 1.20. Giao diện của Anaconda Navigator, chọn gói cài đặt.
▪ Click nút Apply để bắt đầu cài đặt
Hình 1.21. Giao diện của Anaconda Navigator, đồng ý cài đặt sau khi chọn gói.
▪ Người dùng sẽ được nhắc xác nhận cài đặt. Click vào Apply một lần nữa để xác
nhận cài đặt
Hình 1.22. Xác nhận cài đặt gói Python.

▪ (Các) gói sẽ được cài đặt và sẽ xuất hiện trong tab Installed của môi trường đã
chọn
1.4.3 Lệnh conda
Để thêm các gói Python vào môi trường Anaconda bằng terminal hoặc Anaconda
Prompt, có thể sử dụng lệnh conda.
▪ Mở terminal hoặc Anaconda Prompt
▪ Kích hoạt môi trường muốn thêm các gói, đã trình bày trong 1.3.2, bước 4
▪ Sử dụng lệnh conda install để cài đặt (các) gói muốn thêm vào mội trường. Ví dụ:
để cài đặt gói numpy, sẽ sử dụng lệnh sau
conda install numpy
Người dùng cũng có thể cài đặt nhiều gói cùng một lúc bằng cách liệt kê chúng cách
nhau bằng dấu cách
conda install numpy pandas matplotlib
▪ Nhấn Enter để bắt đầu quá trình cài đặt. Ngườ dùng sẽ được nhắc xác nhận cài đặt.
Nhập y để xác nhận và tiếp tục cài đặt
▪ Khi quá trình cài đặt hoàn tất, có thể xác minh rằng (các) gói đã được thêm vào môi
trường bằng cách sử dụng lệnh bên dưới
conda list
▪ Có thể xóa một gói trong môi trường hiện tại bằng cách chạy lệnh conda remove
package-name
Ví dụ: xoá gói Matplotlib khỏi môi trường hiện tại. Sau đó, người dùng chạy lệnh conda
list, Matplotlib sẽ không còn liệt kê
conda remove matplotlib
▪ Để xóa một môi trường, hãy chạy lệnh bên dưới
conda remove --name ENV_NAME --all
ENV_NAME biểu thị tên của môi trường sẽ bị xóa. Người dùng phải đảm bảo huỷ kích
hoạt môi trường trường trước khi xoá bằng cách chạy lệnh conda deactivate.
--all cờ xóa tất cả các gói được cài đặt trong môi trường đó.
1.4.4 Lệnh pip

Để thêm các gói vào môi trường Anaconda bằng lệnh pip, có thể sử dụng lệnh pip
trong môi trường conda đã kích hoạt.
▪ Mở terminal hoặc Anaconda Prompt
▪ Sử dụng lệnh cài đặt pip để cài đặt (các) gói muốn thêm vào môi trường. Ví dụ: để
cài đặt gói numpy, sẽ sử dụng lệnh sau
pip install numpy

Người dùng cũng có thể cài đặt nhiều gói cùng một lúc bằng cách liệt kê chúng cách
nhau bằng dấu cách
pip install numpy pandas matplotlib
▪ Nhấn enter để bắt đầu quá trình cài đặt. (Các) gói sẽ được cài đặt và thêm vào môi
trường đang hoạt động
▪ Có thể xoá hoặc xoá một gói nào đó bằng lệnh
pip uninstall package_name
▪ Nếu người dùng muốn xóa tất cả các gói do pip cài đặt, có thể sử dụng lệnh pip
freeze. Nó có thể liệt kê tất cả các gói đã cài đặt qua PIP và gỡ cài đặt chúng mà
không cần yêu cầu xác nhận. Lệnh chính xác sẽ là:
pip uninstall -y -r <(pip freeze)
▪ Có thể lưu các gói đã cài đặt trong một file có tên là requirements.txt và trực tiếp
gỡ cài đặt các gói pip từ file. Chạy các lệnh này:
pip freeze > requirements.txt
pip uninstall -r requirements.txt. Điều này giúp gỡ cài đặt từng gói một.
pip uninstall -r requirements.txt -y. Điều này giúp xóa tất cả các gói cùng một lúc.
Ngoài ra, cũng có thể sử dụng xargs để gỡ cài đặt tất cả các gói pip với lệnh:
pip freeze | xargs pip uninstall -y
Chú ý: cần có kết nối internet ổn định vì các gói sẽ được tải xuống từ internet. Ngoài
ra, pip là trình quản lý gói mặc định trong python, trong khi conda là trình quản lý gói,
môi trường và phụ thuộc có sẵn với Anaconda Distribution.
1.4.5 Cài đặt Python Spyder IDE và chạy tập lệnh

1.4.5.1 Giới thiệu
Như đã thào luận trong phần 1.2, có rất nhiều trình soạn thảo dành cho việc lập
trình Python tuỳ thuộc vào người dùng lựa chọn. Tuy nhiên, một trong những IDE
Python phổ biến nhất là Spyder (Scientific Python Development Environment). Công cụ
Python này được thiết kế bởi và dành cho các nhà khoa học, kỹ sư và nhà phân tích dữ
liệu. Nó có sự kết hợp độc đáo giữa chức năng chỉnh sửa, phân tích, gỡ lỗi và lập hồ sơ
chức năng của một công cụ phát triển toàn diện với khám phá dữ liệu, thực thi tương
tác, kiểm tra sâu và khả năng trực quan hóa đẹp mắt của một gói khoa học. Trong
phần này, chúng ta sẽ tìm hiểu lý do tại sao Spyder IDE cũng là một công cụ tuyệt vời
cho người mới bắt đầu.
Sau khi thực hiện các bước mô tả trong phần 1.3.1, có hai cách để mở Spyder:
Cách 1: dùng Anaconda Navigator. Nếu người dùng muốn chạy Spyder, chỉ cần click
vào nút Launch.
Hình 1.23. Giao diện của Anaconda Navigator, mở Spyder.

Cách 2: nhập Spyder trong họp tìm kiếm của Windows và Enter
Hình 1.24. Giao diện chính của Spyder.

Ngoài ra, Spyder còn có thể được cài đặt và làm việc trong môi trường ảo. Để làm
được điều này, người dùng phải đảm bảo hoàn thành đến bước 4 trong mục 1.3.2 và
sau đó nhập lệnh: conda install spyder
1.4.5.2 Tổng quan về Menu và Thanh công cụ của Spyder IDE

Cửa sổ chính của Spyder IDE (hình 1.24) chứa menu chính, thanh công cụ và một
số panel.
▪ Trên cùng là menu chính:
Hình 1.25. Menu của Spyder.

▪ Bên dưới Menu là thanh công cụ
Hình 1.26. Thanh công cụ của Spyder.

▪ Ở phía bên phải là console tương tác nơi người dùng có thể viết và chạy code
Hình 1.27. Console của Spyder.

▪ Bên trái là một trình soạn thảo nơi người dùng có thể viết và lưu các tập lệnh Python
Hình 1.28. Trình soạn thảo của Spyder.

▪ Ở bên trái của trình soạn thảo là ngăn Project Explorer, hiển thị tất cả các project
cùng với các thư mục và file liên quan
Hình 1.29. Project Explorer của Spyder.
1.4.5.3 Bắt đầu một project trong Spyder IDE

Trong Spyder IDE, cũng như trong các IDE khác, người dùng có thể tạo một project
để sắp xếp các file, chẳng hạn như hình ảnh, tập lệnh và file text liên quan. Để tạo một
project, chỉ cần chọn Projects › New Project từ menu chính.
Cửa sổ Create new project sẽ hiển thị. Điền thông tin cho project, bao gồm tên và
thư mục (nếu thư mục được chọn đã tồn tại, hãy đảm bảo Existing directory được
chọn ở Project type).
Hình 1.30. Tạo project trên Spyder.

Khi hoàn tất, hãy click vào Create. Ở đây, đã chọn tên MyFirstProject như một ví
dụ minh hoạ và sau đó thư mục project sẽ nằm trong Project explorer.
1.4.5.4 Viết tập lệnh Python đầu tiên trong project

Mọi project đều chứa các file: code, ảnh, thư viện, file text, v.v. Người dùng có thể
tạo một file cho phép viết tập lệnh Python (Python script). Click chuột phải vào thư mục
project và chọn New › File.
Hình 1.31. Tạo Python script.

Hộp thoại file mới hiển thị. Nhập tên cho script, ở đây là MyFile.py như một ví dụ
minh hoạ và click Save. File sẽ xuất hiện trong thư mục project trong ngăn Project
explorer của IDE.
Hình 1.32. File script được tạo thành công.

File cũng sẽ tự động được mở trong khung trình soạn thảo. Ở đây, người dùng có
thể viết code Python, như sau:
Hình 1.33. Code mẫu đầu tiên cho việc minh hoạ.
Sau đó, người dùng có thể lưu file bằng cách nhấn Ctrl+S hoặc chọn File › Save từ
menu
Hình 1.34. Lưu file script.

1.4.5.5 Các tính năng của Spyder IDE
Tương tự như các IDE khác, Spyder IDE hỗ trợ người dùng lập trình tốt với với các
tính năng của nó.
▪ Comments: một trong những tính năng có sẵn cho phép người dùng nhanh chóng
thêm block comment vào code. Click vào dòng lệnh muốn chèn block comment, sau
đó chọn Edit › Add block comment từ menu
Hình 1.35. Tính năng block comment.

Theo cách tương tự, người dùng có thể xóa block comment bằng Edit menu, click
vào bên trong block comment (trình soạn thảo) và chọn Remove block comment
▪ Syntax Highlighting: nếu quan sát trong trình soạn thảo, có nhiều màu khác nhau:
string có màu xanh lá, tên hàm có màu tím. Đây là syntax highlighting, một tính
năng mà hầu hết các trình soạn thảo văn đều có để giúp người dùng dễ dàng tìm
thấy các phần có liên quan trong code. Nó có thể sử dụng quy tắc highlighting mặc
định hoặc chỉ định theo quy tắc theo mục đích người dùng. Để bắt đầu, vào Tools ›
Preferences. Cửa sổ Preferences hiển thị, chọn Syntax coloring ở bên trái, và
click nút Edit selected ở bên phải, như hình 1.36.
Người dùng sẽ thấy trình chỉnh sửa Color scheme, cho phép thay đổi màu sắc của
các phần khác nhau trong code. Sau khi thực hiện thay đổi, click OK, như hình 1.37
Hình 1.36. Tính năng Syntax Highlighting.
Hình 1.37. Thay đổi màu của tính năng Syntax Highlighting.
▪ Syntax Warnings và Auto-Completion: giả sử tạo file mới có tên là Editor.py và
thêm vào project. Nó hiện đang được mở trong trình soạn thảo như hình 1.38.
Hình 1.38. Editor.py trong trình soạn thảo.

Nếu người dùng mắc lỗi cú pháp trong code (ở đây, bỏ qua dấu ] cho một list), IDE
sẽ thông báo cho về lỗi đó bằng biểu tượng x màu đỏ. Người dùng có thể di chuột qua
nó để biết thêm thông tin (hình 1.39).
Hình 1.39. Lỗi cú pháp trong Editor.py.

Spyder IDE cũng cung cấp tính năng completion trong quá trình viết code. Nếu
người dùng bắt đầu viết một từ khóa Python và quên phần còn lại của chính tả, IDE sẽ
đưa ra một danh sách gợi ý.
Ví dụ: nếu chỉ nhập ký tự i và nhấn Tab hoặc Ctrl+Space, người dùng sẽ thấy danh
sách gồm các từ khóa bắt đầu bằng chữ i. Người dùng có thể chọn một trong các gợi ý
hoặc tiếp tục nhập code (hình 1.40).
Hình 1.40. Tính năng completion.

1.4.5.6 Chạy code Python trong Spyder IDE

Người dùng có thể chạy các file project bằng nút Run màu xanh từ thanh công cụ.
Ngoài ra, có thể chọn Run › Run từ menu chính hoặc sử dụng phím tắt (F5).
Hình 1.41. Chạy code và hiển thị kết quả.

Người dùng sẽ thấy kết quả của việc chạy file hiện đang hoạt động trong ngăn
Console. Tuy nhiên, đôi khi mắc lỗi phi cú pháp khi lập trình. Trong tình huống này,
sau khi chạy code, sẽ thấy tóm tắt lỗi trong ngăn Console. Tất nhiên, như trong hầu
hết các IDE, người dùng cũng có thể gỡ lỗi chương trình của mình. Có một nhóm nút
gỡ lỗi cho phép chạy ứng dụng và gỡ lỗi từng bước để tìm lỗi.
Hình 1.42. Hiện thị lỗi của code trong ngăn Console.
1.4.5.7 Thêm một Mô-đun/Gói vào Spyder IDE

Spyder IDE chứa một tập hợp lớn các gói và mô-đun cho Python. Mô-đun là một tệp
được viết bằng Python (có phần mở rộng .py) chứa các class, function hoặc variable
để sử dụng trong chương trình Python. Nhiều mô-đun có thể được nhóm trong một gói.
Nếu muốn sử dụng một gói nào đó trong code, trước tiên cần cài đặt gói đó. Ví dụ:
nếu muốn thử import gói logbook vào chương trình mà không cài đặt gói, thì nó sẽ
không hoạt động. Hãy xem code ví dụ trong hình 1.43.
Console thông báo lỗi: No module named 'logbook'. Giải pháp rất đơn giản, tất cả
những gì người dùng phải làm là vào Console và gõ lệnh sau: !pip install logbook
Người dùng sẽ thấy thông báo về quá trình cài đặt. Bây giờ khi chạy file ví dụ import
gói logbook, nó sẽ hoạt động mà không có lỗi (hình 1.44).
Hình 1.43. Thông báo lỗi việc sử dụng gói chưa được cài đặt trong chương trình.
Hình 1.44. Quá trình cài đặt gói trên Console và chạy chương trình.
1.4.5.8 Variable Explorer

Spyder IDE cũng cho phép người dùng quan sát giá trị của các biến trong tập lệnh
của mình. Theo mặc định, thông tin này nằm trong ngăn trên cùng bên phải có tiêu đề
Variable explorer. Trong ví dụ bên dưới, có thể thấy giá trị của các biến trong tập
lệnh đã chạy ở bên trái.
Hình 1.45. Quan sát giá trị của các biến trên Variable explorer.
Variable explorer cho phép người dùng không chỉ xem các giá trị của biến mà còn
chỉnh sửa các giá trị đó. Ngoài ra, có thể chọn các biến từ ngăn explorer và chọn vẽ
hoặc Histogram từ menu để tạo biểu đồ từ tập hợp dữ liệu đó.
TÓM TẮT
Trong bài này, học viên tìm hiểu:
▪ Sự khác biệt về việc thực thi các chương trình sau khi biên dịch và thông dịch
▪ Các trình soạn thảo phổ biến dành cho việc lập trình Python
▪ Cài đặt Anaconda và thiết lập môi trường ảo
▪ Cài đặt các gói Python trong Anaconda dùng Anaconda Navigator, lệnh pip và lệnh
conda
▪ Các tính năng của Spyder IDE và sử dụng nó để lập trình

CÂU HỎI ÔN TẬP

Cầu 1: Trình bày sự khác biệt giữa trình biên dịch và trình thông dịch
Câu 2: Sinh viên tiến hành cài đặt Anaconda cho Windows với phiên bản mới nhất
Câu 3: Sinh viên hãy kiểm tra phiên bản Python sau khi cài đặt Anaconda là phiên bản
nào?
Câu 4: Sinh viên hãy tạo một môi trường ảo có tên là deeplearning với phiên bản
Python là 3.8 và cài đặt các gói keras, matplotlib, pandas, jupyter và spyder
Câu 5: Sinh viên hãy tạo một project với file test.py, lập lệnh sau, chạy code và kiểm
tra kết quả trên Console
print("Hello, World!")
Câu 6: Sinh viên sử dụng các tính năng Spyder và thực hiện theo yêu cầu:
- Tính năng comments, và thêm nội dung My first code
- Tính năng Syntax Highlighting, thay đổi màu sắc của hàm print thành màu đỏ và
"Hello, World!" thành màu xanh da trời
Câu 7: Sinh viện thực hiện xoá các gói keras và matplotlib trong môi trường ảo hiện
tại và kiểm tra lại bằng conda list
Câu 8: Sinh viên thực hiện xoá môi trường ảo deeplearning và các gói bên trong môi
trường
38 BÀI 2: KIỂU DỮ LIỆU
BÀI 2: KIỂU DỮ LIỆU
▪ Nắm vững cách sử dụng cơ bản với biến
▪ Phân biệt biến cục bộ và biến toàn cục
▪ Lập trình được cho các biến với kiểu dữ liệu tiêu chuẩn bao gồm số, chuỗi, tuple và
dictionary
2.1 Python – biến

Các biến Python là các vị trí bộ nhớ dành riêng được sử dụng để lưu trữ các giá trị
trong chương trình Python. Điều này có nghĩa là khi tạo một biến, người dùng dành một
khoảng trống trong bộ nhớ.
Dựa trên kiểu dữ liệu của một biến, trình thông dịch Python phân bổ bộ nhớ và quyết
định những gì có thể được lưu trữ trong bộ nhớ dành riêng. Do đó, bằng cách gán các
kiểu dữ liệu khác nhau cho các biến Python, người dùng có thể lưu trữ số nguyên, số
thập phân hoặc ký tự trong các biến này.
2.1.1 Tạo biến Python

Các biến Python không cần khai báo rõ ràng để dành dung lượng bộ nhớ. Biến Python
được tạo tự động khi người dùng gán giá trị cho nó. Dấu bằng (=) dùng để gán giá trị
cho biến.
Toán hạng bên trái của toán tử = là tên của biến và toán hạng bên phải của toán tử
= là giá trị được lưu trữ trong biến. Ví dụ: thực hiện tạo project trên Spyder với tên file
main.py và nhập các lệnh sau:
counter = 100 # Creates an integer variable
miles = 1000.0 # Creates a floating point variable
name = "Zara Ali" # Creates a string variable
BÀI 2: KIỂU DỮ LIỆU 39
2.1.2 Print biến Python
Khi tạo một biến Python và gán giá trị cho nó, người dùng có thể xuất nó bằng hàm
print(). Sau đây là phần mở rộng của ví dụ trước và chỉ ra cách in các biến khác nhau
trong Python:
counter = 100 # Creates an integer variable
miles = 1000.0 # Creates a floating point variable
name = "Zara Ali" # Creates a string variable
print (counter)
print (miles)
print (name)
Ở đây, 100, 1000.0 và "Zara Ali" lần lượt là các giá trị được gán cho các biến counter,
miles, và name. Khi chạy chương trình Python ở trên, điều này tạo ra kết quả trên
Console của Spyder như sau:
100
1000.0
Zara Ali
2.1.3 Xoá biến

Người dùng có thể xóa tham chiếu đến một đối tượng số bằng cách sử dụng câu lệnh
del. Cú pháp của câu lệnh del là:
del var1[,var2[,var3[....,varN]]]]
Cũng có thể xóa một đối tượng hoặc nhiều đối tượng bằng cách sử dụng câu lệnh
del.
del var
del var_a, var_b
Các ví dụ sau cho thấy cách có thể xóa một biến và nếu người dùng cố gắng sử dụng
một biến đã xóa thì trình thông dịch Python sẽ báo lỗi:
counter = 100
print (counter)
del counter
print (counter)
Điều này sẽ tạo ra kết quả trên Console:
100
Traceback (most recent call last):
File "main.py", line 7, in <module>
print (counter)
NameError: name 'counter' is not defined
2.1.4 Gán nhiều biến

Python cho phép gán một giá trị cho nhiều biến đồng thời, điều đó có nghĩa là người
dùng có thể tạo nhiều biến cùng một lúc. Ví dụ:
a = b = c = 100
print (a)
print (b)
print (c)
100
100
100
Ví dụ:
a,b,c = 1,2,"Zara Ali"
print (a)
print (b)
print (c)
1
2
Zara Ali
Ở đây, hai đối tượng số nguyên có giá trị 1 và 2 lần lượt được gán cho các biến a và
b và một đối tượng chuỗi có giá trị "Zara Ali" được gán cho biến c.
2.1.5 Tên biến Python

Mỗi biến Python nên có một tên duy nhất như a, b, c. Tên biến có thể có ý nghĩa
như màu sắc, tuổi, tên, v.v. Có một số quy tắc nhất định cần được lưu ý khi đặt tên
biến Python:
▪ Tên biến phải bắt đầu bằng một chữ cái hoặc ký tự gạch dưới
▪ Tên biến không được bắt đầu bằng số hoặc bất kỳ ký tự đặc biệt nào như $, (, * %,
v.v.
▪ Tên biến chỉ có thể chứa các ký tự chữ và số và dấu gạch dưới (A-z, 0-9 và _ )
▪ Tên biến Python phân biệt chữ hoa chữ thường, có nghĩa là name và NAME là hai
biến khác nhau trong Python
▪ Không thể sử dụng các từ khóa dành riêng cho Python để đặt tên cho biến
Ví dụ: Sau đây là các tên biến Python hợp lệ
counter = 100
_count = 100
name1 = "Zara"
name2 = "Nuha"
Age = 20
zara_salary = 100000
print (counter)
print (_count)
print (name1)
print (name2)
print (Age)
print (zara_salary)
100
100
Zara
Nuha
20
100000
Ví dụ: Sau đây là tên biến Python không hợp lệ
1counter = 100
$_count = 100
zara-salary = 100000
print (1counter)
print ($count)
print (zara-salary)
File "main.py", line 3
1counter = 100
^
SyntaxError: invalid syntax
2.1.6 Biến cục bộ - Local variable

Các biến cục bộ trong Python được định nghĩa bên trong một hàm. Người dùng không
thể truy cập biến bên ngoài chức năng.
Hàm Python là một đoạn code có thể sử dụng nhiều lần khi gọi trong chương trình
và phần này sẽ được thảo luận hơn trong những bài sau. Sau đây là một ví dụ để hiển
thị việc sử dụng các biến cục bộ:
def sum(x,y):
sum = x + y
return sum
print(sum(5, 10))
Kết quả là:
15
2.1.7 Biến toàn cục - Global variable

Bất kỳ biến nào được tạo bên ngoài một hàm đều có thể được truy cập trong bất kỳ
hàm nào và vì vậy chúng có phạm vi toàn cục. Sau đây là một ví dụ về biến toàn cục:
x = 5
y = 10
def sum():
sum = x + y
return sum
print(sum())
Kết quả là:
15
2.2 Các kiểu dữ liệu tiêu chuẩn

2.2.1 Số - number
Kiểu dữ liệu số lưu trữ các giá trị số. Chúng là các kiểu dữ liệu không thể thay đổi,
có nghĩa là việc thay đổi giá trị của một kiểu dữ liệu số dẫn đến một đối tượng mới được
phân bổ. Đối tượng số được tạo khi người dùng gán giá trị cho chúng. Ví dụ:
var1 = 1
var2 = 10
Người dùng có thể xoá những biến số này như đã thảo luận trong phần 2.1.3. Python
hỗ trợ bốn loại biến số khác nhau:
▪ int (signed integers) - Chúng thường được gọi đơn giản là số nguyên hoặc int, là
số nguyên dương hoặc âm không có dấu thập phân
▪ long (long integers) - Còn được gọi là long, chúng là số nguyên có kích thước
không giới hạn, được viết như số nguyên và theo sau là chữ hoa hoặc chữ thường L
▪ float (floating point real values) - Còn được gọi là số float, chúng đại diện cho
các số thực và được viết bằng dấu thập phân chia phần nguyên và phần phân số.
Số float cũng có thể ở dạng ký hiệu khoa học, với E hoặc e biểu thị lũy thừa của 10
(2,5e2 = 2,5 x 102 = 250)
▪ complex (complex numbers) - có dạng a + bj, trong đó a và b là số float và J
(hoặc j) biểu thị căn bậc hai của -1 (là một số ảo). Phần thực của số là a, phần ảo
là b. Số phức không được sử dụng nhiều trong lập trình Python.
Ví dụ: Dưới đây là một số ví dụ về số
▪ Python cho phép người dùng sử dụng chữ L viết thường với long, nhưng bạn chỉ nên
sử dụng chữ L viết hoa để tránh nhầm lẫn với số 1. Python hiển thị số nguyên long
với chữ L viết hoa
▪ Một số phức bao gồm một cặp số thực được biểu thị bằng a + bj, trong đó a là phần
thực và b là phần ảo của số phức
2.2.1.1 Chuyển đổi loại số

Python chuyển đổi các số bên trong một biểu thức chứa các loại thành một loại
chung để đánh giá. Nhưng đôi khi, người dùng cần ép buộc một số rõ ràng từ loại này
sang loại khác để đáp ứng các yêu cầu của một toán tử hoặc tham số hàm.
▪ int(x) chuyển đổi x thành số nguyên
▪ long(x) chuyển đổi x thành số nguyên long
▪ float(x) chuyển đổi x thành số thực có dấu phẩy
▪ complex(x) chuyển đổi x thành số phức có phần thực là x và phần ảo là 0
▪ complex(x, y) chuyển đổi x và y thành một số phức có phần thực là x và phần ảo
là y. x và y là các biểu thức số
2.2.1.2 Hàm toán học

Python bao gồm các hàm sau thực hiện các phép tính toán học.
▪ abs(x) - Giá trị tuyệt đối của x: khoảng cách (dương) giữa x và 0
Ví dụ:
print("abs(-45) : ", abs(-45))
print("abs(100.12) : ", abs(100.12))
print("abs(119L) : ", abs(119L))
Khi chạy chương trình trên, nó tạo ra kết quả sau:
abs(-45) : 45
abs(100.12) : 100.12
abs(119L) : 119
▪ ceil(x) - Hàm này trả về số nguyên nhỏ nhất không nhỏ hơn x
Ví dụ:
import math # This will import math module
print("math.ceil(-45.17) : ", math.ceil(-45.17))

print("math.ceil(100.12) : ", math.ceil(100.12))
print("math.ceil(100.72) : ", math.ceil(100.72))
print("math.ceil(119L) : ", math.ceil(119L))
print("math.ceil(math.pi) : ", math.ceil(math.pi))
math.ceil(-45.17) : -45.0
math.ceil(100.12) : 101.0
math.ceil(100.72) : 101.0
math.ceil(119L) : 119.0
math.ceil(math.pi) : 4.0
▪ cmp(x, y) - Hàm này trả về dấu hiệu của hai số: -1 nếu x < y, 0 nếu x == y hoặc
1 nếu x > y
Ví dụ:
print("cmp(80, 100) : ", cmp(80, 100))
print("cmp(180, 100) : ", cmp(180, 100))
print("cmp(-80, 100) : ", cmp(-80, 100))
print("cmp(80, -100) : ", cmp(80, -100))
cmp(80, 100) : -1
cmp(180, 100) : 1
cmp(-80, 100) : -1
cmp(80, -100) : 1
▪ exp(x) - trả về hàm mũ của x: ex
Ví dụ:
print("math.exp(-45.17) : ", math.exp(-45.17))

print("math.exp(100.12) : ", math.exp(100.12))
print("math.exp(100.72) : ", math.exp(100.72))
print("math.exp(119L) : ", math.exp(119L))
print("math.exp(math.pi) : ", math.exp(math.pi))
math.exp(-45.17) : 2.41500621326e-20
math.exp(100.12) : 3.03084361407e+43
math.exp(100.72) : 5.52255713025e+43
math.exp(119L) : 4.7978133273e+51
math.exp(math.pi) : 23.1406926328
▪ fabs(x) - trả về giá trị tuyệt đối của x
Ví dụ:
print("math.fabs(-45.17) : ", math.fabs(-45.17))

print("math.fabs(100.12) : ", math.fabs(100.12))
print("math.fabs(100.72) : ", math.fabs(100.72))
print("math.fabs(119L) : ", math.fabs(119L))
print("math.fabs(math.pi) : ", math.fabs(math.pi))
math.fabs(-45.17) : 45.17
math.fabs(100.12) : 100.12
math.fabs(100.72) : 100.72
math.fabs(119L) : 119.0
math.fabs(math.pi) : 3.14159265359
▪ floor(x) - trả về số nguyên lớn nhất không lớn hơn x
Ví dụ:
print("math.floor(-45.17) : ", math.floor(-45.17))

print("math.floor(100.12) : ", math.floor(100.12))
print("math.floor(100.72) : ", math.floor(100.72))
print("math.floor(119L) : ", math.floor(119L))
print("math.floor(math.pi) : ", math.floor(math.pi))
math.floor(-45.17) : -46.0
math.floor(100.12) : 100.0
math.floor(100.72) : 100.0
math.floor(119L) : 119.0
math.floor(math.pi) : 3.0
▪ log(x) - trả về logarit tự nhiên (Loga Nepe) của x, cho x > 0
Ví dụ:
print("math.log(100.12) : ", math.log(100.12))

print("math.log(100.72) : ", math.log(100.72))
print("math.log(119L) : ", math.log(119L))
print("math.log(math.pi) : ", math.log(math.pi))
math.log(100.12) : 4.60636946656
math.log(100.72) : 4.61234438974
math.log(119L) : 4.77912349311
math.log(math.pi) : 1.14472988585
▪ log10(x) - trả về logarit cơ số 10 của x cho x > 0
Ví dụ:
print("math.log10(100.12) : ", math.log10(100.12))

print("math.log10(100.72) : ", math.log10(100.72))
print("math.log10(119L) : ", math.log10(119L))
print("math.log10(math.pi) : ", math.log10(math.pi))
math.log10(100.12) : 2.00052084094
math.log10(100.72) : 2.0031157171
math.log10(119L) : 2.07554696139
math.log10(math.pi) : 0.497149872694
▪ max(x1, x2,...) - trả về giá trị lớn nhất trong số các đối số của nó: giá trị gần nhất
với vô cực dương
Ví dụ:
print("max(80, 100, 1000) : ", max(80, 100, 1000))
print("max(-20, 100, 400) : ", max(-20, 100, 400))
print("max(-80, -20, -10) : ", max(-80, -20, -10))
print("max(0, 100, -400) : ", max(0, 100, -400))

max(80, 100, 1000) : 1000
max(-20, 100, 400) : 400
max(-80, -20, -10) : -10
max(0, 100, -400) : 100
▪ min(x1, x2,...) - trả về giá trị nhỏ nhất trong số các đối số của nó: giá trị gần nhất
với vô cực âm
Ví dụ:
print("min(80, 100, 1000) : ", min(80, 100, 1000))
print("min(-20, 100, 400) : ", min(-20, 100, 400))
print("min(-80, -20, -10) : ", min(-80, -20, -10))
print("min(0, 100, -400) : ", min(0, 100, -400))
min(80, 100, 1000) : 80
min(-20, 100, 400) : -20
min(-80, -20, -10) : -80
min(0, 100, -400) : -400
▪ modf(x) - trả về phần nguyên và phần phân số của x trong hai mục tuple. Cả hai
phần có cùng dấu là x. Phần nguyên được trả về dưới dạng float
Ví dụ:
print("math.modf(100.12) : ", math.modf(100.12))

print("math.modf(100.72) : ", math.modf(100.72))
print("math.modf(119L) : ", math.modf(119L))
print("math.modf(math.pi) : ", math.modf(math.pi))
math.modf(100.12) : (0.12000000000000455, 100.0)
math.modf(100.72) : (0.71999999999999886, 100.0)
math.modf(119L) : (0.0, 119.0)
math.modf(math.pi) : (0.14159265358979312, 3.0)
▪ pow(x, y) - trả về x lũy thừa của y. Nếu đối số thứ ba (z) được đưa ra, nó trả về x
lũy thừa của y mô đun z, tức là pow(x, y) % z
Ví dụ:
print("math.pow(100, 2) : ", math.pow(100, 2))

print("math.pow(100, -2) : ", math.pow(100, -2))
math.pow(100, 2) : 10000.0
math.pow(100, -2) : 0.0001
math.pow(2, 4) : 16.0
math.pow(3, 0) : 1.0
▪ round(x [,n]) - trả về x được làm tròn đến n chữ số từ dấu thập phân
Ví dụ:
print("round(80.23456, 2) : ", round(80.23456, 2))
print("round(100.000056, 3) : ", round(100.000056, 3))
print("round(-100.000056, 3) : ", round(-100.000056, 3))
round(80.23456, 2) : 80.23
round(100.000056, 3) : 100.0
round(-100.000056, 3) : -100.0
▪ sqrt(x) - trả về căn bậc hai của x cho x > 0
Ví dụ:
print("math.sqrt(100) : ", math.sqrt(100))

print("math.sqrt(7) : ", math.sqrt(7))
print("math.sqrt(math.pi) : ", math.sqrt(math.pi))
math.sqrt(100) : 10.0
math.sqrt(7) : 2.64575131106
math.sqrt(math.pi) : 1.77245385091
2.2.1.3 Hàm số ngẫu nhiên

Các số ngẫu nhiên được sử dụng cho các ứng dụng trò chơi, mô phỏng, thử nghiệm,
bảo mật và quyền riêng tư. Python bao gồm các chức năng sau thường được sử dụng.
▪ choice(seq) - trả về một mục ngẫu nhiên từ một list, tuple hoặc string
Ví dụ:
import random
print("choice([1, 2, 3, 5, 9]) : ", random.choice([1, 2, 3, 5, 9]))

print("choice('A String') : ", random.choice('A String'))
choice([1, 2, 3, 5, 9]) : 2
choice('A String') : n
▪ randrange ([start,] stop [,step]) - trả về một phần tử được chọn ngẫu nhiên từ
khoảng của(start - điểm bắt đầu, stop – điểm dừng, step – bước)
Ví dụ:
import random
# Select an even number in 100 <= number < 1000

print("randrange(100, 1000, 2) : ", random.randrange(100, 1000, 2))
# Select another number in 100 <= number < 1000
print("randrange(100, 1000, 3) : ", random.randrange(100, 1000, 3))
randrange(100, 1000, 2) : 976
randrange(100, 1000, 3) : 520
▪ random() - trả về một số float r ngẫu nhiên, sao cho 0 ≤ r < 1
Ví dụ:
import random
# First random number

print("random() : ", random.random())
# Second random number
print("random() : ", random.random())
random() : 0.281954791393
random() : 0.309090465205
▪ seed([x]) - đặt giá trị bắt đầu bằng số nguyên được sử dụng để tạo số ngẫu nhiên.
Gọi hàm này trước khi gọi bất kỳ hàm ngẫu nhiên nào khác
Ví dụ:
import random
random.seed(10)
print("Random number with seed 10 : ", random.random())
# It will generate same random number
random.seed(10)
# It will generate same random number
random.seed(10)
Random number with seed 10 : 0.57140259469
▪ shuffle(lst) - ngẫu nhiên hóa các mục của một list
Ví dụ:
import random
list = [20, 16, 10, 5];

random.shuffle(list)
print("Reshuffled list : ", list)
random.shuffle(list)
print("Reshuffled list : ", list)
Reshuffled list : [16, 5, 10, 20]
Reshuffled list : [16, 5, 20, 10]
▪ uniform(x, y) - trả về một số float r ngẫu nhiên, sao cho x ≤ r < y
Ví dụ:
import random
print("Random Float uniform(5, 10) : ", random.uniform(5, 10))

print("Random Float uniform(7, 14) : ", random.uniform(7, 14))
Random Float uniform(5, 10) : 5.52615217015
Random Float uniform(7, 14) : 12.5326369199
2.2.1.4 Hàm lượng giác

Python bao gồm các hàm sau thực hiện các phép tính lượng giác.
▪ acos(x) - trả về arccosin của x, tính bằng radian
Ví dụ:
import math
print("acos(0.64) : ", math.acos(0.64))

print("acos(0) : ", math.acos(0))
print("acos(-1) : ", math.acos(-1))
print("acos(1) : ", math.acos(1))
acos(0.64) : 0.876298061168
acos(0) : 1.57079632679
acos(-1) : 3.14159265359
acos(1) : 0.0
▪ asin(x) - trả về arcsin của x, tính bằng radian
Ví dụ:
import math
print("asin(0.64) : ", math.asin(0.64))

print("asin(0) : ", math.asin(0))
print("asin(-1) : ", math.asin(-1))
print("asin(1) : ", math.asin(1))
asin(0.64) : 0.694498265627
asin(0) : 0.0
asin(-1) : -1.57079632679
asin(1) : 1.57079632679
▪ atan(x) - trả về arctan của x, tính bằng radian
Ví dụ:
import math
print("atan(0.64) : ", math.atan(0.64))

print("atan(0) : ", math.atan(0))
print("atan(-1) : ", math.atan(-1))
atan(0.64) : 0.569313191101
atan(0) : 0.0
atan(10) : 1.4711276743
atan(-1) : -0.785398163397
atan(1) : 0.785398163397
▪ atan2(y, x) - trả về atan(y / x), tính bằng radian
Ví dụ:
import math
print(atan2(-0.50,-0.50) : ", math.atan2(-0.50,-0.50))

print("atan2(0.50,0.50) : ", math.atan2(0.50,0.50)(
print("atan2(5,5) : ", math.atan2(5,5))
print("atan2(-10,10) : ", math.atan2(-10,10))
print("atan2(10,20) : ", math.atan2(10,20))
atan2(-0.50,-0.50) : -2.35619449019
atan2(0.50,0.50) : 0.785398163397
atan2(5,5) : 0.785398163397
atan2(-10,10) : -0.785398163397
atan2(10,20) : 0.463647609001
▪ cos(x) - trả về cosin của x radian
Ví dụ:
import math
print("cos(3) : ", math.cos(3))

print("cos(-3) : ", math.cos(-3))
print("cos(0) : ", math.cos(0))
print("cos(math.pi) : ", math.cos(math.pi))
print("cos(2*math.pi) : ", math.cos(2*math.pi))
cos(3) : -0.9899924966
cos(-3) : -0.9899924966
cos(0) : 1.0
cos(math.pi) : -1.0
cos(2*math.pi) : 1.0
▪ hypot(x, y) – trả về Euclidean norm, sqrt(x*x + y*y)
Ví dụ:
import math
print("hypot(3, 2) : ", math.hypot(3, 2))

print("hypot(-3, 3) : ", math.hypot(-3, 3))
print("hypot(0, 2) : ", math.hypot(0, 2))
hypot(3, 2) : 3.60555127546
hypot(-3, 3) : 4.24264068712
hypot(0, 2) : 2.0
▪ sin(x) - trả về sin của x, tính bằng radian
Ví dụ:
import math
print("sin(3) : ", math.sin(3))

print("sin(-3) : ", math.sin(-3))
print("sin(0) : ", math.sin(0))
print("sin(math.pi) : ", math.sin(math.pi))
print("sin(math.pi/2) : ", math.sin(math.pi/2))
sin(3) : 0.14112000806
sin(-3) : -0.14112000806
sin(0) : 0.0
sin(math.pi) : 1.22464679915e-16
sin(math.pi/2) : 1.0
▪ tan(x) - trả về tang của x radian
Ví dụ:
import math
print("tan(3) : ", math.tan(3))

print("tan(-3) : ", math.tan(-3))
print("tan(0) : ", math.tan(0))
print("tan(math.pi) : ", math.tan(math.pi))
print("tan(math.pi/2) : ", math.tan(math.pi/2))
print("tan(math.pi/4) : ", math.tan(math.pi/4))
tan(3) : -0.142546543074
tan(-3) : 0.142546543074
tan(0) : 0.0
tan(math.pi) : -1.22460635382e-16
tan(math.pi/2) : 1.63317787284e+16
tan(math.pi/4) : 1.0
▪ degrees(x) - chuyển đổi góc x từ radian sang độ
Ví dụ:
import math
print("degrees(3) : ", math.degrees(3))

print("degrees(-3) : ", math.degrees(-3))
print("degrees(0) : ", math.degrees(0))
print("degrees(math.pi) : ", math.degrees(math.pi))
print("degrees(math.pi/2) : ", math.degrees(math.pi/2))
print("degrees(math.pi/4) : ", math.degrees(math.pi/4))
degrees(3) : 171.887338539
degrees(-3) : -171.887338539
degrees(0) : 0.0
degrees(math.pi) : 180.0
degrees(math.pi/2) : 90.0
degrees(math.pi/4) : 45.0
▪ radians(x) - chuyển đổi góc x từ độ sang radian
Ví dụ:
import math
print("radians(3) : ", math.radians(3))

print("radians(-3) : ", math.radians(-3))
print("radians(0) : ", math.radians(0))
print("radians(math.pi) : ", math.radians(math.pi))
print("radians(math.pi/2) : ", math.radians(math.pi/2))
print("radians(math.pi/4) : ", math.radians(math.pi/4))
radians(3) : 0.0523598775598
radians(-3) : -0.0523598775598
radians(0) : 0.0
radians(math.pi) : 0.0548311355616
radians(math.pi/2) : 0.0274155677808
radians(math.pi/4) : 0.0137077838904
2.2.1.5 Hằng số toán học

Mô-đun này cũng định nghĩa hai hằng số toán học:
▪ pi - Hằng số toán học pi (𝜋 ≈ 3,141592)
▪ e - Hằng số toán học e ≈ 2,71828
2.2.2 Chuỗi - string

Chuỗi là một trong những loại biến phổ biến nhất trong Python. Người dùng có thể
tạo chúng một cách đơn giản bằng cách đặt các ký tự trong dấu ngoặc kép. Python xử
lý dấu nháy đơn giống như dấu ngoặc kép. Tạo chuỗi đơn giản như gán giá trị cho biến.
Ví dụ:
var1 = 'Hello World!'
var2 = "Python Programming"
2.2.2.1 Truy cập các giá trị trong chuỗi

Python không hỗ trợ kiểu ký tự (character); chúng được coi là các chuỗi có độ dài
một, do đó cũng được coi là một chuỗi con.
Để truy cập các chuỗi con, hãy sử dụng dấu ngoặc vuông để cắt cùng với chỉ mục
hoặc các chỉ số để lấy chuỗi con. Ví dụ:
var2 = "Python Programming"
print("var1[0]: ", var1[0])

print("var2[1:5]: ", var2[1:5])
var1[0]: H
var2[1:5]: ytho
2.2.2.2 Cập nhật chuỗi

Người dùng có thể "cập nhật" một chuỗi hiện có bằng cách (tái) gán biến chứa chuỗi
đó với một chuỗi khác. Giá trị mới có thể được liên kết với giá trị trước đó của nó hoặc
với một chuỗi hoàn toàn khác. Ví dụ:
print("Updated String :- ", var1[:6] + 'Python')
Updated String :- Hello Python
2.2.2.3 Ký tự thoát
Bảng sau đây là danh sách các ký tự thoát hoặc không xuất bởi hàm print() được
có thể được biểu thị bằng ký hiệu dấu gạch chéo ngược (\). Một ký tự thoát được giải
thích; trong một chuỗi dấu nháy đơn cũng như ngoặc kép.
2.2.2.4 Toán tử chuỗi đặc biệt

Giả sử biến chuỗi a chứa 'Hello' và biến b chứa 'Python', sau đó:
2.2.2.5 Toán tử định dạng chuỗi

Một trong những tính năng thú vị nhất của Python là toán tử định dạng chuỗi %.
Toán tử này là duy nhất đối với các chuỗi và bổ sung cho gói có các hàm từ họ printf()
của C. Sau đây là một ví dụ đơn giản.
print("My name is %s and weight is %d kg!" % ('Robot', 21))
Khi đoạn code trên được thực thi, nó tạo ra kết quả:
My name is Robot and weight is 21 kg!
Đây là danh sách đầy đủ các ký hiệu có thể được sử dụng cùng với %
2.2.2.6 Ba dấu ngoặc kép

Bộ ba dấu ngoặc kép cho phép các chuỗi trải dài trên nhiều dòng, bao gồm
NEWLINEs nguyên văn, TAB và bất kỳ ký tự đặc biệt nào khác.
Cú pháp cho ba dấu ngoặc kép liên tiếp:
para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print(para_str)
Khi đoạn code trên được thực thi, nó tạo ra kết quả sau. Lưu ý cách mọi ký tự đặc biệt
đơn lẻ đã được chuyển đổi sang dạng xuất (print) của nó, ngay đến NEWLINE cuối cùng
ở cuối chuỗi giữa up. và đóng ba dấu ngoặc kép. Cũng lưu ý rằng NEWLINE xảy ra với
dấu xuống dòng rõ ràng ở cuối dòng hoặc mã thoát của nó (\n).
this is a long string that is made up of
several lines and non-printable characters such as
TAB ( ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like

this within the brackets [
], or just a NEWLINE within
the variable assignment will also show up.
Các chuỗi gốc hoàn toàn không coi dấu gạch chéo ngược (\) là một ký tự đặc biệt.
Mỗi ký tự người dùng đặt vào một chuỗi gốc sẽ giữ nguyên cách người dùng đã viết nó.
Ví dụ:
print('C:\\nowhere')
Khi đoạn code trên được thực thi, nó tạo ra kết quả sau:
C:\nowhere
Bây giờ hãy sử dụng chuỗi gốc. Chúng ta sẽ đặt biểu thức trong r'expression' như
sau:
print(r'C:\\nowhere')
C:\\nowhere
2.2.2.7 Chuỗi Unicode

Các chuỗi bình thường trong Python được lưu trữ bên trong dưới dạng ASCII 8 bit,
trong khi các chuỗi Unicode được lưu trữ dưới dạng Unicode 16 bit. Điều này cho phép
tập hợp các ký tự đa dạng hơn, bao gồm các ký tự đặc biệt từ hầu hết các ngôn ngữ
trên thế giới. Phần này sẽ hạn chế xử lý các chuỗi Unicode như sau:
print(u'Hello, world!')
Hello, world!
Như có thể thấy, các chuỗi Unicode sử dụng tiền tố u, giống như các chuỗi gốc sử dụng
tiền tố r
2.2.2.8 Một số phương thức chuỗi tích hợp

Python bao gồm các phương thức tích hợp sau để thao tác chuỗi:
▪ capitalize() - được sử dụng để viết hoa chuỗi hiện tại. Nó chỉ đơn giản trả về một
chuỗi với chữ cái đầu tiên được viết hoa, đó là chữ hoa và các ký tự còn lại của chuỗi
đó được chuyển thành chữ thường. Nếu chữ cái đầu tiên của chuỗi đầu vào không
phải là bảng chữ cái hoặc nếu nó đã là chữ in hoa, thì sẽ không có hiệu lực ở đầu ra,
tức là chuỗi gốc không bị sửa đổi
Ví dụ:
str = "tutorial"
str1 = "Hii!"
str2 = "$Hii!"
output = str.capitalize()
output1 = str1.capitalize()
output2 = str2.capitalize()
print("The resultant string is:", output)
print("The resultant string is:", output1)
print("The resultant string is:", output2)
The resultant string is: Tutorial
The resultant string is: Hii!
The resultant string is: $hii!
▪ center(width, fillchar) - sử dụng để định vị chuỗi hiện tại ở giữa theo chiều rộng
đã cho. Phương thức này chấp nhận một giá trị số nguyên đại diện cho độ rộng mong
muốn của chuỗi làm tham số, đặt chuỗi hiện tại ở giữa và điền vào các ký tự còn lại
của chuỗi bằng khoảng trắng. Theo mặc định, các ký tự còn lại trong chuỗi được
điền bằng khoảng trống (trước và sau) và toàn bộ chuỗi sau phần đệm được trả về
dưới dạng đầu ra là giá trị được căn giữa. Người dùng cũng có thể chỉ định ký tự cần
sử dụng để điền bằng cách sử dụng tham số tùy chọn fillchar
Ví dụ: Sau đây là một ví dụ để căn giữa một chuỗi đầu vào với sự trợ giúp của hàm
center().Trong chương trình này một chuỗi "Welcome to Tutorialspoint." được tạo. Sau
đó, hàm center() được gọi trên chuỗi để căn giữa chuỗi và các khoảng trắng thừa còn
lại được lấp đầy bằng ký tự điền được chỉ định là '.'. output được xuất bằng hàm print().
str = "Welcome to Tutorialspoint."
output=str.center(40, '.')
print("The string after applying the center() function is:", output)
The string after applying the center() function is: .......Welcome to
Tutorialspoint........
Ví dụ: Nếu một chữ cái được lấy làm ký tự điền, thì chuỗi output được căn giữa theo
chiều rộng đã cho và các ký tự phụ được đệm bằng cách sử dụng chữ cái được chỉ định
trong tham số trong hàm center().
output=str.center(40, 's')
The string after applying the center() function is: sssssssWelcome to
Tutorialspoint.sssssss
Ví dụ: Nếu fillchar không được chỉ định trong tham số của hàm center(), thì fillchar
mặc định là space ASCII được coi là giá trị đệm.
output=str.center(40)
The string after applying the center() function is: Welcome to
Tutorialspoint.
Ví dụ: Nếu độ rộng tham số được đề cập nhỏ hơn độ dài của chuỗi đầu vào ban đầu,
chuỗi sẽ không thay đổi.
output=str.center(5)
The string after applying the center() function is: Welcome to Tutorialspoint.
▪ count(str, beg= 0,end=len(string)) - sử dụng để đếm số lần xuất hiện không
trùng lặp của chuỗi con được chỉ định làm tham số của hàm. Số lượng chuỗi con
trong một phạm vi cụ thể của chuỗi đó cũng có thể thu được bằng cách chỉ định
điểm bắt đầu và điểm kết thúc của phạm vi trong các tham số của hàm. Nếu chuỗi
con trống, nó trả về số lượng chuỗi trống giữa các ký tự bằng độ dài của chuỗi cộng
với một.
Ví dụ: Một chuỗi "Hello! Welcome to Tutorialspoint." được tạo. Sau đó, chuỗi con được
đếm chỉ định là 'i'. Hàm count() được gọi trên chuỗi có giá trị bắt đầu là 3 và giá trị kết
thúc là 30 làm đối số của nó.
str = "Hello! Welcome to Tutorialspoint."
substr = "i"
print("The number of occurrences of the substring in the input string are: ",
str.count(substr, 3, 30))
The number of occurrences of the substring in the input string are: 2
Ví dụ: Nếu giá trị kết thúc không được chỉ định trong các tham số của hàm, thì chỉ mục
cuối cùng của chuỗi được coi là giá trị kết thúc mặc định.
str = "Hello! Welcome to Tutorialspoint.";
substr = "to";
str.count(substr, 21))
Ví dụ: Nếu giá trị bắt đầu và kết thúc không được chỉ định trong các tham số của hàm,
thì chỉ mục thứ 0 của chuỗi được coi là giá trị bắt đầu mặc định và chỉ mục cuối cùng
của chuỗi được coi là giá trị kết thúc mặc định.
str = "Hello! Welcome to Tutorialspoint."
substr = "t"
str.count(substr))
Ví dụ: Nếu giá trị bắt đầu và kết thúc không được chỉ định trong các tham số của hàm,
thì chỉ mục thứ 0 của chuỗi được coi là giá trị bắt đầu mặc định và chỉ mục cuối cùng
của chuỗi được coi là giá trị kết thúc mặc định. Nếu chuỗi phụ trống, nó trả về số lượng
chuỗi trống giữa các ký tự bằng độ dài của chuỗi cộng với một.
str = "Hello! Welcome to Tutorialspoint.";
substr = "";
str.count(substr))
▪ endswith(suffix, beg=0, end=len(string)) - Xác định xem chuỗi hoặc chuỗi con
của chuỗi (nếu chỉ mục bắt đầu beg và chỉ mục kết thúc end được đưa ra) kết thúc
bằng hậu tố. Hàm này trả về true nếu chuỗi kết thúc bằng hậu tố đã chỉ định, ngược
lại trả về false.
Ví dụ: Một chuỗi "Hello! Welcome to Tutorialspoint." được tạo. Sau đó hàm endwith()
được gọi trên chuỗi chỉ có hậu tố làm đối số của nó và kết quả được in dưới dạng ngõ
ra bằng hàm print().
str = "Hello!Welcome to Tutorialspoint.";
suffix = "oint.";
result=str.endswith(suffix)
print("The input string ends with the given suffix:", result)
The input string ends with the given suffix: True
▪ find(str, beg=0 end=len(string)) - Xác định xem str xuất hiện trong chuỗi hay
trong chuỗi con của chuỗi nếu chỉ mục bắt đầu beg và chỉ mục kết thúc end được
đưa ra sẽ trả về chỉ mục nếu tìm thấy và -1 nếu không.
Ví dụ:
str1 = "Hello! Welcome to Tutorialspoint."
str2 = "to";
result= str1.find(str2)
print("The index where the substring is found:", result)
The index where the substring is found: 15
▪ index(str, beg=0, end=len(string)) - Tương tự như find(), nhưng đưa ra một
ngoại lệ nếu không tìm thấy str
Ví dụ:
str2 = "to";
result= str1.index(str2)
Ví dụ: Các khoảng trắng cũng được tính là các chuỗi con. Nếu có nhiều hơn một khoảng
trắng trong chuỗi đầu vào, thì khoảng trắng đầu tiên gặp phải trong chuỗi đầu vào được
coi là chỉ số kết quả.
str2 = " ";
result= str1.index(str2)
Ví dụ: Phương thức python string index() trả về chỉ mục nơi chuỗi con được tìm thấy
trong phạm vi của chỉ số bắt đầu và kết thúc được chỉ định.
str2 = " ";
result= str1.index(str2, 12, 15)
Ví dụ: Nếu cùng một chuỗi con xuất hiện nhiều lần trong chuỗi đầu vào, thì dựa trên
chỉ số bắt đầu hoặc kết thúc được chỉ định làm tham số của hàm, sẽ thu được chỉ mục
kết quả.
str2 = "to";
result= str1.index(str2, 5)
result= str1.index(str2, 18)
▪ isalnum() - trả về true nếu tất cả các ký tự trong chuỗi đầu vào là chữ và số, và
có ít nhất một ký tự. Nếu không, nó trả về false.
Ví dụ:
Str1 = "tutorial"
str2 = "Aa12"
result1=str1.isalnum()
result2=str2.isalnum()
print("Are all the characters of the string alphanumeric?", result1)
print("Are all the characters of the string alphanumeric?", result2)
Are all the characters of the string alphanumeric? True
Are all the characters of the string alphanumeric? True
Ví dụ: Chỉ các chữ cái viết thường, viết hoa và các số được kiểm tra. Các ký tự khác
như '!', '.', '/', v.v.. không phải là ký tự chữ và số. Ngay cả khi chuỗi chứa bảng chữ cái
có các loại ký tự không phải chữ và số này, thì hàm isalnum() trả về false.
str = "Hello!Welcome."
result=str.isalnum()
print("Are all the characters of the string alphanumeric?", result)
Are all the characters of the string alphanumeric? False
▪ isalpha() - Trả về true nếu chuỗi có ít nhất 1 ký tự và tất cả các ký tự là chữ cái,
ngược lại trả về false
str1 = "Hello!welcome"
str2 = "Welcome"
result1 = str1.isalpha()
result2 = str2.isalpha()
print("Are all the characters of the string alphabetic?", result1)
print("Are all the characters of the string alphabetic?", result2)
Are all the characters of the string alphabetic? False
Are all the characters of the string alphabetic? True
▪ isdigit() - Trả về true nếu chuỗi chỉ chứa các chữ số và false nếu ngược lại
Ví dụ:
str = "1235"
result=str.isdigit()
print("Are all the characters of the string digits?", result)
Are all the characters of the string digits? True
▪ islower() - trả về true nếu tất cả các ký tự trong chuỗi là chữ thường và có ít nhất
một ký tự và ngược lại là false
Ví dụ:
str1 = "Hello! Welcome to Tutorialspoint!";
str2 = "welcome to tutorialspoint";
result1 = str1.islower()
result2 = str2.islower()
print("Are all the cased characters in the string lowercases?", result1)
print("Are all the cased characters in the string lowercases?", result2)
Are all the cased characters in the string lowercases? False
Are all the cased characters of the string lowercases? True
▪ isupper() - Trả về true nếu chuỗi có ít nhất một ký tự và tất cả các ký tự đều là
chữ hoa và nếu ngược lại là false
Ví dụ:
str1 = "PYTHON"
str2 = "this is string example....wow!!!";
# Checking whether the string is in uppercase
res1 = str1.isupper()
res2 = str2.isupper()
# Printing the result
print ("Is the given string in uppercase?: ", res1)
print ("Is the given string in uppercase?: ", res2)
Is the given string in uppercase?: True
Is the given string in uppercase?: False
▪ len(string) - Trả về độ dài của chuỗi
Ví dụ:
str = "this is string example....wow!!!";
print "Length of the string: ", len(str)
Length of the string: 32
Ví dụ: một danh sách các chuỗi được tạo ra. Sau đó, sử dụng phương thức len(),trả về
độ dài của danh sách:
li = ["Python","Java","CSS","Javascript"]
# Returning the length of the list
print("The length of the given list is:", len(li))
The length of the given list is: 4
▪ join(seq) - Hợp nhất (nối) các biểu diễn chuỗi của các phần tử trong chuỗi seq thành
một chuỗi, với chuỗi phân cách
Ví dụ:
s = "-"
seq = ("a", "b", "c"); # This is sequence of strings.
print s.join(seq)
a-b-c
Ví dụ: tất cả các mục trong Dictionary đã cho được nối thành một chuỗi bằng cách sử
dụng từ “MATCH” làm dấu phân cách:
Dictionary = {"Player":"Sachin Tendulkar", "Sports":"Cricket"}
# Providing the separator
sep = "MATCH"
# Joining the items in the dictionary with the given string
res = sep.join(Dictionary)
print(res)
PlayerMATCHSports
▪ lower() - Chuyển đổi tất cả các chữ hoa trong chuỗi thành chữ thường
Ví dụ:
str = "THIS IS STRING EXAMPLE";
print(str.lower())
this is a string
▪ upper() - Chuyển đổi chữ thường trong chuỗi thành chữ hoa
Ví dụ:
str = "this is string example"
print(str.upper())
THIS IS STRING EXAMPLE
2.2.3 List
list là kiểu dữ liệu linh hoạt nhất có sẵn trong Python, có thể được viết dưới dạng list
các giá trị (mục) được phân tách bằng dấu phẩy giữa các dấu ngoặc vuông. Điều quan
trọng về list là các mục trong list không nhất thiết phải cùng kiểu biến.
Việc tạo một list cũng đơn giản như đặt các giá trị khác nhau được phân tách bằng
dấu phẩy giữa các dấu ngoặc vuông. Ví dụ
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"]
Tương tự như chỉ số chuỗi, chỉ số list bắt đầu từ 0 và danh sách có thể được trích
xuất, nối, v.v.
2.2.3.1 Truy cập các giá trị trong list

Để truy cập các giá trị trong list, hãy sử dụng dấu ngoặc vuông để trích xuất cùng
với chỉ số. Ví dụ:
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]
2.2.3.2 Cập nhật list

Người dùng có thể cập nhật một hoặc nhiều phần tử của list bằng cách đưa ở phía
bên trái của toán tử gán và có thể thêm vào các phần tử trong list bằng phương thức
append(). Ví dụ:
list = ['physics', 'chemistry', 1997, 2000];
print("Value available at index 2 : ")
print list[2]
list[2] = 2001;
print("New value available at index 2 : ")
print list[2]
Value available at index 2 :
1997
New value available at index 2 :
2001
Lưu ý - append() được thảo luận trong phần tiếp theo.
2.2.3.3 Xoá phần tử trong list

Để xóa một phần tử danh sách, người dùng có thể sử dụng câu lệnh del nếu biết
chính xác (những) phần tử nào đang xóa hoặc phương thức remove() nếu không biết.
Ví dụ
print list1
del list1[2];
print("After deleting value at index 2 : ")
print list1
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]
Lưu ý - phương thức remove() được thảo luận trong phần tiếp theo.
2.2.3.4 Các hoạt động cơ bản của list

Các list phản hồi các toán tử + và * giống như các chuỗi; chúng cũng có nghĩa là
nối và lặp lại ở đây, ngoại trừ việc kết quả là một list mới, không phải một chuỗi.
Trên thực tế, các list đáp ứng tất cả các thao tác tuần tự chung mà đã sử dụng trên
các chuỗi trong phần trước.
2.2.3.5 Chỉ số và ma trận
List là các dãy, chỉ số hoạt động theo cách tương tự đối với list cũng như đối với
chuỗi. Giả sử đầu vào như sau:
L = ['spam', 'Spam', 'SPAM!']
2.2.3.6 Các hàm và phương thức list

Python bao gồm các hàm list sau:
▪ cmp(list1, list2) - So sánh các phần tử của cả hai list
Ví dụ:
list1, list2 = [123, 'xyz'], [456, 'abc']
print(cmp(list1, list2))
list3 = list2 + [786];
-1
1
-1
▪ len(list) - Trả về số phần tử trong list
Ví dụ
list1, list2 = [123, 'xyz', 'zara'], [456, 'abc']
print("First list length : ", len(list1))
print("Second list length : ", len(list2))
First list length : 3
Second list length : 2
▪ max(list) - Trả về các phần tử từ list với giá trị lớn nhất
Ví dụ:
list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200]
print("Max value element : ", max(list1))
print("Max value element : ", max(list2))

Max value element : zara
Max value element : 700
▪ min(list) - Trả về các phần tử từ list với giá trị lớn nhất
Ví dụ:
list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200]
print("min value element : ", min(list1))
print("min value element : ", min(list2))
min value element : 123
▪ list(seq) - Chuyển đổi một tuple thành list
Ví dụ:
aTuple = (123, 'xyz', 'zara', 'abc')
aList = list(aTuple)
print("List elements : ", aList)
List elements : [123, 'xyz', 'zara', 'abc']
Python bao gồm các phương thức list như sau:
▪ list.append(obj) - Nối đối tượng obj
Ví dụ:
aList = [123, 'xyz', 'zara', 'abc']
aList.append( 2009 );
print("Updated List : ", aList)
Updated List : [123, 'xyz', 'zara', 'abc', 2009]
▪ list.count(obj) - Trả về số lần obj xuất hiện trong danh sách
Ví dụ:
aList = [123, 'xyz', 'zara', 'abc', 123]
print("Count for 123 : ", aList.count(123))
print("Count for zara : ", aList.count('zara'))
Count for 123 : 2
Count for zara : 1
▪ list.extend(seq) - Nối nội dung của seq vào list
Ví dụ:
aList = [123, 'xyz', 'zara', 'abc', 123]
bList = [2009, 'manni']
aList.extend(bList)
print("Extended List : ", aList)
Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
▪ list.index(obj) - Trả về chỉ số thấp nhất trong list mà obj xuất hiện
Ví dụ:
aList = [123, 'xyz', 'zara', 'abc'];
print("Index for xyz : ", aList.index( 'xyz' ) )
print("Index for zara : ", aList.index( 'zara' ))
Index for xyz : 1
Index for zara : 2
▪ list.insert(index, obj) - Chèn đối tượng obj vào list tại chỉ số offset
Ví dụ:
aList.insert( 3, 2009)
print("Final List : ", aList)
Final List : [123, 'xyz', 'zara', 2009, 'abc']
▪ list.pop(obj=list[-1]) - Xóa và trả về đối tượng hoặc đối tượng cuối cùng khỏi
danh sách
Ví dụ:
print("A List : ", aList.pop())
print("B List : ", aList.pop(2))
A List : abc
B List : zara
▪ list.remove(obj) - Xóa đối tượng obj khỏi list
Ví dụ:
aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.remove('xyz')
print("List : ", aList)
aList.remove('abc')
List : [123, 'zara', 'abc', 'xyz']
List : [123, 'zara', 'xyz']
▪ list.reverse() - Đảo ngược các đối tượng của list tại chỗ
Ví dụ:
aList.reverse()
List : ['xyz', 'abc', 'zara', 'xyz', 123]
▪ list.sort([func]) - Sắp xếp các đối tượng của list, sử dụng hàm so sánh nếu được
cung cấp
Ví dụ:
aList.sort()
List : [123, 'abc', 'xyz', 'xyz', 'zara']
2.2.4 Tuple
Một tuple là một tập hợp các đối tượng có thứ tự và không thay đổi. Tuples là dãy,
giống như list. Sự khác biệt giữa tuple và list là, tuple không thể thay đổi không giống
như list và tuple sử dụng dấu ngoặc đơn, trong khi list sử dụng dấu ngoặc vuông.
Tạo một tuple cũng đơn giản như đặt các giá trị khác nhau được phân tách bằng dấu
phẩy. Theo tùy chọn, cũng có thể đặt các giá trị được phân tách bằng dấu phẩy này
giữa các dấu ngoặc đơn. Ví dụ:
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
Tuple trống được viết dưới dạng hai dấu ngoặc đơn không chứa gì
tup1 = ()
Để viết một tuple chứa một giá trị duy nhất, người dùng phải bao gồm dấu phẩy,
mặc dù chỉ có một giá trị
tup1 = (50,)
Giống như chuỗi, chỉ số tuple bắt đầu từ 0 và chúng có thể được trích xuất, nối, v.v.
2.2.4.1 Truy cập các giá trị trong Tuple

Để truy cập các giá trị trong tuple, hãy sử dụng dấu ngoặc vuông để trích xuất cùng
với chỉ số để lấy giá trị có sẵn tại chỉ số đó. Ví dụ:
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])
tup1[0]: physics
tup2[1:5]: [2, 3, 4, 5]
2.2.4.2 Cập nhật Tuple

Tuple là bất biến, điều đó có nghĩa là không thể cập nhật hoặc thay đổi giá trị của
các phần tử tuple. Người dùng có thể lấy các phần của tuple hiện có để tạo bộ dữ liệu
mới như ví dụ sau minh họa:
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# Following action is not valid for tuples
# tup1[0] = 100
# So let's create a new tuple as follows
tup3 = tup1 + tup2
print(tup3)
(12, 34.56, 'abc', 'xyz')
2.2.4.3 Xoá phần tử Tuple

Không thể loại bỏ các phần tử tuple riêng lẻ. Tất nhiên, không có gì sai khi kết hợp
một tuple khác với các phần tử không mong muốn bị loại bỏ. Để loại bỏ một cách rõ
ràng toàn bộ tuple, chỉ cần sử dụng câu lệnh del. Ví dụ:
tup = ('physics', 'chemistry', 1997, 2000)
print(tup)
del tup
print("After deleting tup : ")
print(tup)
Điều này tạo ra kết quả sau đây. Lưu ý một ngoại lệ được nêu ra, điều này là do sau
khi dùng del tup, tuple không còn tồn tại nữa
('physics', 'chemistry', 1997, 2000)
After deleting tup :
File "test.py", line 9, in <module>
print tup;
NameError: name 'tup' is not defined
2.2.4.4 Các hoạt động cơ bản của Tuple

Các tuple phản hồi các toán tử + và * giống như các chuỗi; chúng cũng có nghĩa là
nối và lặp lại ở đây, ngoại trừ việc kết quả là một tuple mới, không phải là một chuỗi.
Trên thực tế, các tuple đáp ứng với tất cả các thao tác trình tự chung mà đã sử dụng
trên các chuỗi trong chương trước.
2.2.4.5 Chỉ số và ma trận

Tuple là các dãy, chỉ số hoạt động theo cách tương tự đối với list cũng như đối với
chuỗi. Giả sử đầu vào như sau:
L = ['spam', 'Spam', 'SPAM!']
2.2.4.6 Không có dấu phân cách kèm theo
Bất kỳ tập nhiều đối tượng nào, được phân tách bằng dấu phẩy, được viết mà không
có ký hiệu xác định, tức là, dấu ngoặc cho list, dấu ngoặc đơn cho tuple, v.v., mặc định
là tuple, như được chỉ ra trong các ví dụ sau:
print('abc', -4.24e93, 18+6.6j, 'xyz')
x, y = 1, 2
print("Value of x , y : ", x,y)
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2
2.2.4.7 Các hàm Tuple

Python bao gồm các hàm tuple sau:
▪ cmp(tuple1, tuple2) - So sánh các phần tử của cả hai tuple
Ví dụ:
tuple1, tuple2 = (123, 'xyz'), (456, 'abc')
print cmp(tuple1, tuple2)
tuple3 = tuple2 + (786,)
-1
1
-1
▪ len(tuple) - Cung cấp tổng chiều dài của tuple
Ví dụ:
tuple1, tuple2 = (123, 'xyz', 'zara'), (456, 'abc')
print("First tuple length : ", len(tuple1))
print("Second tuple length : ", len(tuple2))
First tuple length : 3
Second tuple length : 2
▪ max(tuple) - Trả về các phần tử từ tuple với giá trị lớn nhất
Ví dụ:
tuple1, tuple2 = (123, 'xyz', 'zara', 'abc'), (456, 700, 200)

print("Max value element : ", max(tuple1))
print("Max value element : ", max(tuple2))
Max value element : zara
Max value element : 700
▪ min(tuple) - Trả về các phần tử từ tuple với giá trị nhỏ nhất
Ví dụ:
tuple1, tuple2 = (123, 'xyz', 'zara', 'abc'), (456, 700, 200)
print("min value element : ", min(tuple1))
print("min value element : ", min(tuple2))
▪ tuple(seq) - Chuyển đổi một list thành tuple
Ví dụ:
aTuple = tuple(aList)
print("Tuple elements : ", aTuple)
Tuple elements : (123, 'xyz', 'zara', 'abc')
2.2.5 Dictionary
Mỗi key được phân tách khỏi giá trị của nó bằng dấu hai chấm (:), các phần tử được
phân tách bằng dấu phẩy và toàn bộ nội dung được đặt trong dấu ngoặc nhọn. Một
dictionary trống không có bất kỳ phần tử nào được viết chỉ bằng hai dấu ngoặc nhọn:
{}.
Các key là duy nhất trong một dictionary trong khi các giá trị có thể không. Các giá
trị của dictionary có thể thuộc bất kỳ loại nào, nhưng các key phải thuộc loại dữ liệu
bất biến, chẳng hạn như chuỗi, số hoặc tuple.
2.2.5.1 Truy cập các giá trị trong Dictionary

Để truy cập các phần tử dictionary, có thể sử dụng dấu ngoặc vuông quen thuộc
cùng với key để lấy giá trị của nó. Sau đây là một ví dụ:
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print("dict['Name']: ", dict['Name'])
print("dict['Age']: ", dict['Age'])
dict['Name']: Zara
dict['Age']: 7
Nếu cố gắng truy cập một mục dữ liệu với một key không phải là một phần của
dictionary, chúng ta sẽ gặp lỗi như sau:
print("dict['Alice']: ", dict['Alice'])
dict['Alice']:
print("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'
2.2.5.2 Cập nhật Dictionary

Người dùng có thể cập nhật dictionary bằng cách thêm mục nhập mới hoặc cặp key-
giá trị, sửa đổi mục nhập hiện có hoặc xóa mục nhập hiện có như minh họa bên dưới
trong ví dụ:
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
print("dict['School']: ", dict['School'])
dict['Age']: 8
dict['School']: DPS School
2.2.5.3 Xoá phần tử Dictionary

Người dùng có thể xóa các phần tử riêng lẻ hoặc xóa toàn bộ nội dung của dictionary.
Để xóa hoàn toàn toàn bộ dictionary, chỉ cần sử dụng câu lệnh del. Sau đây là một ví
dụ đơn giản
del dict['Name']; # remove entry with key 'Name'

dict.clear(); # remove all entries in dict
del dict ; # delete entire dictionary
print("dict['School']: ", dict['School'])
Điều này tạo ra kết quả sau đây. Lưu ý rằng một ngoại lệ được đưa ra bởi vì sau khi
dictionary del dict không còn tồn tại nữa.
dict['Age']:
TypeError: 'type' object is unsubscriptable
Lưu ý - phương thức del() được thảo luận trong phần tiếp theo.
2.2.5.4 Thuộc tính của key Dictionary

Giá trị dictionary không có hạn chế. Chúng có thể là bất kỳ đối tượng Python tùy ý
nào, đối tượng tiêu chuẩn hoặc đối tượng do người dùng định nghĩa. Tuy nhiên, điều
này không đúng với các key. Có hai điểm quan trọng cần nhớ về key:
▪ Không được phép có nhiều mục nhập trên mỗi key. Điều đó có nghĩa là không cho
phép key trùng lặp. Khi gặp phải các key trùng lặp trong quá trình gán, cái cuối cùng
sẽ được chọn. Ví dụ:
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
dict['Name']: Manni
▪ Các key phải là bất biến. Điều đó có nghĩa là có thể sử dụng chuỗi, số hoặc tuple
làm key nhưng không được phép sử dụng những thứ như ['key']. Sau đây là một ví
dụ đơn giản
Ví dụ:
dict = {['Name']: 'Zara', 'Age': 7}
dict = {['Name']: 'Zara', 'Age': 7}
TypeError: unhashable type: 'list'
2.2.5.5 Các hàm và phương thức Dictionary

Python bao gồm các hàm dictionary sau:
▪ cmp(dict1, dict2) - So sánh cả hai dict dựa trên key và giá trị, trả về 0 nếu cả hai
dictionary bằng nhau, -1 nếu dict1 < dict2 và 1 nếu dict1 > dic2
Ví dụ:
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Name': 'Mahnaz', 'Age': 27}
dict3 = {'Name': 'Abid', 'Age': 27}
print("Return Value : %d" % cmp (dict1, dict2))
Return Value : -1
Return Value : 1
Return Value : 0
▪ len(dict) - Cung cấp tổng chiều dài của dictionary. Điều này sẽ bằng với số lượng
mục trong dictionary
Ví dụ:
dict = {'Name': 'Zara', 'Age': 7}
print("Length : %d" % len (dict))
Length : 2
▪ str(dict) - Tạo một biểu diễn chuỗi có thể xuất được của một dictionary
Ví dụ:
print("Equivalent String : %s" % str (dict))
Equivalent String : {'Age': 7, 'Name': 'Zara'}
▪ type(variable) - Trả về kiểu của biến. Nếu biến là dictionary thì nó sẽ trả về kiểu
dictionary
Ví dụ:
print("Variable Type : %s" % type (dict))
Variable Type : <type 'dict'>
Python bao gồm các phương thức dictionary sau:
▪ dict.clear() - Loại bỏ tất cả các phần tử của dictionary dict
Ví dụ:
print("Start Len : %d" % len(dict))
dict.clear()
print("End Len : %d" % len(dict))
Start Len : 2
End Len : 0
▪ dict.copy() - Trả về một bản sao của dictionary dict
Ví dụ:
dict2 = dict1.copy()
print("New Dictionary : %s" % str(dict2))
New Dictionary : {'Age': 7, 'Name': 'Zara'}
▪ dict.fromkeys() - Tạo một dictionary mới với các khóa từ seq và các giá trị được đặt
thành giá trị
Ví dụ:
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print("New Dictionary : %s" % str(dict))
dict = dict.fromkeys(seq, 10)
print("New Dictionary : %s" % str(dict))
New Dictionary : {'age': None, 'name': None, 'sex': None}
New Dictionary : {'age': 10, 'name': 10, 'sex': 10}
▪ dict.get(key, default=None) - Trả về giá trị hoặc giá trị mặc định nếu key không
có trong dictionary
Ví dụ:
dict = {'Name': 'Zabra', 'Age': 7}
print("Value : %s" % dict.get('Age'))
print("Value : %s" % dict.get('Education', "Never"))
Value : 7
Value : Never
▪ dict.has_key(key) - Trả về true nếu key trong từ điển dict, ngược lại là false
Ví dụ:
print("Value : %s" % dict.has_key('Age'))
print("Value : %s" % dict.has_key('Sex'))
Value : True
Value : False
▪ dict.items() - Trả về danh sách các cặp tuple (key, value) của dict
Ví dụ:
print("Value : %s" % dict.items())
Value : [('Age', 7), ('Name', 'Zara')]
▪ dict.keys() - Trả về danh sách các key của từ điển dict
Ví dụ:
print "Value : %s" % dict.keys()
Value : ['Age', 'Name']
▪ dict.setdefault(key, default=None) - Tương tự như get(), nhưng sẽ đặt dict[key]
= default nếu key chưa có trong dict
Ví dụ:
print("Value : %s" % dict.setdefault('Age', None))

print("Value : %s" % dict.setdefault('Sex', None))
Value : 7
Value : None
▪ dict.update(dict2) - Thêm các cặp key-giá trị của dict2 vào dict
Ví dụ:
dict2 = {'Sex': 'female'}
dict.update(dict2)
print("Value : %s" % dict)
Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
▪ dict.values() - Trả về danh sách các giá trị của dictionary dict
Ví dụ:
print("Value : %s" % dict.values())
Value : [7, 'Zara']
TÓM TẮT
▪ Cách sử dụng cơ bản với biến bao gồm tạo biến, sử dụng hàm print với biến, xoá
biến, gán biến và phân biến biến cục bộ - toàn cục
▪ Cách sử dụng các biến tiêu chuẩn của Python bao gồm số, chuỗi, list, tuple và
dictionary thông qua các ví dụ

Câu 1: Các loại dữ liệu được hỗ trợ trong Python là gì?
Câu 2: Thực hiện các phép toán và xuất kết quả bằng hàm print
- Tính diện tích hình tròn và thể tích hình cầu với bán kính R = 1.1 mm
- Tính khoảng cách giữa hai điểm p1(4, 0) và (6, 6)
- Cho 𝛼 = 60𝑜 , quy đổi 𝛼 thành radian và tính sin 2𝛼 + 3(𝑐𝑜𝑠𝛼)2
- Tính (x + y) * (x + y) với x = 4, y = 3
Câu 3: Cho chuỗi str = 'Hello World!'?
- Kết quả của print str là gì?
- Kết quả của print str[0] là gì?
- Kết quả của print str[2:5] là gì?
- Kết quả của print str[2:] là gì?
- Kết quả của print str * 2 là gì?
- Kết quả của print str + "TEST" là gì?
- Chuyển đổi str thành chữ thường
Câu 4: Cho list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
- Kết quả của print list[0] là gì?
- Kết quả của print list[1:3] là gì?
- Kết quả của print list[2:] là gì?
- Kết quả của print list * 2 là gì?
- Chuyển đổi str trong câu 3 thành kiểu biến list
Câu 5: Sự khác biệt giữa list và tuple trong Python là gì?
Câu 6: Cho tuple = ( 'abcd', 786 , 2.23, 'john', 70.2)
- Kết quả của print tuple [0] là gì?
- Kết quả của print tuple [1:3] là gì?
- Kết quả của print tuple [2:] là gì?
- Kết quả của print tuple * 2 là gì?
- Kết quả của print tuple + tiny tuple là gì nếu tinytuple = (123, 'john')?
Câu 7: Sử dụng hàm print() xuất chuỗi theo định dạng sau:
Twinkle, twinkle, little star,
How I wonder what you are!
Up above the world so high,
Like a diamond in the sky.
Twinkle, twinkle, little star,
How I wonder what you are
Câu 8: Viết chương trình để hiển thị màu đầu tiên và màu cuối cùng từ list sau
color_list = ["Red","Green","White" ,"Black"]
Câu 9: Viết một chương trình cho một chuỗi các số được phân tách bằng dấu phẩy từ
người dùng và tạo một list và một tuple cho các số đó
Sample data : 3, 5, 7, 23
Output :
List : ['3', ' 5', ' 7', ' 23']
Tuple : ('3', ' 5', ' 7', ' 23')
Câu 10: Viết chương trình xuất ra tất cả các màu từ color_list_1 không có trong
color_list_2
Test Data:
color_list_1 = ["White", "Black", "Red"]
color_list_2 = ["Red", "Green"]
Expected Output:
['Black', 'White']
88 BÀI 3: SỬ DỤNG TOÁN TỬ VÀ TOÁN HẠNG
BÀI 3: SỬ DỤNG TOÁN TỬ VÀ

TOÁN HẠNG
▪ Nắm vững cách sử dụng các loại toán tử phổ biến trong Python bao gồm toán tử số
học, so sánh, gán, bitwise, logic, membership và nhận dạng
▪ Hiểu được mức độ ưu tiên giữa các toán tử khi chạy chương trình
3.1 Các loại toán tử

Toán tử Python là cấu trúc có thể thao tác giá trị của toán hạng. Đây là những biểu
tượng được sử dụng cho mục đích logic, số học và nhiều hoạt động khác.
Xét biểu thức 4 + 5 = 9. Ở đây, 4 và 5 được gọi là toán hạng và + được gọi là toán
tử. Trong phần này, sẽ nghiên cứu các loại toán tử Python khác nhau. Ngôn ngữ Python
hỗ trợ các loại toán tử sau:
▪ Số học
▪ So sánh (quan hệ)
▪ Gán
▪ Logic
▪ Bitwise
▪ Membership
▪ Nhận dạng
3.2 Toán tử số học

Toán tử số học Python được sử dụng để thực hiện các phép toán trên các giá trị số.
Các hoạt động này là cộng, trừ, nhân, chia lấy thương, chia lấy dư, số mũ (luỹ thừa)
và chia làm tròn.
BÀI 3: SỬ DỤNG TOÁN TỬ VÀ TOÁN HẠNG 89
Ví dụ:
a = 21
b = 10
# +
print ("a + b : ", a + b)
# -
print ("a - b : ", a - b)
# *
print ("a * b : ", a * b)
# /
print ("a / b : ", a / b)
# %
print ("a % b : ", a % b)
# số mũ (luỹ thừa)
print ("a ** b : ", a ** b)
# Chia làm tròn
print ("a // b : ", a // b)
Điều này tạo ra kết quả sau
a + b : 31
a - b : 11
a * b : 210
a / b : 2.1
a % b : 1
a ** b : 16679880978201
a // b : 2
3.3 Toán tử so sánh

Các toán tử so sánh trong Python so sánh các giá trị ở hai bên của chúng và quyết
định mối quan hệ giữa chúng. Chúng còn được gọi là các toán tử quan hệ. Các toán tử
này bằng, không bằng, lớn hơn, nhỏ hơn, lớn hơn hoặc bằng và nhỏ hơn hoặc bằng.
Ví dụ:
a = 4
b = 5
# Bằng
print ("a == b : ", a == b)
# Không bằng
print ("a != b : ", a != b)
# Lớn hơn
print ("a > b : ", a > b)
# Nhỏ hơn
print ("a < b : ", a < b)
# Lớn hơn hoặc bằng
print ("a >= b : ", a >= b)
# Ít hơn hoặc bằng
print ("a <= b : ", a <= b)
a == b : False
a != b : True
a > b : False
a < b : True
a >= b : False
a <= b : True
3.4 Toán tử gán

Các toán tử gán trong Python được sử dụng để gán giá trị cho các biến. Các toán tử
này bao gồm toán tử gán đơn giản, gán cộng, gán trừ, gán nhân, chia và gán toán tử,
v.v.
Ví dụ:
# Gán
a = 10
# Gán cộng
a += 5
print ("a += 5 : ", a)
# Gán trừ
a -= 5
print ("a -= 5 : ", a)
# Gán nhân
a *= 5
print ("a *= 5 : ", a)
# Gán trừ
a /= 5
print ("a /= 5 : ",a)
# Gán chia lấy dư
a %= 3
print ("a %= 3 : ", a)
# Gán luỹ thừa
a **= 2
print ("a **= 2 : ", a)
# Gán chia làm tròn
a //= 3
print ("a //= 3 : ", a)
a += 5 : 105
a -= 5 : 100
a *= 5 : 500
a /= 5 : 100.0
a %= 3 : 1.0
a **= 2 : 1.0
a //= 3 : 0.0
3.5 Toán tử bitwise

Toán tử bitwise hoạt động trên các bit và thực hiện thao tác từng bit. Giả sử nếu a
= 60; và b = 13; Bây giờ ở định dạng nhị phân, giá trị của chúng sẽ lần lượt là 0011
1100 và 0000 1101.
a = 0011 1100
b = 0000 1101
--------------------------
a&b = 12 (0000 1100)
a|b = 61 (0011 1101)
a^b = 49 (0011 0001)
~a = -61 (1100 0011)
a << 2 = 240 (1111 0000)
a>>2 = 15 (0000 1111)
Ví dụ:
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
# Binary AND
c = a & b # 12 = 0000 1100
print ("a & b : ", c)
# Binary OR
c = a | b # 61 = 0011 1101
print ("a | b : ", c)
# Binary XOR
c = a ^ b # 49 = 0011 0001
print ("a ^ b : ", c)
# Binary Ones Complement
c = ~a; # -61 = 1100 0011
print ("~a : ", c)
# Binary Left Shift
c = a << 2; # 240 = 1111 0000
print ("a << 2 : ", c)
# Binary Right Shift
c = a >> 2; # 15 = 0000 1111
print ("a >> 2 : ", c)

a & b : 12
a | b : 61
a ^ b : 49
~a : -61
a >> 2 : 240
a >> 2 : 15
3.6 Toán tử logic

Có các toán tử logic sau được hỗ trợ bởi ngôn ngữ Python. Giả sử biến a = 10 và
biến b = 20 thì
3.7 Toán tử Menbership

Toán tử membership của Python kiểm tra membership theo trình tự, chẳng hạn như
chuỗi, list hoặc tuple. Có hai toán tử membership như được giải thích bên dưới
Ví dụ:
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print("Line 1 - a is available in the given list")
else:
print("Line 1 - a is not available in the given list")
if ( b not in list ):
print("Line 2 - b is not available in the given list")
else:
print("Line 2 - b is available in the given list")
a = 2
if ( a in list ):
print("Line 3 - a is available in the given list")
else:
print("Line 3 - a is not available in the given list")
Khi thực hiện chương trình trên, nó tạo ra kết quả sau
Line 1 - a is not available in the given list
Line 2 - b is not available in the given list
Line 3 - a is available in the given list
3.8 Toán tử nhận dạng

Toán tử nhận dạng so sánh vị trí bộ nhớ của hai đối tượng. Có hai toán tử nhận dạng
được giải thích bên dưới
Ví dụ:
a = 20
b = 20
if ( a is b ):
print("Line 1 - a and b have same identity")
else:
print("Line 1 - a and b do not have same identity")
if ( id(a) == id(b) ):
else:

b = 30
if ( a is b ):
else:
if ( a is not b ):
else:
Line 1 - a and b have same identity
Line 2 - a and b have same identity
Line 3 - a and b do not have same identity
Line 4 - a and b do not have same identity
3.9 Mức độ ưu tiên giữa các toán tử

Bảng sau liệt kê tất cả các toán tử theo thứ tự ưu tiên cao nhất đến thấp nhất
Toán tử Mô tả
** Luỹ thừa
~+- Phần bù, cộng và trừ (tên phương thức cho hai phương thức cuối cùng
là +@ và -@)
* / % // Nhân, chia, chia lấy dư và chia làm tròn
+- Cộng, trừ
>> << Dịch phải và dịch trái bitwise
& Bitwise AND
^| XOR và OR
<= < > >= Toán tử so sánh
<> == != Toán tử bằng
= %= /= Toán tử gán
//= -= +=
*= **=
is is not Toán tử nhận dạng
in not in Toán tử membership
not or and Toán tử logic
Độ ưu tiên của toán tử ảnh hưởng đến cách một biểu thức được đánh giá. Ví dụ: x
= 7 + 3 * 2; ở đây, x được gán 13, không phải 20 vì toán tử * có độ ưu tiên cao hơn
+, do đó, trước tiên, nó nhân 3*2 rồi cộng với 7.
Ở đây, các toán tử có mức độ ưu tiên cao nhất sẽ xuất hiện ở đầu bảng, những toán
tử có mức độ ưu tiên thấp nhất sẽ xuất hiện ở cuối bảng.
Ví dụ:
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print("Value of (a + b) * c / d is ", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print("Value of ((a + b) * c) / d is ", e)
e = (a + b) * (c / d); # (30) * (15/5)
print("Value of (a + b) * (c / d) is ", e)
e = a + (b * c) / d; # 20 + (150/5)
print("Value of a + (b * c) / d is ", e)
Value of (a + b) * c / d is 90
Value of ((a + b) * c) / d is 90
Value of (a + b) * (c / d) is 90
Value of a + (b * c) / d is 50
TÓM TẮT
▪ Trong bài này, học viên phải nắm vững cách sử dụng các loại toán tử phổ biến trong
Python bao gồm toán tử số học, so sánh, gán, bitwise, logic, membership và nhận
dạng
▪ Hiểu được mức độ ưu tiên giữa các toán tử khi chạy chương trình

Câu 1: Mục đích của toán tử **, //, is, not in là gì?
Câu 2: Gán list màu cho biến: ["yellow", "white", "blue"]
# Nhập lệnh vào bên dưới và kiểm tra kết quả
lst =
print(lst)
Câu 3: Gán phép chia của a cho b cho biến
a = 10
b = 3
Result =
print(result)
Câu 4: Cộng 100 vào biến sử dụng +=
vertical_speed = 750
print(vertical_speed)
Câu 5: Sử dụng toán tử chia lấy dư cho 1000 và 400 sau đó gán cho biến
remainder =
print(remainder)
Câu 6: Sử dụng toán tử lũy thừa **, gán bình phương 11111 cho biến
p_result=
print(p_result)
Câu 7: Cho đoạn code sau:
a.
w = 2
x = 5
y = 7
a = w + y
b = y - w
c = y % x
d = y // w
e = y ** w
f = w * x
g = y / x
print(a,b,c,d,e,f,g)
b.
w = 20
x = 10
y = 15
z = 2
result_1 = (w+x)*y/z
result_2 = ((w+x)*x)/z
result_3 = ((w+x)*(y/z))**z
result_4 = w+(x*y)/z
print('The value of (w+x)* y/z is',result_1)
print('The value of ((w+x)*x)/z is',result_2)
print('The value of ((w+x)*(y/z))**z is',result_3)
print('The value of w+(x*y)/z is',result_4)
c.
a = False
b = False
x = not(a)
y = not(b)
print(a or b)
print(x or y)
print(a or x)
print(x or b)
print(a and b)
print(a and x)
print(y and b)
print(x and y)
d.
a = 1
b = 20
if a < 10:
print('Demo string 1')
else:
e.
a = 1
b = 20
if a < 10 or b == 20:
else:
f.
a = 1
b = 20
if a < 10 and not(b == 20):
else:
g.
x = 3
y = 6
z = 3
if x > 3:
print('Demo String 1')
else:
if x != z:
else:
if y < x:
else:
if y == x:

else:
if z <= x:
else:
if y >= 6:
else:
Sinh viên cho kết kết quả sau khi chạy đoạn code trên.
BÀI 4: CÂU LỆNH ĐIỀU KIỆN VÀ VÒNG LẶP 103
BÀI 4: CÂU LỆNH ĐIỀU KIỆN

VÀ VÒNG LẶP
▪ Giải thích cách sử dụng câu lệnh điều kiện của if cũng như các biến thể của nó và
vòng lặp bao gồm for và while
▪ Mô tả cú pháp cho các câu lệnh có điều kiện và vòng lặp trong Python
▪ Xác định được khi nào sử dụng vòng lặp for và while
▪ Lập trình được các tác vụ bằng câu lệnh điều kiện và vòng lặp trong Python
4.1 Câu lệnh điều kiện – Ra quyết định

Ra quyết định là dự đoán các điều kiện xảy ra trong khi thực hiện chương trình và
chỉ định các hành động được thực hiện theo các điều kiện.
Các cấu trúc quyết định đánh giá nhiều biểu thức tạo ra kết quả TRUE hoặc FALSE.
Người dùng cần xác định hành động nào sẽ thực hiện và câu lệnh nào sẽ thực hiện nếu
kết quả là TRUE hoặc FALSE nếu ngược lại. Dạng chung của một cấu trúc ra quyết định
điển hình được tìm thấy trong hầu hết các ngôn ngữ lập trình (hình 4.1).
Ngôn ngữ lập trình Python giả định mọi giá trị non-zero và non-null là TRUE và nếu
nó là zero hoặc null, thì nó được coi là giá trị FALSE.
4.1.1 Câu lệnh IF

Tương tự như của các ngôn ngữ khác. Câu lệnh if trong Python được sử dụng để xác
định xem một câu lệnh hoặc tập hợp các câu lệnh cụ thể có được thực hiện hay không.
Câu lệnh if chứa một biểu thức logic sử dụng dữ liệu nào được so sánh và quyết định
được đưa ra dựa trên kết quả so sánh. Nó bao gồm một đoạn code chỉ thực thi khi điều
kiện của câu lệnh if là TRUE. Nếu điều kiện là FALSE thì điều kiện sẽ không được thực
hiện. Python hỗ trợ các điều kiện logic toán học tiêu chuẩn như đã thảo luận trong phần
3.3
Cú pháp:
104 BÀI 4: CÂU LỆNH ĐIỀU KIỆN VÀ VÒNG LẶP
if expression:
statement(s)
Hình 4.1. Lưu đồ của câu lệnh if.

Lưu ý – Phần thụt lề của phần thân vòng lặp trong Python cho biết nội dung của câu
lệnh if. Cần phải thụt lề nội dung sau khi đã khai báo câu lệnh if. Phần thân bắt đầu
bằng một dòng thụt đầu dòng và kết thúc bằng dòng không thụt lề đầu tiên.
Ví dụ:
age = 16
limit = 25
if (age == 16):
print('Age is correct as mentioned')
if (age < 25):
print('Below age')
if (age > 10):
print('Teen')
if (age <= limit):
print('Under age limit')
if (age >= limit):
print('Above limit')
Khi đoạn mã trên được thực thi, nó tạo ra kết quả sau
Age is correct as mentioned
Below age
Teen
Under age limit
Ví dụ: nhập vào một số bất kỳ với hàm input và kiểm tra có phải là số chẵn không.
num = int(input('Enter a number:'))
if (num%2 == 0):
print('Number is Even')
Enter a number:10
Number is Even
Trong Python, có tổng cộng 5 biến thể câu lệnh if khác nhau.
4.1.2 Câu lệnh if…else

Một câu lệnh else có thể được kết hợp với một câu lệnh if, chứa khối mã thực thi
nếu biểu thức điều kiện trong câu lệnh if chuyển thành 0 hoặc giá trị FALSE. Câu lệnh
else là một câu lệnh tùy chọn và chỉ có thể có nhiều nhất một câu lệnh khác theo sau
if.
Cú pháp:
if expression:
statement(s)
else:
statement(s)
Hình 4.2. Lưu đồ của câu lệnh if…else.

Nói cách khác, câu lệnh if-else bao gồm 2 khối trong đó một câu lệnh hoặc tập hợp các
câu lệnh đầu tiên chỉ thực thi khi điều kiện của câu lệnh if là đúng. Nếu điều kiện của
câu lệnh if là sai thì một câu lệnh hoặc tập hợp các câu lệnh trong phần else sẽ được
thực hiện.
Ví dụ:
history = 45
science = 57
if (history > science):
print('History marks greater than Science')
else:
print('Science marks greater than History')
Science marks greater than History
Trong ví dụ trên, nếu điểm lịch sử lớn hơn điểm khoa học, điều kiện if sẽ được thỏa
mãn tức là TRUE và hàm print tương ứng sẽ được thực thi. Ngược lại, nếu điểm lịch sử
nhỏ hơn điểm khoa học, điều kiện if không thỏa tức là FALSE, thì hàm print của else
sẽ được thực thi.
4.1.3 Câu lệnh if…elif…else

Người dùng có thể chọn từ nhiều lựa chọn thay thế tại đây. Trong biến thể của câu
lệnh if này, có nhiều điều kiện if khác được khai báo. Nếu điều kiện đầu tiên không
thỏa mãn thì điều kiện tiếp theo sẽ được thực hiện. Nhưng nếu điều kiện này cũng
không thỏa mãn thì điều kiện tiếp theo sẽ được thực hiện. Hãy xem cú pháp và lưu đồ
của câu lệnh if…elif…else.
Cú pháp:
if condition1:
statements(s)
elif condition2:
statements(s)
elif condition3:
statements(s)
else:
statements(s)
Hình 4.3. Lưu đồ của câu lệnh if…elif…else.

Lưu ý – elif là viết tắt của else if. Nếu điều kiện cho if là FALSE thì điều kiện elif được
kiểm tra và thực hiện nếu tìm thấy ĐÚNG hoặc, các câu lệnh sau elif được thực thi.
Ví dụ: Nhập số điểm của sinh viên từ 0-50 và đánh giá như sau:
▪ Nếu điểm nhỏ hơn 20, thì xuất ra 'Student Failed'
▪ Nếu điểm lớn hơn hoặc bằng 20 và nhỏ hơn 40, thì xuất ra 'Student passed with B
Grade'
▪ Nếu điểm khác với hai trường hợp trên, thì xuất ra 'Student passed with A Grade'
marks = int(input('Enter marks from 0-50: '))
if (marks<20):
print('Student Failed')
elif (marks>=20 and marks<40):
print('Student passed with B Grade')
else:
print('Student passed with A Grade')
Enter marks from 0-50: 35
Student passed with B Grade
4.1.4 Câu lệnh if lồng nhau - Nested if

Người dùng có thể có một câu lệnh if…else bên trong một câu lệnh if…else khác.
Điều này được gọi là lồng các vòng lặp. Python cung cấp cho người dùng phương thức
lồng nhau. Các câu lệnh này có thể được lồng vào nhau theo bất kỳ thứ tự nào. Cách
duy nhất để xác định độ sâu của lồng là sử dụng thụt đầu dòng. Chúng có thể gây nhầm
lẫn, do đó nên tránh sử dụng cho đến khi thực sự cần thiết.
Hình 4.4. Lưu đồ của câu lệnh if…else lồng.

Ví dụ: nhập một số nguyên và kiểm tra đó là số 0, nguyên âm hoặc nguyên dương
val = int(input('Enter a number: '))
if val>=0:
if val == 0:
print('Number is Zero')
else:
print('Number is positive')
else:
print('Number is negative')
Enter a number: 24
Number is positive
Enter a number: 0
Number is Zero
Enter a number: -10
Number is negative
4.1.5 Câu lệnh if viết tắt - Shorthand if

if viết tắt có thể được sử dụng khi chỉ cần xử lý một câu lệnh bên trong khối if. Câu
lệnh if và câu lệnh có thể nằm trên cùng một dòng. Người dùng cũng có thể sử dụng
câu lệnh else cùng với câu lệnh if viết tắt.
Cú pháp:
if condition: statement
else: statement
Ví dụ:
name = 'Robotic'
if name == 'Robotic': print('Hello Robotic')
else: print('What is your name?')
Hello Robotic
4.1.6 Câu lệnh if…else viết tắt - Shorthand if…else

Nếu chỉ có một câu lệnh được thực hiện trong cả hai khối if và else, kiểu viết tắt
này có thể được sử dụng để viết các câu lệnh if…else trên một dòng.
Cú pháp:
statement_when_True if condition else statement_when_False
Ví dụ:
name = 'Robotic'
print('Hello Robotic') if name == 'Robotic' else print('What is your name?')
What is your name?
4.2 Vòng lặp

Nói chung, các câu lệnh được thực hiện tuần tự: Câu lệnh đầu tiên trong một hàm
được thực thi trước, tiếp theo là câu lệnh thứ hai, v.v. Có thể xảy ra tình huống khi
người dùng cần thực thi một khối code nhiều lần.
Các ngôn ngữ lập trình cung cấp các cấu trúc điều khiển khác nhau cho phép thực
hiện các đường dẫn phức tạp hơn. Một câu lệnh lặp cho phép thực hiện một câu lệnh
hoặc một nhóm câu lệnh nhiều lần.
4.2.1 Vòng lặp for

Vòng lặp for trong Python là một loại vòng lặp được sử dụng để lặp lại một tập hợp
các câu lệnh nhiều lần, được sử dụng để duyệt tuần tự các cấu trúc dữ liệu hoặc các
đối tượng có thể lặp lại khác cho đến khi điều kiện được thỏa mãn. Nó có khả năng lặp
qua các mục (item) của bất kỳ trình tự (sequence) nào, chẳng hạn như list hoặc string…
Cú pháp:
for iterating_var in sequence:
statements(s)
Trong đó,
itrating_var: biến lấy từng giá trị riêng lẻ của sequence trong mỗi lần lặp
sequence: cấu trúc dữ liệu như list, string, tuple, dictionary, phạm vi (range)
statements: code thực thi
Hình 4.5. Lưu đồ của vòng lặp for.

Mỗi item của sequence được gán cho biến lặp (iterating_var) và sau đó tập hợp các
câu lệnh được thực hiện trên nó. Điều này tiếp tục tiếp tục theo thứ tự cho đến khi điều
kiện bên trong vòng lặp được đáp ứng là toàn bộ sequence đã hết.
Nói cách khác, giả sử một sequence chứa list biểu thức, nó sẽ được đánh giá trước.
Sau đó, mục đầu tiên trong sequence được gán cho biến lặp itrating_var. Tiếp theo,
khối câu lệnh được thực thi. Mỗi mục trong list được gán cho itrating_var và khối (các)
câu lệnh được thực thi cho đến khi toàn bộ sequence hết.
Ví dụ:
cars = ['BMW', 'Audi', 'Tata', 'Ford']
for n in cars:
print('Car Company:', n)
num = [1, 3, 5, 7, 9]
sum = 0
for i in num:
sum = sum + i
print('The sum is:', sum)
Car Company: BMW
Car Company: Audi

Car Company: Tata
Car Company: Ford
The sum is: 25
Ví dụ:
for letter in 'Python':
print('Current Letter :', letter)
fruits = ['banana', 'apple', 'mango']
for fruit in fruits:
print('Current fruit :', fruit)
Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n
Current fruit : banana
Current fruit : apple
Current fruit : mango
4.2.1.1 Lặp bằng cách lập chỉ mục trình tự

Một phương pháp khác để lặp qua từng mục là sử dụng phần bù chỉ mục (index
offset) trong sequence. Cũng có thể lặp lại bằng cách sử dụng index của sequence. Khái
niệm cơ bản trước tiên là tính toán độ dài của list bằng cách sử dụng hàm len(), sau
đó lặp sequence trong phạm vi đó bằng cách sử dụng hàm range().
Ví dụ:
cars = ['BMW', 'Audi', 'Tata', 'Ford']
for index in range(len(cars)):
print('Car Company:', cars[index])
Car Company: BMW
Car Company: Audi
Car Company: Tata
Car Company: Ford
4.2.1.2 Hàm range()

Hàm range() trong Python được sử dụng để tạo một dãy số liên tiếp cũng như để
lặp qua một vòng lặp trong một số lần cố định. Vòng lặp sẽ được thực hiện cho đến khi
số được chỉ định trong hàm range() kết thúc.
Cú pháp:
range(start, stop, step_size)
Trong đó,
start: cho biết bắt đầu lặp lại.
stop: chỉ ra rằng vòng lặp sẽ tiếp tục cho đến khi đạt đến điểm dừng. Nó là tùy chọn.
step_size: được sử dụng để bỏ qua các số cụ thể của lần lặp, việc này hoàn toàn phụ
thuộc vào người dùng. Kích thước bước được đặt ở 1 theo mặc định.
Lưu ý – Nếu một đối số duy nhất được chuyển đến hàm range(), thì nó sẽ bắt đầu các
dãy số đó bắt đầu từ 0. Nếu range(5) được chỉ định, thì phạm vi giá trị là từ 0 đến 4.
Ví dụ:
# To print a range of numbers
for i in range(6):
print('Number:', i)
Number: 0
Number: 1
Number: 2
Number: 3
Number: 4
Number: 5
Ví dụ:
# print values of list using range() in for loop
students = ['Rock', 'John', 'Tia', 'Jenny', 'David']
for name in range(len(students)):
print("Welcome", students[name])
Welcome Rock
Welcome John
Welcome Tia
Welcome Jenny
Welcome David
4.2.1.3 Vòng lặp for với else

Từ khóa else chỉ định một khối code có thể được sử dụng cùng với vòng lặp for cho
biết khi vòng lặp for thực hiện xong các item trong sequence, khối code này sẽ được
thực thi tiếp theo. Sau khi tất cả các lần lặp của vòng lặp for đã hoàn thành, câu lệnh
else sẽ được thực thi.
Ví dụ:
for n in range(0, 5):
print('Numbers are:', n)
else:
print('No items left')
Numbers are: 0
Numbers are: 1
Numbers are: 2
Numbers are: 3
Numbers are: 4
No items left
Ví dụ:
dislike_choice = 'Worst'
genre = {'Good': 'rock', 'Good': 'jazz', 'Bad': 'reggae', 'Better': 'house',
'Best': 'pop', 'Best': 'hiphop'}
for s in genre:
if s == dislike_choice:
print('I do not like:', genre[s])
break
else:
print('Worst genre not found')
Worst genre not found
4.2.1.4 Vòng lặp for lồng

Python cho phép người dùng lồng vòng lặp for bên trong vòng lặp for khác. Đối với
mỗi lần lặp của vòng lặp bên ngoài, vòng lặp bên trong sẽ được thực hiện n lần. Trừ
khi vòng lặp bên ngoài không kết thúc, các lần lặp lại vòng lặp bên trong sẽ tiếp tục
thực hiện.
Ví dụ:
rows = int(input('Enter no. of rows: '))
for i in range(rows+1):
for j in range(i):
print('*', end = '')
print()
Enter no. of rows: 7
*
**
***
****
*****
******
*******
4.2.2 Vòng lặp while

Vòng lặp while được phân loại là một loại vòng lặp không xác định. Về cơ bản, điều
này có nghĩa là trong vòng lặp while của python, không thể dự đoán số lần nó sẽ được
thực thi. Đôi khi nó thậm chí có thể được coi là một câu lệnh if lặp lại.
Chức năng chính của vòng lặp while trong python là thực thi lặp lại một khối câu
lệnh miễn là điều kiện/biểu thức kiểm tra được thỏa mãn (TRUE). Dòng tiếp theo trong
chương trình sẽ chỉ được thực thi khi điều kiện/biểu thức kiểm tra trở thành FALSE.
Cú pháp:
while expression:
statement(s)
Trong Python, tất cả các câu lệnh được thụt đầu dòng bởi cùng một số khoảng trắng
ký tự sau cấu trúc lập trình được coi là một phần của một khối code. Python sử dụng
thụt đầu dòng làm phương pháp nhóm các câu lệnh. Theo mặc định, mọi giá trị khác 0
được xác định là TRUE trong khi None và 0 được hiểu là FALSE.
Hình 4.6. Lưu đồ của vòng lặp while.

Ví dụ:
count = 0
while (count < 9):
print('The count is:', count)
count = count + 1
print("Good bye!")
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!
Khối ở đây, bao gồm các câu lệnh print và tăng, được thực hiện lặp lại cho đến khi
count không còn nhỏ hơn 9. Với mỗi lần lặp lại, giá trị hiện tại của count được hiển thị
và sau đó tăng thêm 1.
4.2.2.1 Vòng lặp vô hạn

Một vòng lặp trở thành vòng lặp vô hạn nếu một điều kiện không bao giờ trở thành
FALSE. Người dùng phải thận trọng khi sử dụng vòng lặp while vì có khả năng điều
kiện này không bao giờ chuyển thành giá trị FALSE. Điều này dẫn đến một vòng lặp
không bao giờ kết thúc. Một vòng lặp như vậy được gọi là một vòng lặp vô hạn.
Một vòng lặp vô hạn có thể hữu ích trong lập trình client/server khi server cần chạy
liên tục để các chương trình client có thể giao tiếp với nó khi cần thiết.
Ví dụ:
var = 1
while var == 1 :
num = input("Enter a number: ")
print("You entered: ", num)
Enter a number :20
You entered: 20
Enter a number :29
You entered: 29
Enter a number :3
You entered: 3
Enter a number between :Traceback (most recent call last):
num = raw_input("Enter a number: ")
KeyboardInterrupt: Interrupted by user
Ví dụ trên diễn ra trong một vòng lặp vô tận và cần sử dụng CTRL+C để thoát khỏi
chương trình.
4.2.2.2 Vòng lặp while viết tắt

Tương tự như cú pháp câu lệnh if, nếu mệnh đề while chỉ bao gồm một câu lệnh
duy nhất, thì nó có thể được đặt trên cùng một dòng với tiêu đề while.
Ví dụ:
flag = 1
while (flag): print('Given flag is really true!')

Ví dụ trên vì nó đi vào vòng lặp vô hạn và cần nhấn tổ hợp phím CTRL+C để thoát.
4.2.2.3 Sử dụng câu lệnh else với vòng lặp while

Python hỗ trợ để có một câu lệnh else được liên kết với một câu lệnh vòng lặp. Nếu
câu lệnh else được sử dụng với vòng lặp while, nó sẽ được thực thi khi điều kiện trở
thành FALSE.
Ví dụ:
count = 0
while count < 5:
print (count, " is less than 5")
count = count + 1
else:
print(count, " is not less than 5")
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
4.2.2.4 Câu lệnh điều khiển vòng lặp

Để thay đổi việc thực hiện các vòng lặp so với trình tự bình thường của chúng, các
câu lệnh điều khiển vòng lặp được sử dụng. Nếu có bất kỳ phạm vi nào còn lại sau khi
thực hiện các câu lệnh đã cho, mọi đối tượng tự động được tạo trong phạm vi đó sẽ bị
xóa. Dưới đây là một số câu lệnh điều khiển được hỗ trợ bởi Python:
▪ break - được sử dụng bất cứ khi nào cần dừng việc thực hiện chương trình mặc dù
điều kiện của vòng lặp while là TRUE
Ví dụ:
list = [1,25,37,4,85,6,17,58,9]
i=0
while (i < len(list)):
print (list[i])
i+=1
if (i==5):
break
1
25
37
4
85
Trong chương trình này, đầu tiên xác định một list các số ngẫu nhiên và sau đó chúng
tôi bắt đầu biến đếm i. Vòng lặp while được thực thi với điều kiện là i nhỏ hơn chiều
dài của list. Nếu i đạt đến phần thử thứ 5 trong list, câu lệnh break được sử dụng để
kết lúc vòng lặp khi giá trị biến i là 4.
▪ continue - với sự trợ giúp của câu lệnh continue, điều khiển được đưa trở lại đầu
vòng lặp
Ví dụ:
a = 0
b = 'mississippi'
while a < len(b):
if b[a]== 's' or b[a] == 'i':
a+=1
continue
print ("The current letter is : ", b[a])
a+=1
The current letter is : m
The current letter is : p
The current letter is : p
Khi thực hiện thành công chương trình, tất cả các chữ cái ngoại trừ 'i' và 's' được trả
về. Mỗi lần lặp sẽ tính đến toàn bộ từ 'mississippi' và xuất ra chữ cái đầu tiên sau khi
loại bỏ 'i' và 's'. Do đó, chữ cái đầu tiên được in là m và sau đó p được in hai lần vì nó
xuất hiện hai lần trong từ đã chọn.
▪ pass - khi cần tạo các vòng lặp trống, sử dụng câu lệnh pass. Câu lệnh pass cũng
được sử dụng trong các câu lệnh điều khiển trống, hàm và class
Ví dụ:
a = 'Hello World'
i=0
while i <= len(a):
i+=1
pass
print("The value of i is: ", i)
The value of i is : 12
Trong chương trình trên, chúng ta cần tạo một vòng lặp trống trong đó chúng ta lưu
trữ tất cả các giá trị của chuỗi 'Hello World'. Tiếp theo, một biến đếm i được bắt đầu.
Đối với điều này, sử dụng hàm len() để tính số lượng chữ cái trong chuỗi hiện tại. Vòng
lặp while được xác định sao cho nó hiển thị số lượng chữ cái chính xác trong chuỗi.
Biến đếm được tăng thêm một cho mỗi lần lặp miễn là tất cả các chữ cái trong chuỗi
được tính đến khi thực hiện chương trình.
TÓM TẮT
▪ Cách sử dụng câu lệnh điều kiện của if và các biến thể của nó
▪ Cách sử dụng vòng lặp for và while trong các trư
▪ Viết chương trình Python cho các tác vụ dựa trên câu lệnh điều kiện và vòng lặp
BÀI TẬP
Câu 1: Làm thế nào để sử dụng lệnh if và các biến thể của nó trong Python? Cho ví
dụ.
Câu 2: Tại sao sử dụng lệnh if và các biến thể của nó?
Câu 3: Làm thế nào để viết một vòng lặp for, while trong Python? Cho ví dụ
Câu 4: Viết chương trình nhập vào 4 số nguyên. Tìm và xuất ra số lớn nhất
Hướng dẫn: Ta có 4 số nguyên a, b, c, d. Tìm 2 số nguyên lớn nhất x, y của 2 cặp (a,
b) và (c, d). Sau đó so sánh 2 số nguyên x, y để tìm ra số nguyên lớn nhất
Câu 5: Viết chương trình giải phương trình bậc 2: ax2 + bx + c = 0, với a, b, c nhập
vào từ bàn phím
Câu 6: Viết chương trình nhập tìm các số chia hết cho 5 và 7 trong khoảng 1500 –
2700
Câu 7: Viết chương trình để xuất dấu * như sau , sử dụng vòng lặp for lồng nhau
*
**
***
****
*****
****
***
**
*
Câu 8: Viết chương trình nhận một chuỗi ký tự từ người dùng và đảo ngược từ đó
Câu 9: Viết chương trình nhập một dãy số và đếm số chẵn và lẻ trong dãy số đó
Ví dụ: number = (1, 2, 3, 4, 5, 6, 7, 8, 9)
Câu 10: Viết chương trình xuất tất cả các số từ 0 đến 100 ngoại trừ số 10 và số 20
Câu 11: Viết chương trình chấp nhận một chuỗi ký tự bao gồm số và chữ, sau đó tính
tổng số chữ số và chữ cái
Câu 12: Viết chương trình kiểm tra xem một chuỗi có đại diện cho một số nguyên hay
không. Ví dụ: Input a string: Python
The string is not an integer
BÀI 5: LẬP TRÌNH PYTHON 123
BÀI 5: LẬP TRÌNH PYTHON
▪ Hiểu cách định nghĩa hàm và phạm vi biến cho việc lập trình
▪ Hiểu cách các module được tải bằng câu lệnh import; kiểm tra các module được phát
hiện thông qua các vị trí tìm kiếm; và tổ chức thành package cho việc lập trình
▪ Hiểu cấu trúc của hệ thống file bao gồm cách mở, đóng và xoá file với các chế độ
khác nhau
▪ Mô tả được lỗi và ngoại lệ, xử lý được khi chúng xảy ra và định nghĩa, sử dụng ngoại
lệ tuỳ chỉnh
▪ Mô tả được các khái niệm liên quan đến lập trình hướng đối tượng; phân biệt được
lớp và đối tượng
▪ Tạo các lớp đóng vai trò là bản thiết kế cho mọi đối tượng trong Python; tìm hiểu
cách lập trình, gọn gàng và hiệu quả
5.1 Hàm
Hàm là một khối code có tổ chức, có thể tái sử dụng để thực hiện một hành động
đơn lẻ có liên quan. Cung cấp tính mô-đun tốt hơn cho ứng dụng và mức độ tái sử dụng
code cao.
Python cung cấp cho người dùng nhiều hàm sẵn như print(), v.v. nhưng người dùng
cũng có thể tạo các hàm của riêng mình. Các hàm này được gọi là hàm do người dùng
định nghĩa.
5.1.1 Định nghĩa hàm

Người dùng có thể định nghĩa hàm để cung cấp chức năng cần thiết. Dưới đây là các
quy tắc đơn giản để định nghĩa một hàm trong Python.
▪ Các khối hàm bắt đầu bằng từ khóa def theo sau là tên hàm và dấu ngoặc đơn ()
▪ Mọi tham số hoặc đối số đầu vào phải được đặt trong các dấu ngoặc đơn này. Người
dùng cũng có thể định nghĩa các tham số bên trong các dấu ngoặc đơn này
124 BÀI 5: LẬP TRÌNH PYTHON
▪ Câu lệnh đầu tiên của một hàm có thể là một câu lệnh tùy chọn - docstring
▪ Khối code trong hàm bắt đầu bằng dấu hai chấm (:) và được thụt vào đầu dòng
▪ Câu lệnh return [biểu thức] thoát khỏi một hàm, tùy chọn trả lại một biểu thức khi
gọi hàm. Câu lệnh return không có đối số, None
5.1.2 Cú pháp
def functionname(parameters):
"function_docstring"
function_suite
return [expression]
Theo mặc định, các tham số có hành vi theo vị trí và người dùng cần thông báo
cho chúng theo cùng thứ tự mà chúng đã được xác định.
Ví dụ: Hàm sau lấy một chuỗi làm tham số đầu vào và xuất nó trên màn hình tiêu
chuẩn.
def printme(str):
"This prints a passed string into this function"
Print(str)
return
Để hiểu hơn về docstring, trong phần này sẽ được thảo luận. Chuỗi mô tả tài liệu
trong Python hay thường được gọi là docstring, là một chuỗi ký tự và nó được sử dụng
trong định nghĩa lớp, mô-đun, hàm hoặc phương thức.
docstring là rất hữu ích để hiểu về chức năng của phần lớn các đoạn code, cụ thể
là mục đích chung của bất kỳ class, module hoặc hàm nào, trong khi các chú thích
(comment) được sử dụng cho đoạn code, câu lệnh và biểu thức, có quy mô nhỏ hơn.
Chúng là một đoạn văn bản mô tả được viết bởi người lập trình để biết dòng code hoặc
biểu thức có chức năng là gì và cũng dành cho người lập trình khác muốn đóng góp cho
dự án đó.
5.1.2.1 So sánh giữa Docstring và chú thích (Comment)

docstring có chức năng tương tự như chú thích, nhưng chúng là dạng chú thích
nâng cao, logic hơn và hữu ích hơn. docstring đóng vai trò làm đoạn code giải thích
cho class, module và package. Mặt khác, chú thích chủ yếu được sử dụng để giải thích
các phần đoạn code không rõ ràng.
docstring được biểu thị bằng dấu ngoặc kép đóng và mở trong khi chú thích bắt
đầu bằng # ở phần đầu.
Lưu ý rằng không thể truy cập chú thích bằng thuộc tính doc và help.
Ví dụ:
def string_reverse(str1):
#In ra chuỗi ký tự
print(str1)
print(string_reverse.__doc__)
5.1.2.2 Các kiểu viết docstring

Có một số cách viết hoặc sử dụng docstring, cụ thể là docstring nằm trên một
dòng và nằm trên nhiều dòng.
▪ docstring nằm trên một dòng: Người dùng có thể sử dụng ba dấu nháy kép đơn, và
dấu nháy kép đơn mở và dấu nháy kép đơn đóng cần phải giống nhau. Ngoài ra,
dấu nháy kép đóng cùng dòng với dấu nháy kép mở đầu
Ví dụ:
def square(a):
'''Trả về kết quả'''
return a**a
print (square.__doc__)
▪ docstring trên nhiều dòng: chứa dòng ký tự chuỗi tương tự như trong docstring
trên một dòng, nhưng nó được theo sau bởi một khoảng trống duy nhất cùng với
đoạn văn bản mô tả. Định dạng chung để viết một docstring trên nhiều dòng được
thể hiện thông qua ví dụ
Ví dụ:
def square(a):
"""Nhận vào bình phương của một giá trị số
Số lượng tham số chỉ có một
a (int): là một giá trị số
Trả về:
Int: Trả về giá trị
"""
return a
print(square.__doc__)
5.1.2.3 Một số phương thức được tích hợp để truy cập docstring
Tất cả các hàm, class, phương thức được tích hợp sẵn đều có một đoạn văn bản
docstring mô tả chức năng của nó. Người dùng có thể truy cập bằng một trong hai
cách.
▪ Thuộc tính doc
▪ Hàm help
Ví dụ:
import math
print("----------doc attr: ")

print(math.__doc__)
print("----------Help function: ")
help(math)
Người dùng sẽ nhận thấy rằng đầu ra của hàm help dài dòng hơn thuộc tính
__doc__.
5.1.2.4 Chú thích hàm trong Python

Chuỗi đầu tiên sau tiêu đề hàm được gọi là docstring, viết tắt của từ “documentation
string”. Nó được sử dụng để giải thích về chức năng của hàm. Mặc dù không bắt buộc,
nhưng đây là một cách nên làm trong quá trình lập trình. Trong ví dụ bên dưới, có một
chuỗi doc ngay bên dưới tiêu đề hàm. Thường sử dụng dấu nháy kép ba để docstring
có thể mở rộng đến nhiều dòng. docstring này có thể được sử dụng bởi người lập trình
nhờ thuộc tính __doc__ của hàm.
Ví dụ:
def vi_du(a):
"""ví dụ về định nghĩa hàm"""
print("Lập trình",a)
vi_du("Python")
print(vi_du.__doc__)
Kết quả:
Lập trình Python
ví dụ về định nghĩa hàm
5.1.3 Gọi hàm
Việc định nghĩa một hàm chỉ đặt tên cho nó, chỉ định các tham số sẽ được đưa vào
hàm và cấu trúc các khối code.
Khi cấu trúc cơ bản của một hàm được hoàn thiện, người dùng có thể thực thi nó
bằng cách gọi nó từ một hàm khác hoặc trực tiếp từ Anaconda Prompt. Sau đây là ví
dụ gọi hàm printme()
# Function definition is here
def printme(str):
print(str)
return
# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")
I'm first call to user defined function!
Again second call to the same function
5.1.4 Chuyển theo tham chiếu so với giá trị

Tất cả các tham số (đối số) trong ngôn ngữ Python đều được chuyển theo tham
chiếu. Điều đó có nghĩa là nếu bạn thay đổi tham số đề cập đến trong một hàm, thì
thay đổi đó cũng phản ánh lại trong hàm gọi.
Ví dụ:
def changeme( mylist ):
"This changes a passed list into this function"
mylist.append([1,2,3,4])
print("Values inside the function: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print("Values outside the function: ", mylist)
Ở đây, đang duy trì tham chiếu của đối tượng đã chuyển và các giá trị nối thêm
trong cùng một đối tượng. Vì vậy, điều này sẽ tạo ra kết quả sau:
Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]
Có một ví dụ khác trong đó đối số được chuyển theo tham chiếu và tham chiếu đang
bị ghi đè bên trong hàm được gọi.
def changeme(mylist):
"This changes a passed list into this function"
mylist = [1,2,3,4] # This would assig new reference in mylist
print("Values inside the function: ", mylist)
return
# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print("Values outside the function: ", mylist)
Tham số mylist là cục bộ của hàm changeme. Thay đổi mylist trong hàm không
ảnh hưởng đến mylist. Điều này sẽ tạo ra kết quả sau:
Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]
5.1.5 Đối số của hàm

Người dùng có thể gọi một hàm bằng cách sử dụng các loại đối số chính thức sau:
▪ Đối số bắt buộc
▪ Đối số từ khóa
▪ Đối số mặc định
▪ Đối số có độ dài thay đổi
5.1.5.1 Đối số bắt buộc

Các đối số bắt buộc là các đối số được chuyển cho một hàm theo đúng thứ tự vị trí.
Ở đây, số lượng đối số trong lệnh gọi hàm phải khớp chính xác với định nghĩa hàm.
Để gọi hàm printme(), người dùng nhất định phải truyền vào một đối số, nếu không
nó sẽ báo lỗi cú pháp như sau:
def printme(str):
print(str)
return
printme()
printme()
TypeError: printme() takes exactly 1 argument (0 given)
5.1.5.2 Đối số từ khóa

Các đối số từ khóa có liên quan đến các lệnh gọi hàm. Khi sử dụng đối số từ khóa
trong lệnh gọi hàm, trình gọi sẽ xác định đối số theo tên tham số.
Điều này cho phép bỏ qua các đối số hoặc sắp xếp chúng không theo thứ tự vì trình
thông dịch Python có thể sử dụng các từ khóa được cung cấp để khớp các giá trị với các
tham số. Người dùng cũng có thể gọi từ khóa hàm printme() theo các cách sau:
def printme(str):
print(str)
return
printme( str = "My string")
My string
Ví dụ sau đây cho thấy rõ ràng hơn. Lưu ý rằng thứ tự của các tham số không quan
trọng.
def printinfo( name, age ):
"This prints a passed info into this function"
print("Name: ", name)
print("Age ", age)
return
# Now you can call printinfo function

printinfo( age=50, name="miki" )
Name: miki
Age 50
5.1.5.3 Đối số mặc định

Đối số mặc định là đối số giả định giá trị mặc định nếu giá trị không được cung cấp
trong lệnh gọi hàm cho đối số đó. Ví dụ sau đưa ra ý tưởng về các đối số mặc định, nó
sẽ xuất tuổi mặc định nếu nó không được thông qua
def printinfo(name, age = 35):
"This prints a passed info into this function"
print("Name: ", name)
print("Age ", age)
return
printinfo(age=50, name="miki")
printinfo(name="miki")
Name: miki
Age 50
Name: miki
Age 35
5.1.5.4 Đối số có độ dài thay đổi

Người dùng có thể cần xử lý một hàm để có nhiều đối số hơn mức đã chỉ định trong
khi định nghĩa hàm. Các đối số này được gọi là đối số có độ dài thay đổi và không được
đặt tên trong định nghĩa hàm, không giống như đối số bắt buộc và mặc định. Cú pháp
cho một hàm với các đối số biến không phải từ khóa:
def functionname([formal_args,] *var_args_tuple ):
"function_docstring"
function_suite
return [expression]
Dấu hoa thị (*) được đặt trước tên biến chứa các giá trị của tất cả các đối số biến không
phải từ khóa. Tuple này vẫn trống nếu không có đối số bổ sung nào được chỉ định trong
khi gọi hàm. Sau đây là một ví dụ đơn giản:
def printinfo( arg1, *vartuple ):
"This prints a variable passed arguments"
print("Output is: ")
print(arg1)
for var in vartuple:
print(var)
return
printinfo(10)
printinfo(70, 60, 50)
Output is:
10
Output is:
70
60
50
5.1.6 Hàm ẩn danh

Các hàm này được gọi là ẩn danh vì chúng không được khai báo theo cách tiêu chuẩn
bằng cách sử dụng từ khóa def. Người dùng có thể sử dụng từ khóa lambda để tạo
các hàm ẩn danh nhỏ.
▪ lambda có thể nhận bất kỳ số lượng đối số nào nhưng chỉ trả về một giá trị ở dạng
biểu thức. Chúng không thể chứa các lệnh hoặc nhiều biểu thức
▪ Hàm ẩn danh không thể là lệnh gọi trực tiếp để xuất vì lambda yêu cầu một biểu
thức
▪ Các hàm lambda có namespace cục bộ riêng và không thể truy cập các biến khác
với các biến trong danh sách tham số của chúng và các biến trong namespace toàn
cục
▪ Mặc dù có vẻ như lambda là phiên bản một dòng của hàm, nhưng chúng không
tương đương với các câu lệnh nội tuyến trong C hoặc C++, mục đích của chúng là
bằng cách chuyển phân bổ ngăn xếp hàm trong khi gọi vì lý do hiệu suất
Cú pháp của các hàm lambda chỉ chứa một câu lệnh duy nhất, như sau:
lambda [arg1 [,arg2,.....argn]]:expression
Sau đây là ví dụ cho thấy cách thức hoạt động của hàm lambda:
sum = lambda arg1, arg2: arg1 + arg2;
# Now you can call sum as a function
print("Value of total : ", sum( 10, 20 ))
print("Value of total : ", sum( 20, 20 ))
Value of total : 30
Value of total : 40
5.1.7 Câu lệnh return

Câu lệnh return [biểu thức] thoát khỏi một hàm, tùy chọn trả lại một biểu thức khi
gọi. Câu lệnh return không có đối số trả về None.
Tất cả các ví dụ trên không trả lại bất kỳ giá trị nào. Người dùng có thể trả về một
giá trị từ một hàm như sau:
def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2
print("Inside the function: ", total)
return total
# Now you can call sum function
total = sum( 10, 20 );
print("Outside the function: ", total)
Inside the function: 30
Outside the function: 30
5.1.8 Phạm vi biến
Tất cả các biến trong một chương trình có thể không truy cập được ở tất cả các vị
trí trong chương trình đó. Điều này phụ thuộc vào nơi đã khai báo một biến.
Phạm vi của một biến xác định phần chương trình mà có thể truy cập vào một mã
định danh cụ thể. Có hai phạm vi biến cơ bản trong Pythonbao gồm biến toàn cục và
biến cục bộ, như đã thảo luận trong bài 2.
Các biến được xác định bên trong thân hàm có phạm vi cục bộ và những biến được
xác định bên ngoài có phạm vi toàn cụ. Điều này có nghĩa là các biến cục bộ chỉ có thể
được truy cập bên trong hàm mà chúng được khai báo, trong khi các biến toàn cục có
thể được truy cập trong toàn bộ thân chương trình bởi tất cả các hàm. Khi gọi một hàm,
các biến được khai báo bên trong nó sẽ được đưa vào phạm vi. Sau đây là một ví dụ
đơn giản:
total = 0 # This is global variable.
def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2 # Here total is local variable.
print("Inside the function local total: ", total)
return total
# Now you can call sum function
sum(10, 20)
print("Outside the function global total: ", total)
Inside the function local total: 30
Outside the function global total: 0
5.2 Module
Một module cho phép sắp xếp hợp lý code Python. Nhóm code liên quan vào một
module làm cho mã dễ hiểu và dễ sử dụng hơn. Module là một đối tượng Python với
các thuộc tính được đặt tên tùy ý mà có thể liên kết và tham chiếu.
Đơn giản, một module là một file bao gồm code Python, có thể định nghĩa các hàm,
class và biến. Một module cũng có thể bao gồm code có thể chạy được.
Ví dụ: Đây là một ví dụ về một module đơn giản, support.py

def print_func( par ):
print("Hello: ", par)
return
5.2.1 Lệnh import

Người dùng có thể sử dụng bất kỳ file nguồn Python nào làm module bằng cách thực
thi câu lệnh import trong một số file nguồn Python khác. Quá trình import có cú pháp
sau:
import module1[, module2[,... moduleN]
Khi trình thông dịch gặp câu lệnh import, nó sẽ nhập module nếu có trong đường
dẫn tìm kiếm. Đường dẫn tìm kiếm là danh sách các thư mục mà trình thông dịch tìm
kiếm trước khi nhập module. Ví dụ: để import module support.py, người dùng cần đặt
lệnh sau ở đầu script.
# Import module support
import support
# Now you can call defined function that module as follows
support.print_func("Zara")
Hello: Zara
Một module chỉ được tải một lần, bất kể số lần nó được nhập. Điều này ngăn quá
trình thực thi module diễn ra lặp đi lặp lại nếu xảy ra nhiều lần nhập.
5.2.2 Lệnh from…import

Câu lệnh from của Python cho phép import các thuộc tính cụ thể từ một module
vào namespace hiện tại. from...import có cú pháp sau
from modname import name1[, name2[, ... nameN]]
Ví dụ: Sử dụng lại module support.py như phần trước
from support import print_func
print_func("Robot")
Hello: Robot
Câu lệnh này không import toàn bộ module vào namespace hiện tại; nó chỉ nhập hàm
print_func từ module support. Để thấy rõ điều này, bổ sung module support.py như
sau:
a = 1000
def print_func( par ):
print("Hello: ", par)
return
Và viết một đoạn code trong một script khác như sau:
from support import print_func
print_func("Robot")
print(a)
Hello: Robot
File "E:\Hutech\Subjects\LT_python\test\untitled0.py", line 4, in <module>

print(a)
NameError: name 'a' is not defined
Một lỗi sẽ xảy ra vì biến a chưa được định nghĩa. Thay đổi đoạn code như sau:
from support import print_func, a
print_func("Robot")
print(a)
Hello: Robot
1000
5.2.3 Lệnh from…import *

Cũng có thể import tất cả các tên từ một module vào namespace hiện tại bằng cách
sử dụng câu lệnh import sau thông qua ví dụ trên với module support.py.
Điều này cung cấp một cách dễ dàng để import tất cả các mục từ một mô-đun
vào không gian tên hiện tại. Tuy nhiên, lệnh này nên được sử dụng một cách thận
trọng.
5.2.4 Định vị module

Khi người dùng import một module, trình thông dịch Python sẽ tìm kiếm module
theo trình tự sau:
▪ Thư mục hiện tại
▪ Nếu không tìm thấy module, Python sẽ tìm kiếm từng thư mục trong biến
PYTHONPATH
▪ Nếu vẫn thất bại, Python sẽ kiểm tra đường dẫn mặc định. Trên UNIX (hệ điều hành
máy tính đa nhiệm), đường dẫn mặc định này thường là /usr/local/lib/python/
Đường dẫn tìm kiếm module được lưu trữ trong module sys dưới dạng biến sys.path.
Biến sys.path chứa thư mục hiện tại, PYTHONPATH và mặc định phụ thuộc vào cài đặt.
5.2.5 Biến PYTHONPATH

PYTHONPATH là một biến môi trường, bao gồm một danh sách các thư mục. Cú pháp
của PYTHONPATH giống như cú pháp của biến PATH. Đây là một PYTHONPATH điển
hình từ hệ điều hành Windows:
set PYTHONPATH = c:\python20\lib
Và đây là một PYTHONPATH điển hình từ hệ điều hành UNIX:
set PYTHONPATH = /usr/local/lib/python
5.2.6 Namespace và phạm vi

Biến là tên (mã định danh) ánh xạ tới các đối tượng. Một namespace là một
dictionary các tên biến (key) và các đối tượng (giá trị) tương ứng của chúng.
Một câu lệnh Python có thể truy cập các biến trong namespace cục bộ và toàn cục.
Nếu biến cục bộ và biến toàn cục có cùng tên thì biến cục bộ sẽ che khuất biến toàn
cục.
Mỗi hàm có namespace cục bộ riêng. Các phương thức class tuân theo quy tắc phạm
vi giống như các hàm thông thường. Python đưa ra những phỏng đoán về việc các biến
là cục bộ hay toàn cục. Nó giả định rằng bất kỳ biến nào được gán một giá trị trong
một hàm là cục bộ. Do đó, để gán giá trị cho một biến toàn cục trong một hàm, trước
tiên người dùng phải sử dụng câu lệnh global.
Câu lệnh global VarName cho Python biết rằng VarName là một biến toàn cục.
Python ngừng tìm kiếm namespace cục bộ cho biến.
Ví dụ: xác định một biến Money trong namespace toàn cục. Trong hàm AddMoney,
chúng ta gán cho Money một giá trị, do đó Python coi Money là một biến cục bộ. Tuy
nhiên, chúng ta đã truy cập giá trị của biến cục bộ Money trước khi đặt nó, do đó, một
UnboundLocalError là kết quả. Việc bỏ comment câu lệnh global sẽ khắc phục lỗi.
Money = 2000
def AddMoney():
# Uncomment the following line to fix the code:
# global Money
Money = Money + 1
print Money
AddMoney()
print Money
5.2.7 Hàm dir()

Hàm tích hợp dir() trả về một list các chuỗi được sắp xếp có chứa các tên được xác
định bởi một module.
list chứa tên của tất cả các module, biến và hàm được xác định trong một module.
Sau đây là một ví dụ đơn giản.
Ví dụ:
# Import built-in module math
import math
content = dir(math)
print(content)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos',
'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos',
'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial',
'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose',
'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2',
'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh',
'tau', 'trunc']
Ở đây, biến chuỗi đặc biệt __name__ là tên của module và __file__ là tên tệp mà
module được tải từ đó.
5.2.8 Hàm reload()

Khi module được import vào script, code ở phần cao nhất của module chỉ được thực
thi một lần. Do đó, nếu người dùng muốn import lại thì có thể sử dụng hàm reload().
Cú pháp của hàm reload():
reload(module_name)
Ở đây, module_name là tên của module muốn tải lại chứ không phải chuỗi chứa tên
module. Ví dụ: để tải lại module support, hãy làm như sau:
reload(support)
5.3 File I/O

Python hỗ trợ xử lý một dữ liệu lớn và dữ liệu này có thể đến từ nhiều nguồn khác
nhau, bao gồm cơ sở dữ liệu, bảng tính Excel, và các trang web cộng đồng như Kaggle.
Không chỉ là source, mà bất kỳ loại tệp nào, chẳng hạn như .csv, .txt, .parquet, v.v.
Trước khi có thể bắt đầu hiểu dữ liệu, trước tiên phải hiểu các thao tác file Python cơ
bản như cách truy cập, đọc và ghi dữ liệu để có thể thực hiện phân tích trên chúng.
5.3.1 Xuất ra màn hình

Cách đơn giản nhất để tạo ngõ ra là sử dụng câu lệnh print trong đó có nhiều biểu
thức được phân tách bằng dấu phẩy. Hàm này chuyển đổi các biểu thức chuyển thành
một chuỗi và ghi kết quả vào ngõ ra tiêu chuẩn như sau:
print("Python is really a great language,", "isn't it?")
Điều này tạo ra kết quả sau trên màn hình tiêu chuẩn:
Python is really a great language, isn't it?
5.3.2 Đọc bàn phím

Python cung cấp hai hàm tích hợp để đọc một dòng văn bản từ ngõ vào tiêu chuẩn,
theo mặc định đến từ bàn phím. Các hàm này là:
▪ raw_input
▪ input
5.3.2.1 Hàm raw_input

Hàm raw_input([prompt]) đọc một dòng từ đầu vào tiêu chuẩn và trả về nó dưới
dạng một chuỗi.
str = raw_input("Enter your input: ")
print("Received input is: ", str)
Điều này nhắc người dùng nhập bất kỳ chuỗi nào và nó sẽ hiển thị cùng một chuỗi
trên màn hình. Khi gõ "Hello Python!", ngõ ra của nó như thế này:
Enter your input: Hello Python
Received input is: Hello Python
5.3.2.2 Hàm input

Hàm input([prompt]) tương đương với raw_input, ngoại trừ việc hàm này giả
định ngõ vào là một biểu thức Python hợp lệ và trả về kết quả đã đánh giá
str = input("Enter your input: ")
print("Received input is: ", str)
Điều này sẽ tạo ra kết quả sau đối với ngõ vào đã nhập:
Enter your input: [x*5 for x in range(2,10,2)]
Recieved input is: [10, 20, 30, 40]
5.3.3 Mở và đóng file

Cho đến bây giờ, người dùng đã đọc và ghi vào ngõ vào và ngõ ra tiêu chuẩn. Bây
giờ, sẽ xem cách sử dụng các file dữ liệu thực tế.
Python cung cấp các hàm và phương thức cơ bản cần thiết để thao tác với file theo
mặc định. Người dùng có thể thực hiện hầu hết thao tác với đối tượng file.
5.3.3.1 Hàm open

Trước khi có thể đọc hoặc ghi một file, người dùng phải mở file đó bằng hàm open()
tích hợp sẵn của Python. Hàm này tạo một đối tượng file, được sử dụng để gọi các
phương thức hỗ trợ khác được liên kết với nó. Cú pháp như sau:
file object = open(file_name [, access_mode][, buffering])
Dưới đây là thông số chi tiết:
▪ file_name: đối số file_name là một giá trị chuỗi chứa tên của file muốn truy cập
▪ access_mode: xác định chế độ trong đó file phải được mở, nghĩa là đọc, ghi, thêm,
v.v. Một danh sách đầy đủ các giá trị có thể được đưa ra dưới đây trong bảng. Đây
là tham số tùy chọn và chế độ truy cập tệp mặc định là đọc (r)
▪ buffering: nếu giá trị buffering (bộ đệm) được đặt thành 0, thì không có bộ đệm
nào diễn ra. Nếu giá trị bộ đệm là 1, bộ đệm dòng được thực hiện trong khi truy cập
file. Nếu chỉ định giá trị bộ đệm là một số nguyên lớn hơn 1, thì hành động tạo bộ
đệm được thực hiện với kích thước bộ đệm được chỉ định. Nếu giá trị âm, kích thước
bộ đệm là mặc định của hệ thống
Dưới đây là danh sách các chế độ mở file khác nhau:
▪ r: mở một file chỉ để đọc. Con trỏ tệp được đặt ở đầu file. Đây là chế độ mặc định
▪ rb: mở một file chỉ để đọc ở định dạng nhị phân. Con trỏ tệp được đặt ở đầu tệp.
Đây là chế độ mặc định
▪ r+: mở một file cho cả đọc và viết. Con trỏ tệp đặt ở đầu file
▪ rb+: mở một file cho cả đọc và viết ở định dạng nhị phân. Con trỏ tệp đặt ở đầu file
▪ w: mở một file chỉ để viết. Viết đè nếu file tồn tại. Nếu file không tồn tại, hãy tạo
một file mới để viết
▪ wb: mở một file chỉ để ghi ở định dạng nhị phân. Viết đè nếu file tồn tại. Nếu file
không tồn tại, hãy tạo một file mới để viết
▪ w+: mở một file cho cả viết và đọc. Viết đè nếu file tồn tại. Nếu file không tồn tại,
hãy tạo một file mới để đọc và viết
▪ wb+: mở một file để viết và đọc ở định dạng nhị phân. Viết đè nếu file tồn tại. Nếu
file không tồn tại, hãy tạo một file mới để đọc và viết
▪ a: mở một file để nối thêm. Con trỏ ở cuối nếu file tồn tại. Tức là file đang ở chế độ
nối thêm. Nếu file không tồn tại, nó sẽ tạo một file mới để viết
▪ ab: mở một file để nối thêm ở định dạng nhị phân. Con trỏ ở cuối nếu file tồn tại.
Tức là file đang ở chế độ nối thêm. Nếu file không tồn tại, nó sẽ tạo một file mới để
viết
▪ a+: mở một file cho cả việc nối thêm và đọc. Con trỏ ở cuối nếu file tồn tại. File mở
ở chế độ nối thêm. Nếu file không tồn tại, nó sẽ tạo một file mới để đọc và viết
▪ ab+: mở một file cho cả việc nối thêm và đọc ở định dạng nhị phân. Con trỏ ở cuối
nếu file tồn tại. File mở ở chế độ nối thêm. Nếu file không tồn tại, nó sẽ tạo một file
mới để đọc và viết
5.3.3.2 Thuộc tính đối tượng file

Khi một file được mở và người dùng có một đối tượng file, có thể nhận được nhiều
thông tin khác nhau liên quan đến file đó.
Dưới đây là danh sách tất cả các thuộc tính liên quan đến đối tượng file:
▪ file.closed: trả về true nếu tệp bị đóng, false nếu không
▪ file.mode: trả về chế độ truy cập mà file đã được mở
▪ file.name: trả về tên của file
▪ file.softspace: trả về false nếu không gian được yêu cầu rõ ràng với print, ngược
lại là true
Ví dụ:
# Open a file
fo = open("foo.txt", "wb")
print("Name of the file: ", fo.name)
print("Closed or not: ", fo.closed)
print("Opening mode: ", fo.mode)
print("Softspace flag: ", fo.softspace)
Điều này tạo ra kết quả sau:
Name of the file: foo.txt
Closed or not: False
Opening mode: wb
Softspace flag: 0
5.3.3.3 Phương thức close

Phương thức close() của một đối tượng file là xóa mọi thông tin chưa được viết và
đóng đối tượng file, sau đó không thể viết thêm nữa.
Python tự động đóng file khi đối tượng tham chiếu của file được gán lại cho file khác.
Đó là một cách thực hành tốt để sử dụng phương thức close() để đóng file. Cú pháp
như sau:
fileObject.close()
Ví dụ:
# Open a file
print("Name of the file: ", fo.name)
# Close file
fo.close()
Name of the file: foo.txt
5.3.4 Đọc và viết file

Đối tượng file cung cấp một tập hợp các phương thức truy cập. Trong phần này sẽ
xem cách sử dụng các phương thức read() và write() để đọc và viết file.
5.3.4.1 Phương thức write()

Phương thức write() viết bất kỳ chuỗi nào vào một file đang mở. Điều quan trọng
cần lưu ý là chuỗi Python có thể có dữ liệu nhị phân chứ không chỉ văn bản. Phương
thức write() không thêm ký tự xuống dòng ('\n') vào cuối chuỗi. Cú pháp như sau:
fileObject.write(string)
Ở đây, tham số được truyền là nội dung được viết vào file đã mở.
Ví dụ:
# Open a file
fo.write( "Python is a great language.\nYeah its great!!\n")
# Close opend file
fo.close()
Phương thức trên sẽ tạo file foo.txt và sẽ viết nội dung đã cho vào file đó và cuối cùng
nó sẽ đóng file đó. Nếu mở tệp này, nó sẽ có nội dung sau:
Python is a great language.
Yeah its great!!
5.3.4.2 Phương thức read()

Phương thức read() đọc một chuỗi từ một file đang mở. Điều quan trọng cần lưu ý
là chuỗi Python có thể có dữ liệu nhị phân ngoài dữ liệu văn bản. Cú pháp như sau:
fileObject.read([count])
Ở đây, tham số được truyền là số byte được đọc từ file đã mở. Phương thức này bắt
đầu đọc từ đầu file và nếu count bị thiếu, thì nó sẽ cố đọc càng nhiều càng tốt, có thể
cho đến cuối file.
Ví dụ: lấy file foo.txt đã tạo ở trên
# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10);
print("Read String is: ", str)
# Close opend file
fo.close()
Read String is: Python is
5.3.5 Vị trí file
Phương thức tell() cho biết vị trí con trỏ hiện tại trong file; nói cách khác, lần đọc
hoặc viết tiếp theo sẽ xảy ra ở số byte đó kể từ đầu file.
Phương thức seek(offset[, from]) thay đổi vị trí con trỏ trong file hiện tại. Đối số
offset cho biết số byte sẽ được di chuyển. Đối số from chỉ định vị trí tham chiếu từ đó
các byte sẽ được di chuyển.
Nếu from được đặt thành 0, điều đó có nghĩa là sử dụng phần đầu của file làm vị trí
tham chiếu và 1 có nghĩa là sử dụng vị trí hiện tại làm vị trí tham chiếu và nếu nó được
đặt thành 2 thì phần cuối của file sẽ được lấy làm vị trí tham chiếu.
Ví dụ: lấy file foo.txt đã tạo ở trên
# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print("Read String is: ", str)
# Check current position
position = fo.tell()
print("Current file position : ", position)
# Reposition pointer at the beginning once again
position = fo.seek(0, 0);
str = fo.read(10)
print("Again read String is : ", str)
# Close opend file
fo.close()
Read String is: Python is
Current file position: 10
Again read String is: Python is
5.3.6 Đổi tên và xóa file

Module os cung cấp các phương thức giúp thực hiện các thao tác xử lý file, chẳng
hạn như đổi tên và xóa file. Để sử dụng module này, trước tiên cần import module đó
và sau đó có thể gọi bất kỳ hàm liên quan nào.
5.3.6.1 Phương thức rename()

Phương thức rename() nhận hai đối số, tên file hiện tại và tên file mới. Cú pháp như
sau:
os.rename(current_file_name, new_file_name)
Ví dụ: sau đây là ví dụ đổi tên tệp hiện có test1.txt
import os
# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )
5.3.6.2 Phương thức remove()

Người dùng có thể sử dụng phương thức remove() để xóa file bằng cách cung cấp
tên của file sẽ bị xóa làm đối số. Cú pháp như sau:
os.remove(file_name)
Ví dụ: xóa file test2.txt hiện có trong ví dụ trên
import os
# Delete file test2.txt
os.remove("text2.txt")
5.3.7 Thư mục trong Python

Tất cả các file được chứa trong các thư mục khác nhau và Python cũng không gặp
vấn đề gì khi xử lý các file này. Module os có một số phương pháp giúp tạo, xóa và
thay đổi thư mục.
5.3.7.1 Phương thức mkdir()

Người dùng có thể sử dụng phương thức mkdir() của module os để tạo các thư mục
trong thư mục hiện tại. Cần cung cấp một đối số cho phương thức này có chứa tên của
thư mục sẽ được tạo. Cú pháp như sau:
os.mkdir("newdir")
Ví dụ: tạo một thư mục test trong thư mục hiện tại
import os
# Create a directory "test"
os.mkdir("test")
5.3.7.2 Phương thức chdir()

Người dùng có thể sử dụng phương thức chdir() để thay đổi thư mục hiện tại, nhận
một đối số, là tên của thư mục muốn tạo thư mục hiện tại. Cú pháp như sau:
os.chdir("newdir")
Ví dụ: sau đây là ví dụ để vào thư mục "/home/newdir"
import os
# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")
5.3.7.3 Phương thức getcwd()

Phương thức getcwd() hiển thị thư mục làm việc hiện tại. Cú pháp như sau:
os.getcwd()
Ví dụ: cung cấp cho thư mục hiện tại
import os
# This would give location of the current directory
os.getcwd()
5.3.7.4 Phương thức rmdir()

Phương thức rmdir() xóa thư mục, được truyền dưới dạng đối số trong phương thức.
Trước khi xóa một thư mục, tất cả nội dung trong đó phải được xóa. Cú pháp như sau:
os.rmdir('dirname')
Ví dụ: xóa thư mục "/tmp/test". Nó được yêu cầu cung cấp tên đầy đủ của thư mục,
nếu không nó sẽ tìm kiếm thư mục đó trong thư mục hiện tại.
import os
# This would remove "/tmp/test" directory.
os.rmdir("/tmp/test")
5.4 Python - Xử lý ngoại lệ và xác nhận

Python cung cấp hai tính năng rất quan trọng để xử lý mọi lỗi không mong muốn
trong chương trình và để thêm khả năng sửa lỗi trong đó.
5.4.1.1 Exception Handling (xử lý ngoại lệ)

Dưới đây là danh sách tất cả các ngoại lệ tiêu chuẩn có sẵn trong Python.
▪ Exception: class cơ sở cho tất cả các ngoại lệ
▪ StopIteration: xảy ra khi phương thức next() của iterator không trỏ đến bất kỳ đối
tượng nào
▪ SystemExit: tăng lên bởi hàm sys.exit()
▪ StandardError: class cơ sở cho tất cả các ngoại lệ dựng sẵn ngoại trừ
StopIteration và SystemExit
▪ ArithmeticError: class cơ sở cho tất cả các lỗi xảy ra khi tính toán số
▪ OverflowError: tăng lên khi một phép tính vượt quá giới hạn tối đa cho một loại số
▪ FloatingPointError: tăng lên khi tính toán dấu phẩy động không thành công
▪ ZeroDivisionError: tăng lên khi phép chia cho 0 diễn ra đối với tất cả các loại số
▪ AssertionError: tăng lên trong trường hợp thất bại của câu lệnh Assert
▪ AttributeError: tăng trong trường hợp tham chiếu hoặc gán thuộc tính không thành
công
▪ EOFError: xảy ra khi không có ngõ vào từ hàm raw_input() hoặc input() và đến
cuối file
▪ ImportError: tăng lên khi một câu lệnh import không thành công
▪ KeyboardInterrupt: xảy ra khi người dùng làm gián đoạn quá trình thực thi chương
trình, thường bằng cách nhấn Ctrl+c
▪ LookupError: class cơ sở cho tất cả các lỗi tra cứu
▪ IndexError: xảy ra khi không tìm thấy chỉ mục trong một chuỗi
▪ KeyError: xảy ra khi không tìm thấy key được chỉ định trong dictionary
▪ NameError: xảy ra khi không tìm thấy mã định danh trong namespace cục bộ hoặc
toàn cục
▪ UnboundLocalError: xảy ra khi cố gắng truy cập một biến cục bộ trong một hàm
hoặc phương thức nhưng không có giá trị nào được gán cho nó
▪ EnvironmentError: class cơ sở cho tất cả các exception xảy ra bên ngoài môi
trường Python
▪ IOError: xảy ra khi thao tác input/output không thành công, chẳng hạn như câu
lệnh print hoặc hàm open() khi cố mở một file không tồn tại
▪ OSError: tăng lên cho các lỗi liên quan đến hệ điều hành
▪ SyntaxError: xảy ra khi có lỗi trong cú pháp Python
▪ IndentationError: tăng lên khi thụt đầu dòng không được chỉ định đúng cách
▪ SystemError: xảy ra khi trình thông dịch tìm thấy sự cố nội bộ, nhưng khi gặp lỗi
này, trình thông dịch Python không thoát
▪ SystemExit: xảy ra khi thoát trình thông dịch Python bằng cách sử dụng hàm
sys.exit(). Nếu không được xử lý trong code, khiến trình thông dịch thoát ra
▪ TypeError: xảy ra khi một thao tác hoặc hàm được thử không hợp lệ đối với loại dữ
liệu đã chỉ định
▪ ValueError: xảy ra khi hàm tích hợp sẵn cho một loại dữ liệu có loại đối số hợp lệ,
nhưng các đối số có giá trị không hợp lệ được chỉ định
▪ RuntimeError: xảy ra khi lỗi được tạo không thuộc bất kỳ danh mục nào
▪ NotImplementedError: xảy ra khi một phương thức trừu tượng cần được triển
khai trong một class kế thừa không thực sự được triển khai
5.4.1.2 Assertion (xác nhận) trong Python

Một xác nhận là một kiểm tra độ chính xác, có thể bật hoặc tắt khi hoàn thành việc
kiểm tra chương trình.
Cách dễ nhất để nghĩ về một xác nhận là so sánh nó với một câu lệnh raise-if (hay
nói chính xác hơn, một câu lệnh raise-if-not). Một biểu thức được kiểm tra và nếu kết
quả trả về là sai, một ngoại lệ sẽ được đưa ra.
Các xác nhận được thực hiện bởi câu lệnh assert, từ khóa mới nhất của Python,
được giới thiệu trong phiên bản 1.5.
Các lập trình viên thường đặt các xác nhận ở đầu hàm để kiểm tra ngõ vào hợp lệ
và sau lệnh gọi hàm để kiểm tra ngõ ra hợp lệ.
Lệnh assert
Khi gặp một câu lệnh assert, Python sẽ đánh giá biểu thức đi kèm, điều này hy
vọng là đúng. Nếu biểu thức sai, Python sẽ đưa ra một ngoại lệ AssertionError. Cú
pháp như sau:
assert Expression[, Arguments]
Nếu xác nhận không thành công, Python sử dụng ArgumentExpression làm đối số
cho AssertionError. Các ngoại lệ AssertionError có thể phát hiện và xử lý giống như
bất kỳ ngoại lệ nào khác bằng cách sử dụng câu lệnh try- except, nhưng nếu không
được xử lý, chúng sẽ chấm dứt chương trình và tạo ra một traceback.
Một traceback là một báo cáo chứa các hàm được thực hiện trong code tại một thời
điểm cụ thể. Traceback được biết đến với nhiều tên, bao gồm stack trace, strack
traceback, backtrace, ... Khi kết quả của chương trình là 1 exception, Python sẽ xuất
ra traceback lập tức để giúp người dùng biết sai ở đâu.
Ví dụ: đây là một hàm chuyển đổi nhiệt độ từ độ Kelvin sang độ F. Vì 0 độ Kelvin càng
lạnh càng tốt, nên hàm này sẽ ngừng hoạt động nếu nó thấy nhiệt độ âm.
def KelvinToFahrenheit(Temperature):
assert (Temperature >= 0),"Colder than absolute zero!"
return ((Temperature-273)*1.8)+32
print(KelvinToFahrenheit(273))
print(int(KelvinToFahrenheit(505.78)))
print(KelvinToFahrenheit(-5))
32.0
451
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!
5.4.2 Ngoại lệ là gì?

Một ngoại lệ (exception) là một sự kiện, xảy ra trong quá trình thực thi chương trình
làm gián đoạn luồng câu lệnh của chương trình. Nói chung, khi một script Python gặp
tình huống mà nó không thể đối phó, nó sẽ đưa ra một exception. Một exception là
một đối tượng Python đại diện cho một lỗi.
Khi một script Python đưa ra một exception, nó phải xử lý ngoại lệ đó ngay lập tức
nếu không nó sẽ kết thúc và thoát.
5.4.3 Xử lý một ngoại lệ

Nếu có một số code đáng ngờ có thể gây ra ngoại lệ, người dùng có thể bảo vệ
chương trình bằng cách đặt code đáng ngờ đó vào khối try:. Sau khối try:, hãy bao
gồm một câu lệnh except:, theo sau là một khối code xử lý sự cố một cách tinh tế nhất
có thể. Cú pháp như sau:
try:
You do your operations here;
......................
except ExceptionI:
If there is ExceptionI, then execute this block.
except ExceptionII:
If there is ExceptionII, then execute this block.
......................
else:
If there is no exception then execute this block.
Dưới đây là một số điểm quan trọng về cú pháp nêu trên:
▪ Một câu lệnh try có thể có nhiều câu lệnh exception. Điều này hữu ích khi khối try
chứa các câu lệnh có thể đưa ra các loại exception khác nhau
▪ Người dùng cũng có thể cung cấp một mệnh đề except chung để xử lý bất kỳ
exception nào
▪ Sau (các) mệnh đề except, có thể bao gồm else. Code trong khối else thực thi nếu
code trong khối try: không đưa ra exception
▪ Khối else là một nơi tốt cho code không cần try: bảo vệ khối
Ví dụ: mở một file, viết nội dung vào file và xuất hiện vì không có vấn đề gì cả
try:
fh = open("testfile.txt", "w")
fh.write("This is my test file for exception handling!!")
except IOError:
print("Error: can\'t find file or read data")
else:
print("Written content in the file successfully")
fh.close()
Written content in the file successfully
Ví dụ: mở một file mà không có quyền viết, vì vậy nó sẽ phát sinh một exception
try:
fh = open("testfile", "r")
except IOError:
else:
print("Written content in the file successfully")
Error: can't find file or read data
5.4.3.1 Mệnh đề except với không exception

Người dùng cũng có thể sử dụng câu lệnh except mà không có exception nào được
định nghĩa như sau:
try:
......................
except:
If there is any exception, then execute this block.
......................
else:
Loại câu lệnh try-except này nắm bắt tất cả các trường hợp exception xảy ra. Tuy
nhiên, việc sử dụng loại câu lệnh try-except này không được coi là một phương pháp
lập trình tốt, bởi vì nó bắt được tất cả các exception nhưng không khiến lập trình viên
xác định nguyên nhân cốt lõi của vấn đề có thể xảy ra.
5.4.3.2 Mệnh đề except với nhiều exception

Người dùng cũng có thể sử dụng câu lệnh except tương tự để xử lý nhiều exception
như sau:
try:
......................
except(Exception1[, Exception2[,...ExceptionN]]]):
If there is any exception from the given exception list,
then execute this block.
......................
else:
5.4.3.3 Mệnh đề try-finally

Người dùng có thể sử dụng khối finally: cùng với khối try:. Khối finally là nơi để
đặt bất kỳ code nào phải thực thi, cho dù khối try có đưa ra exception hay không. Cú
pháp của câu lệnh try-finally:
try:
......................
Due to any exception, this may be skipped.
finally:
This would always be executed.
......................
Lưu ý: không thể sử dụng else cùng với finally
Ví dụ:
try:
fh = open("testfile", "w")
finally:
Nếu không có quyền mở file ở chế độ viết, thì điều này sẽ tạo ra kết quả sau:
Error: can't find file or read data
Ví dụ tương tự có thể được viết rõ ràng hơn như sau:
try:
fh = open("testfile", "w")
try:
finally:
print("Going to close the file")
fh.close()
except IOError:
Khi một exception được đưa vào khối try, việc thực thi sẽ ngay lập tức chuyển sang
khối finally. Sau khi tất cả các câu lệnh trong finally được thực thi, exception lại được
đưa ra và được xử lý trong các câu lệnh except nếu xuất hiện trong lớp cao hơn tiếp
theo của câu lệnh try-except.
5.4.3.4 Đối số của một exception

Một exception có thể có một đối số, là một giá trị cung cấp thông tin bổ sung về
sự cố. Nội dung của đối số thay đổi tùy theo exception. Người dùng nắm bắt đối số
của một exception bằng cách cung cấp một biến trong mệnh đề except như sau:
# Define a function here.
def temp_convert(var):
try:
return int(var)
except ValueError as
Argument:
print("The argument does not contain numbers\n", Argument)
# Call above function here.
temp_convert("xyz")
The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'
5.5 Python - Hướng đối tượng

Python đã là một ngôn ngữ hướng đối tượng kể từ khi nó tồn tại. Do đó, việc tạo và
sử dụng các class và đối tượng hết sức dễ dàng. Phần này giúp người dùng trong việc
sử dụng hỗ trợ lập trình hướng đối tượng (Object-Oriented Programming – OOP) của
Python.
5.5.1 Tổng quan về thuật ngữ OOP

▪ class − Một nguyên mẫu do người dùng định nghĩa cho một đối tượng xác định một
tập hợp các thuộc tính đặc trưng cho bất kỳ đối tượng nào của class. Các thuộc tính
là các thành viên dữ liệu (biến lớp và biến thể hiện) và các phương thức, được truy
cập thông qua ký hiệu dấu chấm
▪ Biến class - Một biến được chia sẻ bởi tất cả các phiên bản của một class. Các biến
class được định nghĩa bên trong một class nhưng bên ngoài bất kỳ phương thức nào
của lớp. Các biến class không được sử dụng thường xuyên như các biến thực thể
(instance variable)
▪ Thành viên dữ liệu (data member) − Một biến lớp hoặc biến thực thể chứa dữ
liệu được liên kết với một class và các đối tượng của nó
▪ Chồng hàm (function overloading) - Gán nhiều hơn một hành vi cho một hàm
cụ thể. Hoạt động được thực hiện khác nhau tùy theo loại đối tượng hoặc đối số liên
quan
▪ Biến thực thể (instance variable) − Một biến được định nghĩa bên trong một
phương thức và chỉ thuộc về thực thể hiện tại của một class
▪ Kế thừa (inheritance) - Việc chuyển các đặc điểm của một class sang các class
khác được bắt nguồn từ nó
▪ Instance - Một đối tượng riêng lẻ của một class nhất định. Ví dụ, một đối tượng obj
thuộc về một class Circle, là một instance của class Circle
▪ Khởi tạo (instantiation) - Tạo một instance của một lớp
▪ Phương thức − Một loại hàm đặc biệt được định nghĩa trong định nghĩa class
▪ Đối tượng (object) − Một instance duy nhất của cấu trúc dữ liệu được định nghĩa
bởi class của nó. Một đối tượng bao gồm cả các thành viên dữ liệu (biến lớp và biến
thực thể) và các phương thức
▪ Nạp chồng toán tử (operator overloading) − Gán nhiều hơn một hàm cho một
toán tử cụ thể
5.5.2 Tạo class

Câu lệnh class tạo ra một định nghĩa class mới. Tên của class ngay sau từ khóa
class theo sau là dấu hai chấm như sau:
class ClassName:
'Optional class documentation string'
class_suite
▪ class có một chuỗi tài liệu, có thể được truy cập thông qua ClassName.__doc__
▪ class_suite bao gồm tất cả các câu lệnh thành phần xác định các thành viên lớp,
thuộc tính dữ liệu và hàm
Ví dụ:
class Employee:
'Common base class for all employees'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
▪ Biến empCount là một biến class có giá trị được chia sẻ giữa tất cả các instance của
lớp này. Điều này có thể được truy cập dưới dạng Employee.empCount từ bên trong
class hoặc bên ngoài class
▪ Phương thức đầu tiên __init__() là một phương thức đặc biệt, được gọi là hàm tạo
class hoặc phương thức khởi tạo mà Python gọi khi tạo một instance mới của lớp
này
▪ Khai báo các phương thức khác của class giống như các hàm thông thường, ngoại
trừ đối số đầu tiên của mỗi phương thức là self. Python thêm đối số self vào list;
không cần đưa nó vào khi gọi các phương thức
5.5.3 Tạo đối tượng instance

Để tạo các instance của một class, người dùng gọi class đó bằng tên class và đặt
vào bất kỳ đối số nào mà phương thức __init__ của nó chấp nhận
Ví dụ: dựa vào ví dụ tạo class Employee ở trên
"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
5.5.4 Truy cập thuộc tính

Truy cập các thuộc tính của đối tượng bằng toán tử dấu chấm với đối tượng. Biến
class sẽ được truy cập bằng tên class như sau:
emp1.displayEmployee()
Bây giờ, đặt tất cả các khái niệm lại với nhau:
class Employee:
empCount = 0
self.name = name
"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
Name : Zara ,Salary: 2000
Name : Manni ,Salary: 5000
Total Employee 2
Có thể thêm, xóa hoặc sửa đổi các thuộc tính của class và đối tượng bất kỳ lúc nào
emp1.age = 7 # Add an 'age' attribute.
emp1.age = 8 # Modify 'age' attribute.
del emp1.age # Delete 'age' attribute.
Thay vì sử dụng các câu lệnh thông thường để truy cập các thuộc tính, có thể sử
dụng các hàm sau:
▪ getattr(obj, name[, default]) - truy cập thuộc tính của đối tượng
▪ hasattr(obj,name) - kiểm tra xem một thuộc tính có tồn tại hay không
▪ setattr(obj,name,value) - đặt một thuộc tính. Nếu thuộc tính không tồn tại, thì
nó sẽ được tạo
▪ delattr(obj, name) - xóa một thuộc tính
Ví dụ:
hasattr(emp1, 'age') # Returns true if 'age' attribute exists
getattr(emp1, 'age') # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(emp1, 'age') # Delete attribute 'age'
5.5.5 Thuộc tính class tích hợp

Mỗi class Python tuân theo các thuộc tính dựng sẵn và chúng có thể được truy cập
bằng cách sử dụng toán tử dấu chấm giống như bất kỳ thuộc tính nào khác.
▪ __dict__ − Dictionary chứa không gian tên của class

▪ __doc__ − Chuỗi tài liệu class hoặc không có, nếu không định nghĩa
▪ __name__ − Tên class
▪ __module__ − Tên module trong đó class được định nghĩa. Thuộc tính này là
"__main__" trong chế độ tương tác
▪ __bases__ − Một tuple trống có thể chứa các class cơ sở, theo thứ tự xuất hiện của
chúng trong list class cơ sở
Ví dụ: truy cập tất cả các thuộc tính trong class Employee ở ví dụ trên
class Employee:
empCount = 0
self.name = name
print("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__bases__:", Employee.__bases__)
print("Employee.__dict__:", Employee.__dict__)
Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2,
'displayEmployee': <function displayEmployee at 0xb7c8441c>,
'__doc__': 'Common base class for all employees',
'__init__': <function __init__ at 0xb7c846bc>}
5.5.6 Huỷ đối tượng

Python tự động xóa các đối tượng không cần thiết (kiểu dựng sẵn hoặc instance
class) để giải phóng không gian bộ nhớ. Quá trình Python thu hồi định kỳ các khối bộ
nhớ không còn được sử dụng nữa được gọi là thu gom rác.
Trình thu gom rác của Python chạy trong khi thực thi chương trình và được kích hoạt
khi số lượng tham chiếu của đối tượng bằng không. Số lượng tham chiếu của một đối
tượng thay đổi khi số lượng bí danh trỏ tới nó thay đổi.
Số lượng tham chiếu của một đối tượng tăng lên khi nó được gán một tên mới hoặc
được đặt trong một vùng chứa (list, tuple hoặc dictionary). Số lượng tham chiếu của
đối tượng giảm khi đối tượng bị xóa bằng del, tham chiếu của đối tượng được gán lại
hoặc tham chiếu của đối tượng nằm ngoài phạm vi. Khi số lượng tham chiếu của một
đối tượng bằng 0, Python sẽ tự động thu thập nó.
a = 40 # Create object <40>
b = a # Increase ref. count of <40>
c = [b] # Increase ref. count of <40>
del a # Decrease ref. count of <40>
b = 100 # Decrease ref. count of <40>
c[0] = -1 # Decrease ref. count of <40>
Thông thường, người dùng sẽ không nhận thấy khi trình thu gom rác lấy lại không
gian của nó. Nhưng một class có thể triển khai phương thức đặc biệt __del__(), được
gọi là hàm hủy. Phương thức này có thể được sử dụng để dọn sạch mọi tài nguyên
không phải bộ nhớ được sử dụng bởi một instance.
Ví dụ: Hàm hủy __del__() này xuất tên class của một instance sắp bị hủy
class Point:
def __init__( self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print(class_name, "destroyed")
pt1 = Point()
pt2 = pt1
pt3 = pt1
print(id(pt1), id(pt2), id(pt3)) # prints the ids of the obejcts
del pt1
del pt2
del pt3
3083401324 3083401324 3083401324
Point destroyed
Lưu ý - Tốt nhất nên xác định các class trong file riêng biệt, sau đó import chúng vào
file chương trình chính.
5.5.7 Class kế thừa

Thay vì bắt đầu từ đầu, có thể tạo một class bằng cách lấy nó từ một class có sẵn
bằng cách liệt kê class parent trong dấu ngoặc đơn sau tên class mới. Class child kế
thừa các thuộc tính của class parent và có thể sử dụng các thuộc tính đó như thể
chúng được định nghĩa trong class child. Một class child cũng có thể ghi đè các thành
viên dữ liệu và phương thức từ class parent.
Cú pháp: Các classp dẫn xuất được khai báo giống như class parent của chúng;
tuy nhiên, một danh sách các class cơ sở để kế thừa được đưa ra sau tên class
class SubClassName (ParentClass1[, ParentClass2, ...]):
'Optional class documentation string'
class_suite
Ví dụ:
class Parent: # define parent class
parentAttr = 100
def __init__(self):
print("Calling parent constructor")
def parentMethod(self):
print('Calling parent method')
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print("Parent attribute :", Parent.parentAttr)
class Child(Parent): # define child class
def __init__(self):
print("Calling child constructor")
def childMethod(self):
print('Calling child method')
c = Child() # instance of child
c.childMethod() # child calls its method
c.parentMethod() # calls parent's method
c.setAttr(200) # again call parent's method
c.getAttr() # again call parent's method
Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200
Tương tự, có thể tạo một class từ nhiều class parent như sau:
class A: # define your class A
.....
class B: # define your class B
.....
class C(A, B): # subclass of A and B
.....
Có thể sử dụng các hàm issubclass() hoặc isinstance() để kiểm tra mối quan hệ của
hai class và các instance.
▪ Hàm boolean issubclass(sub, sup) trả về true nếu sub đã cho thực sự là một class
của sup
▪ Hàm boolean isinstance(obj, Class) trả về true nếu obj là một instance của Class
5.5.8 Phương thức ghi đè

Có thể ghi đè các phương thức của class parent. Một lý do để ghi đè các phương
thức của class parent là vì muốn chức năng đặc biệt hoặc khác trong subclass (class
child).
Ví dụ:
class Parent: # define parent class
def myMethod(self):
print('Calling parent method')

class Child(Parent): # define child class
def myMethod(self):
print('Calling child method')
c = Child() # instance of child
c.myMethod() # child calls overridden method
Calling child method
5.5.9 Nạp chồng toán tử - Overloading Operator

Giả sử đã tạo một lớp Vector để biểu diễn các vectơ hai chiều, điều gì sẽ xảy ra khi
sử dụng toán tử cộng để cộng chúng? Người dùng có thể định nghĩa phương thức
__add__ trong class để thực hiện phép cộng vectơ và sau đó toán tử cộng sẽ hoạt động
theo mong đợi
Ví dụ:
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print(v1 + v2)
Vector(7,8)
5.5.10 Ẩn dữ liệu
Các thuộc tính của một đối tượng có thể hiển thị hoặc không hiển thị bên ngoài định
nghĩa class. Người dùng cần đặt tên cho các thuộc tính có tiền tố gạch dưới kép và
những thuộc tính đó sẽ không hiển thị trực tiếp.
Ví dụ:
class JustCounter:
__secretCount = 0
def count(self):
self.__secretCount += 1
print(self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print(counter.__secretCount)
1
2
print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'
Python bảo vệ các thành viên đó bằng cách thay đổi tên bên trong để bao gồm tên
class. Có thể truy cập các thuộc tính như object._className__attrName. Nếu thay thế
dòng cuối cùng như sau, thì nó phù hợp:
class JustCounter:
__secretCount = 0
def count(self):
self.__secretCount += 1
print(self.__secretCount)
counter = JustCounter()
counter.count()
counter.count()
print(counter._JustCounter__secretCount)
1
2
2
TÓM TẮT
▪ Định nghĩa hàm và phạm vi biến cho việc lập trình
▪ Cách các module được tải bằng câu lệnh import; kiểm tra các module được phát hiện
thông qua các vị trí tìm kiếm; và tổ chức thành package cho việc lập trình
▪ Cấu trúc của hệ thống file bao gồm cách mở, đóng và xoá file với các chế độ khác
nhau
▪ Mô tả được lỗi và ngoại lệ, xử lý được khi chúng xảy ra và định nghĩa, sử dụng ngoại
lệ tuỳ chỉnh
▪ Mô tả được các khái niệm liên quan đến lập trình hướng đối tượng; phân biệt được
lớp và đối tượng
▪ Tạo các lớp đóng vai trò là bản thiết kế cho mọi đối tượng trong Python; tìm hiểu
cách lập trình, gọn gàng và hiệu quả
BÀI TẬP
I. Hàm
Câu 1: Tìm số lớn nhất trong ba số
Câu 2: Tìm số lớn nhất và nhỏ nhất trong bốn số
Câu 3: Tính tổng và tích của tất cả các số trong một list
Sample List : (8, 2, 3, -1, 7)
Expected Output : 19, -336
Câu 4: Đảo ngược chuỗi đầu vào
Sample String : "1234abcd"
Expected Output : "dcba4321"
Câu 5: Tính giai thừa của một số (số nguyên không âm). Hàm chấp nhận số làm đối
số
Câu 6: Đếm số lượng chữ hoa và chữ thường cho một chuỗi đầu vào
Sample String : 'The quick Brow Fox'
Expected Output :
No. of Upper case characters : 3
No. of Lower case Characters : 12
Câu 7: Viết hàm nhận một số làm tham số và kiểm tra xem số đó có phải là số nguyên
tố hay không
Chú ý: Số nguyên tố là số tự nhiên lớn hơn 1, chia hết cho 1 và chính nó
Câu 8: Phát hiện số lượng biến cục bộ được khai báo trong một hàm
Câu 9: Viết một hàm nhận một số thực làm tham số để chuyển đổi độ sang radian và
một hàm khác nhận một số thực làm tham số để chuyển đổi radian sang độ
Câu 10: Viết hàm nhận hai số thực làm tham số của chiều cao và bán kính để tính thể
tích và diện tích hình trụ
Câu 11: Viết hàm nhận hai số thực làm tham số của góc và bán kính để tính độ dài
cung của một hình tròn
Câu 13: Tìm giá trị median của ba giá trị

Input first number: 15
Input second number: 26
Input third number: 29
The median is 26.0
Câu 14: Viết hàm để xuất ra các số chẵn từ list đã cho
Sample List : [1, 2, 3, 4, 5, 6, 7, 8, 9]
Expected Output : [2, 4, 6, 8]
Câu 15: Giải phương trình bậc 2: ax2 + bx + c = 0, với a, b, c nhập vào từ bàn phím
Câu 16: Tìm các số chia hết cho 5 và 7 trong khoảng 1500 – 2700
Câu 17: Viết chương trình để tính tuổi của một con chó theo năm con chó. Lưu ý: Trong
hai năm đầu tiên, một năm của con chó bằng 10.5 năm của con người. Sau đó, mỗi
năm con chó bằng 4 năm con người
Ví dụ:
Input a dog's age in human years: 15
The dog's age in dog's years is 73
Câu 18: Viết một hàm nhận tên tháng làm tham số và đổi thành số ngày
Ví dụ:
Input the name of Month: February
No. of days: 28/29 days
Câu 19: Viết hàm giải hệ phương trình
𝑎𝑥 + 𝑏𝑦 = 𝑐
{
𝑑𝑥 + 𝑒𝑦 = 𝑓
Xuất các giá trị của x, y trong đó a, b, c, d, e và f là tham số đầu vào của hàm
Câu 20: Viết một hàm nhận một số làm tham số để tạo bảng cửu chương (từ 1 đến
10)
Ví dụ:
Input a number: 6
6x1=6
6 x 2 = 12
6 x 3 = 18
6 x 4 = 24
6 x 5 = 30
6 x 6 = 36
6 x 7 = 42
6 x 8 = 48
6 x 9 = 54
6 x 10 = 60
II. File I/O
Câu 1: Đọc toàn bộ file văn bản
Câu 2: Đọc n dòng đầu tiên của một file
Câu 3: Thêm văn bản vào file và hiển thị văn bản
Câu 4: Đọc từng dòng tệp và lưu nó vào list
Câu 5: Tìm các từ dài nhất trong file văn bản
Câu 6: Đếm số dòng trong một file văn bản
Câu 7: Đếm tần suất xuất hiện của các từ trong một file văn bản
Câu 8: Sao chép nội dung của một file sang một file khác
Câu 9: Kết hợp từng dòng từ file đầu tiên với dòng tương ứng trong file thứ hai
Câu 10: Tạo 26 file văn bản có tên A.txt, B.txt, v.v. cho đến Z.txt.
III. Xử lý ngoại lệ và xác nhận
Câu 1: Viết chương trình nhập thực hiện phép chia và xử lý ngoại lệ ZeroDivisionError
khi chia một số cho 0
Câu 2: Viết chương trình nhắc người dùng nhập một số và đưa ra một ngoại lệ
ValueError nếu đầu vào không phải là một số hợp lệ
Câu 3: Viết chương trình mở file và xử lý ngoại lệ FileNotFoundError nếu file không tồn
tại
Câu 4: Viết chương trình nhắc người dùng nhập hai số và đưa ra ngoại lệ TypeError
nếu đầu vào không phải là số
Câu 5: Viết chương trình thực thi một thao tác trên list và xử lý ngoại lệ IndexError
nếu chỉ mục nằm ngoài phạm vi
Câu 6: Viết chương trình Python thực thi thao tác danh sách và xử lý ngoại lệ
AttributeError nếu thuộc tính không tồn tại
IV. Hướng đối tượng
Câu 1: Tạo một lớp Vehicle mà không có bất kỳ biến và phương thức nào
Câu 2: Tạo lớp Vehicle với các thuộc tính đối tượng max_speed và mileage
Câu 3: Tạo một class đại diện cho một Circle. Bao gồm các phương pháp để tính diện
tích và chu vi của nó
Câu 4: Tạo một class person. Bao gồm các thuộc tính như tên, quốc gia và ngày sinh.
Thực hiện một phương pháp để xác định tuổi của người đó
Lưu ý: sử dụng gói datetime
Câu 5: Tạo class calculator. Bao gồm các phương thức cho các phép tính số học cơ bản
Câu 6: Tạo một class đại diện cho một shape. Bao gồm các phương pháp để tính diện
tích và chu vi của nó. Triển khai các lớp con cho các hình dạng khác nhau như hình
tròn, hình tam giác và hình vuông
Câu 7: Tạo một class đại diện cho một shopping cart. Bao gồm các phương pháp để
thêm và xóa các mặt hàng và tính tổng giá
Câu 8: Tạo class đại diện cho một bank. Bao gồm các phương pháp quản lý tài khoản
và giao dịch của khách hàng
TÀI LIỆU THAM KHẢO

1. http://www.nuvoton.com/hq/products/microcontrollers/arm-cortex-m0-
mcus/?__locale=en
2. https://www.nuvoton.com/resource-files/DA00-NUC140ENF1.pdf
3. http://www.tula.vn/modules.php?name=monline&file=sdtc1&_run=view&cid=84&
arrange=tu5&desc=1&showcol=52735&showtype=0

GT Python Final

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

GT Python Final

Uploaded by

Copyright:

Available Formats

BỘ GIÁO DỤC VÀ ĐÀO TẠO

LẬP TRÌNH PYTHON

Biên soạn: TS. Phạm Quốc Thiện

Tài Liệu Lưu Hành Tại HUTECH www.hutech.edu.vn

2.2.2 Chuỗi - string .............................................................Error! Bookmark not defined.

TÀI LIỆU THAM KHẢO .......................................................... ERROR! BOOKMARK NOT DEFINED.

NỘI DUNG MÔN HỌC

KIẾN THỨC TIỀN ĐỀ

YÊU CẦU MÔN HỌC

CÁCH TIẾP NHẬN NỘI DUNG MÔN HỌC

PHƯƠNG PHÁP ĐÁNH GIÁ MÔN HỌC

BÀI 1: PYTHON LÀ GÌ?

Sau khi học xong bài này, học viên có thể:

▪ Phân biệt trình biên dịch và trình thông dịch

▪ Nắm được các tính năng chính của Spyder

1.1 Giới thiệu

Hình 1.1. IDLE – trình soạn thảo Python cơ bản.

1.1.1 Trình biên dịch và trình thông dịch

1.1.2 Ví dụ về biên dịch và thông dịch

1.2 Anaconda và trình soạn thảo Python

1.2.1 Python IDLE

1.2.2 Visual Studio Code

1.2.4 Visual Studio

1.2.6 Wing Python IDE

1.2.7 Jupyter Notebook

1.3 Cài đặt python và thiết lập môi trường

1.3.1 Cài đặt Anaconda trên Windows

Hình 1.6. Giao diện của License Agreement.

Hình 1.7. Giao diện của Select Installation Type.

Hình 1.8. Giao diện của Choose Installation Location.

Hình 1.9. Giao diện của Advanced Installation Option.

Hình 1.10. Công cụ Command Prompt.

Hình 1.11. Giao diện của quá trình cài đặt.

Hình 1.14. Giao diện chính của Anaconda Navigator.

1.3.2 Thiết lập môi trường ảo cho Python bằng Anaconda

Hình 1.15. Công cụ Anaconda Prompt.

Hình 1.16. Thiết lập môi trường ảo trên Anaconda Prompt.

1.4 Cài đặt gói Python trong Anaconda

1.4.1 Các gói Python

1.4.1.1 Gói Python cho khoa học và tính toán số

1.4.2 Anaconda Navigator

Hình 1.22. Xác nhận cài đặt gói Python.

1.4.4 Lệnh pip

pip install numpy

1.4.5 Cài đặt Python Spyder IDE và chạy tập lệnh

Hình 1.23. Giao diện của Anaconda Navigator, mở Spyder.

Hình 1.24. Giao diện chính của Spyder.

1.4.5.2 Tổng quan về Menu và Thanh công cụ của Spyder IDE

Hình 1.25. Menu của Spyder.

Hình 1.26. Thanh công cụ của Spyder.

Hình 1.27. Console của Spyder.

Hình 1.28. Trình soạn thảo của Spyder.

Hình 1.29. Project Explorer của Spyder.

1.4.5.3 Bắt đầu một project trong Spyder IDE

Hình 1.30. Tạo project trên Spyder.

1.4.5.4 Viết tập lệnh Python đầu tiên trong project

Hình 1.31. Tạo Python script.

Hình 1.32. File script được tạo thành công.

Hình 1.34. Lưu file script.

Hình 1.35. Tính năng block comment.

Hình 1.36. Tính năng Syntax Highlighting.

Hình 1.38. Editor.py trong trình soạn thảo.

Hình 1.39. Lỗi cú pháp trong Editor.py.

Hình 1.40. Tính năng completion.