CHƢƠNG 1.

CÔNG NGHỆ THÔNG TIN TRONG CÁCH MẠNG

CÔNG NGHIỆP 4.0 VÀ THỜI CHUYỂN ĐỔI SỐ ................................ 7
1.1. Cuộc Cách mạng Công nghiệp 4.0.............................................................. 7
1.2. Thời chuyển đổi số ...................................................................................... 9
1.2.1. Thời chuyển đổi số là gì? ..................................................................... 9
1.2.2. Các cấp độ của chuyển đổi số .............................................................. 9
1.2.3. Các yếu tố của chuyển đổi số ............................................................. 11
1.3. Vai trò của CNTT trong Cách mạng Công nghiệp 4.0 và Thời chuyển đổi
số ...................................................................................................................... 12
1.3.1. CNTT tạo nên các công nghệ lõi trong Cách mạng Công nghiệp 4.0 12
1.3.2. CNTT có vai trò quan trọng trong xây dựng hạ tầng số .................... 14
1.4. Cách mạng công nghiệp 4.0 ở một số quốc gia ........................................ 17
1.4.1. Xây dựng cơ sở hạ tầng số ................................................................. 17
1.4.2. Thanh toán điện tử - Thương mại điện tử .......................................... 18
1.4.3. Chính phủ điện tử ............................................................................... 20
1.5. Những ứng dụng hiện tại và tương lai của CNTT .................................... 22
1.5.1. Vận hành xuất sắc .............................................................................. 22
1.5.2. Trải nghiệm khách hàng xuất sắc ...................................................... 23
1.5.3. Trải nghiệm sản phẩm........................................................................ 24
1.5.4. Các mô hình kinh tế chia sẻ ............................................................... 24
CHƢƠNG 2. PYTHON VÀ MÔI TRƢỜNG LÀM VIỆC.................... 25
2.1. Giới thiệu về Python ................................................................................. 25
2.1.1. Lịch sử của Python ............................................................................. 25
2.1.2. Các tính năng chính của Python ........................................................ 25
2.1.3. Sử dụng Python .................................................................................. 27
2.1.4. Những lý do chọn Python để lập trình ............................................... 27
2.1.5. Cài đặt và thực thi Python ................................................................. 28
2.2. Môi trường làm việc Anaconda ................................................................ 31
2.3. Jupiter notebook ........................................................................................ 34
2.3.1. Tổng quan về notebook ...................................................................... 35

1
 2.3.2. Làm việc với notebook ....................................................................... 36
2.4. Bài Tập ...................................................................................................... 39
CHƢƠNG 3. KIỂU DỮ LIỆU TRONG PYTHON ............................... 41
3.1. Định danh và từ khóa ................................................................................ 41
3.2. Biến trong Python ..................................................................................... 42
3.3. Kiểu dữ liệu số trong Python .................................................................... 43
3.3.1. Các kiểu dữ liệu số............................................................................. 43
3.3.2. Chuyển đổi giữa các kiểu dữ liệu số .................................................. 44
3.4. Module Decimal trong Python .................................................................. 45
3.5. Module Fraction trong Python .................................................................. 46
3.6. Module Math trong Python ....................................................................... 47
CHƢƠNG 4. CÂU LỆNH......................................................................... 51
4.1. Lệnh lựa chọn if ........................................................................................ 51
4.1.1. Lệnh if ................................................................................................ 51
4.1.2. Lệnh if-else ......................................................................................... 53
4.1.3. Lệnh if-elif-else .................................................................................. 54
4.1.4. Lệnh if lồng nhau ............................................................................. 56
4.2. Lệnh lặp .................................................................................................... 57
4.2.1. Lệnh for..in ......................................................................................... 57
4.2.2. Lệnh while .......................................................................................... 62
4.3. Lệnh break và continue ............................................................................. 64
4.3.1. Lệnh break ......................................................................................... 64
4.3.2. Lệnh continue ..................................................................................... 65
4.4. Bài tập ....................................................................................................... 67
CHƢƠNG 5. HÀM TRONG PYTHON .................................................. 71
5.1. Cơ bản về hàm trong Python .................................................................... 71
5.1.1. Hàm trong Python là gì? ................................................................... 71
5.1.2. Cú pháp của hàm Python ................................................................... 71
5.1.3. Ví dụ về hàm Python .......................................................................... 72
5.1.4. Gọi hàm trong Python........................................................................ 72

2
 5.1.5. Docstring trong Python ...................................................................... 73
5.1.6. Lệnh return trong hàm Python ........................................................... 73
5.1.7. Phạm vi và thời gian tồn tại của các biến.......................................... 74
5.1.8. Các loại hàm trong Python ................................................................ 75
5.2. Các hàm Python tích hợp sẵn .................................................................... 75
5.3. Hàm Python do người dùng tự định nghĩa ................................................ 79
5.3.1. Hàm Python do người dùng định nghĩa là gì? ................................... 79
5.4. Tham số hàm Python ................................................................................. 80
5.4.1. Tham số của hàm Python ................................................................... 80
5.4.2. Tham số mặc định trong hàm Python ................................................ 81
5.4.3. Tham số keyword trong Python ......................................................... 82
5.4.4. Tham số tùy biến trong hàm Python .................................................. 83
5.5. Hàm đệ quy trong Python ......................................................................... 84
5.5.1. Hàm đệ quy trong Python là gì? ........................................................ 84
5.5.2. Ví dụ về hàm đệ quy trong Python ..................................................... 84
5.5.3. Ưu điểm của hàm đệ quy .................................................................... 85
5.5.4. Nhược điểm của đệ quy: .................................................................... 86
5.6. Hàm vô danh, Lambda trong Python ........................................................ 87
5.6.1. Hàm Lambda trong Python là gì?...................................................... 87
5.6.2. Cú pháp hàm Lambda trong Python .................................................. 87
5.6.3. Ví dụ về hàm Lambda trong Python................................................... 87
5.6.4. Sử dụng Lambda trong Python .......................................................... 88
5.7. Biến toàn cục (global), biến cục bộ (local), biến nonlocal trong Python.. 89
5.7.1. Biến toàn cục trong Python ................................................................ 89
5.7.2. Biến cục bộ trong Python ................................................................... 90
5.7.3. Biến cục bộ và biến toàn cục ............................................................. 90
5.7.4. Biến nonlocal trong Python ............................................................... 92
5.8. Từ khóa global trong Python..................................................................... 92
5.8.1. Quy tắc của từ khóa global trong Python .......................................... 93
5.8.2. Cách sử dụng từ khóa global trong Python ....................................... 93

3
 5.9. Module trong Python ................................................................................ 96
5.9.1. Module trong Python là gì? ............................................................... 96
5.9.2. Làm sao để nhập module trong Python? ........................................... 97
5.9.3. Sử dụng lệnh import ........................................................................... 98
5.9.4. Nhập module và sửa tên khi nhập ...................................................... 98
5.9.5. Lệnh from...import trong Python ....................................................... 98
5.9.6. Nhập tất cả tên ................................................................................... 99
5.9.7. Đường dẫn tìm kiếm module Python ................................................. 99
5.9.8. Nạp lại module ................................................................................... 99
5.9.9. Hàm dir() trong Python ................................................................... 100
5.10. Package trong Python ........................................................................... 101
5.10.1. Package trong Python là gì? ......................................................... 101
5.10.2. Nhập module từ package trong Python ......................................... 103
5.11. Bài tập ................................................................................................... 103
CHƢƠNG 6. DỮ LIỆU CÓ CẤU TRÚC TRONG PYTHON............ 111
6.1. List .......................................................................................................... 111
6.1.1. Kiểm tra sự tồn tại của một phần tử ................................................ 112
6.1.2. Duyệt mảng ...................................................................................... 113
6.1.3. Các phép toán trên mảng ................................................................. 113
6.1.4. Trích xuất mảng con ........................................................................ 114
6.1.5. Xóa phần tử của mảng ..................................................................... 114
6.1.6. Một số phương thức xử lý trong mảng............................................. 115
6.1.7. List lồng nhau .................................................................................. 116
6.1.8. List và chuỗi ..................................................................................... 116
6.2. Dictionary ............................................................................................... 116
6.2.1. Thêm một phần tử ............................................................................ 117
6.2.2. Một số hàm, phương thức thông dụng ............................................. 117
6.3. Tuple ....................................................................................................... 117
6.4. Mảng một chiều ...................................................................................... 118
6.4.1. Khởi tạo mảng một chiều ................................................................. 118

4
 6.4.2. Truy cập mảng một chiều ................................................................. 119
6.4.3. Các phép toán trên mảng một chiều ................................................ 120
6.4.4. Tích vô hướng của hai vector ........................................................... 121
6.5. Mảng nhiều chiều .................................................................................... 122
6.5.1. Khởi tạo ma trận .............................................................................. 122
6.5.2. Truy cập vào các phần tử của ma trận ............................................ 124
6.5.3. Các phép toán trên ma trận ............................................................. 124
6.5.4. Các phép toán giữa hai ma trận ...................................................... 126
6.5.5. Các phép toán giữa ma trận và vector ............................................. 126
6.5.6. Tích giữa hai ma trận, tích giữa ma trận và vector ......................... 127
6.5.7. Chuyển vị ma trận ............................................................................ 128
6.5.8. Reshape ma trận ............................................................................... 129
6.6. Bài tập ..................................................................................................... 130

5
CHƢƠNG 1. CÔNG NGHỆ THÔNG TIN TRONG
CÁCH MẠNG CÔNG NGHIỆP 4.0 VÀ THỜI
CHUYỂN ĐỔI SỐ

1.1. Cuộc Cách mạng Công nghiệp 4.0

Có nhiều cách kiến giải khác nhau và đa chiều về khái niệm Công nghiệp
4.0 (CN4.0). Ví dụ: có nghiên cứu xem CN4.0 „là sự hợp nhất của những công
nghệ, tạo sự liên kết giữa không gian vật lý, số và sinh học… là khả năng hàng tỷ
người có thể kết nối với nhau thông qua các thiết bị di động với năng lực tính
toán và khả năng lưu trữ dữ liệu cực lớn và việc truy cập không giới hạn với tri
thức nhân loại‟; công nghệ lõi thúc đẩy những liên kết này là robot tự hành, dữ
liệu lớn (big data), trí tuệ nhân tạo (AI), in 3D, điện toán đám mây, thực tế ảo,
internet vạn vật (IoT) (Nguyễn Hoàng Hà 2017; Nguyễn Trường Thắng 2017).

Bản chất của cuộc Cách mạng CN4.0

7
 Một là, tuy điểm vượt trội của CN4.0 nằm ở sự hợp nhất, kết nối giữa các
công nghệ với nhau, nhưng không nhất thiết phải ứng dụng đầy đủ nhiều công
nghệ trong cùng một chuỗi giá trị. Điều này có ý nghĩa quan trọng, bởi chi phí lớn
và năng lực tiếp cận hạn chế đối với các công nghệ ở bậc cao như AI, robot,
blockchain sẽ làm nản lòng các doanh nghiệp và hệ thống công quyền đặc biệt ở
các nước đang phát triển và cấp địa phương trong việc đầu tư ứng dụng và phát
triển CN4.0. Ngược lại, nhận thức CN4.0 có thể triển khai với kết nối internet,
ứng dụng thông minh, điện toán đám mây, blockchain sẽ giúp các địa phương và
doanh nghiệp nhỏ và vừa (DNNVV) mạnh dạn đổi mới, ứng dụng CN4.0 với chi
phí thấp, hiệu quả cao cho những mô hình cung cấp hàng hóa và dịch vụ truyền
thống của mình.

Hai là, bản chất của CN4.0 là sự kết hợp giữa thế giới thực và ảo trên nền
tảng số, qua đó làm thay đổi không gian vật lý, mối quan hệ giữa thông tin và trí
tuệ, giữa chủ động và tự động hóa, giữa máy móc và dữ liệu. Hệ quả là mỗi sự
đổi mới này lại kéo theo những thay đổi căn bản về mô hình kinh doanh và tổ
chức doanh nghiệp, bao gồm thiết kế, sản xuất, phân phối và dịch vụ. Có thể thấy,
những công nghệ CN4.0 đã tạo lập những thể chế mới, chiều hợp tác mới, thay
đổi hẳn mối quan hệ giữa nhà sản xuất – người tiêu dùng, hàng hóa – dịch vụ
(Kim 2018).

Ba là, khác với các cuộc cách mạng công nghiệp trước đây, khi các công
nghệ mới thay thế công nghệ cũ như năng lượng điện thay thế máy hơi nước,
công nghệ của CN4.0 không thay thế mà còn bổ sung, mở rộng năng lực của công
nghệ thế hệ trước, ví dụ: các mô hình co-working, smart city sẽ mở rộng không
gian và tạo nền tảng phát triển các hoạt động kinh doanh truyền thống. Như vậy,
mặc dù CN4.0 đều nhấn mạnh sự tích hợp, kết nối giữa các công nghệ, nhưng
không loại trừ ứng dụng riêng biệt của các công nghệ đơn lẻ.

Bốn là, lợi ích của CN4.0 là vô cùng rộng lớn và còn đang phát triển. Có ý
kiến cho rằng CN4.0 đang phát triển theo cấp số nhân (Nguyễn Hoàng Hà 2017).
Nếu chúng ta chứng kiến sự nâng cấp cấu hình của các dòng sản phẩm điện thoại
di động và sản phẩm kỹ thuật số khác thì có thể thấy nhận xét này không hề thổi

8
phồng triển vọng phát triển của CN4.0; và người ta chưa nhìn thấy giới hạn của
xu hướng này.

1.2. Thời chuyển đổi số

1.2.1. Thời chuyển đổi số là gì?

Thời chuyển đổi số là thời đại mà mọi vật dần được số hoá và rất nhiều
công nghệ số được phát triển và sử dụng. Như vậy, đã có sự chuyển đổi kết nối
giữa thế giới thực thể (vật lý) và không gian số. Mọi điều xảy ra trên thế giới các
thực thể, được tính toán điều khiển trên không gian số và ngược lại.

Sự đột phá của các công nghệ số đã tạo nên những thay đổi lớn này, đây là
các công nghệ lõi trong cuộc cách mạng CN4.0, bao gồm:

 Điện toán đám mây

 Internet vạn vật
 Block chain
 Trí tuệ nhân tạo
 Dữ liệu lớn
 Khoa học dữ liệu

1.2.2. Các cấp độ của chuyển đổi số

Có ba cấp độ của chuyển đổi số:

9
a. Số hóa thông tin (Digitization)

Số hóa thông tin là việc chuyển đổi dữ liệu từ dạng vật lý (analog) sang
dạng kỹ thuật số (digital)

Ví dụ: Chuyển đổi dữ liệu trên giấy thành kỹ thuật số bằng công nghệ nhận
dạng chữ viết. Thay đổi việc ghi chép vào biểu mẫu trên giấy bằng việc nhập liệu
trực tiếp trên máy tính, điện thoại, v.v. Dữ liệu dưới dạng kỹ thuật số giúp dễ
dàng lưu trữ, tìm kiếm và khai thác.

b. Số hóa quy trình (Digitalization)

Số hóa quy trình là việc áp dụng công nghệ để tự động hóa quy trình hiện
tại, giúp giảm chi phí vận hành và tăng hiệu quả.

Ví dụ: Số hóa quy trình cấp chứng minh nhân dân, cấp bằng lái xe, xin tạm
ứng khi đi công tác, giúp loại bỏ các công đoạn sử dụng giấy, giúp tiết kiệm công
sức đi lại xin phê duyệt, nâng cao năng suất lao động của khối phòng ban hỗ trợ.

c. Chuyển đổi số (Digital Transformation)

Chuyển đổi số là quá trình khai thác các công nghệ số và các khả năng hỗ
trợ để tạo ra một mô hình kinh doanh số mới mạnh mẽ. Trích từ nguồn:
https://www.gartner.com/en/informationtechnology/glossary/digital-business-
transformation.

Chuyển đổi số không nhất thiết nói về công nghệ số, mà nói về việc công
nghệ số giúp con người giải quyết các vấn đề truyền thống. Và con người ưu tiên
các giải pháp số hiện đại thay vì các giải pháp cũ. (Nguồn: Jo Caudron, Dado

10
Van Peteghem - Digital Transformation: A Model to Master Digital Disruption -
Trang 280)

1.2.3. Các yếu tố của chuyển đổi số

Ba yếu tố của chuyển đổi số:

Chuyển đổi số = Chuyển đổi kinh doanh + Chuyển đổi con người + Chuyển
đổi công nghệ.

a. Chuyển đổi kinh doanh:

Thay đổi và tối ưu hóa mô hình kinh doanh thông qua tối ưu hóa các quy
trình nghiệp vụ

b. Chuyển đổi con người:

Nhiệm vụ của chuyển đổi con người trong chuyển đổi số là gắn kết con
người và phát triển năng lực. Trong đó gắn kết con người bao gồm lãnh đạo liên
phòng ban và nhân viên liên phòng ban; phát triển năng lực bao gồm quản lý
năng lực và sự thay đổi kết hợp với liên tục đào tạo và luân chuyển.

c. Chuyển đổi công nghệ:

Yếu tố công nghệ bao gồm việc ứng dụng những hạ tầng số, các nền tảng
số, các công nghệ mới (Big Data, Blockchain, …) để mang lại lới thế vượt bậc.

Chuyển đổi số thành công cần có sự chuyển đổi của cả 3 yếu tố:

d. Trải Nghiệm Khách Hàng Xuất Sắc:

là việc thực thi chiến lược kinh doanh với: chi phí thấphơn, rủi ro thấp hơn,
tạo ra nhiều doanh thu hơn, tạo ra nhiều giá trị hơn so với các đối thủ cạnh tranh

e. Mô Hình Kinh Doanh Mới:

Là việc tạo ra sự hài lòng và gắn kết của khách hàng nhiều hơn so với
những đối thủ cạnh tranh. Trong đó trải nghiệm khách hàng là kết quả của tất cả
những tương tác giữa khách hàng và doanh nghiệp, ví dụ như lần đầu gặp mặt,
thời điểm mua hàng, quá trình sử dụng, thời điểm rời bỏ hoặc giới thiệu cho
khách hàng mới.

11
f. Vận Hành Xuất Sắc:

Là việc tạo ra những mô hình kinh doanh ít có (hoặc không có) sự cạnh
tranh từ các đối thủ. Trong đó mô hình kinh doanh là cách doanh nghiệp tạo ra
giá trị, đưa giá trị đến với khách hàng, đem về doanh thu và phân bổ chi phí.

1.3. Vai trò của CNTT trong Cách mạng Công nghiệp 4.0 và
Thời chuyển đổi số
1.3.1. CNTT tạo nên các công nghệ lõi trong Cách mạng Công nghiệp 4.0

a. Điện toán đám mây (Cloud computing)

Lưu giữ và truy nhập dữ liệu và chương trình trên các “đám mây” (clouds)
qua Internet thay vì trên máy tính của người dùng. Dữ liệu được lưu giữ thường
trực tại các máy chủ trên Internet và chỉ lưu trữ tạm thời ở máy khách.

Ví dụ: Google drive, Gmail, Dropbox

b. Internet vạn vật (IoT)

Là sự kết nối trên mạng (internetworking) của các vật thể, thiết bị
(connected devices, “smart devices”).

Các thực thể, thiết bị có khả năng trao đổi thông tin, dữ liệu chỉ qua internet
mà không cần tương tác trực tiếp (người với người, người với máy, máy với máy
(M2M).

Ví dụ: Sức khoẻ một người có thể nối với Hồ sơ sức khoẻ điện tử,
wearables, trái tim cấy ghép, cơ sở tri thức về bệnh, hệ cảnh báo, chỉ dẫn xử lý...

c. Chuỗi khối (Block-chain)

Về bản chất, blockchain như cơ sở dữ liệu thông thường: lưu trữ dữ liệu với
các thuộc tính duy nhất:

 Phân cấp - không ai có toàn quyền kiểm soát thông tin nào đi vào.
 Đồng thuận - nhiều bên khác nhau lưu trữ các bản sao chính xác của
cùng một hồ sơ gốc, vì vậy đa số phải đồng ý về dữ liệu được thêm
vào
 „Chỉ thêm‟, nghĩa là không thể chỉnh sửa những gì đã có, chỉ có thể
thêm.

12
  Thông tin mới không thể xung đột với những gì đã được thêm.
 Thông tin có thể được truy cập và nhân rộng bởi tất cả mọi người.

d. Dữ liệu lớn (Big data)

Dữ liệu lớn nói về các tập dữ liệu rất lớn và/hoặc rất phức tạp, vượt quá khả
năng xử lý của các kỹ thuật IT truyền thống

Tuy nhiên, dữ liệu lớn có thể rất nhỏ. Không phải mọi tập dữ liệu to đều lớn.

13
1.3.2. CNTT có vai trò quan trọng trong xây dựng hạ tầng số

Hạ tầng số, đặc biệt là hạ tầng dữ liệu, là yếu tố quyết định để phát triển
trong thời chuyển đổi số.

a. Hạ tầng dữ liệu

Hạ tầng số, đặc biệt là hạ tầng dữ liệu là yếu tố quyết định để phát triển
trong thời chuyển đổi số, cách mạng CN4.0.

14
15
 Xây dựng các cơ sở dữ liệu dùng chung để phối hợp, giải quyết các bài toán
vĩ mô:

b. Hạ tầng kết nối

Internet đóng một vai trò quan trọng để kết nối các hệ thống, thiết bị trong
cách mạng CN4.0. Trên thực tế, IoT đã trở thành một trong những công nghệ lõi
trong cuộc cách mạng này.

16
 Ở Singapore, tiêu biểu có thể kể đến sự phát triển của hệ thống cáp quang và
mạng 4G, nhờ đó tăng đáng kể tốc độ truyền tải thông tin. Nhờ mạng cáp quang
mà tốc độ kết nối Internet trung bình của Singapore đã tăng từ 5,4 Megabit mỗi
giây (Mbps) năm 2012 lên 20 Mbps năm 2016, ngang với Nhật Bản và Phần Lan.
Tương tự như vậy, Singapore cũng nằm trong nhóm đầu các quốc gia có tốc độ
kết nối 4G nhanh nhất thế giới, một phần nhờ liên tục đầu tư cảithiện hạ tầng
mạng.

1.4. Cách mạng công nghiệp 4.0 ở một số quốc gia

1.4.1. Xây dựng cơ sở hạ tầng số

a. Singapore

Singapore đã đạt được nhiều tiến bộ trong việc cải thiện cơ sở hạ tầng số
hóa, qua đó thúc đẩy tăng cường năng lực và mở rộng ứng dụng số hóa trong các
hộ gia đình và doanh nghiệp. Tiêu biểu có thể kể đến sự phát triển của hệ thống
cáp quang và mạng 4G, nhờ đó tăng đáng kể tốc độ truyền tải thông tin. Nhờ
mạng cáp quang mà tốc độ kết nối Internet trung bình của Singapore đã tăng từ
5,4 Megabit mỗi giây (Mbps) năm 2012 lên 20 Mbps năm 2016, ngang với Nhật
Bản và Phần Lan. Tương tự như vậy, Singapore cũng nằm trong nhóm đầu các
quốc gia có tốc độ kết nối 4G nhanh nhất thế giới, một phần nhờ liên tục đầu tư
cải thiện hạ tầng mạng. Tổng lượng đăng kí băng thông rộng cáp quang và đăng
ký 4G tại Singapore đã tăng gấp đôi trong vòng 5 năm qua. Tốc độ internet nhanh
hơn thúc đẩy các hộ gia đình Singapore chuyển dần nhiều hoạt động của mình
vào không gian kỹ thuật số. Phát hiện từ khảo sát thường niên của Cơ quan Phát
triển Thông tin - Truyền thông Singapore (IMDA) cho thấy từ năm 2010 đến
2015 sốlượng người tham gia vào các hoạt động internet như mua sắm trực tuyến
và các giao dịch tài chính trực tuyến tăng lên đáng kể. Ở khu vực doanh nghiệp,
các khoản đầu tư vào các tài sản số nhằm tăng cường năng lực số của các doanh
nghiệp cũng ngày càng nhiều. Trong khoảng thời gian 2013-2015, tổng chi vốn
cho các tài sản số cố định1 tăng hàng năm trung bình 7,1%. Theo đó, các doanh
nghiệp cũng tăng cường sử dụng các công cụ số trong các hoạt động kinh doanh
thường nhật, tăng cường áp dụng thanh toán điện tử và các dịch vụ di dộng trong

17
kinh doanh.

Ngoài những xu hướng nổi bật trên, mức độ ứng dụng các loại công cụ và
năng lực kỹ thuật số như dịch vụ điện toán đám mây, các nhà máy thông minh,…
cũng tăng nhanh trong những năm gần đây. Với nhiều nỗ lực của Chính phủ
Singapore hướng đến số hóa nền kinh tế (như thông qua Chương trình sáng kiến
Quốc gia Thông minh) thì mức độ ứng dụng số hóa của các hộ gia đình và doanh
nghiệp được duy trì và ngày càng phát triển.

b. Hàn Quốc

Theo kết quả khảo sát của Bộ Khoa học, Công nghệ thông tin và truyền
thông, và Quy hoạch Hàn Quốc thì tỷ lệ dân số Hàn Quốc sử dụng Internet (tính
từ trẻ 3 tuổi trở lên) năm 2016 đạt 88,3%, tăng 3,2% so với năm 2015. Đặc biệt,
số người cao tuổi sử dụng internet tăng mạnh, cứ hai người trên 60 tuổi lại có một
người dùng internet. Tỷ lệ sử dụng Internet ở lứa tuổi từ 10 tới 40 tuổi đạt mức
tuyệt đối 100%. Thời gian sử dụng Internet bình quân là 14,3 giờ/tuần, tăng 0,6
giờ so với năm 2015. Tần suất sử dụng Internet nhiều hơn một lần/tuần đạt
98,9%. Phương tiện để truy cập internetđang có chiềuhướng chuyển từ máy tính
sang điện thoại smartphone. Tỷ lệ sở hữu smartphone trên mỗi hộ gia đình tăng từ
84,1% vào năm 2014 lên 88,5% vào năm 2016, trong khi tỷ lệ sở hữu máy tính
giảm từ 78,2% xuống còn 75,3%. Tỷ lệ số hộ gia đình Hàn Quốc kết nối mạng
internet đạt 99,2%, đứng đầu trong số 175 quốc gia thuộc Liên minh viễn thông
quốc tế (ITU). Theo tổ chức nghiên cứu Internet Akamai, Hàn Quốc hiện là quốc
gia có tốc độ kết nối internet nhanh nhất thế giới, vượt trên cả Nhật Bản và Mỹ.

1.4.2. Thanh toán điện tử - Thương mại điện tử

a. Singapore

Singapore là thị trường thanh toán điện tử (TTĐT) phát triển mạnh nhất
trong các nước ASEAN, với tỷ lệ dân số sử dụng internet khoảng 80% và năm
2015, chỉ số TTĐT của nước này ở khoảng 56%-57%. Singapore là nước nhanh
chóng tiếp thu công nghệ mới với số người sử dụng ví điện tử (VĐT) đã tăng gấp
đôi trong năm 2015 và chiếm tới 23% trong tổng dân số của nước này, hay chiếm

18
hơn 41% trong tổng số người mua sắm trực tuyến.

Singapore là một trong những nước áp dụng TTĐT đầu tiên trên thế giới.
Các hoạt động TTĐT phát triển với tốc độ khá nhanh. Tuy nhiên, đến nay
Singapore vẫn thua kém nhiều nước khác, cụ thể như Trung Quốc, về việc ứng
dụng công nghệ TTĐT. Hầu hết mọi người ở Singapore đều có điện thoại thông
minh, nhưng cứ 10 người thì lại có 9 người vẫn muốn trả tiền cho các giao dịch
hằng ngày theo cách cũ bằng tiền mặt. 43% số người Singapore tham gia khảo sát
cho biết rằng họ sử dụng tiền mặt nhiều nhất, gần gấp đôi so với con số 25% ở
Trung Quốc. Lý do là Singapore có nhiều chương trình TTĐT, nhưng thiếu sự kết
nối, liên thông giữa các hệ thống thanh toán này, do vậy gây nhiều phiền toái, rõ
nhất là người dân phải mang theo nhiều thẻ và các doanh nghiệp cũng phải chi
phí tốn kém để cài đặt nhiều hệ thống.

b. Hàn Quốc

Thương mại điện tử đã được áp dụng mạnh mẽ tại Hàn Quốc, chiếm trên
40% tất cả các giao dịch thương mại năm 2015, trong đó, giao dịch B2B chiếm
hơn 90% và giao dịch B2G chiếm gần 6%.

Ngân hàng điện tử (E-banking) được giới thiệu tại Hàn Quốc vào năm 1999.
Hầu hết các ngân hàng tăng thêm 0,1-0,5 điểm phần trăm lãi suất huy động cho
khách hàng đăng ký internet banking, và cho họ 0,5 điểm phần trăm chiết khấu
trên lãi suất cho vay. Đến năm 2010, 42,3% người dùng internet ở độ tuổi 12 trở
lên đã sử dụng dịch vụ ngân hàng điện tử. Mức độ sử dụng bình quân cho ngân
hàng Internet là 4,9 lần mỗi tháng. Hầu hết người dùng Internet banking thông
qua máy tính (96,2%), trong khi 9,2% sử dụng điện thoại di động.

c. Trung Quốc

Thương mại trực tuyến đã trở thành một trong những hoạt động trực tuyến
phổ biến nhất tại Trung Quốc, với hơn một nửa trong số tất cả người dùng
Internet tham gia vào mua sắm trực tuyến (Bảng 4). Phương tiện kết nối thực hiện
mua sắm trực tuyến chủ yếu là máy tính để bàn và điện thoại di động. Mua sắm
trực tuyến ở Trung Quốc đã phát triển phù hợp với nhu cầu của người dùng cuối

19
cùng. Cầu gia tăng với sản phẩm nước ngoài có chất lượng cao đã dẫn đến sự gia
tăng các giao dịch xuyên biên giới theo phương thức B2C.

Hình 1-1. Số người mua sắm trực tuyến và tỷ lệ sử dụng, giai đoạn 2009-2015.

Sự phổ biến của thương mại điện tử đến từ số lượng người dùng Internet
ngày càng tăng ở Trung Quốc. Ngành công nghiệp thương mại điện tử của Trung
Quốc chịu sự chi phối bởi các nền tảng thương mại trực tuyến của Taobao
(Alibaba), Tmall và Jingdon.com (JD.com). Quy mô lớn của thị trường thương
mại điện tử của Trung Quốc đã thu hút các nhà bán lẻ truyền thống lớn như Công
ty Suning Appliance (vận hành website suning.com) cũng như các đối thủ quốc tế
lớn như Amazon (vận hành website amazon.cn) và Walmart (có lượng khách
hàng lớn qua website yihaodian.com). Ngành thương mại điện tử thu hút lượng
lao động trực tiếp trên 2,5 triệu người và lao động gián tiếp trên 18 triệu người.

Kỷ nguyên thanh toán phổ biến bằng tiền mặt ở Trung Quốc dường như
đang dần đi đến hồi kết. Hình thức thanh toán qua thẻ tín dụng dường như cũng
đang dần trở thành quá khứ. Người dân Trung Quốc ngày càng chuộng hình thức
thanh toán không dùng tiền mặt, như quét mã QR, thanh toán bằng ví điện tử. Rất
nhiều sản phẩm tiêu dùng cơ bản đều cho phép thanh toán di động. Hai ứng dụng
thanh toán điện tử phổ biến nhất hàng ngày tại Trung Quốc là WeChat Pay
(Tenpay) của Tencent và Alipay của Alibaba.

1.4.3. Chính phủ điện tử

20
a. Hàn Quốc

Những nỗ lực đầu tiên trong việc xây dựng chính phủ điện tử được tiến
hành vào cuối những năm 1980 bằng việc thực hiện dự án Hệ thống thông tin cơ
bản quốc gia (NBIS), trong đó tập trung vào việc triển khai các ccác ứng dụng
CNTT trên toàn quốc. Năm 1994, Bộ Giao thông đã được tổ chức lại thành Bộ
Thông tin và Truyền thông (MIC).

Năm 1995, Hàn Quốc ban hành luật Khung về thúc đẩy thông tin hóa và
năm 1996 ban hành Kế hoạch tổng thể Quốc gia về thúc đẩy thông tin hóalần thứ
nhất. Năm 1999, Chính phủ ban hành Kế hoạch Tổng thể thứ hai về an toàn thông
tin(được gọi là Cyber Korea 21). Kế hoạch thứ ba – được gọi là e-Korea Vision
2006, được ban hành năm 2002, được coi là một sự thúc đẩy mạnh mẽ các nỗ lực
của Chính phủ hướng tới áp dụng rộng rãi thông tin và dịch vụ trực tuyến. Thống
kê năm 2013 đã cho thấy sự tiếp cận dịch vụ liên quan đến chính phủ điện tử tăng
lên mạnh mẽ.

Hình 1-2. Sử dụng các dịch vụ chính phủ điện tử ở Hàn Quốc năm 2013.

b. Trung Quốc

Ngay từ năm 2004 Chính phủ Trung Quốc đã đổi mới quản lý nhà nước
định hướng chức năng chính phủ điện tử. Tháng 8 năm 2004, Trung Quốc đã
thông qua Luật Chữ ký điện tử để điều chỉnh chữ ký điện tử, thiết lập hiệu lực
pháp lý của chữ ký điện tử nhằm bảo vệ các quyền và lợi ích hợp pháp của tất cả

21
các bên liên quan. Đây là luật đầu tiên của Trung Quốc về các ứng dụng chính
phủ điện tử, có hiệu lực từ đầu năm 2005. Tính đến cuối năm 2009 Trung Quốc
đã thành lập hơn 45.000 cổng thông tin của chính phủ. 75 cơ quan nhà nước và
trung ương, 32 chính quyền cấp tỉnh, 333 chính quyền cấp quận/huyện và hơn 80
chính quyền cấp thị trấn đã thiết lập trang web riêng của họ, cung cấp nhiều dịch
vụ trực tuyến tạo thuận lợi cho công việc và đời sống của người dân.Việc xây
dựng chính phủ điện tử đã cải thiện hiệu quả công việc và sự minh bạch thông tin
của chính phủ.

Thêm nữa, để tạo điều kiện tương tác với công chúng, Chính phủ Trung
Quốc đã hoạt động tích cực trên các mạng xã hội như Sina Weibo và Tencent
WeChat. Tương tác thông qua hình thức blog nhanh (hay còn gọi là tiểu blog –
Microblogging) cũng phát triển nhanh chóng kể từ khi microblogging chính trị
đầu tiên đi vào hoạt động năm 2009 và đến đầu 2015 đã có khoảng 280.000 tài
khoản Weibo của chính phủ, bao phủ nhiều hoạt động của các cơ quan từ cơ quan
cảnh sát, Tòa án tối cao đến cá nhân quan chức chính phủ. Tháng 4 năm 2015,
chính quyền thành phố Bắc Kinh đã ký một thỏa thuận với Alibaba để trực tuyến
hóa các dịch vụ công tương tự như thỏa thuận giữa Alibaba với các thành phố
Thượng Hải, Quảng Châu và Thẩm Quyến. Các doanh nghiệp Trung Quốc cũng
tích cực sử dụng các dịch vụ chính phủ điện tử. Năm 2014, khoảng 51,1% số
doanh nghiệp sử dụng Internet để tìm kiếm thông tin từ chính phủ.

1.5. Những ứng dụng hiện tại và tƣơng lai của CNTT
Một số ứng dụng thành công của CNTT trong Cách mạng CN4.0 và Thời
chuyển đổi số.

1.5.1. Vận hành xuất sắc

Vận hành xuất sắc (Skywise) của Airbus

 Tăng sản xuất A350 lên 33% nhờ triển khai Skywise

 Giảm 50% sự chậm trễ do bảo trì

 Tiết kiệm 3 triệu $ mỗi năm cho việc khắc phục các lỗi thường xuyên
xảy ra trong cabin. Chi phí được yêu cầu bảo hành dưới 4-7 triệu $ mỗi
năm

22
 Vận hành xuất sắc của TOYOTA: Thiết lập chương trình gọi là “Advanced
IT for Manufacturing” để kết hợp chặt chẽ các lĩnh vực của doanh nghiệp. Ban
chỉ đạo ở Bắc Mỹ của chương trình đã triển khai 32 hệ thống sản xuất thông
minh. Ví dụ: Toyota có 6 nhà máy lắp ráp xe ở Mỹ, với 14 nhà máy ở Bắc Mỹ;
tạo ra khoảng 365.000 việc làm ở Mỹ

1.5.2. Trải nghiệm khách hàng xuất sắc

DBS: Tập đoàn dịch vụ tài chính hàng đầu ở châu Á với sự hiện diện tại 18
thị trường. Đã ra mắt DB digibank - một ứng dụng di động đột phá được thiết kế
để giúp khách hàng thao tác đơn giản hơn, nhanh hơn và tiện lợi hơn. Thiết kế lấy
con người làm trung tâm. Hơn 2,5 triệu khách hàng ở Singapore. Hơn 1,2 triệu
giao dịch trên thiết bị kỹ thuật số mỗi ngày. Tài khoản tại ngân hàng di động
chiếm hơn 60% trong số hơn 500.000 lượt đăng nhập mỗi ngày. Cho phép khách
hàng bắt đầu các mối quan hệ ngân hàng mà không cần phải đến chi nhánh.

Amazon: Nhà bán lẻ trực tuyến lớn nhất thế giới. Điều đưa Amazon trở
thành một thương hiệu huyền thoại là sự kết hợp giữa trải nghiệm của khách hàng
và sản phẩm, giữ người mua hàng quay lại. Đi đầu trong một số đổi mới trong
hoạt động logistic với hàng loạt tùy chọn được thiết kế cho khách hàng:

 Tùy chọn giao nhận hàng- tùy chọn vận chuyển hay một số trường hợp
được giao hàng miễn phí

 Tùy chọn đặt hàng - đặt mua hàng với chỉ một cú nhấp chuột

 Tùy chọn đổi trả hàng

Cung cấp trải nghiệm kỹ thuật số cho khách hàng

 Khách hàng có thể đặt hàng qua ứng dụng

 72% khách hàng mong đợi phản hồi trong vòng 1h. Amazon giám sát
Twitter @AmazonHelp xử lý bảy ngày một tuần bằng bảy ngôn ngữ

 Cung cấp trải nghiệm đa kênh: ứng dụng, phương tiện truyền thông,
trang web, …

23
1.5.3. Trải nghiệm sản phẩm

o Khả năng tìm kiếm: sắp xếp theo thương hiệu; đánh giá của khách hàng,
giá cả, tính khả dụng theo danh mục cụ thể.

o Sử dụng trí tuệ nhân tạo – Alexa giúp công việc hàng ngày của bạn dễ
dàng hơn và cung cấp các đề xuất tốt hơn khi thực hiện

1.5.4. Các mô hình kinh tế chia sẻ

Airbnb: Là một thị trường cộng đồng cho việc đặt và cho thuê phòng, căn
hộ online, có trụ sở tại Silicon Valley, California.

Uber: Là một công ty kinh doanh mạng lưới giao thông vận tải và công ty
taxi dựa trên ứng dụng có trụ sở tại San Francisco, California, và hoạt động tại
các thành phố ở nhiều nước.

24
CHƢƠNG 2. PYTHON VÀ MÔI TRƢỜNG LÀM
VIỆC

2.1. Giới thiệu về Python

Python là ngôn ngữ lập trình được tạo ra bởi Guido van Rossum và là một
trong những ngôn ngữ lập trình nhập môn tốt nhất cho người lần đầu tiếp xúc với
ngôn ngữ lập trình. Python hoàn toàn tạo kiểu động và sử dụng cơ chế cấp phát
bộ nhớ tự động. Python có cấu trúc dữ liệu đơn giản nhưng hiệu quả đối với lập
trình hướng đối tượng. Cú pháp lệnh của Python thì rõ ràng, dễ hiểu và cách gõ
linh động làm cho nó nhanh chóng trở thành một ngôn ngữ lý tưởng để viết script
và phát triển ứng dụng trong nhiều lĩnh vực, ở hầu hết các nền tảng.

2.1.1. Lịch sử của Python

Python là một ngôn ngữ được thiết kế bắt đầu vào cuối những năm 1980 và
được phát hành lần đầu tiên vào tháng 2 năm 1991bởi Guido Van Rossum.

Vào cuối những năm 1980, Guido Van Rossum làm việc trong Amoeba,
phân phối một nhóm hệ điều hành. Ông muốn sử dụng một ngôn ngữ thông dịch
để truy cập vào những cuộc gọi hệ thống Amoeba và ông quyết định tạo ra một
ngôn ngữ mở rộng của ngôn ngữ như ABC (ABC có cú pháp rất dễ hiểu) dẫn đến
một thiết kế của ngôn ngữ mới, chính là Python. Rossum là fan của một sê-ri
chương trình hài cuối những năm 1970, và cái tên “Python” được lấy từ tên một
phần trong sê-ri đó “Monty Python‟s Flying Circus”. Hiện tại nhiều phiên bản
Python đang tồn tài, trong giáo trình này chúng tôi sẽ dùng phiên bản Python 3.6
để mô tả cho các ví dụ cũng như những bài thực hành.

2.1.2. Các tính năng chính của Python

25
 Ngôn ngữ lập trình đơn giản, dễ học: Python có cú pháp rất đơn giản, rõ
ràng. Nó dễ đọc và viết hơn rất nhiều khi so sánh với những ngôn ngữ lập trình
khác như C++, Java, C#. Python làm cho việc lập trình trở nên thú vị, cho phép
bạn tập trung vào những giải pháp chứ không phải cú pháp.

Miễn phí, mã nguồn mở: Chúng ta có thể tự do sử dụng và phân phối

Python, thậm chí là dùng cho mục đích thương mại. Vì là mã nguồn mở, nên
chúng ta không những có thể sử dụng các phần mềm, chương trình được viết
trong Python mà còn có thể thay đổi mã nguồn của nó. Python có một cộng đồng
rộng lớn, không ngừng cải thiện nó mỗi lần cập nhật.

Khả năng di chuyển: Các chương trình Python có thể di chuyển từ nền tảng
này sang nền tảng khác và chạy nó mà không có bất kỳ thay đổi nào. Các ứng
dụng xây dựng bằng Python thực thi được trên hầu hết tất cả các nền tảng như
Windows, macOS, Linux.

Khả năng mở rộng và có thể nhúng: Giả sử một ứng dụng đòi hỏi sự phức
tạp rất lớn, bạn có thể dễ dàng kết hợp các phần code bằng C, C++ và những
ngôn ngữ khác (có thể gọi được từ C) vào code Python. Điều này sẽ cung cấp cho
các ứng dụng những tính năng tốt hơn cũng như khả năng scripting mà những
ngôn ngữ lập trình khác khó có thể làm được.

Ngôn ngữ thông dịch cấp cao: Không giống như C/C++, với Python, bạn
không phải lo lắng những nhiệm vụ khó khăn như quản lý bộ nhớ, dọn dẹp những
dữ liệu vô nghĩa, ... Khi chạy code Python, nó sẽ tự động chuyển đổi code sang
ngôn ngữ máy tính có thể hiểu. Bạn không cần lo lắng về bất kỳ hoạt động ở cấp
thấp nào.

Thư viện tiêu chuẩn lớn để giải quyết những tác vụ phổ biến: Python có một
số lượng lớn thư viện tiêu chuẩn giúp cho công việc lập trình trở nên dễ thở hơn
rất nhiều, đơn giản vì không phải tự viết tất cả code. Ví dụ: Bạn cần kết nối cơ sở
dữ liệu MySQL trên Web server? Bạn có thể nhập thư viện MySQLdb và sử dụng
nó. Những thư viện này được kiểm tra kỹ lưỡng và được sử dụng bởi hàng trăm
người. Vì vậy, bạn có thể chắc chắn rằng nó sẽ không làm hỏng code hay ứng
dụng của mình.

26
 Hướng đối tượng: Mọi thứ trong Python đều là hướng đối tượng. Lập trình
hướng đối tượng (OOP) giúp giải quyết những vấn đề phức tạp một cách trực
quan.

2.1.3. Sử dụng Python

Lập trình ứng dụng web: Chúng ta có thể tạo web app có khả năng mở rộng
(scalable) được bằng cách sử dụng framework và CMS (Hệ thống quản trị nội
dung) được tích hợp trong Python. Một vài nền tảng phổ biến để tạo web app:
Django, Flask, Pyramid, Plone, Django CMS. Các trang như Mozilla, Reddit,
Instagram và PBS đều được viết bằng Python.

Khoa học và tính toán: Có nhiều thư viện trong Python cho khoa học và tính
toán số liệu, như SciPy và NumPy, được sử dụng cho những mục đích chung
chung trong tính toán. Và, có những thư viện cụ thể như: EarthPy cho khoa học
trái đất, AstroPy cho Thiên văn học, ... Ngoài ra, Python còn được sử dụng nhiều
trong machine learning, khai thác dữ liệu và deep learning.

Tạo nguyên mẫu phần mềm: Python chậm hơn khi so sánh với các ngôn ngữ
được biên dịch như C++ và Java. Nó có thể không phải là lựa chọn tốt nếu nguồn
lực bị giới hạn và yêu cầu về hiệu quả là bắt buộc. Tuy nhiên, Python là ngôn ngữ
tuyệt vời để tạo những nguyên mẫu (bản chạy thử - prototype). Ví dụ, bạn có thể
sử dụng Pygame (thư viện viết game) để tạo nguyên mẫu game trước. Nếu thích
nguyên mẫu đó có thể dùng C++ để viết game thực sự.

Ngôn ngữ tốt để dạy lập trình: Python được nhiều công ty, trường học sử
dụng để dạy lập trình cho trẻ em và những người mới lần đầu học lập trình. Bên
cạnh những tính năng và khả năng tuyệt vời thì cú pháp đơn giản và dễ sử dụng
của nó là lý do chính cho việc này.

2.1.4. Những lý do chọn Python để lập trình

a. Cú pháp đơn giản:

Lập trình bằng Python rất thú vị, dễ dàng để hiểu và code vì cú pháp của
Python khá giống với ngôn ngữ tự nhiên, ví dụ như đoạn code dưới đây:

27
a=2
b=5
sum=a+b
print(sum)
Ngay cả khi chưa lập trình bao giờ, bạn có thể dễ dàng đoán được đoạn code
này thêm vào hai số a, b, tính tổng và in tổng của chúng.

b. Không quá khắt khe:

Không cần xác định kiểu của một biến trong Python, không cần thêm dấu
chấm phẩy vào cuối câu lệnh. Python buộc bạn tuân theo những bài tập có sẵn
(như chỉ dẫn đúng). Điều nhỏ nhặt này giúp cho việc học Python dễ dàng với
người mới hơn rất nhiều.

c. Viết code ít hơn:

Python cho phép viết những chương trình có nhiều chức năng tốt hơn với ít
dòng code hơn.

d. Cộng đồng lớn, hỗ trợ tốt:

Python có một cộng đồng hỗ trợ rộng lớn, có nhiều diễn đàn hoạt động trực
tuyến giúp bạn khi bị mắc kẹt với vấn đề nào đó trong Python:

 https://www.reddit.com/r/learnpython/
 https://groups.google.com/forum/#!forum/comp.lang.python
 https://stackoverflow.com/tags/python

2.1.5. Cài đặt và thực thi Python

a. Cài đặt Python trên Windows

Tải Python tại https://www.python.org/downloads/, chọn phiên bản cần.

Nhấp đúp vào file vừa tải về để cài đặt. Tại đây có 2 tùy chọn, bạn chọn một cái
để cài.

 Install Now: Mặc định cài Python vào ổ C, cài sẵn IDLE (cung cấp
giao diện đồ họa để làm việc với Python), pip và tài liệu, tạo shortchut,
...
 Customize installation: Cho phép bạn chọn vị trí cài và tính năng cần
thiết.

28
 Mở IDE để tạo file mới trong IDE bạn nhấp vào File > New Windows hoặc
nhấn tổ hợp phím tắt Ctrl + N, gõ đoạn code Python: print("Xin chào!") vào file
vừa tạo, rồi nhấn Ctrl + S để lưu. File sẽ có đuôi là .py, đặt một cái tên cho nó,
chẳng hạn: kinhte-python.py. Nhấn Run -> Run module hoặc F5 để xem kết quả.

29
b. Cài đặt trên Ubuntu

Cài đặt các denpendency sau:

$ sudo apt-get install build-essential checkinstall

$ sudo apt-get install libreadline-gplv2-dev
libncursesw5-dev libssl-dev libsqlite3-dev tk-dev
libgdbm-dev libc6-dev libbz2-dev
Sau đó tải Python tại đây: https://www.python.org/downloads/

Trong terminal, đi đến thư mục chứa file tải về và chạy lệnh sau để giải nén
file. Tên file sẽ khác nhau tùy thuộc vào bản bạn tải về.

$ tar -xvf Python-3.6.2.tgz

Chuyển đến thư mục đã giải nén, nhập lệnh:
$ cd Python-3.6.0
Thực hiện các lệnh sau để biên dịch mã nguồn Python trên Ubuntu.

$ ./configure
$ make
$ make install
Để thuận tiện trong việc viết coded và thực thi code bạn nên cài đặt Sublime
Text trên máy để viết code Python trên Linux. Nhập lệnh sau để cài:

$ sudo add-apt-repository -y ppa:webupd8team/sublime-

text-2
$ sudo apt-get update
$ sudo apt-get install sublime-text
Mở Sublime Text, vào File > New File hoặc nhấn Ctrl + N để tạo một file
mới.

Lưu file với tên tùy chọn, chẳng hạn tinhoccoso-python.py

Viết code và lưu lại: print("Xin chào!")

Chuyển đến Tool  Build (Ctrl+B) bạn sẽ nhìn thấy kết quả của dòng lệnh
trên ở cuối cửa sổ Sublime Text.

c. Cài đặt trên MacOS

Tải Python: https://www.python.org/downloads/ sau đó mở file tải về để cài

đặt theo hướng dẫn, thông báo cài đặt thành công sẽ hiện ra khi hoàn tất. Bạn có
thể sử dụng ứng dụng viết code yêu thích hoặc dùng Sublime Text (công cụ được

30
rất nhiều lập trình viên yêu thích). Mở trình biên tập code của bạn lên, tạo file
mới, lưu với phần mở rộng là .py.

Viết code sau và lưu lại: print("Xin chào!")

Tùy thuộc vào trình biên tập code của bạn mà lệnh để chạy code sẽ khác
nhau, với Sublime Text thì nhấn Ctrl+B để xem kết quả khi chạy lệnh.

2.2. Môi trƣờng làm việc Anaconda

Anaconda là nền tảng (platform) mã nguồn mở trên Python thông dụng nhất
hiện nay. Anaconda là môi trường để tiếp cận nhanh và dễ để học làm việc với dữ
liệu trên Python hoặc R và làm việc được trong nhiều môi trường làm việc của
các hệ điều hành khác nhau: Windows, Linux và Mac OS X. Để làm việc được
với Anaconda hệ thống máy tính cần đáp ứng các yêu cầu sau:

 Hệ điều hành: Windows Vista trở lên, 64-bit macOS 10.10+, hoặc
Linux bao gồm Ubuntu, RedHat, CentOS 6+ và các biến thể khác.
Windows chỉ hỗ trợ phiên bản Anaconda 2.2 trở về trước.
 Kiến trúc hệ thống: 64-bit x86, 32-bit x86 với Windows hoặc Linux,
Power8 hoặc Power9. Tối thiếu 3GB trống trên đĩa cứng để tải và cài
đặt.
Để cài đặt phần mềm ta có thể làm theo các bước sau:

1. Download và cài đặt Anaconda tại:

https://www.anaconda.com/download/

2. Lưu ý: hãy chắc là bạn chọn tuỳ chọn được khoanh đỏ bên dưới để thêm
các câu lệnh Anaconda vào System Environment Variable (PATH) của Windows

31
 Hình 2-1. Một số tuỳ chỉnh khi cài đặt Anaconda

3. Sau khi cài đặt xong, mở Command prompt / Terminal và gõ dòng lệnh
bên dưới để kiểm tra Anaconda đã được cài đặt chưa?

conda –v

Hình 2-2. Kiểm tra phiên bản Anaconda và Python

4. Gõ lệnh dưới đây để mở Jupyter Notebook và bắt đầu viết chương trình
đầu tiên với Python.

32
jupyter notebook
Trong đó: Jupyter Notebook là một ứng dụng web mã nguồn mở cho phép
bạn tạo hoặc chia sẻ những văn bản chứa live code, công thức toán học, hình ảnh
trực quan, mô phỏng và văn bản. Đây là một công cụ tuyệt với để bạn có thể tạo
ra những thực nghiệm, những bộ kiểm tra một cách nhanh và trực quan nhất.

Lưu ý: Hãy chuyển đến thư mục bạn muốn làm việc trước khi thực thi lệnh
jupyter notebook.

Hình 2-3. Mở Jupyter Notebook

5. Đây là giao diện của Jupyter notebook. Bạn có thể quản lý tất cả file
notebook của mình tại đây.

Hình 2-4. Giao diện chính của Jupyter Notebook

6. Tạo mới một Notebook bằng cách chọn New -> Python 3

33
 Hình 2-5. Tạo mới một notebook

7. Bắt đầu viết chương trình Python đầu tiên bằng cách gõ

print("Hello wolrd")
Sau đó, nhấn Ctrl + Enter để chạy

Hình 2-6. Chương trình đầu tiên - Hello world.

Giải thích: Khi bạn nhấn Ctrl + Enter là bạn đã yêu cầu Jupyter Notebook
chạy đoạn lệnh Python print(“Hello world”).

Bạn đã cài đặt xong môi trường làm việc bao gồm Python và có rất nhiều
thư viện hữu ích có sẵn cho việc hiện thực ứng dụng.

2.3. Jupiter notebook

Ở mục trên chúng ta đã cài đặt Anaconda và sử dụng nhanh Jupyter
Notebook, mục này chúng ta sẽ tìm hiểu sâu hơn về Jupyter Notebook và cách sử
dụng nó

Jupyter Notebook là gì: Jupyter Notebook là một ứng dụng web mã nguồn
mở cho phép bạn tạo hoặc chia sẻ những văn bản chứa:

- Live code

- Mô phỏng

34
 - Văn bản diễn giải

- Jupyter Notebook là một công cụ tuyệt vời để:

Học và thử nghiệm với Python

Xử lý / biến đổi dữ liệu (Data processing / transformations)

Mô phỏng số học (vẽ biểu đồ)

Thống kê mô hình

Machine learning

2.3.1. Tổng quan về notebook

Khởi động Jupyter Notebook và tạo mới một notebook

Notebook khi mới được tạo có tên mặc định là Untitled. Bạn có thể click
vào chữ “Untitled” phía trên cũng, bên phải logo Jupyter để tự thay đổi tên theo ý
của bạn. Ví dụ ở đây đổi tên thành notebook01

Chuyển về Tab quản lý file của Jupyter, bạn sẽ thấy một file mới có tên
notebook01.ipynb với trạng thái là Running vì notebook này đang được mở. Bạn

35
cũng có thể tắt một notebook bằng cách nhấn Shutdown.

2.3.2. Làm việc với notebook

Một notebook bao gồm nhiều cell (ô). Khi tạo mới một notebook, bạn luôn
được tạo sẵn một cell rỗng đầu tiên.

Cell trên có kiểu là “Code”, điều đó có nghĩa là bạn có thể gõ code Python
và thực thi ngay lập tức. Để thực thi code, bạn có thể nhấn nút Run cell hoặc nhấn
Ctrl + Enter.

Kết quả ngay lập tức được hiển thị tại ô bên dưới. Một cell rỗng sẽ được tạo
sau khi bạn thực thi code. Hãy gõ tiếp một đoạn code Python để thử nghiệm:

36
 Bạn có thể chuyển loại cell từ Code thành Markdown để viết những đoạn
văn bản giải thích code của bạn chẳng hạn. Để chuyển đổi bạn click vào
ComboBox Code và chọn Markdown như hình:

Sau khi chuyển, hãy nhập ngay một đoạn Markdown để thử nghiệm, người
học tự tìm hiểu Markdown là gì.

Bạn cũng nhấn nút Run cell hoặc nhấn Ctrl + Enter để xem kết quả.

Đoạn Markdown của bạn vừa được thay thế bằng một đoạn văn bản có định
dạng khác giúp người dùng dễ phân biệt với những phần khác của chương trình,
các định dạng này do người dùng thiết lập (người học tìm hiểu thêm về định dạng
/ cú pháp của Markdown).

Nếu muốn chỉnh sửa đoạn Markdown vừa chạy thì chỉ việc click vào kết
quả vừa xuất hiện và sẽ chuyển sang chế độ chỉnh sửa.

Có các phím tắt để có thể sử dụng Jupyter notebook một cách linh hoạt và
nhanh hơn.

37
 Đặc tính Checkpoints: Một trong những chức năng hay của Jupyter
Notebook là Checkpoints. Bằng cách tạo các Checkpoints lưu trạng thái hiện tại
của notebook, Jupyter Notebook cho phép bạn có thể quay lại thời điểm tạo
Checkpoints để kiểm tra hoặc hoàn tác trước đó.

Để tạo Checkpoint, chọn File -> Save and Checkpoint. Nếu bạn muốn xem
lại các Checkpoints trước đó thì chọn File -> Revert to Checkpoint.

Chức năng Export notebook: Jupyter Noteboook cho phép bạn export
notebook của bạn ra một vài loại file như: PDF, HTML, … Để làm được điều đó,
bạn chọn File -> Download as:

38
 Đây là những tính năng cơ bản và hữu hiệu của Jupyter Notebook người học
có thể sử dụng chúng cho dự án Python sắp tới của mình. Jupyter Notebook là
một công cụ sử dụng Python hoàn hảo cho việc tính toán khoa học (Scientific
computing) và phân tích dữ liệu (data analysis) với những thư viện như numpy,
pandas và mathplotlib.

2.4. Bài Tập

Bài thực hành số 1: Thực hành tìm hiểu môi trường lập trình Python để giải
quyết bài toán, tìm hiểu yêu cầu của bài toán.

Bài thực hành số 2: Thực hành tìm hiểu môi trường làm việc của Jupiter
notebook, Anaconda và thao tác trên dữ liệu của bài toán đã đưa ra.

39
CHƢƠNG 3. KIỂU DỮ LIỆU TRONG PYTHON

3.1. Định danh và từ khóa

Định danh là tên được đặt cho các thực thể như lớp (class), hàm (function),
biến (variable), ... trong Python. Nó giúp phân biệt thực thể này với thực thể khác.

Quy tắc viết định danh trong Python:

• Định danh có thể là sự kết hợp giữa các chữ cái viết thường (từ a đến z)
hoặc viết hoa (A đến Z) hoặc các số (từ 0 đến 9) hoăc dấu gạch dưới (_). Ví dụ
định danh hợp lệ: bien_1, tinh_tong_0_9, firstClass.

• Định danh không thể bắt đầu bằng một chữ số, ví dụ 1bien là không hợp
lệ, nhưng bien1 thì đúng.

• Python không hỗ trợ các ký tự đặc biệt như !, @, #, $, %,... trong định
danh.

• Định danh có thể dài bao nhiêu tùy ý.

• Tên lớp thường bắt đầu với một chữ cái hoa. Tất cả các định danh khác bắt
đầu với chữ cái thường.

• Định danh bắt đầu với một dấu dạch dưới _ thì là định danh private.

• Định danh bắt đầu với 2 dấu gạch dưới __ thì mức độ private cao hơn.

• Nếu định danh bắt đầu và kết thúc bằng 2 dấu gạch dưới (__init__ chẳng
hạn) thì định danh đó là tên đặc biệt được ngôn ngữ định nghĩa.

• Nên đặt tên định danh có nghĩa. Dù c = 10 vẫn đúng, nhưng viết count =
10 sẽ rõ nghĩa hơn và dễ hiểu nó là gì hơn dù bạn đã xem code một đoạn dài sau
đó.

41
 • Python là ngôn ngữ lập trình phân biệt chữ hoa, chữ thường, nghĩa là bien
và Bien là không giống nhau.

• Khi đặt định danh nhiều từ bạn có thể dùng dấu gạch dưới giữa các từ,
day_la_mot_bien_dai, kiểu vậy.

• Bạn có thể viết theo phong cách HoaRoiThuong như thế này để phân biệt
các từ trong trường hợp biến dài.

• Định danh phải khác các keyword. Các từ khóa trong Python:

and continue except global lambda Pass while

as def False if None Raise with
assert del finally import nonlocal return yield
break elif for in not True
class else from is or Try

3.2. Biến trong Python

Biến là một vị trí trong bộ nhớ được sử dụng để lưu trữ dữ liệu (giá trị).
Biến được đặt tên duy nhất để phân biệt giữa các vị trí bộ nhớ khác nhau. Các
quy tắc để viết tên một biến giống như quy tắc viết các định danh trong Python.
Trong Python, bạn không cần khai báo biến trước khi sử dụng, chỉ cần gán cho
biến một giá trị và nó sẽ tồn tại. Cũng không cần phải khai báo kiểu biến, kiểu
biến sẽ được nhận tự động dựa vào giá trị mà bạn đã gán cho biến.

Gán giá trị cho biến: Để gán giá trị cho biến ta sử dụng toán tử =. Bất kỳ
loại giá trị nào cũng có thể gán cho biến hợp lệ. Ví dụ:

hoa = "Hồng"
la = 3
canh = 5.5
Gán nhiều giá trị: Trong Python bạn có thể thực hiện gán nhiều giá trị
trong một lệnh như sau:

hoa, la, canh = "Hồng", 3, 5.5

Nếu muốn gán giá trị giống nhau cho nhiều biến thì có thể viết lệnh như
sau:

hoa, la, canh = 3

Lệnh trên sẽ gán giá trị 3 cho cả 3 biến là hoa, la và canh.

42
3.3. Kiểu dữ liệu số trong Python
3.3.1. Các kiểu dữ liệu số

Python hỗ trợ số nguyên, số thập phân và số phức, chúng lần lượt được định
nghĩa là các lớp int, float, complex trong Python. Số nguyên và số thập phân được
phân biệt bằng sự có mặt hoặc vắng mặt của dấu thập phân. Ví dụ: 5 là số
nguyên, 5.0 là số thập phân. Python cũng hỗ trợ số phức và sử dụng hậu tố j hoặc
J để chỉ phần ảo. Ví dụ: 3+5j. Ngoài int và float, Python hỗ trợ thêm 2 loại số nữa
là Decimal và Fraction. Sử dụng hàm type() để kiểm tra xem biến hoặc giá trị
thuộc lớp số nào và hàm isinstance() để kiểm tra xem chúng có thuộc về một
class cụ thể nào không? Ví dụ:

a = 9
#Output: <class 'int'>
print(type(a))
#Output: <class 'float'>
print(type(5.0))
#Output: (10+2j)
b = 8 + 2j
print(b + 2)
#Kiểm tra xem b có phải là số phức không
#Output: True
print(isinstance(b, complex))
Số nguyên trong Python không bị giới hạn độ dài, số thập phân bị giới hạn
đến 16 số sau dấu thập phân. Những con số chúng là làm việc hàng ngày thường
là hệ số 10, nhưng lập trình viên máy tính (thường là lập trình viên nhúng) cần
làm việc với hệ thống số nhị phân, thập lục phân và bát phân. Để biểu diễn những
hệ số này trong Python, ta đặt một tiền tố thích hợp trước số đó.

Tiền tố hệ số cho các số Python:

Hệ thống số Tiền tố

Hệ nhị phân 0b hoặc 0B

Hệ bát phân 0o hoặc 0O

Hệ thập lục phân 0x hoặc 0X

Ví dụ về việc sử dụng các tiền tố hệ số trong Python, và khi dùng hàm

43
print() để in giá trị của chúng ra màn hình, ta sẽ nhận được số tương ứng trong hệ
số 10.

# Output: 187
print(0b10111011)
# Output: 257 (250 + 7)
print(0xFA + 0b111)
# Output: 15
print(0o17)
Cú pháp Mô tả
x+y Cộng hai số x và y
x-y Trừ số x cho y
x*y Nhân hai số x và y
Chia x cho y, kết quả là số thực hoặc số phức (nếu x hoặc y
x/y
là số phức)
x // y Chia x cho y, kết quả là số nguyên đã làm tròn
x%y Kết quả là phần dư của phép chia x cho y
x ** y Tính xy
abs(x) Trị tuyệt đối của x
Trả về bộ hai giá trị là phần nguyên và phần dư của phép
divmod(x, y)
chia x cho y
pow(x, y) Hàm tính giá trị xy (giống phép toán **)
pow(x, y, z) Tính nhanh phép toán (x ** y) % z
round(x, n)
Làm tròn số x đến n chữ số, nếu n dương làm tròn các chữ
số sau dấu thập phân, nếu n âm làm trong các chữ số trước
dấu thập phân

Bảng 3-1. Các phép toán và hàm số học.

3.3.2. Chuyển đổi giữa các kiểu dữ liệu số

Chúng ta có thể chuyển đổi kiểu số này sang kiểu số khác. Điều này còn
được gọi là cưỡng chế (coercion). Các phép toán như cộng, trừ sẽ ngầm chuyển
đổi số nguyên thành số thập phân (một cách tự động) nếu có một toán tử trong
phép toán là số thập phân.

44
 Ví dụ: Nếu bạn thực hiện phép cộng giữa số nguyên là 2 và số thập phân là
3.0, thì 2 sẽ bị cưỡng chế chuyển thành số thập phân 2.0 và kết quả trả về sẽ là số
thập phân 5.0.

>>> 2 + 3.0
5.0
Ta có thể sử dụng các hàm Python tích hợp sẵn như int(), float() và
complex() để chuyển đổi giữa các kiểu số một cách rõ ràng. Những hàm này thậm
chí có thể chuyển đổi từ các chuỗi.

>>> int(3.6)
3
>>> int(-1.2)
-1
>>> float(7)
7.0
>>> complex('2+8j')
(2+8j)
Khi chuyển đổi từ số thập phân sang số nguyên, số sẽ bị bỏ bớt, chỉ lấy phần
nguyên.

3.4. Module Decimal trong Python

Class float được tích hợp trong Python, thông thường nếu tính tổng 1.1 và
2.2 ta nghĩ kết quả sẽ là 3.3, nhưng nếu bạn kiểm tra tính đúng sai của phép toán
này trong Python, sẽ nhận được kết quả là False.

>>> (1.1 + 2.2) == 3.3

False
Điều này là do, các số thập phân được thực hiện trong phần cứng máy tính
dưới dạng phân số nhị phân, vì máy tính chỉ hiểu các số nhị phân (0 và 1) nên hầu
hết các phân số thập phân mà chúng ta biết, không thể được lưu trữ chính xác
trong máy tính. Ví dụ, ta không thể biểu diễn phân số 1/3 dưới dạng số thập phân,
vì nó là một số thập phân vô hạn tuần hoàn, với các số sau dấu thập phân dài vô
hạn, nên ta chỉ có thể ước tính nó. Khi chuyển đổi phần thập phân 0.1, sẽ dẫn đến
phần nhị phân dài vô hạn của 0.000110011001100110011... và máy tính chỉ lưu
trữ một phần số hữu hạn sau dấu chấm của nó thôi. Do đó, số được lưu trữ chỉ
xấp xỉ 0.1 chứ không bao giờ bằng 0.1. Đó là lý do vì sao, phép cộng chúng ta nói

45
đến ở trên không đưa ra kết quả như chúng ta mong đợi. Đó là giới hạn của phần
cứng máy tính chứ không phải lỗi của Python.

Giờ bạn thử gõ phép cộng trên vào Python xem kết quả trả về là bao nhiêu
nhé:

>>> 1.1+2.2
3.3000000000000003
Để khắc phục vấn đề này, chúng ta có thể sử dụng mô-đun Decimal trong
Python. Trong khi số float chỉ lấy 16 số sau dấu thập phân thì mô-đun Decimal
cho phép tùy chỉnh độ dài của số.

import decimal
# Output: 0.1
print(0.1)
#Output:
0.1000000000000000055511151231257827021181583404541015
625
print(decimal.Decimal(0.1))
Nếu muốn code ngắn gọn hơn, bạn có thể nhập mô-đun Decimal và sửa tên
mô-đun thành D.

from decimal import Decimal as D

#Output: 3.3
print(D('1.1') + D('2.2'))
#Output: 10.000
print(D('4.0') * D('2.50'))
Trong code này ta nhập mô-đun Decimal và sửa tên nó thành D, kết quả
không đổi so với code trên.

Khi nào nên sử dụng Decimal thay cho float? Ta thường sử dụng Decimal
trong các trường hợp sau:

Khi tạo ứng dụng tài chính, cần biểu diễn phần thập phân chính xác.

Khi muốn kiểm soát mức độ chính xác của số.

Khi muốn thực hiện các phép toán giống như đã học ở trường.

3.5. Module Fraction trong Python

Python cung cấp các phép toán liên quan đến phân số thông qua mô-đun

46
fractions. Một phân số có tử số và mẫu số, cả hai đều là số nguyên. Ta có thể tạo
đối tượng phân số (Fraction) theo nhiều cách khác nhau:

import fractions
# Tạo phân số từ số thập phân
print(fractions.Fraction(4.5))
# Output: 9/2
# Tạo phân số từ số nguyên
print(fractions.Fraction(9))
# Output: 9
# Tạo phân số bằng cách khai báo tử, mẫu số
print(fractions.Fraction(2,5))
# Output: 2/5
Khi tạo phân số từ float, ta có thể nhận được những kết quả không bình
thường, điều này là do hạn chế của phần cứng máy tính như đã thảo luận trong
phần mô-đun decimal. Đặc biệt, bạn có thể khởi tạo một phân số từ string. Đây là
cách khởi tạo được ưa thích khi sử dụng số thập phân.

import fractions
# Khởi tạo phân số từ float
print(fractions.Fraction(0.1))
# Output: 3602879701896397/36028797018963968
# Khởi tạo phân số từ string
print(fractions.Fraction('0.1'))
# Output: 1/10
Kiểu dữ liệu phân số hỗ trợ đầy đủ các phép toán cơ bản như cộng, trừ,
nhân, chia, logic:

# Output: 1
print(F(2,5) + F(3,5))
# Output: 3/5
print(F(2,5) + F(1,5))
# Output: 7/1
print(1 / F(3,7))
# Output: False
print(F(-2,9) > 0)
# Output: True
print(F(-2,9) < 0)

3.6. Module Math trong Python

Python cung cấp các mô-đun math và random để giải quyết các vấn đề toán
học khác như lượng giác, logarit, xác suất và thống kê, v.v... Mô-đun math có khá

47
nhiều hàm và thuộc tính và có thể tham khảo thêm, ví dụ về math trong Python.

from fractions import Fraction as F

import math
# Output: 3.141592653589793
print(math.pi)
# Output: -1.0
print(math.cos(math.pi))
# Output: 22026.465794806718
print(math.exp(10))
# Output: 2.0
print(math.log2(4))
# Output: 1.1752011936438014
print(math.sinh(1))
# Output: 40320
print(math.factorial(8))
Sử dụng python như một máy tính bỏ túi: Trình thông dịch hoạt động như
một máy tính đơn giản: Bạn có thể nhập vào một phép tính và nó sẽ viết ra giá trị.
Cú pháp biểu thức khá đơn giản: các toán tử như +, -, * và / làm việc giống như
trong hầu hết các ngôn ngữ lập trình khác (Pascal, C), dấu ngoặc đơn () có thể
được sử dụng để nhóm. Ví dụ:

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # phép chia luôn trả về một số dạng thập
phân với dấu chấm
1.6
Số nguyên (ví dụ như 2, 4, 20) có kiểu int, số dạng thập phân (như 5.0, 1.6)
có kiểu float. Phép chia (/) luôn luôn trả về kiểu float. Để thực hiện phép chia lấy
phần nguyên (loại bỏ các số sau dấu thập phân) bạn có thể sử dụng toán tử //; để
tính phần dư thì sử dụng % như ví dụ dưới đây:

>>> 17 / 3 # phép chia thường trả về số thập phân

5.666666666666667
>>>
>>> 17 // 3 # phép chia lấy số nguyên, loại bỏ phần
sau dấu thập phân
5
>>> 17 % 3 # toán tử % trả về số dư của phép chia

48
2
>>> 5 * 3 + 2 # thương * số chia + số dư
17
Với Python, bạn có thể sử dụng toán tử ** để tính số mũ:

>>> 5 ** 2 # 5 bình phương

25
>>> 2 ** 7 # 2 mũ 7
128
Dấu bằng = được sử dụng để gán giá trị cho 1 biến. Sau đó, không có kết
quả nào được hiển thị trước dấu nhắc lệnh tiếp theo:

>>> width = 20
>>> height = 5 * 9
>>> width * height
900
Trong chế độ tương tác, biểu thức được in ra cuối cùng sẽ được gán cho
biến _, giúp dễ dàng thực hiện các phép tính tiếp theo hơn. Ví dụ:

>>> tax = 12.5 / 100

>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
Bạn nên coi biến này là read-only, đừng gán giá trị cho nó - vì nếu tạo ra
một biến cùng tên nó sẽ chiếm mất biến mặc định này và không còn làm được
những thứ hay ho như trên nữa.

49
CHƢƠNG 4. CÂU LỆNH

4.1. Lệnh lựa chọn if

Trong cuộc sống chúng ta rất hay gặp phải những tình huống đòi hỏi phải đưa ra
lựa chọn, hoặc là cái này hoặc là cái kia. Câu lệnh lựa chọn if trong lập trình Python
cũng tương tự như vậy, nó cho phép chúng ta lựa chọn thực thi một hoặc một vài lệnh
khi các điều kiện cụ thể xảy ra.

Có 3 loại lệnh lựa chọn trong Python:

Lệnh if

Lệnh if-else

Lệnh if-elif-else

4.1.1. Lệnh if

Lệnh if cho phép đưa ra các quyết định thực hiện lệnh dựa trên việc kiểm tra một
điều kiện nào đó là đúng (true).

a. Cú pháp:

if điều_kiện:
khối_lệnh
b. Sơ đồ hoạt động:

51
Hình 4-1.

Trong đó:

+ điều_kiện là biểu thức hoặc biến có giá trị đúng (true) hoặc sai (false).

+ khối_lệnh là một hoặc nhiều lệnh đƣợc viết sau dấu hai chấm (:).

Lƣu ý: các lệnh trong một khối_lệnh phải thụt đầu dòng giống nhau.

Nếu điều_kiện có giá trị đúng thì khối_lệnh sẽ được thực hiện. Còn nếu
điều_kiện có giá trị sai thì bỏ qua khối_lệnh và thực hiện các lệnh tiếp theo
(nếu có).

Ví dụ 4-1: Lệnh if đơn giản

x=6
y=3
if x>y:
print('x lớn hơn y')
Với ví dụ trên, điều kiện là x>y và khối lệnh chỉ có một lệnh print('x lớn
hơn y'). Vì x>y trả trả về giá trị đúng nên lệnh print('x lớn hơn y') được
thực thi và cho kết quả như sau:

Ví dụ 4-2: Chương trình sau cho phép người dùng nhập một số nguyên và cho
biết số vừa nhập là số chẵn hay số lẻ.

x=int(input("Nhập vào một số nguyên:"))

if x%2==0:
print("x là số chẵn")
if x%2==1:
print("x là số lẻ")

52
 Ví dụ 4-3: Chương trình cho phép nhập vào 3 số nguyên và tìm giá trị số lớn
nhất.

a=int(input('Nhập a: '))
b=int(input('Nhập b: '))
c=int(input('Nhập c: '))
max = a;
if b > max:
max = b;
if c > max:
max = c;
print('Giá trị số lớn nhất là: ', max);

4.1.2. Lệnh if-else

Ở trên chúng ta đã biết dạng đơn giản nhất của câu lệnh if, cho phép lựa chọn để
thực hiện hay không một khối lệnh. Python cũng cho phép chúng ta lựa chọn một
trong hai khối lệnh để thực hiện bằng cách dùng cấu trúc if như sau:

a. Cú pháp:

if điều_kiện:
khối_lệnh1
else:
khối_lệnh2
b. Sơ đồ hoạt động:

Hình 4-2.

Lệnh if-else kiểm tra giá trị của điều_kiện. Nếu điều_kiện cho giá trị đúng
thì chỉ có khối_lệnh1 được thực hiện, ngược lại nếu điều_kiện cho giá trị sai

53
thì chỉ có khối_lệnh2 được thực hiện.

Ví dụ 4-4: Chương trình kiểm tra một số nguyên là số chẵn hay lẻ được viết lại
như sau:

x=int(input("Nhập một số nguyên:"))

if x%2==0:
print("x là số chẵn")
else:
print("x là số lẻ")
Chạy chương trình trên với x=3, khi đó điều kiện x%2==0 trả về giá trị sai nên
lệnh print("x là số lẻ") được thực hiện và cho kết quả như sau:

4.1.3. Lệnh if-elif-else

Câu lệnh if cho phép chúng ta lựa chọn thực hiện một hành động nào đó hay
không. Câu lệnh if – else cho phép lựa chọn thực hiện giữa hai hành động. Python cho
phép ta có thể đưa ra nhiều lựa chọn hơn với lệnh if-elif-else bằng cách thêm vào cấu
trúc elif để thực hiện. Do đó nhiều điều kiện hơn được kiểm tra và tạo ra nhiều lựa
chọn hơn.

a. Cú pháp:

if (điều_kiện1):
khối_lệnh1
elif (điều_kiện2):
khối_lệnh2
...
elif (điều_kiệnN):
khối_lệnhN
else:
khối_lệnh(N+1)
b. Sơ đồ hoạt động:

54
Hình 4-3.

Lệnh if-elif-else sẽ kiểm tra giá trị của các điều_kiện từ trên xuống. Nếu gặp
điều_kiện đầu tiên có giá trị đúng thì thực hiện khối_lệnh tương ứng và thoát
khỏi câu lệnh if-elif-else. Nếu tất cả các điều_kiện đều có giá trị sai thì chỉ có khối
lệnh sau else (khối_lệnhN+1) được thực hiện.

Ví dụ 4-5: Chương trình nhập điểm trung bình của học sinh và in xếp loại của
học sinh đó ra màn hình.

diemTB=float(input("Nhập điểm trung bình:"))

if diemTB>=8:
print("Loại Giỏi")
elif diemTB>=6.5:
print("Loại Khá")
elif diemTB>=5:
print("Loại Trung bình")
else:
print("Loại Yếu")
Chạy chương trình trên với điểm trung bình nhập vào là 7 thì điều kiện
diemTB>=6.5 trả về giá trị đúng đầu tiên nên câu lệnh print("Loại Khá") được
thực thi và thoát khỏi câu lệnh If. Kết quả như sau:

55
4.1.4. Lệnh if lồng nhau

Trong nhiều tình huống chúng ta muốn kiểm tra thêm một điều kiện khác sau khi
một điều kiện đã được ước lượng là đúng. Trong tình huống như vậy, chúng ta có thể
sử dụng các lệnh if lồng nhau trong Python.

Lệnh if lồng nhau là lệnh if mà trong khối_lệnh của câu lệnh if có chứa câu lệnh
if khác.

Ví dụ 4-6: Chương trình nhập vào 3 số nguyên, tìm và in ra màn hình số lớn
nhất.

a=int(input('Nhập a: '))
b=int(input('Nhập b: '))
c=int(input('Nhập c: '))
if a>b:
if a>c:
max = a
else:
max = c
else:
if b>c:
max = b
else:
max = c
print('Giá trị số lớn nhất là: ', max)
Lưu ý, tùy theo trường hợp cụ thể ta phải chọn lệnh if lồng nhau hoặc không.
Trong ví dụ trên, nếu dùng các lệnh if riêng rẽ thì chương trình sẽ rõ ràng hơn (ví dụ
3-3).

Ví dụ 4-7: Chương trình yêu cầu nhập 2 số nguyên và một phép toán thuộc nhóm
{+, -, *, /}, sau đó thực hiện phép tính tương ứng.

a=int(input('Nhập a: '))
b=int(input('Nhập b: '))
pt=input("Nhập phép toán:")
if pt=='+':
print(a,'+', b,'=', a+b)
elif pt=='-':
print(a,'-', b,'=', a-b)
elif pt=='*':
print(a,'*', b,'=', a*b)
elif pt=='/':

56
 if b!=0:
print(a,'/', b,'=', a/b)
else:
print('Lỗi vì chia cho 0!')
else:
print('Phép toán không hợp lệ!')

4.2. Lệnh lặp

Một trong những điểm mạnh của máy tính là khả năng thực hiện một dãy các
lệnh lặp đi lặp lại. Điều đó có được là do sử dụng các cấu trúc lặp trong các ngôn ngữ
lập trình. Nó cho phép một hoặc nhiều lệnh trong chương trình thực hiện lặp đi lặp lại
cho đến khi một điều kiện xác định được thỏa mãn. Trong phần này chúng ta sẽ tìm
hiểu các loại vòng lặp trong ngôn ngữ lập trình Python.

4.2.1. Lệnh for..in

Lệnh lặp for được sử dụng để lặp một biến qua một dãy (List, String…) theo thứ
tự mà chúng xuất hiện và được sử dụng để lặp một lệnh hoặc một khối lệnh với số lần
lặp xác định trước.

a. Cú pháp:

for bien in day_lap:

khối_lệnh
Trong đó:

bien là biến dùng để lưu giá trị lần lượt của các phần tử trong day_lap tại
mỗi vòng lặp

day_lap là tập hợp các phần tử, số phần tử của day_lap là số lần lặp

khối_lệnh là một hoặc nhiều lệnh cần thực hiện

Lệnh lặp thực hiện theo các bước như sau:

Bƣớc 1: Phần tử đầu tiên của day_lap sẽ được gán cho bien

Bƣớc 2: Thực hiện các lệnh trong khối_lệnh. Nếu bien đã nhận phần tử
cuối cùng trong day_lap thì chuyển sang bƣớc 4

Bƣớc 3: Gán phần tử tiếp theo trong day_lap cho bien rồi quay về bƣớc 2

57
 Bƣớc 4: Kết thúc lệnh lặp.

Nói cách khác, bien sẽ lần lượt nhận từng giá trị từ phần tử đầu tiên cho đến
phần tử cuối cùng trong day_lap. Với mỗi lần bien nhận giá trị thì khối_lệnh
được thực hiện.

Số lần lặp của lệnh for được xác định ngay từ đầu của lệnh. Nghĩa là nó không bị
thay đổi cho dù số phần tử của day_lap bị thay đổi trong khi thực hiện
khối_lệnh.

b. Sơ đồ hoạt động:

Hình 4-4.

Điều_kiện_lặp chỉ sai khi số lần thực hiện khối_lệnh bằng số phần tử của
day_lap.

Ví dụ 4-8: Lệnh lặp với dãy lặp là một chuỗi kí tự

for letter in 'Python':

print(letter)
Biến letter lần lượt được gán các kí tự trong chuỗi 'Python' từ đầu đến
cuối. Với mỗi lần được gán giá trị thì thực hiện lệnh print(letter). Chương trình
cho kết quả như sau:

58
 Ví dụ 4-9: Lệnh lặp với dãy lặp là một mảng:

for ngon_ngu in ['Python', 'Java', 'C']:

print('Tôi thích lập trình :', ngon_ngu)
Chạy chương trình trên được kết quả như sau:

Một cách khác để sử dụng lệnh lặp for khá thuận tiện trong nhiều tình huống đó
là sử dụng hàm range(). Hàm này sẽ trả về một dãy các số nguyên trong đó tổng số
phần tử sẽ phụ thuộc vào các tham số truyền vào. Cú pháp như sau:

range(start, end, step)

Trong đó:

start: là giá trị bắt đầu

end: là giá trị kết thúc, phần tử cuối cùng luôn nhỏ hơn giá trị này

step: là khoảng cách giữa các phần tử, hay còn gọi là bước nhảy

Chẳng hạn:

range(5) là dãy [0, 1, 2, 3, 4]

rang(1,11) là dãy [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(1, 10, 2) là dãy [1, 3, 5, 7, 9]

Ví dụ 4-10: Chương trình tính tổng các số nguyên từ 1 đến 10.

S=0
for i in range(1,11): #rang(1,11) là dãy các số nguyên từ
1 đến 10

59
 S=S+i
print('Tổng các số từ 1 đến 10 la: ', S)
Kết quả chạy chương trình trên như sau:

Lệnh lặp for lồng nhau: Tương tự như lệnh if lồng nhau, một lệnh lặp for được
gọi là lồng nhau khi nó nằm bên trong một vòng lặp for khác.

Ví dụ 4-11: Xét đoạn chương trình sau:

for i in [1,2,3]:
print('Lần lặp i= ', i);
for letter in 'Python':
print(letter);
Trong ví dụ trên, vòng lặp for letter là lệnh nằm trong thân lệnh lặp for i.
Do vậy, cứ mỗi lần lặp của lệnh lặp for i thì khối lệnh sau được thực hiện:

print('Lần lặp i= ', i);

for letter in 'Python':
print(letter);
Chương trình cho kết quả như sau:

60
 Ví dụ 4-12: Chương trình in ra màn hình các tổ hợp 2 phần tử trong tập hợp 4
phần tử {1, 2, 3, 4}.

for i in range(1,4):
for j in range(i+1, 5):
print(i,',',j)
Thực hiện chương trình trên cho kết quả như sau:

Ví dụ 4-13: Chương trình tính n! của một số nguyên với n nhập từ bàn phím.

n=int(input('Nhập n: '))
gthua = 1
for i in range(2, n+1):
gthua = gthua* i
print(n,'! = ', gthua)
Ví dụ 4-14: Chương trình nhập vào một số nguyên n, nếu n lẻ tính tổng các số lẻ
từ 1 đến n, nếu n chẳn tính tổng các số chẳn từ 2 đến n.

61
n=int(input('Nhập n: '))
S=0
if n%2==1:
for i in range(1, n+1,2):
S = S + i
print('Tổng các số lẻ từ 1 đến ', n,' là: ', S)
else:
for i in range(2, n+1,2):
S = S + i
print('Tổng các số chẵn từ 0 đến', n,' là: ', S)
Chúng ta cũng có thể viết lại đơn giản như sau:

n=int(input('Nhập n: '))
S=0
for i in range(n%2, n+1,2):
S = S + i
print('Tổng cần tìm là: ', S)
Ví dụ 4-15: Chương trình tính tổng các ước số không tầm thường (ước số khác 1
và khác n) của một số nguyên n.

n=int(input('Nhập n: '))
S=0
for i in range(2, int(n/2)+1):
if n%i==0:
S=S+i
print('Tổng các ước không tầm thường là: ', S)

4.2.2. Lệnh while

Lệnh lặp for thường được được sử dụng khi số lần lặp xác định trước. Trong khi
số lần lặp không được xác định trước thì ta nên sử dụng lệnh while như sau:

a. Cú pháp:

while(điều_kiện):
khối_lệnh
b. Sơ đồ hoạt động:

62
Hình 4-5.

Lệnh lặp while sẽ lặp lại thực hiện khối_lệnh trong khi điều_kiện còn
đúng. Nếu điều_kiện sai thì thoát khỏi lệnh lặp.

Ví dụ 4-16: Xét đoạn chương trình sau:

dem = 1;
while dem <= 10:
print('Đây là lần lặp ', dem);
dem=dem+1;
print('Lệnh lặp kết thúc')
Đầu tiên chương trình gán giá trị của dem là 1. Sau đó chương trình chuyển đến
thực hiện lệnh while. Phần biểu thức điều kiện được kiểm tra với giá trị hiện tại của
dem là 1, nhỏ hơn 10. Kết quả kiểm tra điều kiện là đúng nên các lệnh trong thân vòng
lặp while được thực hiện. Giá trị của biến dem là 2 sau lần lặp đầu tiên. Sau đó biểu
thức điều kiện lại được kiểm tra lần nữa. Quá trình này cứ lặp đi lặp lại cho đến khi giá
trị của biến dem lớn hơn 10. Khi đó lệnh lặp kết thúc và thực hiện lệnh print() cuối
cùng.

Lệnh lặp while kiểm tra điều kiện ngay khi bắt đầu thực hiện vòng lặp. Do đó các
lệnh trong thân vòng lặp sẽ không được thực hiện nếu ngay từ ban đầu điều kiện đó là
sai.

Biểu thức điều kiện trong vòng lặp có thể phức tạp tùy theo yêu cầu của bài toán.
Các biến trong biểu thức điều kiện có thể bị thay đổi giá trị trong thân vòng lặp, nhưng
cuối cùng điều kiện đó phải sai để lệnh lặp được kết thúc.

Ví dụ 4-17: Chương trình tìm ước lớn nhất nhỏ hơn chính nó của một số nguyên
n(n>1).

63
n=int(input('Nhập n: '))
i=n-1;
while n%i !=0:
i=i-1
print('Ước cần tìm là', i);
Ví dụ 4-18: Chương trình tìm ước số chung lớn nhất của hai số nguyên.

a=int(input('Nhập a: '))
b=int(input('Nhập b: '))
while b!=0:
r = a % b
a = b
b = r
print('Ước số chung lớn nhất là: ', a);

4.3. Lệnh break và continue

4.3.1. Lệnh break

Câu lệnh break có thể được sử dụng để kết thúc ngay một lệnh lặp For hoặc
While mà không cần kiểm tra điều kiện vòng lặp.

Khi chương trình gặp lệnh break trong một vòng lặp, ngay lập tức lệnh lặp được
kết thúc và chương trình tiếp tục thực hiện các lệnh sau vòng lặp (nếu có).

Ví dụ 4-19: Xét đoạn lệnh sau:

for letter in 'Python':

if letter == 'h':
break
print('Kí tự hiện tại :', letter)
print()
var = 10
while var > 0:
print('Giá trị biến var hiện tại :', var)
var = var -1
if var == 5:
break
Với lệnh for trong ví dụ trên, lặp việc in từng kí tự trong chuỗi 'Python'cho
đến khi gặp lệnh kí tự h. Khi đó, điều kiện letter == 'h' có giá trị true nên lệnh
break được thực hiện và thoát khỏi lệnh lặp.

Còn lệnh while sẽ dừng lặp khi biến var có giá trị 5 do lệnh break được thực
hiện vì điều kiện var==5 có giá trị đúng. Kết quả chạy đoạn chương trình trên như

64
sau:

Ví dụ 4-20: Chương trình cho phép người dùng lặp lại việc nhập một chuỗi kí tự
và in ra độ dài của chuỗi vừa nhập cho đến khi chuỗi nhập vào là 'quit'.

while True:
s = input('Nhập một chuỗi kí tự: ')
if s == 'quit':
break
print('Độ dài chuỗi vừa nhập là: ', len(s))
print('Kết thúc!')
Lệnh while với điều kiện True giúp lệnh while lặp lại vô điều kiện. Đến khi
chuỗi nhập vào là „quit‟ thì lệnh break được thực hiện làm chương trình thoát khỏi
lệnh while.

Ví dụ 4-21: Chương trình cho phép nhập vào chuỗi họ tên của một người và in
ra màn hình họ của chuỗi vừa nhập.

hten = input('Nhập vào họ tên: ')

for letter in s:
if letter == ' ':
break
print(letter, end= '')
print('\nKết thúc!')
Lệnh For trên sẽ duyệt qua từng kí tự của chuỗi s và in kí tự ra màn hình cho đến
khi gặp kí tự space (' ') đầu tiên. Khi đó điều kiện letter ==' ' đúng nên thực
hiện lệnh break thoát khỏi lệnh lặp.

4.3.2. Lệnh continue

Lệnh continue kết thúc lần lặp hiện hành và bắt đầu lần lặp kế tiếp trong các lệnh
lặp while và for. Khi gặp lệnh continue trong chương trình, các câu lệnh còn lại trong
thân của vòng lặp được bỏ qua và chuyển đến bước đầu của vòng lặp trong lần lặp kế

65
tiếp.

Ví dụ 4-22: Xét đoạn lệnh sau:

for letter in 'Python':

if letter == 'h':
continue
print('Kí tự hiện tại :', letter)

var = 10
while var > 0:
var = var -1
if var == 5:
continue
print('Biến lặp hiện tại :', var)
Ở vòng lặp for trong ví dụ trên, letter nhận từng kí tự trong chuỗi 'Python' và
in ra màn hình. Riêng trường hợp letter nhận kí tự „h‟ thì lệnh continue thực hiện
nên bỏ qua lệnh print và quay về lần lặp tiếp theo. Do vậy kết quả in ra màn hình
thiếu kí tự h.

Còn lệnh lặp while, sẽ bỏ qua lệnh print khi biến var có giá trị 5 (do điều kiện
var==5 có giá trị đúng nên lệnh continue thực hiện) và quay về đầu vòng lặp tiếp
theo. Kết quả thực hiện chương trình trên như sau:

Ví dụ 4-23: Chương trình nhập một số nguyên dương n và in ra màn hình các số
lẻ từ 1 đến n.

n = int(input('Nhập vào số nguyên dương: '))

for i in range(1, n+1):
if i%2 == 0:
continue

66
 print(i, end= ' ')
print('\nKết thúc!')

4.4. Bài tập

Bài 4-1. Nhập bốn số x1, x2, x3, x4, tìm số lớn nhất và số nhỏ nhất của bốn số đó.

Bài 4-2. Nhập các hệ số, giải và biện luận các hệ phương trình sau theo quy tắc
Cramer:

Bài 4-3. Nhập các hệ số giải phương trình ax2+bx+c=0

Bài 4-4. Nhập chỉ số điện kế tháng trước và tháng này. Hãy tính số kW tiêu thụ và tiền
điện cho mỗi hộ dựa vào bảng giá sau (áp dụng từ ngày 20/3/2019):

Mức Số kWh sử dụng Đơn giá (VNĐ)

1 kWh từ 0 – 50 1,678

2 kWh từ 51 – 100 1,734

3 kWh từ 101 – 200 2,014

4 kWh từ 201 – 300 2,536

5 kWh từ 301 – 400 2,834

6 kWh từ 401 trở lên 2,927

Bài 4-5. Nhập độ dài ba cạnh a, b, c. Cho biết a, b, c có phải là ba cạnh của một tam
giác không? Nếu là ba cạnh của một tam giác thì cho biết đó làm tam giác gì: đều, cân
hay tam giác thường?

Bài 4-6. Nhập một số nguyên dương n (nếu nhập n≤0 thì chương trình phải yêu cầu
nhập lại). Sau đó tính các tổng sau:

67
 ( )

( )
( )

( ) ( )( )

. . . …n, khi n lẻ
{
. . . …n, khi n chẳn

Bài 4-7. Nhập n, k nguyên đảm bảo phải dương và k≤n. Tính tổ hợp chập k của n theo

công thức: ( )

Bài 4-8. Cho dãy Fibonaci xác định như sau: F0=0, F1=1, Fn = Fn-1 + Fn-2, với n≥2.
Hãy nhập số nguyên n≥2 và tính S = F0 + F1 + F2 +...+ Fn.

Bài 4-9. Tìm và in lên màn hình tất cả các số nguyên trong phạm vi từ 10 đến 99 sao
cho tích của hai chữ số của nó thì bằng hai lần tổng của hai chữ số của nó. Ví dụ: số
N=36 có hai chữ số là 3 và 6, và 3*6 = 2*(3+6). Tương tự đối với số 44.

Bài 4-10. Số n là hoàn hảo nếu tổng các ước số nhỏ hơn n bằng chính n, ví dụ
6=1+2+3. Viết chương trình liệt kê các số hoàn hảo nhỏ hơn 1000.

Bài 4-11. Nhập một số nguyên n, cho biết đó là số nguyên tố hay không. Nếu không
phải là số nguyên tố thì phân tích số đó thành tích các thừa số nguyên tố. Ví dụ nhập
n=1470, khi đó tích các thừa số nguyên tố của n=2.3.5.7.7.

Bài 4-12. Nhập một số nguyên n, in ra màn hình tất cả các số nguyên tố nhỏ hơn hoặc
bằng n.

Bài 4-13. Nhập vào 1 số nguyên, in ra màn hình số đảo ngược của số đó. Ví dụ nhập
số 34679, khi đó hiển thị lên màn hình số: 97643.

Bài 4-14. Viết một chương trình kiểm tra một số có phải là số đối xứng hay không? Số
đối xứng là số khi viết ngược cũng bằng chính nó. Ví dụ: 121, 2332,…

Bài 4-15. Nhập số tiền gởi, số tháng, lãi suất 1 tháng. Tính số tiền nhận được.

68
Bài 4-16. Nhập số tiền gởi, số tháng. Tính số tiền nhận được dựa vào bảng lãi suất như
như sau:

Kì hạn Lãi cuối kỳ

(số tháng) (%/năm)
1-5 6.0
6-12 6.6
13-14 7.5
15-17 7.6
18-23 7.7
24-35 8.0
>36 8.5
Viết chương trình tìm ước số chung lớn nhất và bội số chung nhỏ nhất của hai số
nguyên.

69
CHƢƠNG 5. HÀM TRONG PYTHON

5.1. Cơ bản về hàm trong Python

Hàm trong Python là gì? Cú pháp, thành phần và các loại hàm trong Python
như thế nào? Làm sao để tạo hàm trong Python? Những câu hỏi này của bạn sẽ
được giải đáp trong chương này.

5.1.1. Hàm trong Python là gì?

Trong Python, hàm là một nhóm các lệnh có liên quan đến nhau được dùng
để thực hiện một tác vụ, nhiệm vụ cụ thể nào đó. Hàm giúp chia chương trình
Python thành những khối/phần/mô-đun nhỏ hơn. Khi chương trình Python quá
lớn, hoặc cần mở rộng, thì các hàm giúp chương trình có tổ chức và dễ quản lý
hơn.

Hàm còn có một tác dụng vô cùng quan trọng nữa là tránh việc phải lặp lại
code để thực thi những tác vụ tương tự nhau, giúp code gọn hơn và có thể tái sử
dụng.

5.1.2. Cú pháp của hàm Python

def ten_ham(các tham số/đối số):
"""Chuỗi văn bản để mô tả cho hàm (docstring)"""
Các câu lệnh
Về cơ bản, một định nghĩa hàm Python sẽ bao gồm các thành phần sau:

1. Từ khóa def: Đánh dấu sự bắt đầu của tiêu đề hàm.

2. ten_ham: Là định danh duy nhất dành cho hàm. Việc đặt tên hàm phải
tuân thủ theo quy tắc viết tên và định danh trong Python.

3. Các tham số/đối số: Chúng ta truyền giá trị cho hàm thông qua các tham
số này. Chúng là tùy chọn.

71
 4. Dấu hai chấm (:): Đánh dấu sự kết thúc của tiêu đề hàm.

5. docstring: Chuỗi văn bản tùy chọn để mô tả chức năng của hàm.

6. Các câu lệnh: Một hoặc nhiều lệnh Python hợp lệ tạo thành khối lệnh.
Các lệnh này phải có cùng một mức thụt đầu dòng (thường là 4 khoảng trắng
hoặc 1 dấu tab trên bàn phím).

7. Lệnh return: Lệnh này là tùy chọn, dùng khi cần trả về giá trị từ hàm.

5.1.3. Ví dụ về hàm Python

Ví dụ 5-1: Dưới đây là một định nghĩa hàm đơn giản, gồm tên hàm, tham số
của hàm, mô tả hàm và một câu lệnh.

def chao(ten):
"""Hàm này dùng để
chào một người được truyền
vào như một tham số"""
print("Xin chào, " + ten + "!")

5.1.4. Gọi hàm trong Python

Khi một hàm đã được định nghĩa, bạn có thể gọi nó từ một hàm khác,
chương trình khác hoặc thậm chí tại dấu nhắc lệnh. Để gọi hàm chúng ta chỉ cần
nhập tên hàm với những tham số thích hợp là được.

Ví dụ để gọi hàm chao() vừa định nghĩa bên trên, ta gõ lệnh sau ngay tại dấu
nhắc:

>>> chao ("Bình")

Ta sẽ nhận được kết quả như sau:

72
5.1.5. Docstring trong Python

Chuỗi đầu tiên ngay sau tiêu đề hàm được gọi là docstring (documentation
string), nó được dùng để giải thích chức năng cho hàm. Mặc dù docstring là
không bắt buộc, nhưng việc bạn giải thích ngắn gọn về chức năng của hàm sẽ
giúp người dùng sau, thậm chí là bạn, khi gọi hàm có thể hiểu ngay hàm sẽ làm gì
mà không cần phải tìm lại định nghĩa hàm để xem xét.

Việc thêm tài liệu cho code là một thói quen tốt. Chẳng có gì đảm bảo là sau
1 vài tháng quay trở lại bạn nhớ được chi tiết, rõ ràng đoạn code đã viết trước đó
mà không có sai sót gì.

Trong ví dụ bên trên chúng ta có một docstring ngay bên dưới tiêu đề hàm.
Docstring thường được viết trong cặp 3 dấu ngoặc kép. Chuỗi này sẽ xuất hiện
như một thuộc tính __doc__ của hàm.

Để kiểm tra docstring của hàm chao() bên trên, bạn nhập code sau và chạy
thử nhé:

print(chao.__doc__)
Đây là kết quả:

5.1.6. Lệnh return trong hàm Python

Lệnh return thường được dùng để thoát hàm và trở về nơi mà tại đó hàm
được gọi.

a. Cú pháp của lệnh return:

return [danh_sach_bieu_thuc]

73
 Lệnh này có thể chứa biểu thức được tính toán và giá trị trả về. Nếu không
có biểu thức nào trong câu lệnh hoặc không có lệnh return trong hàm thì hàm sẽ
trả về None.

Ví dụ 5-2: Ví dụ về lệnh return:

def gia_tri_tuyet_doi(so):
"""Hàm này trả về giá trị tuyệt đối
của một số nhập vào"""
if so >= 0:
return so
else:
return -so
# Đầu ra: 5
print(gia_tri_tuyet_doi(5))
# Đầu ra: 8
print(gia_tri_tuyet_doi(-8))
# Đầu ra: Giá trị tuyệt đối của số nhập vào
num=int(input("Nhập số cần lấy giá trị tuyệt đối: "))
print (gia_tri_tuyet_doi(num))
Khi chạy code trên, ta được kết quả như sau:

5
8
Nhập số cần lấy giá trị tuyệt đối: -7 7

5.1.7. Phạm vi và thời gian tồn tại của các biến

Phạm vi của biến là đoạn chương trình mà ở đó biến được thừa nhận. Các
tham số và biến được xác định bên trong một hàm khong thể "nhìn thấy" từ bên
ngoài. Do đó, những biến và tham số này chỉ có phạm vi trong hàm.

Thời gian tồn tại của biến là khoảng thời gian mà biến đó xuất hiện trong bộ
nhớ. Khi hàm được thực thi thì biến sẽ tồn tại.

Biến bị hủy khi chúng ta thoát khỏi hàm. Hàm không nhớ giá trị của biến
trong những lần gọi hàm trước đó.

def ham_in():
x = 15
print("Giá trị bên trong hàm:",x)
x = 30
ham_in()
print("Giá trị bên ngoài hàm:",x)

74
 Trong chương trình trên, ta dùng cùng một biến x, một biến bên trong hàm
ham_in(), một biến x ở ngoài và thực hiện lệnh in hai giá trị này để bạn nhận thấy
phạm vi của biến. Giá trị của x chúng ta khởi tạo là 30, mặc dù hàm ham_in() đã
thay đổi giá trị của x thành 15, nhưng nó không ảnh hưởng gì đến giá trị của x ở
bên ngoài hàm. Khi chạy chương trình ta được kết quả:

Giá trị bên trong hàm: 15

Giá trị bên ngoài hàm: 30
Điều này là do biến x bên trong hàm là khác với biến x bên ngoài hàm. Dù
chúng có cùng tên, nhưng thực ra lại là 2 biến khác nhau với phạm vi khác nhau.
Biến x trong hàm là biến cục bộ, chỉ có tác dụng trong hàm đó. Biến x bên ngoài
hàm có thể nhìn thấy từ bên trong hàm và có phạm vi trên toàn bộ chương trình.

Với biến bên ngoài hàm, ta có thể đọc giá trị của biến ở trong hàm, nhưng
không thể thay đổi được giá trị của nó. Để thay đổi giá trị cho các biến kiểu này,
chúng phải được khai báo là các biến global bằng cách sử dụng từ khóa global.

5.1.8. Các loại hàm trong Python

Về cơ bản, Python có 2 loại hàm chính là hàm được tích hợp sẵn trong
Python và hàm do người dùng định nghĩa. Trong các phần tới, chúng ta sẽ tìm
hiểu kỹ hơn về 2 loại hàm này.

5.2. Các hàm Python tích hợp sẵn

Trong bài trước bạn đã biết rằng Python có loại hàm cơ bản, một là hàm tích
hợp sẵn, hai là hàm do người dùng tự định nghĩa. Phần này, chúng ta sẽ tìm hiểu
về danh sách các hàm được tích hợp sẵn trên Python.

Trình thông dịch của Python có sẵn một số hàm để sử dụng. Các hàm này
được gọi là hàm tích hợp. Ví dụ, print() là hàm in các giá trị được cung cấp
cho hàm ra màn hình, hàm list() tạo một list trong Python,

Trong phiên bản Python 3.6 có 68 hàm Python được tích hợp sẵn. Dưới đây
là danh sách các hàm đó, cùng với mô tả ngắn gọn về chúng

Hàm Mô tả

75
 Hàm Mô tả
abs() Trả về giá trị tuyệt đối của một số

all() Trả về True khi tất cả các phần tử trong iterable là đúng

any() Kiểm tra bất kỳ phần tử nào của iterable là True

ascii() Tả về string chứa đại diện (representation) có thể in

bin() Chuyển đổi số nguyên sang chuỗi nhị phân

bool() Chuyển một giá trị sang Boolean

bytearray() Trả về mảng kích thước byte được cấp

bytes() Trả về đối tượng byte không đổi

callable() Kiểm tra xem đối tượng có thể gọi hay không

chr() Trả về một ký tự (một chuỗi) từ Integer

classmethod() Trả về một class method cho hàm

compile() Trả về đối tượng code Python

complex() Tạo một số phức

delattr() Xóa thuộc tính khỏi đối tượng

dict() Tạo Dictionary

dir() Trả lại thuộc tính của đối tượng

divmod() Trả về một Tuple của Quotient và Remainder

enumerate() Trả về đối tượng kê khai

eval() Chạy code Python trong chương trình

exec() Thực thi chương trình được tạo động

filter() Xây dựng iterator từ các phần tử True

float() Trả về số thập phân từ số, chuỗi

76
 Hàm Mô tả
format() Trả về representation được định dạng của giá trị

frozenset() Trả về đối tượng frozenset không thay đổi

getattr() Trả về giá trị thuộc tính được đặt tên của đối tượng

globals() Trả về dictionary của bảng sumbol toàn cục hiện tại

hasattr() Trả về đối tượng dù có thuộc tính được đặt tên hay không

hash() Trả về giá trị hash của đối tượng

help() Gọi Help System được tích hợp sẵn

hex() Chuyển Integer thành Hexadecimal

id() Trả về định danh của đối tượng

input() Đọc và trả về chuỗi trong một dòng

int() Trả về số nguyên từ số hoặc chuỗi

isinstance() Kiểm tra xem đối tượng có là Instance của Class không

issubclass() Kiểm tra xem đối tượng có là Subclass của Class không

iter() Trả về iterator cho đối tượng

len() Trả về độ dài của đối tượng

list() Tạo list trong Python

locals() Trả về dictionary của bảng sumbol cục bộ hiện tại

map() Áp dụng hàm và trả về một list

max() Trả về phần tử lớn nhất

memoryview() Trả về chế độ xem bộ nhớ của đối số

min() Trả về phần tử nhỏ nhất

next() Trích xuất phần tử tiếp theo từ Iterator

77
 Hàm Mô tả
object() Tạo một đối tượng không có tính năng (Featureless Object)

oct() Chuyển số nguyên sang bát phân

open() Trả về đối tượng File

ord() Trả về mã Unicode code cho ký tự Unicode

pow() Trả về x mũ y

print() In đối tượng được cung cấp

property() Trả về thuộc tính property

range() Trả về chuỗi số nguyên từ số bắt đầu đến số kết thúc

repr() Trả về representation có thể in của đối tượng

reversed() Trả về iterator đảo ngược của một dãy

round() Làm tròn số thập phân

set() Tạo một set các phần tử mới

setattr() Đặt giá trị cho một thuộc tính của đối tượng

slice() Cắt đối tượng được chỉ định bằng range()

sorted() Trả về list được sắp xếp

staticmethod() Tạo static method từ một hàm

str() Trả về một representation không chính thức của một đối tượng

sum() Thêm một mục vào Iterable

super() Cho phép tham chiếu đến Parent Class bằng super

tuple() Tạo một Tuple

type() Trả về kiểu đối tượng

vars() Trả về thuộc tính __dict__ của class

78
 Hàm Mô tả
zip() Trả về Iterator của Tuple

__import__() Hàm nâng cao, được gọi bằng import

Nếu muốn biết hàm này cụ thể làm gì, có đối số nào, bạn chỉ cần nhập lệnh:

print(ten_ham.__doc__)

5.3. Hàm Python do ngƣời dùng tự định nghĩa

Bên cạnh các hàm Python tích hợp sẵn, bạn còn có thể tự định nghĩa hàm
Python, những hàm này gọi là hàm Python do người dùng định nghĩa (user-
defined functions). Việc sử dụng những hàm tự định nghĩa này có lợi ích gì, cách
để định nghĩa hàm trong Python ra sao, chúng ta sẽ tìm hiểu trong phần này.

5.3.1. Hàm Python do người dùng định nghĩa là gì?

Các hàm mà ta tự mình định nghĩa để thực hiện một số công việc cụ thể
được gọi là hàm do người dùng định nghĩa. Việc định nghĩa hàm và gọi hàm đã
được đề cập đến trong phần 5.1.8.

Các hàm có sẵn trong Python được gọi là hàm tích hợp. Nếu ta sử dụng
những hàm được người dùng khác viết dưới dạng thư viện, thì những hàm này
gọi là hàm thư viện (library function). Như vậy, hàm ta tự định nghĩa có thể trở
thành một hàm thư viện đối với người dùng nào đó.

a. Ưu điểm khi sử dụng hàm Python do người dùng định nghĩa

Hàm do người dùng định nghĩa giúp phân tích một chương trình lớn thành
những phần nhỏ, khiến chương trình dễ hiểu, dễ duy trì và gỡ lỗi hơn.

Khi một đoạn code bị lặp lại trong chương trình, thì có thể sử dụng hàm để
gom đoạn code này lại và chạy khi cần bằng cách gọi hàm.

Các lập trình viên cùng làm việc trong một dự án lớn, có thể phân chia công
việc cho nhau bằng cách tạo các hàm khác nhau.

b. Ví dụ về hàm do người dùng tự định nghĩa

Để định nghĩa một hàm, bạn đã biết khi tìm hiểu về tổng quan về hàm

79
Python. Ở đây, mình sẽ nhắc lại cú pháp cơ bản khi định nghĩa 1 hàm:

def ten_ham(DoiSo1,DoiSo2,...,DoiSon)
khối lệnh của hàm

def them_so(a,b):
tong = a + b
return tong
so1 = 5
so2 = 6
so3 = int(input("Nhập một số: "))
so4 = int(input("Nhập một số nữa: "))
print("Tổng hai số đầu là: ", them_so(so1, so2))
print ("Tổng của hai số sau là: ", them_so(so3, so4))
Trong ví dụ trên, hàm int(), input(), print() là hàm tích hợp sẵn trong
Python. Ở đây, chúng ta định nghĩa hàm them_so(), có chức năng là thêm hai số,
tính tổng 2 số và trả về kết quả. Đầu ra của chương trình này như sau:

Nhập một số: 8

Nhập một số nữa: 10
Tổng hai số đầu là: 11
Tổng của hai số sau là: 18
Việc đặt tên hàm theo chức năng hoặc nhiệm vụ của hàm sẽ giúp người đọc
code dễ hiểu hơn, bạn nên luyện tập điều nay khi code.

5.4. Tham số hàm Python

Trong phần trước chúng ta đã tìm hiểu về hàm Python tích hợp sẵn và hàm
Python do người dùng định nghĩa với số lượng tham số tùy biến. Bạn sẽ biết cách
để định nghĩa hàm bằng cách sử dụng tham số mặc định, keyword và tham số tùy
biến trong bài này.

Tùy vào việc bạn định nghĩa hàm Python theo cách nào mà chúng ta có thể
gọi hàm khác nhau, tất nhiên, dù gọi hàm theo cách nào thì kết quả cuối cùng vẫn
hợp lý và giống nhau.

5.4.1. Tham số của hàm Python

Trong phần 5.3 hàm do người dùng định nghĩa, chúng ta đã biết cách định
nghĩa và gọi một hàm, giống như ví dụ dưới đây:

80
def Xin_chao(ten,loi_chao):
"""Hàm Xin_chao chào một người
với thông điệp cho trước """
print("Xin chào",ten + ', ' + loi_chao)
Xin_chao("Nam","đọc bài vui vẻ nha!")
Khi chạy code trên, ta sẽ nhận được dòng chữ trên màn hình như sau:

Xin chào Nam, đọc bài vui vẻ nha!

Như bạn thấy, hàm Xin_chao() này có 2 tham số. Do đó, nếu chúng ta gọi
hàm với 2 tham số, nó sẽ chạy "ngon lành" và không gặp phải thông báo lỗi nào.

Nếu gọi hàm với số tham số khác 2, trình thông dịch sẽ hiển thị thông báo
lỗi. Nếu muốn, bạn có thể thử gọi hàm Xin_chao() trên với 1 tham số và không
có tham số.

#Thông báo lỗi khi gọi hàm Xin_chao() với 1 tham số

TypeError: Xin_chao() missing 1 required positional
argument: 'loi_chao'
#Thông báo lỗi khi gọi hàm Xin_chao() mà không có tham
số
TypeError: Xin_chao() missing 2 required positional
arguments: 'ten' and 'loi_chao'
Bên cạnh việc định nghĩa hàm với số tham số cố định, bạn có thể dùng
những cách mà chúng tôi giới thiệu dưới đây để tạo số tham số tùy biến cho hàm:

5.4.2. Tham số mặc định trong hàm Python

Trong Python, tham số của hàm có thể có giá trị mặc định. Chúng ta có thể
cung cấp giá trị mặc định này cho một tham số bằng cách sử dụng toán tử gán
( = ) như ví dụ dưới đây:

def Xin_chao(ten, loi_chao = "đọc bài vui nha!"):

""" Hàm này chào một người với thông điệp cho trước.
Nếu thông điệp không được cung cấp,
nó sẽ được mặc định là "đọc bài vui nha!"
"""
print("Xin chào",ten + ', ' + loi_chao)
Xin_chao("Hải")
Xin_chao("Dũng","bạn khỏe không?")
Khi chạy code trên, ta có kết quả đầu ra như sau:
Xin chào Hải, đọc bài vui nha!
Xin chào Dũng, bạn khỏe không?

81
 Trong hàm này, tham số ten không có giá trị mặc định và bắt buộc phải có

khi gọi hàm. Tham số loi_chao có giá trị mặc định là "đọc bài vui nha!" . Vì
vậy, khi gọi hàm bạn có thể cung cấp tham số này hoặc không. Nếu cung cấp
tham số loi_chao , nó sẽ ghi đè lên giá trị mặc định.

Trong một hàm, số lượng tham số có giá trị mặc định không bị giới hạn,
nhưng một khi có tham số mặc định, tất cả các tham số nằm bên phải của tham số
mặc định cũng phải có giá trị mặc định. Nghĩa là, các tham số không mặc định
không thể nằm sau các tham số mặc định. Ví dụ, nếu bạn định nghĩa hàm
Xin_chao() như sau:

def Xin_chao(loi_chao = "đọc bài vui nha!",ten):

Thì sẽ nhận được thông báo lỗi:

SyntaxError: non-default argument follows default

argument

5.4.3. Tham số keyword trong Python

Khi gọi một hàm với vài giá trị, những giá trị này sẽ được gán cho các tham
số theo vị trí của chúng. Ví dụ, trong hàm Xin_chao() ở trên, khi
gọi Xin_chao("Dũng","bạn khỏe không?") , giá trị "Dũng" được gán cho tham

số ten và giá trị "bạn khỏe không?" được gán cho loi_chao .

Python cho phép gọi hàm bằng các tham số keyword. Khi gọi hàm theo cách
nay, thứ tự (vị trí) của tham số có thể thay đổi, nhưng kết quả vẫn hợp lệ và tương
tự các cách gọi hàm khác.

# 2 tham số keyword
Xin_chao(ten = "Dũng",loi_chao = "bạn khỏe không?")
# 2 tham số keyword, thứ tự tham số thay đổi
Xin_chao(loi_chao = "bạn khỏe không?",ten = "Dũng")
# 1 tham số keyword, 1 theo vị trí
Xin_chao("Dũng",loi_chao = "bạn khỏe không?")
Như bạn thấy bên trên, có thể kết hợp các tham số theo keyword hoặc vị trí
khi gọi hàm. Nhưng phải nhớ rằng các tham số keyword phải đi sau tham số theo
vị trí. Nếu tham số theo vị trí ở sau tham số keyword bạn sẽ nhận được thông báo
lỗi:

82
Xin_chao(ten = "Dũng","bạn khỏe không?")
Thông báo lỗi:

SyntaxError: non-keyword argument after keyword

argument

5.4.4. Tham số tùy biến trong hàm Python

Đôi khi, ta không biết trước số lượng tham số sẽ được truyền vào hàm, đó là
lúc cần phải sử dụng cách gọi hàm với số lượng tham số tùy biến.

Trong định nghĩa hàm, ta sử dụng dấu hoa thị * trước tên tham số để biểu
thị loại tham số, như ví dụ dưới đây:

def Xin_chao(*ten_chao):
"""
Hàm này sẽ chào một danh sách người cho trước
"""
for ten in ten_chao:
print("Xin chào",ten)

Xin_chao("Hải","Hoa","Công","Sơn")
Khi chạy code trên ta được kết quả như sau:
Xin chào Hải
Xin chào Hoa
Xin chào Công
Xin chào Sơn

Ở đây, ta gọi hàm với nhiều tham số. Tham số này được "gói" lại thành một
tuple trước khi truyền vào hàm. Bên trong hàm, chúng ta sử dụng vòng
lặp for để lấy tất cả các tham số trong tuple.

83
5.5. Hàm đệ quy trong Python
Trong các phần trước, bạn đã biết về hàm Python, các hàm Python tích hợp
sẵn và hàm Python do người dùng định nghĩa. Trong bài này chúng ta sẽ tìm hiểu
thêm về hàm đệ quy trong Python, hàm tự gọi chính nó, cũng như cách tạo hàm
đệ quy và ví dụ minh họa.

5.5.1. Hàm đệ quy trong Python là gì?

Đệ quy là cách lập trình hoặc code một vấn đề, trong đó hàm tự gọi lại chính
nó một hoặc nhiều lần trong khối code. Thông thường, nó trả giá trị trả về của lần
gọi hàm. Nếu định nghĩa hàm thỏa mãn điều kiện đệ quy thì hàm được gọi là hàm
đệ quy.

Điều kiện chấm dứt: Một hàm đệ quy cần phải có điều kiện chấm dứt đề
dừng việc tự gọi lại nó. Hàm đệ quy chấm dứt khi mỗi lần gọi đệ quy thì số giải
pháp của vấn đề được giảm bớt và tiến gần đến điều kiện cơ sở. Một điều kiện cơ
sở là điểm mà ở đó vấn đề được giải quyết và không cần đệ quy thêm. Nếu các
lần gọi đệ quy không thể đến được điều kiện cơ sở thì hàm đệ quy trở thành một
vòng lặp vô hạn.

Như vậy, có thể nói đệ quy trong khoa học máy tính là một phương pháp
giải quyết vấn đề dựa trên việc giải quyết các trường hợp nhỏ hơn của cùng vấn
đề đó.

Trong Python, hàm đệ quy cũng tương tự như vậy, có thể gọi đến chính nó
và có một điều kiện cơ sở để chấm dứt đệ quy.

5.5.2. Ví dụ về hàm đệ quy trong Python

Ví dụ kinh điển nhất về hàm đệ quy chính là tính giai thừa của một số
nguyên. Giai thừa của một số là kết quả của phép nhân từ một đến số đó. Ví dụ, 5
giai thừa (được viết là 5!) là 1*2*3*4*5= 120.

Trong Python, hàm tính giai thừa của một số được viết như sau:

def giaithua(n):
"""Đây là hàm tính giai thừa của
một số nguyên"""

84
 if n == 1:
return 1
else:
return (n * giaithua(n-1))
num = 5
num1 = int(input("Nhập số cần tính giai thừa: "))
print("Giai thừa của", num, "là", giaithua(num))
print("Giai thừa của", num1, "là", giaithua(num1))
Trong ví dụ trên, bạn hãy nhìn vào phần định nghĩa hàm giaithua(n) ,

trong lệnh if...else, hàm giaithua(n) đã gọi lại chính nó. Chạy code trên ta được
kết quả sau:

Khi gọi hàm giaithua(n) với số nguyên dương, nó sẽ gọi đệ quy bằng
cách giảm dần số. Mỗi một lần gọi hàm, nó sẽ nhân số với giai thừa của 1 cho đến
khi số bằng 1. Việc gọi đệ quy này có thể được giải thích trong các bước sau:

giaithua(4) # Lần gọi đầu tiên với 4

4 * giaithua(3) # Lần gọi thứ hai với 3
4 * 3 * giaithua(2) # Lần gọi thứ ba với 2
4 * 3 * 2 * giaithua(1) # Lần gọi thứ tư với 1
4 * 3 * 2 * 1 # Trả về từ lần gọi 4 khi số =1
4 * 3 * 2 # Trả về từ lần gọi 3
4 * 6 # Trả về từ lần gọi 2
24 # Trả về từ lần gọi 1
Phép đệ quy trên kết thúc khi số giảm xuống đến 1. Đây được gọi là điều
kiện cơ sở. Mỗi hàm đệ quy phải có một điều kiện cơ sở để dừng việc đệ quy nếu
không nó sẽ trở thành hàm vô hạn, tự gọi mãi đến nó.

5.5.3. Ưu điểm của hàm đệ quy

85
 Các hàm đệ quy làm cho code trông gọn gàng và nhẹ nhàng hơn.

Những nhiệm vụ phức tạp có thể được chia thành những vấn đề đơn giản
hơn bằng cách sử dụng đệ quy.

Tạo trình tự với đệ quy dễ dàng hơn so với việc sử dụng những vòng lặp
lồng nhau.

5.5.4. Nhược điểm của đệ quy:

Đôi khi logic đằng sau đệ quy khá khó để hiểu rõ.

Gọi đệ quy tốn kém (không hiệu quả) vì chúng chiếm nhiều bộ nhớ và thời
gian.

Các hàm đệ quy rất khó để gỡ lỗi.

Mỗi một lần hàm đệ quy tự gọi nó sẽ lưu trữ trên bộ nhớ. Vì thế, nó tiêu tốn
nhiều bộ nhớ hơn so với hàm truyền thống. Python sẽ dừng gọi hàm sau 1000 lần
gọi. Nếu bạn chạy code dưới đây:

def giaithua(n):
"""Đây là hàm tính giai thừa của
một số nguyên by """
if n == 1:
return 1
else:
return (n * giaithua(n-1))
print (giaithua(1001))
Sẽ nhận được thông báo lỗi:

RecursionError: maximum recursion depth exceeded in

comparison
Có thể giải quyết vấn đề này bằng cách điều chỉnh số lần gọi đệ quy, như
sau:

import sys
sys.setrecursionlimit(5000)

def giaithua(n):
"""Đây là hàm tính giai thừa của
một số nguyên by """
if n == 1:

86
 return 1
else:
return (n * giaithua(n-1))
print (giaithua(1001))
Nhưng nhớ rằng, vẫn còn có giới hạn đầu vào cho hàm giai thừa. Vì lý do
này, bạn nên sử dụng đệ quy một cách khôn ngoan. Để tính giai thừa thì đệ quy
không phải là giải pháp tốt nhất, đối với các vấn đề khác như di chuyển trong thư
mục (traversing a directory) thì đệ quy là một giải pháp tốt.

5.6. Hàm vô danh, Lambda trong Python

Chúng ta đã đi được một nửa chặng đường trong phần hàm Python, ở phần
này các bạn sẽ được tìm hiểu về hàm vô danh, còn được gọi là hàm Lambda.
Hàm Lambda là gì, cú pháp hàm Lambda ra sao và làm thế nào để sử dụng hàm
Lambda với ví dụ cụ thể.

5.6.1. Hàm Lambda trong Python là gì?

Trong Python, hàm vô danh là hàm được định nghĩa mà không có tên. Nếu
các hàm bình thường được định nghĩa bằng cách sử dụng từ khóa def , thì hàm

vô danh được định nghĩa bằng cách sử dụng từ khóa lambda . Vì lý do đó mà hàm
vô danh còn được gọi là hàm Lambda.

5.6.2. Cú pháp hàm Lambda trong Python

Một hàm Lambda trong Python có cú pháp sau;

lambda tham_so: bieu_thuc

Hàm Lambda có thể có nhiều tham số nhưng chỉ có 1 biểu thức. Biểu thức
sẽ được đánh giá và trả về. Hàm Lambda có thể được sử dụng ở bất cứ nơi nào
đối tượng hàm được yêu cầu.

5.6.3. Ví dụ về hàm Lambda trong Python

Đây là ví dụ về hàm Lambda với nhiệm vụ nhân đôi số nhập vào.

nhan_doi = lambda a: a * 2

# Kết quả: 20

87
# By
print(nhan_doi(10))
Trong ví dụ này, lambda a: a * 2 là hàm Lambda. a ở đây là tham số

và a * 2 là biểu thức (đảm nhiệm việc tính toán và trả về kết quả). Hàm này
không có tên, nó trả về một đối tượng hàm - được gán định danh
là nhan_doi. Chúng ta có thể gọi nó như một hàm bình thường, lệnh sau:

nhan_doi = lambda a: a * 2
gần giống như:

def nhan_doi(a):
return a * 2

5.6.4. Sử dụng Lambda trong Python

Thường thì hàm Lambda được sử dụng khi cần một hàm vô danh trong thời
gian ngắn, ví dụ như dùng làm đối số cho một hàm bậc cao hơn. Hàm Lambda
thường được sử dụng cùng với các hàm Python tích hợp sẵn như filter() hay
map(),...

a. Ví dụ dùng hàm Lambda với filter():

Hàm filter() sẽ lấy các tham số là một hàm và một list. Hàm được gọi với tất
cả các mục trong list và list mới sẽ được trả về, chứa các mục mà hàm đánh giá là
True. Đây là ví dụ dùng hàm filter() để lọc ra các số chẵn trong list.

list_goc = [10, 9, 8, 7, 6, 1, 2, 3, 4, 5]

list_moi = list(filter(lambda a: (a%2 == 0) ,

list_goc))

# Kết quả: [10, 8, 6, 2, 4]

# By
print(list_moi)
b. Ví dụ dùng hàm Lambda với map():

Hàm map() cũng lấy các tham số là một hàm và một list. Hàm được gọi với
tất cả các mục trong list và list mới được trả về chứa các mục được hàm trả về
tương ứng cho mỗi mục. Nói thì có vẻ lằng nhằng, bạn xem ví dụ sau sẽ dễ hiểu
hơn nhiều:

88
list_goc = [10, 9, 8, 7, 6, 1, 2, 3, 4, 5]

list_moi = list(map(lambda a: a*2 , list_goc))

# Kết quả: [20, 18, 16, 14, 12, 2, 4, 6, 8, 10]

# By
print(list_moi)

5.7. Biến toàn cục (global), biến cục bộ (local), biến nonlocal
trong Python
Trong phần này bạn sẽ học về biến toàn cục (global), biến cục bộ (local),
biến nonlocal trong Python và trường hợp sử dụng các biến này.

5.7.1. Biến toàn cục trong Python

Trong ngôn ngữ lập trình Python, một biến được khai báo bên ngoài hàm
hoặc trong phạm vi toàn cục được gọi là biến toàn cục hay biến global. Biến toàn
cục có thể được truy cập từ bên trong hoặc bên ngoài hàm.

Hãy xem ví dụ về cách tạo biến toàn cục trong Python.

x = "Biến toàn cục" #khai báo biến x

#Gọi x từ trong hàm vidu()
def vidu():
print("x trong hàm vidu() :", x)

vidu()
#Gọi x ngoài hàm vidu()
print("x ngoài hàm vidu():", x)
Trong ví dụ trên, ta khai báo biến x là biến toàn cục, và định nghĩa
hàm vidu() để in biến x. Cuối cùng ta gọi hàm vidu() để in giá trị của biến x.

Chạy code trên ta sẽ được kết quả là:

x trong hàm vidu(): Biến toàn cục

x ngoài hàm vidu(): Biến toàn cục
Chuyện gì sẽ xảy ra nếu bạn thay đổi giá trị của x trong hàm?

x = 2
def vidu():
x=x*2
print(x)

vidu()

89
 Nếu chạy code này bạn sẽ nhận được thông báo lỗi:

UnboundLocalError: local variable 'x' referenced

before assignment
Lỗi này xuất hiện là do Python xử lý x như một biến cục bộ và x không

được định nghĩa trong vidu() .

Để thay đổi biến toàn cục trong một hàm bạn sẽ phải sử dụng từ khóa
global. Chúng tôi sẽ nói kỹ hơn trong bài về từ khóa global.

5.7.2. Biến cục bộ trong Python

Biến được khai báo bên trong một hàm hoặc trong phạm vi cục bộ được gọi
là biến cục bộ hay biến local.

def vidu():
y = "Biến cục bộ"
vidu()
print(y)
Khi chạy code trên bạn sẽ nhận được thông báo lỗi:

NameError: name 'y' is not defined

Lỗi này xuất hiện là do chúng ta đã cố truy cập vào biến cục bộ y trong
phạm vi toàn cục, nhưng y chỉ làm việc trong hàm vidu() hoặc phạm vi cục bộ.

Thông thường, để tạo một biến cục bộ, chúng ta sẽ khai báo nó trong một
hàm như ví dụ dưới đây:

def vidu():
y = "Biến cục bộ"
print(y)
vidu()
Chạy code trên ta sẽ được kết quả

Biến cục bộ
Chúng ta quay trở lại xem xét vấn đề trước đó, lúc x là một biến toàn cục

và chúng ta muốn thay đổi x trong vidu() .

5.7.3. Biến cục bộ và biến toàn cục

90
 Ở đây, chúng ta sẽ học cách dùng biến cục bộ và toàn cục trong cùng một
code.

x = 2

def vidu():
global x
y = "Biến cục bộ"
x = x * 2
print(x)
print(y)
#Viết bởi
vidu()
Chạy code trên ta sẽ có đầu ra:

4
Biến cục bộ
Trong code trên, chúng ta khai báo x là biến toàn cục và y là biến cục bộ

trong vidu() và dùng toán tử * để thay đổi biến toàn cục và in cả giá trị của x và

y. Sau khi gọi hàm vidu() giá trị của x sẽ thành 4 vì được nhân đôi.

Ví dụ sử dụng biến toàn cục và cục bộ trùng tên:

x = 5

def vidu():
x = 10
print("Biến x cục bộ:", x)

vidu()
print("Biến x toàn cục:", x)
Sau khi chạy code trên ta có đầu ra:

Biến x cục bộ: 10

Biến x toàn cục: 5
Trong code trên, chúng ta sử dụng cùng tên x cho cả biến cục bộ và biến
toàn cục. Khi in cùng biến x chúng ta nhận được hai kết quả khác nhau vì biến
được khai báo ở cả hai phạm vi, cục bộ (bên trong hàm vidu() ) và toàn cục (bên

ngoài hàm vidu() ).

Khi chúng ta in biến trong hàm vidu() nó sẽ xuất ra Biến x cục bộ: 10 ,

91
đây được gọi là phạm vi cục bộ của biến. Tương tự khi ta in biến bên ngoài
hàm vidu() sẽ cho ra Biến x toàn cục: 5 , đây là phạm vi toàn cục của biến.

5.7.4. Biến nonlocal trong Python

Từ nonlocal này mình không biết dịch sang tiếng Việt sao cho chuẩn. Trong
Python, biến nonlocal được sử dụng trong hàm lồng nhau nơi mà phạm vi cục bộ
không được định nghĩa. Nói dễ hiểu thì biến nonlocal không phải biến local,
không phải biến global, bạn khai báo một biến là nonlocal khi muốn sử dụng nó ở
phạm vi rộng hơn local, nhưng chưa đến mức global.

Để khai báo biến nonlocal ta cần dùng đến từ khóa nonlocal.

Ví dụ:

def ham_ngoai():
x = "Biến cục bộ"

def ham_trong():
nonlocal x
x = "Biến nonlocal"
print("Bên trong:", x)

ham_trong()
print("Bên ngoài:", x)

hamngoai()
Chạy code trên bạn sẽ có đầu ra:

Bên trong: Biến nonlocal

Bên ngoài: Biến nonlocal
Trong code trên có một hàm lồng là ham_trong() , ta dùng từ

khóa nonlocal để tạo biến nonlocal. Hàm ham_trong() được định nghĩa trong

phạm vi của ham_ngoai() .

Lưu ý: Nếu chúng ta thay đổi giá trị của biến nonlocal, sự thay đổi sẽ xuất
hiện trong biến cục bộ.

5.8. Từ khóa global trong Python

Trong phần trước, khi nhắc đến vấn đề thay đổi giá trị của biến toàn cục

92
trong một hàm mình có nói phải dùng từ khóa Python là global , nhưng chưa nói
rõ cách dùng vì muốn dành riêng một bài để viết chi tiết về từ khóa này.

Từ khóa global để làm gì và cách dùng nó trong Python ra sao? Mời các
bạn cùng theo dõi nhé.

Trong Python, từ khóa global cho phép bạn chỉnh sửa biến bên ngoài
phạm vi hiện tại. Nó được sử dụng để tạo biến global và thực hiện thay đổi cho
biến trong bối cảnh cục bộ.

5.8.1. Quy tắc của từ khóa global trong Python

Khi chúng ta tạo biến trong một hàm, nó mặc định là biến cục bộ.

Khi chúng ta định nghĩa một biến bên ngoài hàm, nó mặc định là biến toàn
cục. Bạn không cần phải sử dụng từ khóa global.

Chúng ta sử dụng từ khóa global để đọc và viết biến toàn cục trong một
hàm.

Sử dụng từ khóa global bên ngoài một hàm thì không có tác dụng gì cả.

5.8.2. Cách sử dụng từ khóa global trong Python

Ví dụ 5-3: Truy cập biến toàn cục từ trong một hàm

a = 1 # Biến toàn cục

def them():
print(a)

them()
Khi chạy code trên chúng ta nhận được đầu ra là 1. Tuy nhiên, có vài trường
hợp chúng ta cần chỉnh sửa biến toàn cục từ bên trong hàm, đó chính là trường
hợp mình nhắc đến từ đầu, vậy phải làm sao?

Ví dụ 5-4: Chỉnh sửa biến toàn cục trong một hàm

Giả sử ta cần sửa giá trị của a thành a + 9 trong hàm them() , nếu viết code
sau:

93
a = 1 # Biến toàn cục

def them():
a = a + 9
print(a)

them()
Bạn sẽ nhận được thông báo lỗi:

UnboundLocalError: local variable 'a' referenced

before assignment
Đó là do chúng ta chỉ có thể truy cập vào biến toàn cục mà không thể chỉnh
sửa nó trong một hàm. Giải pháp cho vấn đề này là sử dụng từ khóa global . Khi
đó, đoạn code trên sẽ được viết lại như sau:

a = 1 # Biến toàn cục

def them():
global a
a = a + 9
print("Trong them():", a)

them()
print("Trong main:", a)
Chạy code trên ta được kết quả đầu ra là:

Trong them(): 10
Trong main: 10
Ở đây, chúng ta định nghĩa a là một biến toàn cục trong hàm them() , sau

đó tăng giá trị của a lên 9, tức là a = a + 9. Sau đó, chúng ta gọi hàm them() ,

cuối cùng, in biến toàn cục a. Kết quả là thay đổi được thực hiện cho biến a

trong hàm them() cũng xảy ra trên biến toàn cục bên ngoài hàm, a = 10.

Ví dụ 5-5: Chia sẻ biến toàn cục global thông qua mô-đun trong Python

Trong Python, chúng ta tạo ra một mô-dun config.py để giữ các biến toàn
cục và chia sẻ thông tin thông qua các mô-đun Python trong cùng một chương
trình. Đây là cách chúng ta có thể chia sẻ biến toàn cục qua các mô-đun Python.

Tạo một file config.py để lưu trữ biến toàn cục:

94
a = 0
b = "rỗng"
Tạo một file update.py để thay đổi các biến toàn cục:

import config

config.a = 10
config.b = ""
Viết file main.py để kiểm tra sự thay đổi:

import config
import update

print(config.a)
print(config.b)
Khi chạy file main.py, đầu ra sẽ là:

10
Ở đây, ta đã tạo ra 3 file là config.py, update.py và main.py. Mô-đun
config.py lưu trữ 2 biến toàn cục là a và b. Trong file update.py chúng ta nhập

mô-đun config.py và sửa đổi giá trị của biến a, b . Tương tự trong file main.py,
ta nhập cả 2 mô-đun config.py và update.py. Cuối cùng, chúng ta dùng lệnh in để
kiểm tra xem giá trị của biến a và b đã được thay đổi hay chưa.

Ví dụ 5-6: Sử dụng biến toàn cục trong hàm lồng nhau.

Trong ví dụ này bạn sẽ biết cách để sử dụng biến toàn cục trong hàm lồng
nhau.

def ham1():
x = 20

def ham2():
global x
x = 25

print("Trước khi gọi ham2: ", x)

print("Đang gọi ham2")
ham2()
print("Sau khi gọi ham2: ", x)

ham1()
print("x trong main: ", x)

95
 Chạy code trên ta được:

Trước khi gọi ham2: 20

Đang gọi ham2
Sau khi gọi ham2: 20
x trong main: 25
Ở đây, chúng ta khai báo biến toàn cục ở trong hàm lồng tên là ham2() .

Trong ham1() , x không bị ảnh hưởng bởi từ khóa global .

Trước và sau khi gọi hàm ham2() , x sẽ lấy giá trị của biến cục bộ là 20 .

Bên ngoài hàm ham1(), x sẽ lấy giá trị toàn cục, được khia báo

trong ham2() là 25 . Đây là do ta sử dụng từ khóa global trong x để tạo biến

toàn cục trong ham2() . Nếu chúng ta thực hiện bất kỳ sự thay đổi nào

cho x trong ham2() thì thay đổi sẽ xuất hiện bên ngoài phạm vi cục bộ.

5.9. Module trong Python

Trong phần này chúng ta sẽ biết cách để tạo và nhập một module
trong Python. Chúng ta sẽ tìm hiểu vài cách để nhập, sử dụng module tùy chỉnh
cũng như module được tích hợp sẵn trong Python.

5.9.1. Module trong Python là gì?

Module (mô-đun) đề cập đến một file chứa những câu lệnh Python và các
định nghĩa. Một file chứa code Python, ví dụ module1.py được gọi là module và

tên của module sẽ là module1 .

Module thường được sử dụng khi muốn chia chương trình lớn thành những
file nhỏ hơn để dễ quản lý và tổ chức. Phổ biến nhất là những hàm Python hay
phải sử dụng sẽ được định nghĩa trong một module và nhập vào Python thay vì
sao chép định nghĩa trong những chương trình khác nhau. Nhờ thế, module cho
phép tái sử dụng code.

Bây giờ ta thử tạo một module bằng cách nhập code sau vào file và lưu với
tên module1.py .

96
#Ví dụ về module Python

def them(p, q):

"""Module này thêm 2 số
và trả về kết quả
by """

ket_qua = p + q
return ket_qua
Ở đây, chúng ta định nghĩa hàm them() trong module module1 . Hàm sẽ
lấy vào 2 số và trả về tổng của chúng.

5.9.2. Làm sao để nhập module trong Python?

Chúng ta có thể nhập các định nghĩa từ module này vào module khác hoặc
vào trình thông dịch trong Python. Chúng ta sử dụng từ khóa import để thực
hiện việc này. Để nhập một module đã được định nghĩa, chúng ta nhập lệnh sau
tại dấu nhắc của Python.

>>> import module1

Lệnh này không nhập tên của hàm được định nghĩa trong một cách trực tiếp
trong bảng hiện tại, nó chỉ nhập tên của module mà thôi. Sử dụng tên module để
truy cập vào hàm với toán tử (.). Ví dụ:

>>> module1.them(4.5,5.5)
10.0
Hãy chắc chắn bạn đã gõ đúng tên module, tên hàm (phân biệt chữ hoa, chữ
thường) nếu bạn nhận được thông báo sau: "ModuleNotFoundError: No module
named..."

Python đã có sẵn rất nhiều module tiêu chuẩn. Bạn có thể kiểm tra danh
sách đầy đủ tại địa chỉ: https://docs.python.org/3/py-modindex.html. Tại đây,
bạn có thể xem tên module, nhiệm vụ của chúng là gì. Các file này có sẵn trong
Lib ở thư mục bạn cài đặt Python. Những module này có thể nhập vào tương tự
như cách chúng ta nhập module tự định nghĩa.

Có rất nhiều cách để nhập module như dưới đây:

97
5.9.3. Sử dụng lệnh import

Chúng ta có thể sử dụng lệnh import để nhập module và truy cập vào các
định nghĩa bên trong nó, sử dụng toán tử . như mô tả bên trên. Đây là ví dụ:

# Lệnh import để nhập module có sẵn trong Python

#
import math
print("Giá trị của pi là: ", math.pi)
Khi chạy code Python trên ta được kết quả:

Giá trị của pi là: 3.141592653589793

5.9.4. Nhập module và sửa tên khi nhập

# Nhập module và sửa tên nó
#
import math as m
print("Giá trị của pi là: ", m.pi)
Chúng ta đã đổi tên module math là m, điều này có thể giúp tiết kiệm thời
gian trong một số trường hợp. Chú ý, việc đổi tên này chỉ áp dụng trong phạm vi
lệnh, chứ không thực sự đổi tên module trong Lib. Khi đã đổi tên, bạn phải gõ
đúng tên module, math lúc này không được công nhận trong phạm vi lệnh nữa,
mà bạn phải dùng m mới đúng.

5.9.5. Lệnh from...import trong Python

Chúng ta có thể nhập một tên cụ thể từ module mà không cần nhập toàn bộ
module như ví dụ dưới đây:

# Chỉ nhập pi từ module math

#
from math import pi
print("Giá trị của pi là: ",pi)
Code trên chỉ nhập thuộc tính pi từ module math. Trong trường hợp này
không cần sử dụng toán tử ".". Chúng ta có thể nhập nhiều thuộc tính của module
như ví dụ dưới đây:

# Nhập nhiều thuộc tính từ module math

#
>>> from math import pi, e
>>> pi

98
3.141592653589793
>>> e
2.718281828459045

5.9.6. Nhập tất cả tên

Ta có thể nhập tất cả tên (các định nghĩa) từ một module sử dụng code sau:

# Nhập tất cả tên từ module math

#
form math import *
print("Giá trị của pi là: ",pi)
Chúng ta nhập tất cả các định nghĩa từ module math nên tất cả tên đều có
thể nhìn thấy trong phạm vi này, ngoại trừ những tên bắt đầu bằng dấu gạch dưới
_.

Nhập mọi thứ với dấu hoa thị * không phải là một thói quen lập trình tốt. Vì
nó có thể dẫn đến những định nghĩa bị trùng lặp cho cùng một định danh và khiến
cho việc đọc code trở nên khó khăn hơn.

5.9.7. Đường dẫn tìm kiếm module Python

Khi nhập module, Python sẽ tìm một vài nơi. Trình thông dịch tìm các
module có sẵn, nếu không thấy nó sẽ vào danh sách các thư mục được định nghĩa
trong sys.path. Thứ tự tìm kiếm sẽ là:

Thư mục hiện tại.

PYTHONPATH (một biến môi trường với danh sách thư mục).

Thư mục mặc định có vị trí phụ thuộc vào chọn lựa trong quá trình cài đặt.

Nhập lần lượt các lệnh sau để xem đường dẫn:

>>> import sys

>>> sys.path
Chúng ta có thể chỉnh sửa danh sách này để thêm các path tùy chỉnh theo
mong muốn.

5.9.8. Nạp lại module

Trình thông dịch Python chỉ nhập một module trong một phiên. Điều này

99
làm cho mọi thứ trở nên hiệu quả hơn. Dưới đây là ví dụ minh họa cho cách hoạt
động này.

Bạn viết code sau trong file mới, đặt tên là module_1 :

print("Code đã hoạt động")

Giờ ta thử nhập module module_1 để xem sự hiệu quả của việc nhập
module nhiều lần.

>>> import module_1

Code đã hoạt động
>>> import module_1
>>> import module_1
>>> import module_1
>>>
Bạn có thể thấy rằng code trên chỉ thực hiện một lần, nghĩa là module_1 chỉ
được nhập 1 lần trong 1 phiên làm việc đó. Bây giờ nếu bạn sửa đổi code
trong module_1 bạn phải nạp lại nó. Để làm điều này bạn phải khởi động lại trình
thông dịch, nhưng cách này có vẻ không ổn lắm.

Python cung cấp cách thông minh hơn để làm điều này. Bạn có thể sử dụng
hàm reload() trong module imp để nạp lại module_1 , như dưới đây:

>>> import module_1

Code đã hoạt động
>>> import module_1
>>> import module_1
>>> import module_1
>>> import imp
>>> imp.reload(module_1)
Code đã hoạt động
<module 'module_1' from
'C:/Users/Quantrimangcom/Python/Python36-
32\\module_1.py'>

5.9.9. Hàm dir() trong Python

Hàm dir() trong Python được sử dụng để tìm ra các tên được định nghĩa
trong một module. Ví dụ, bạn định nghĩa hàm them() trong ví dụ ban đầu.

Bạn nhập lần lượt các lệnh sau:

100
>>> import Quantrimangcom
>>> dir(Quantrimangcom)
Và kết quả trả về:

['__builtins__', '__cached__', '__doc__', '__file__',

'__loader__', '__name__', '__package__', '__spec__',
'them']
>>>
Kết quả đầu ra là danh sách các tên được định nghĩa trong module, được sắp
xếp theo thứ tự (cùng với them ). Tất cả các tên bắt đầu với dấu gạch dưới là các

thuộc tính Python mặc định, được liên kết với module. Ví dụ, __name__ chứa tên
module.

>>> import Quantrimangcom

>>> Quantrimangcom.__name__
'Quantrimangcom'
>>>
Tất cả các tên được xác định trong không gian tên (namespace) có thể được
tìm thấy bằng cách sử dụng dir() mà không cần tham số nào.

>>> a=10
>>> b=15
>>> quantrimangcom=20
>>> import math
>>> dir()
['Quantrimangcom', '__annotations__', '__builtins__',
'__doc__', '__file__', '__loader__', '__name__',
'__package__', '__spec__', 'a', 'b', 'math',
'quantrimangcom', 'them', 'vidu']
>>>

5.10. Package trong Python

Trong phần trước bạn đã tìm hiểu về module, cách tạo và gọi một module
trong Python. Ở phần này, chúng ta sẽ học cách phân chia code thành những
module hiệu quả, rõ ràng, sử dụng các package trong Python. Thêm nữa là cách
để nhập và sử dụng package của riêng bạn, hoặc package bạn tải về từ đâu đó vào
chương trình Python.

5.10.1. Package trong Python là gì?

101
 Thông thường người dùng không lưu trữ tất cả các file của mình trên máy
tính ở cùng một thư mục, vị trí, mà sử dụng hệ thống phân cấp thư mục để truy
cập dễ dàng hơn. Các tệp tương tự hoặc cùng liên quan đến một chủ đề nào đó sẽ
được để trong cùng một thư mục, chẳng hạn các bài học về hàm Python sẽ lưu
trong thư mục hàm Python. Tương tự như vậy, Python có các package cho thư
mục và module cho file.

Khi chương trình đang code ngày càng lớn với rất nhiều module, chúng ta
sẽ đặt những module giống nhau vào một package, và những nhóm module khác
vào package khác. Điều này giúp dễ dàng quản lý chương trình hơn và nó cũng
dễ hiểu hơn.

Nếu như thư mục có thể chứa các thư mục con thì package cũng vậy, trong
một package có thể có package con và các module khác.

Một thư mục phải chứa file có tên __init__.py để Python hiểu thư mục này
là một package. File này có thể để trống, nhưng thông thường các lập trình viên
thường đặt code khởi tạo cho package ở đây.

Giả sử, ta đang phát triển chương trình có tên QTM, với các package con,
module như sau:

Hình 5-1.

102
5.10.2. Nhập module từ package trong Python

Ta có thể nhập các module từ package sử dụng toán tử dấu chấm (.).

Ví dụ, nếu muốn nhập module mo.py trong ví dụ trên, bạn làm như sau:

import QTM.Video.mo
Nếu trong module mo.py chứa hàm có tên là chon_video(), bạn sẽ phải sử
dụng tên đầy đủ để tham chiếu tới nó:

import QTM.Video.mo.chon_video(video1)
Nếu cấu trúc trên dài quá, bạn có thể nhập module mà không cần tiền tố
package như sau:

from QTM.Video import mo

Ta có thể gọi hàm đơn giản như sau:

mo.chon_video(video1)
Ngoài ra, còn một cách nữa để chỉ nhập hàm được yêu cầu (lớp hoặc biến)
từ module trong 1 package như sau:

from QTM.Video.mo import chon_video

Sau đó, trực tiếp gọi hàm này:

chon_video(video1)
Dù dễ dàng hơn, nhưng cách nhập sau cùng này không được khuyến khích
sử dụng. Việc dùng tên đầy đủ sẽ giúp giảm tình trạng nhầm lẫn và tránh bị trùng
giữa những định danh giống nhau.

Trong khi nhập các package, Python sẽ tìm kiếm danh sách thư mục được
định nghĩa trong sys.path, giống như đường dẫn tìm kiếm module.

5.11. Bài tập

Bài 5-1. Định nghĩa 1 hàm có thể tính tổng hai số.

Gợi ý:

Định nghĩa 1 hàm với 2 số là đối số. Bạn có thể tính tổng trong hàm và trả
về giá trị.

Code mẫu:

103
def SumFunction(number1,
number2): #định nghĩa hàm tính tổng
return number1+number2
print (SumFunction(5,7)) #in tổng 2 số 5 và 7
Bài 5-2. Định nghĩa một hàm có thể chuyển số nguyên thành chuỗi và in nó ra
giao diện điều khiển

Gợi ý:

Sử dụng str() để chuyển đổi một số thành chuỗi.

Code mẫu:

def printValue(n):
print (str(n))
printValue(3)
Bài 5-3. Định nghĩa hàm có thể nhận hai số nguyên trong dạng chuỗi và tính tổng
của chúng, sau đó in tổng ra giao diện điều khiển.

Gợi ý:

Sử dụng int() để chuyển đổi một chuỗi thành số nguyên.

Code mẫu:

def printValue(s1,s2):
print (int(s1)+int(s2))
printValue("3","4") #Kết quả là 7
Bài 5-4. Định nghĩa hàm có thể nhận 2 chuỗi từ input và nối chúng sau đó in ra
giao diện điều khiển

Gợi ý:

Sử dụng + để nối các chuỗi.

Code mẫu:

def printValue(s1,s2):
print (s1+s2)
printValue("3","4") #Kết quả là 34
Bài 5-5. Định nghĩa một hàm có input là 2 chuỗi và in chuỗi có độ dài lớn hơn
trong giao diện điều khiển. Nếu 2 chuỗi có chiều dài như nhau thì in tất cả các
chuỗi theo dòng.

104
 Gợi ý:

Sử dụng hàm len() để lấy chiều dài của một chuỗi

Code mẫu:

def printValue(s1,s2):
# Bài tập Python 30 Code by Quantrimang.com
len1 = len(s1)
len2 = len(s2)
if len1>len2:
print (s1)
elif len2>len1:
print (s2)
else:
print(s1)
print (s2)
printValue("one","three")
Bài 5-6. Định nghĩa hàm có thể chấp nhận input là số nguyên và in "Đây là một
số chẵn" nếu nó chẵn và in "Đây là một số lẻ" nếu là số lẻ.

Gợi ý:

Sử dụng toán tử % để kiểm tra xem số đó chẵn hay lẻ.

Code mẫu:

def checkValue(n):
if n%2 == 0:
print ("Đây là một số chẵn")
else:
print ("Đây là một số lẻ")
checkValue(7)
Bài 5-7. Định nghĩa một hàm có thể in dictionary chứa key là các số từ 1 đến 3
(bao gồm cả hai số) và các giá trị bình phương của chúng.

Gợi ý:

Sử dụng dict[key]=value để nhập mục vào dictionary.

Sử dụng toán từ ** để lấy bình phương của một số.

Code mẫu:

def printDict():
d=dict()

105
 d[1]=1
d[2]=2**2
d[3]=3**2
print (d)
# Bài tập Python 32, Code by Quantrimang.com
printDict()
Chạy code trên bạn sẽ được kết quả là một dictionary như sau: {1: 1, 2: 4, 3:
9}.

Bài 5-8. Định nghĩa một hàm có thể in dictionary chứa các key là số từ 1 đến 20
(bao gồm cả 1 và 20) và các giá trị bình phương của chúng.

Gợi ý:

Sử dụng dict[key]=value để nhập mục vào dictionary.

Sử dụng toán từ ** để lấy bình phương của một số.

Sử dụng range() cho các vòng lặp.

Code mẫu:

def printDict():
d=dict()
for i in range(1,21):
d[i]=i**2
print (d)
# Bài tập Python 33, Code by Quantrimang.com
printDict()
Kết quả khi chạy code trên là: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8:
64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289,
18: 324, 19: 361, 20: 400}

Bài 5-9. Định nghĩa một hàm có thể tạo dictionary, chứa các key là số từ 1 đến 20
(bao gồm cả 1 và 20) và các giá trị bình phương của chúng. Hàm chỉ in các giá trị
mà thôi.

Gợi ý:

Sử dụng dict[key]=value để nhập mục vào dictionary.

Sử dụng toán từ ** để lấy bình phương của một số.

Sử dụng range() cho các vòng lặp.

106
 Sử dụng keys() để di lặp các key trong dictionary. Có thể sử dụng item() để
nhận cặp key/value.

Code mẫu:

def printDict():
d=dict()
for i in range(1,21):
d[i]=i**2
for (k,v) in d.items():
print (v)
# Bài tập Python 34, Code by Quantrimang.com
printDict()
Kết quả bạn nhận được khi chạy code trên là các giá trị bình phương của số
từ 1 đến 20.

Bài 5-10. Định nghĩa một hàm có thể tạo ra một dictionary chứa key là những số
từ 1 đến 20 (bao gồm cả 1 và 20) và các giá trị bình phương của key. Hàm chỉ cần
in các key.

Gợi ý:

Tương tự như bài 34.

Code mẫu:

def printDict():
d=dict()
for i in range(1,21):
d[i]=i**2
for k in d.keys():
print (k)
# Bài Python 35, Code by Quantrimang.com
printDict()
Chạy code trên bạn sẽ nhận được các key trong dictionary, chính là các số
từ 1 đến 20.

Bài 5-11. Định nghĩa một hàm có thể tạo và in list chứa các giá trị bình phương
của các số từ 1 đến 20 (tính cả 1 và 20).

Gợi ý:

Sử dụng toán tử ** để lấy giá trị bình phương.

107
 Sử dụng range() cho vòng lặp.

Sử dụng list.append() để thêm giá trị vào list.

Code mẫu:

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print (li)
# Bài Python 36, Code by Quantrimang.com
printList()
Chạy code trên bạn sẽ nhận được một list chứa các giá trị bình phương của
các số từ 1 đến 20.

Bài 5-12. Định nghĩa một hàm có thể tạo list chứa các giá trị bình phương của các
số từ 1 đến 20 (bao gồm cả 1 và 20) và in 5 mục đầu tiên trong list.

Gợi ý:

Sử dụng toán tử ** để lấy giá trị bình phương.

Sử dụng range() cho vòng lặp.

Sử dụng list.append() để thêm giá trị vào list.

Sử dụng [n1:n2] để cắt list

Code mẫu:

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print (li[:5])
# Bài Python 37, Code by Quantrimang.com
printList()
Chạy code trên bạn sẽ nhận được một list chứa giá trị bình phương của các
số từ 1 đến 5.

Bài 5-13. Định nghĩa một hàm có thể tạo ra list chứa các giá trị bình phương của
các số từ 1 đến 20 (bao gồm cả 1 và 20), rồi in 5 mục cuối cùng trong list.

Gợi ý:

108
 Tương tự bài Bài 5-12

Code mẫu:

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print li[-5:]
# Bài Python 38, Code by Quantrimang.com
printList()
Khi chạy code trên bạn sẽ nhận được list chứa giá trị bình phương của 16,
17, 18, 19, 20.

Bài 5-14. Định nghĩa một hàm có thể tạo list chứa giá trị bình phương của các số
từ 1 đến 20 (bao gồm cả 1 và 20). Sau đó in tất cả các giá trị của list, trừ 5 mục
đầu tiên.

Gợi ý:

Tương tự bài Bài 5-12, Bài 5-13.

Code mẫu:

def printList():
li=list()
for i in range(1,21):
li.append(i**2)
print (li[5:])
printList()
Kết quả:

[36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256,
289, 324, 361, 400]
Bài 5-15. Định nghĩa 1 hàm có thể tạo và in một tuple chứa các giá trị bình
phương của các số từ 1 đến 20 (tính cả 1 và 20).

Gợi ý:

Sử dụng toán tử ** để lấy giá trị bình phương.

Sử dụng range() cho vòng lặp.

Sử dụng list.append() để thêm giá trị vào list.

109
 Sử dụng tuple() để lấy giá tuple từ list.

Code mẫu:

def printTuple():
li=list()
for i in range(1,21):
li.append(i**2)
print (tuple(li))

printTuple()
Kết quả:

(1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169,
196, 225, 256, 289, 324, 361, 400)

110
CHƢƠNG 6. DỮ LIỆU CÓ CẤU TRÚC TRONG
PYTHON

Trong Python có 4 kiểu dữ liệu List, Tuple, Set, Dictionary nên việc hiểu ý nghĩa
và cách sử dụng của từng kiểu sẽ giúp chúng ta quyết định nên sử dụng kiểu nào khi
làm việc trong thực tế.

Nếu muốn tạo mảng thực sự trong Python, chúng ta cần sử dụng cấu trúc dữ liệu
mảng của thư viện numpy. Để giải quyết các vấn đề toán học thì mảng numpy sẽ hiệu
quả hơn các kiểu dữ liệu tập hợp. Các vấn đề về mảng một chiều và mảng nhiều chiều
sử dụng thư viện numpy sẽ được trình bày ở các Mục 5.4 và Mục 5.5.

6.1. List
List trong Python là một dạng dữ liệu cho phép lưu trữ nhiều kiểu dữ liệu khác
nhau và chúng ta có thể truy xuất đến các phần tử bên trong nó thông qua vị trí các
phần tử. Có thể xem list trong Python như một mảng tuần tự trong các ngôn ngữ khác.

List chứa dãy các giá trị, mỗi giá trị được gọi là phần tử, các phần tử có thứ tự
theo chỉ số bắt đầu từ 0. List không chứa phần tử nào được gọi là list rỗng, kí hiệu là
[].

Để khai báo một list trong Python, sử dụng cặp dấu [] và bên trong là các giá trị
của list.

list_name = [value1, value2,… valueN]

Ví dụ:

numbers = [1,2,3,4,5]
names = [‘Mary’, ‘Peter’, ‘Alice’]
emply = []
Ví dụ đầu tiên là list chứa 5 số nguyên. Ví dụ thứ 2 là list chứa 3 xâu kí tự. Ví dụ

111
thứ 3 là list rỗng. Các phần tử trong list không nhất thiết phải cùng kiểu. Ví dụ sau là
list chứa xâu kí tự, số thực, số nguyên.

mix = ['Mary' , 2.5, 5]

Để truy cập đến các phần tử trong list, có thể làm tương tự như đối với chuỗi.
Các phần tử trong một list được đánh dấu bắt đầu từ 0 theo chiều từ trái sang phải và
từ -1 theo chiều từ phải sang trái.

Ví dụ:

names=['Mary','Peter','Alice']
print(names[1])
print(names[-2])
#Kết quả hiển thị:
# Peter
# Peter
Để biết được số lượng phần tử của 1 list, có thể sử dụng hàm len(list_name).

names=['Mary','Peter','Alice']
print(len(names))
#kết quả hiện thị là 3

6.1.1. Kiểm tra sự tồn tại của một phần tử

Kiểm tra theo chỉ số (index)

Trong nhiều trường hợp chúng ta muốn truy xuất một phần tử bất kỳ (dựa vào chỉ
số) của mảng, nếu truy xuất đến một phần tử không tồn tại thì ứng dụng sẽ báo lỗi. Do
đó, trước khi truy xuất một phần tử, cần kiểm tra xem phần tử này đã tồn tại hay chưa.
Hiện tại Python không hỗ trợ hàm nào để kiểm tra sự tồn tại của một phần tử trong
mảng.

Có 2 cách:

Cách 1 Cách 2
if index < len(list_name): try:
list_name[index] list_name[index]
else: except IndexError: # handle
# handle this this
Kiểm tra theo giá trị:

Để kiểm tra một giá trị có tồn tại/ không tồn tại trong mảng, có thể sử dụng toán

112
tử in/not in. Ví dụ:

names = ['Mary', 'Peter', 'Alice']

print ('Mary' in names)
#Kết quả hiển thị: True
names = ['Mary', 'Peter', 'Alice']
print ('Alice' not in names)
#Kết quả hiển thị: False

6.1.2. Duyệt mảng

Dùng toán tử in để duyệt mảng. Xem các ví dụ sau:

names = ['Mary', 'Peter', 'Alice']

for name in names:
print(name)
"""Kết quả hiển thị:
Mary
Peter
Alice """
numbers=[1,2,3,4]
for i in range(len(numbers)):
numbers[i] = numbers[i] * 2
print(numbers)
# Kết quả hiển thị [2, 4, 6, 8]

6.1.3. Các phép toán trên mảng

Sử dụng toán tử + để nối giá trị của 2 mảng.

Ví dụ:

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
>>> c [1, 2, 3, 4, 5, 6]
Sử dụng toán tử * để lặp lại mảng một số lần nhất định

Ví dụ 6-1:

a = [0] * 4
>>>[0, 0, 0, 0]
Ví dụ 6-2:

b = [1, 2, 3] * 3
>>>[1, 2, 3, 1, 2, 3, 1, 2, 3]

113
 Ví dụ 1 lặp lại [0] 4 lần. Ví dụ 2 lặp lại [1,2,3] 3 lần.

6.1.4. Trích xuất mảng con

Tạo các mảng con thông qua toán tử lấy khoản [start:end]. Mặc định start là
vị trí đầu mảng và end là vị trí cuối mảng

Ví dụ 6-3:

t=['a','b','c','d','e','f']
print(t[1:3]) # ['b', 'c']
print(t[:4]) # ['a', 'b', 'c', 'd']
print((t[3:])) #['d', 'e', 'f']
print(t[:]) #['a', 'b', 'c', 'd', 'e', 'f']

6.1.5. Xóa phần tử của mảng

Có thể xóa một phần tử thông qua toán tử del. Thứ tự của các phần tử sẽ dịch
chuyển vào vị trí của phần tử bị xóa.

numbers = [1, 2, 3, 4, 5]
del numbers[0]
print (numbers)
# Kết quả hiển thị: [2, 3, 4, 5])
Có thể xóa một khoản dựa vào toán tử lấy khoản [start:end]. Ví dụ:

numbers = [1, 2, 3, 4, 5]
del numbers[1:3]
print (numbers)
# Kết quả hiển thị: [1, 4, 5]
Tương tự như xóa, ta muốn lấy một phần tử nào ra khỏi mảng có thể sử dụng
phương thức list.pop().

Trả về giá trị của phần tử được lấy ra và mảng bây giờ không còn phần tử này
nữa.

numbers = [1, 2, 3, 4, 5]
x = numbers.pop(1)
print('x = ',x)
print(numbers)
# Kết quả hiển thị
# x = 2
# [1, 3, 4, 5]

114
6.1.6. Một số phương thức xử lý trong mảng

list.append (new_value): Thêm phần tử có giá trị new_value vào cuối mảng.

names = ['Mary', 'Peter', 'Alice','Jack']

names.append('Anna')
print(names)
# Kết quả hiển thị: ['Mary', 'Peter', 'Alice', 'Jack',
'Anna']
list1.extend(list2): Thêm nhiều phần tử vào cuối mảng.
names1 = ['Mary', 'Peter', 'Alice']
names2 = ['Jack', 'Anna']
names1.extend(names2)
print(names1)
# Kết quả hiển thị: ['Mary', 'Peter', 'Alice', 'Jack',
'Anna']
list.index(obj): Tìm vị trí của một phần tử trong mảng. Nếu tìm thấy sẽ trả về

vị trí của phần tử đầu tiên tìm thấy.

Ví dụ 6-4:

names = ['Mary', 'Peter', 'Alice','Jack']

print ("Index of Mary: ", names.index('Mary'))
print ("Index of Alice: ", names.index('Alice'))
# Kết quả hiển thị:
# Index of Mary :0
# Index of Alice :2
list.reverse(): Đảo ngược thứ tự các phần tử của một mảng. Phương thức này

không trả về kết quả mà thay đổi trực tiếp mảng list.

Ví dụ 6-5:

names = ['Mary', 'Peter', 'Alice','Jack']

names.reverse()
print(names)
# Kết quả hiển thị: ['Jack', 'Alice', 'Peter', 'Mary']
list.sort(): Sắp xếp các phần tử trong list theo thứ tự tăng dần. Nếu muốn sắp

xếp theo thứ tự giảm dần thì ta truyền tham số reverse=True vào phương thức.

names = ['Mary', 'Peter', 'Alice','Jack','Anna']

names.sort()
print(names)
# Kết quả hiển thị: ['Alice', 'Anna', 'Jack', 'Mary',
'Peter']

115
names = ['Mary', 'Peter', 'Alice','Jack','Anna']
names.sort(reverse=True)
print(names)
# Kết quả hiển thị: ['Peter', 'Mary', 'Jack', 'Anna',
'Alice']

6.1.7. List lồng nhau

Do list có thể chứa nhiều kiểu dữ liệu khác nhau nên có thể khai báo một list
chứa một hoặc nhiều list khác nhau.

birthday = [20,3,2020]
user = ['Alice', birthday]
print(user)
# ['Alice', [20, 3, 2020]]
Ta có thể truy xuất đến các phần tử trong list lồng nhau theo cấp từ ngoài vào
trong.

6.1.8. List và chuỗi

Có thể kết hợp list và chuỗi để tách các ký tự trong chuỗi thành một danh sách
như sau:

a='Python'
b=list(a)
print(b)
# Kết quả hiển thị: ['P', 'y', 't', 'h', 'o', 'n']
Hoặc có thể tách các từ trong chuỗi bằng hàm split()

a='I can do it'

b=a.split()
print(b)
Kết quả hiển thị: ['I', 'can', 'do', 'it']
Cũng có thể hợp nhất thành chuỗi từ các phần tử trong danh sách bằng hàm
join()

a=['I','can','do','it']
b='-'
c= b.join(a)
print(c)
# Kết quả hiển thị: I-can-do-it

6.2. Dictionary

116
 Dictionary cũng là một cấu trúc mảng, nhưng các phần tử bao gồm key và value.
Một dictionary được khai báo bằng cặp dấu ngoặc {…}

dictionary_name = {key1:value1,key2:value2,…,keyN:valueN}
Ví dụ:

point = {'x': 3, 'y': 6, 'z' : 9}

Truy xuất một giá trị dựa vào key của đối tượng: print point[x] (Hiển thị 3)

6.2.1. Thêm một phần tử

Để thêm một phần tử vào đối tượng đã khai báo, sử dụng cấu trúc dict[key] =
value.

Ví dụ:

user = {'name': 'Hoa', 'age': 20}

user['country'] = 'Vietnam'
print (user)
# Kết quả: {'name': 'Hoa', 'age': 20, 'country':
'Vietnam'}

6.2.2. Một số hàm, phương thức thông dụng

dict.clear(): Xóa toàn bộ dữ liệu bên trong đối tượng

dict.copy(): Trả về một bản copy của đối tượng

dict.fromkeys(seq[,value]): Tạo một đối tượng với danh sách key từ seq và

nếu có truyền value thì lấy đó làm giá trị cho các phần tử.

dict.get(key,default=None): Trả về giá trị của key đã cho. Nếu key không có

mặt thì phương thức này trả về None

dict.keys(): Trả về một list chứa các key

dict.values(): Trả về một list chứa các value.

6.3. Tuple
Tuple cũng là một cấu trúc mảng, tương tự như cấu trúc của List. Một số điểm
khác nhau cơ bản là khai báo Tuple sử dụng cặp dấu ngoặc (…) và một tuple đã được
khai báo rồi thì không thay đổi được giá trị và không hỗ trợ các phương thức như

117
append(), pop()…

Ví dụ:

my_tuple = ('x', 'y', 'z')

print (my_tuple)
>>> Hiển thị: ('x', 'y', 'z')
Tuple vẫn hỗ trợ cách để truy xuất phần tử giống List như là truy xuất theo index,
range, tìm kiếm…

6.4. Mảng một chiều

Để làm việc với mảng, chúng ta cần khai báo import numpy để có thể bắt đầu sử
dụng các hàm của numpy. Vì numpy là thư viện được sử dụng thường xuyên nên
thường được khai báo gọn thành np (np có thể thay bằng các từ khác nhưng không
được trùng với từ khóa).

import numpy as np

6.4.1. Khởi tạo mảng một chiều

Để có mảng một chiều A=[1 2 3], thực hiện như sau:

import numpy as np
A=np.array([1,2,3])
print(A) #hiển thị [1 2 3]
print(type(A[0])) #hiển thị <class 'numpy.int32'>
Các phần tử của mảng A mặc định là kiểu số nguyên numpy.int32. Chú ý rằng
type(var) trả về kiểu dữ liệu của biến var. Nếu cần khai báo A là mảng với các phần

tử là số thực ta viết như sau:

import numpy as np
A = np.array([1.0, 2.0])
# hoặc np.array([1., 2.]) hoặc np.array([1., 2])
print(type(A[0]))
# hiển thị <class 'numpy.float64'>
Ta cũng có thể ép kiểu, ví dụ kiểu dữ liệu thực numpy.float64, ta có thể sử dụng
từ khóa dtype như sau: A = np.array([1, 2], dtype = np.float64)

a. Khởi tạo các mảng một chiều đặc biệt

Mảng toàn giá trị 0: Dùng hàm numpy.zeros(x)

118
 Ví dụ: np.zeros(3) >>> [0 0 0]

Mảng toàn giá trị 1: Dùng hàm numpy.one(x)

Ví dụ: np.ones(4) >>>[1 1 1 1]

Ngoài ra numpy còn cung cấp hai hàm đặc biệt numpy.zeros_like và
numpy.ones_like giúp tạo các mảng toàn các giá trị 0 và mảng toàn các giá trị 1 với số

phần tử bằng số phần tử của đối số.

import numpy as np
A=np.array([1,2,3,4])
B=np.zeros_like(A)
C=np.ones_like(A)
print(A) #hiển thị [1 2 3 4]
print(B) #hiển thị [0 0 0 0]
print(C) #hiển thị [1 1 1 1]
b. Tạo mảng cấp số cộng

np.arange(n): Tạo mảng các số nguyên từ 0 đến n-1

np.arange(m,n): Tạo mảng các số nguyên từ m đến n-1

np.arange(a,b,c): Để tạo một mảng cấp số cộng với phần tử đầu là a, công sai

c dương, phần tử cuối là số lớn nhất nhỏ hơn b. Nếu c là một số âm và b<a thì phần tử
cuối là phần tử nhỏ nhất của cấp số cộng lớn hơn b.

Ví dụ:

np.arange(0, 5, 0.5) tạo mảng cấp số cộng với phần tử đầu là 0, công sai 0.5,

và phần tử cuối là số lớn nhất nhỏ hơn 5.

np.arange(5, 2, -0.5) tạo mảng cấp số cộng với phần tử đầu là 5, công sai -
0.5, và phần tử cuối là số nhỏ nhất lớn hơn 2.

print(np.arange(0, 5, 0.5)) #hiển thị [0. 0.5 1. 1.5 2.

2.5 3. 3.5 4. 4.5]
print(np.arange(5, 2, -0.5)) #hiển thị [5. 4.5 4. 3.5
3. 2.5]

6.4.2. Truy cập mảng một chiều

Số phần tử của mảng A được xác định bằng thuộc tính shape.

119
import numpy as np
A = np.array([1, 2, 3, 4])
print(A.shape) #hiển thị (4,)
Kết quả trả về là một tuple. Nếu A là mảng một chiều, kết quả trả về sẽ có dạng
(d,) trong đó d là số phần tử của mảng A và là phần tử duy nhất của tuple này. Ở ví dụ

trên sau số 4 còn dấu (,) nữa để chắc chắn rằng kết quả là một tuple.

Mỗi thành phần trong mảng một chiều tương ứng với một chỉ số. Chỉ số trong
mảng numpy cũng giống như chỉ số trong list, bắt đầu từ 0 tính từ trái sang phải và chỉ
số ngược bắt đầu từ -1 tính từ phải sang trái.

Để truy cập nhiều phần tử của mảng một chiều, ta có nhiều cách khác nhau:

import numpy as np
A = np.array([1, 2, 3, 4, 5, 6])
k=[0,2,4]
print(A[k]) #hiển thị [1 3 5]
Trong ví dụ này, k là một list, các phần tử của nó có thể coi là các chỉ số của
mảng A. A[k] trả về một mảng numpy, là mảng con của A với các phần tử có chỉ số
được chỉ ra trong list các chỉ số k.

k cũng có thể là một mảng numpy chứa các số nguyên là chỉ số hợp lệ của A.

k=np.array([0,2,4]).
Ngoài ra, cách đánh chỉ số của mảng numpy cũng được sử dụng các quy tắc khác
giống như cách đánh chỉ số của một list.

import numpy as np
A = np.array([1, 2, 3, 4, 5, 6])
print(A[:3]) #hiển thị [1 2 3]
print(A[2:]) #hiển thị [3 4 5 6]
print(A[2:4]) #hiển thị [3 4]
Ta cũng có thể thay đổi giá trị của nhiều phần tử trong mảng. Ví dụ:

import numpy as np
A = np.array([1, 2, 3, 4, 5, 6])
A[[1,2,3]]=0 #thay giá trị các phần tử tại chỉ số 1,2,3
bằng giá trị 0
print(A) #hiển thị [1 0 0 0 5 6]
print(A[::-1]) #đảo ngược mảng A  [6 5 0 0 0 1]

6.4.3. Các phép toán trên mảng một chiều

120
a. Phép toán giữa mảng một chiều với một số vô hướng

Để cộng/trừ/nhân/chia/lũy thừa của mọi phần tử mảng một chiều A với một số vô
hướng x ta chỉ cần lấy A ?x hoặc x ?A trong đó ? có thể thay bằng các phép tính +, -,
*,/, **

import numpy as np
A = np.array([1, 2, 3, 4, 5])
A=A+2
print(A) #[3 4 5 6 7]
b. Phép toán giữa hai mảng một chiều

Để thực hiện các phép toán giữa hai mảng một chiều, số phần tử của hai mảng
phải như nhau. Các phép toán +, -, *, /,** sẽ được thực hiện theo kiểu element-wise,
tức lấy từng cặp phần tử tương ứng của hai mảng để tính toán rồi lấy kết quả. Ví dụ:

import numpy as np
A = np.array([1, 2, 3])
B = np.array([4, 5, 6])
print(A*B) #hiển thị [4 10 18]
print(A**B) #hiển thị [1 32 729]
c. Các hàm toán học trong numpy

np.abs, np.log, np.exp, np.sin, np.cos, np.tan: Cũng được áp dụng lên từng phần
tử của mảng.

Để tìm giá trị lớn nhất hay nhỏ nhất của mảng một chiều, chúng ta sử dụng hàm
np.min hoặc np.max.

Để tìm chỉ số mà tại đó mảng một chiều đạt giá trị nhỏ nhất hay lớn nhất, ta có
thể sử dụng np.argmin hoặc np.argmax.

6.4.4. Tích vô hướng của hai vector

Tích vô hướng của hai vectors a và b có cùng số phần tử được định nghĩa như
sau: np.sum(a*b) hoặc np.dot(a,b), tức lấy a nhân với b theo từng cặp phần tử (element
– wise) rồi tính tổng các phần tử.

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

121
print(np.sum(a*b)) # 32
print(np.dot(a,b)) # 32

6.5. Mảng nhiều chiều

Trong numpy, người ta thường dùng mảng numpy hai chiều để thể hiện một ma
trận. Mảng hai chiều có thể coi là một mảng của các mảng một chiều. Trong đó, mỗi
mảng nhỏ một chiều tương ứng với một hàng của ma trận. Nói cách khác, ma trận có
thể được coi là mảng của các vector hàng – mỗi vector hàng được biểu diễn bằng một
mảng numpy một chiều.

6.5.1. Khởi tạo ma trận

Python không có kiểu xây dựng riêng dành cho ma trận, vậy nên chúng ta có thể
biểu diễn ma trận dưới dạng một list lồng nhau.

A = [[1, 4, 5, 12],
[-5, 8, 9, 0],
[-6, 7, 11, 19]]
print("A =", A)
print("A[1] =", A[1]) # Hàng thứ 2 của ma trận
print("A[1][2] =", A[1][2]) # Phần tử thứ 3 của hàng thứ
2
print("A[0][-1] =", A[0][-1]) # Phần tử cuối cùng của
hàng 1
column = [];
for row in A:
column.append(row[1])
print("Cột thứ 2 =", column)
Chạy chương trình, output được trả về là:

A = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]

A[1] = [-5, 8, 9, 0]
A[1][2] = 9
A[0][-1] = 12
Cột thứ 2 = [4, 8, 7]
Tuy nhiên, list lồng nhau chỉ dùng để biểu diễn ma trận thường dùng các tính
toán đơn giản. Tương tự như cách tạo mảng một chiều ta cũng có thể sử dụng thư viện
numpy để tạo ma trận.

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6]])

122
print(A) #hiển thị [[1 2 3]
[4 5 6]]
a. Tạo các ma trận đặc biệt

Tạo ma trận đơn vị (ma trận đơn vị là một ma trận vuông có tất cả các phần tử
trên đường chéo bằng 1), sử dụng hàm np.eys(N, M=None, k=0, dtype=<type
'float'>)

import numpy as np
print(np.eye(4))
"""Hiển thị:
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
"""
Để tạo một ma trận đường chéo, hoặc muốn trích xuất đường chéo của một ma
trận, ta dùng hàm np.diag()

import numpy as np
B=np.diag([1,2,3])
print(B)
"""Hiển thị:
[[1 0 0]
[0 2 0]
[0 0 3]]
"""
print(np.diag(B)) # hiển thị [1 2 3]
Nếu đầu vào là mảng một chiều, trả về mảng hai chiều thể hiện ma trận có đường
chéo là các phần tử thuộc mảng đầu vào.

Nếu đầu vào là một mảng hai chiều (có thể không vuông), trả về mảng một chiều
chứa các giá trị ở hàng i, cột thứ i với 0<=i<=min(m,n). Trong đó m, n lần lượt là số
hàng và số cột của ma trận được biểu diễn bằng mảng hai chiều ban đầu.

Đường chéo phụ của một ma trận cũng có thể được lấy bằng cách sử dụng hàm
này và chỉ ra giá trị của k:

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7,8,9]])
print(np.diag(A,k=1))
Tương tự như mảng một chiều, để tìm kích thước của mảng hai chiều, ta cũng sử

123
dụng thuộc tính shape.

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])
print(A.shape) # (3,3)

6.5.2. Truy cập vào các phần tử của ma trận

a. Truy cập vào từng phần tử

Để truy cập vào phần tử ở hàng thứ i, cột thứ j của ma trận (chỉ số bắt đầu từ 0),
ta có thể coi phần tử đó là phần tử thứ j của mảng i trong mảng hai chiều ban đầu.

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])
print(A[0][1]) # 2
Ở đây, A[0] chính là mảng một chiều [1 2 3], trong mảng này, ta lấy phần tử có
chỉ số là 1, phần tử đó có giá trị là 2. Vậy A[0][1]=2.

b. Truy cập vào nhiều phần tử của ma trận

Để truy cập vào hàng có chỉ số i của ma trận A, ta chỉ cần dùng A[i] hoặc A[i,:]
hoặc A[i][:]. Để truy cập vào cột có chỉ số j, ta dùng A[:,j].

Nhiều phần tử trong cùng một hàng: Việc truy cập vào nhiều phần tử trong một
hàng tương tự như với mảng một chiều. Ví dụ:

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])
print(A[0,1:]) #hiển thị [2 3]
print(A[1][:]) #hiển thị [4 5 6]
Nhiều phần tử trong cùng một cột:

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])
print(A[[0,1],-1]) #hiển thị [3 6]
Nhiều hàng, nhiều cột: Nếu muốn trích một ma trận con từ ma trận ban đầu, giả
sử lấy ma trận được tạo bởi hàng có chỉ số 0 và 2, cột có chỉ số 1 và 2, ta làm như sau:

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])
print(A[[0,2],[1,2]]) #hiển thị [2 9]

6.5.3. Các phép toán trên ma trận

124
a. Các hàm np.sum, np.min, np.max, np.mean, np.abs, np.sin, np.exp,…

Cách quy ước axis của ma trận: axis = 0 là tính theo chiều từ trên xuống
dưới, nghĩa là phương của nó cùng với phương của các cột. Tương tự axis = 1 sẽ
có phương cùng với phương của các hàng. Hãy quan sát hình dưới đây và ghi nhớ cách
quy ước quan trọng này.

Hình 6-1.

Xét ma trận A:

1 2 3
A=  4 5 6 
7 8 9 

Và các hàm trên tác động lên A theo axis=0 (tức các cột của A). Ví dụ:

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])
print(A)
print(np.sum(A,axis=0)) # [12 15 18]
print(np.min(A,axis=0)) # [1 2 3]
print(np.max(A,axis=0)) # [7 8 9]
print(np.mean(A,axis=0)) # [4. 5. 6.]
Các giá trị theo các hàm trên lần lượt là tổng, giá trị nhỏ nhất, giá trị lớn nhất,
trung bình cộng theo mỗi cột. Kết quả trả về là các mảng một chiều có số phần tử bằng
số cột của A.

Tương tự như thế, ví dụ sau thay axis = 1 sẽ tính trên các hàng.

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6],[7, 8, 9]])
print(A)
print(np.sum(A,axis=1)) #[ 6 15 24]
print(np.min(A,axis=1)) #[1 4 7]

125
print(np.max(A,axis=1)) #[3 6 9]
print(np.mean(A,axis=1)) #[2. 5. 8.]
Kết quả trả về cũng là các mảng một chiều có số phần tử bằng với số hàng của A.
Khi không đề cập tới axis, kết quả được tính trên toàn bộ ma trận.

b. Tính toán giữa ma trận và một số vô hướng:

Các phần tử của ma trận sẽ được kết hợp với số vô hướng bằng các phép toán
tương ứng để tạo ra một ma trận mới cùng kích thước. Điều này tương tự như tính toán
giữa mảng một chiều và một số vô hướng, đúng với các mảng numpy với số chiều bất
kỳ.

6.5.4. Các phép toán giữa hai ma trận

Các phép toán cộng, trừ, nhân, chia, luỹ thừa (+, -, *, /, **) giữa hai ma trận cùng
kích thước cũng được thực hiện dựa trên từng cặp phần tử. Kết quả trả về là một ma
trận cùng kích thước với hai ma trận đã cho.

Ví dụ sau thực hiện phép toán A*B

import numpy as np
A = np.array([[1, 3, 5],[7, 9, 11]])
B = np.array([[0, 2, 4],[6, 8 ,10]])
print(A*B)
# Hiển thị
#[[ 0 6 20]
# [ 42 72 110]]
Chú ý: Cách viết A*B được thực hiện trên từng cặp phần tử của A và B.

6.5.5. Các phép toán giữa ma trận và vector

Tương tự các phép toán giữa hai ma trận cùng kích thước, các phép toán giữa
một ma trận và vector cũng bao gồm +,-,*,/,**. Ví dụ: Thực hiện phép cộng và nhân
ma trận A cho vector b như sau:

import numpy as np
A=np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
b=np.array([1,2,3])
print(A+b)
#hiển thị kết quả
#[[ 1 3 5]

126
# [ 4 6 8]
# [ 7 9 11]]
print(A*b)
#hiển thị kết quả
#[[ 0 2 6]
# [ 3 8 15]
# [ 6 14 24]]
Kết quả của phép toán A+b thu được bằng cách lấy từng hàng của A cộng với b.
Kết quả của A*b thu được bằng cách lấy từng cột của A nhân với phần tử tương ứng
của b. Quy luật tương tự xảy ra với cả phép -, / và **.

6.5.6. Tích giữa hai ma trận, tích giữa ma trận và vector

a. Tích giữa hai ma trận

Trong đại số tuyến tính, tích của hai ma trận A  R mxn và B  R nxp được ký hiệu là
C  AB  R mxp trong đó phần tử ở hàng thứ i cột thứ j (tính từ 0) của C được tính theo
công thức:

n 1
cij   aik bkj
k 0

Chú ý rằng để phép nhân thực hiện được, số cột của ma trận thứ nhất phải bằng
với số hàng của ma trận thứ hai (ở đây đều bằng n).

Cho ma trận A, B, trong đó A.shape[1] == B.shape[0]. Tích của hai ma trận có

thể được thực hiện bằng thuộc tính .dot hoặc hàm np.dot.

import numpy as np
A=np.array([[1, 2, 1], [2, 0, 1]]) #ma trận A có kích
thước 2x3
B=np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) #ma trận B
có kích thước 3x3
C = A.dot(B) #hoặc C = np.dot(A,B)
print(C) # ma trận C có kích thước 2x3
#hiển thị kết quả:
#[[12 16 20]
# [ 6 9 12]]
b. Tích giữa một ma trận và một vector

Trong ĐSTT, tích giữa một ma trận và một vector được coi là một trường hợp
đặc biệt của tích giữa một ma trận và một ma trận có số cột bằng một. Xem ví dụ dưới

127
đây:

import numpy as np
A=np.array([[1, 2, 1], [2, 0, 1]]) #ma trận A có kích
thước 2x3
b=np.array([0, 1, 2]) #vector b
C = A.dot(b) #hoặc C = np.dot(A,b)
print(C) # hiển thị [4 2]
D = b.dot(A)
print(D)
""" hiển thị
raceback (most recent call last):
File
"C:/Users/FPTShop/PycharmProjects/Hello/xinh/demo.py",
line 6, in <module>
D = b.dot(A)
ValueError: shapes (3,) and (2,3) not aligned: 3 (dim 0)
!= 2 (dim 0)
"""
Nếu đặt b lên trước A thì có lỗi xảy ra vì xung đột chiều. Tuy nhiên nếu mảng
một chiều b có kích thước bằng 2 thì lại có thể nhân với mảng hai chiều A được.

import numpy as np
A=np.array([[1, 2, 1], [2, 0, 1]])
b=np.array([1, 2]) #vector b
C = b.dot(A)
print(C) # hiển thị kết quả [5, 2, 3]

6.5.7. Chuyển vị ma trận

Ma trận chuyển vị của ma trận A được định nghĩa như sau: Nếu A là một ma trận
có kích thước m x n với các giá trị aij tại hàng i, cột j thì ma trận chuyển vị B = AT là
ma trận có kích thước n x m với các giá trị: bij = aji

Ví dụ:

T 1 4 
1 2 3   
 4 5 6   2 5 
  3 6 

Có hai cách để lấy chuyển vị của một ma trận: dùng phương thức (.T) hoặc dùng
hàm np.transpose()

import numpy as np
A = np.array([[1, 2, 3],[4, 5, 6]])

128
B = A.T # hoặc B = np.transpose(A)
print(B)

6.5.8. Reshape ma trận

Khi làm việc với ma trận, chúng ta sẽ phải thường xuyên làm việc với các phép
biến đổi kích thước của ma trận. Phép biến đổi kích thước có thể coi là việc sắp xếp lại
các phần tử của một ma trận vào một ma trận khác có tổng số phần tử như nhau.

Trong numpy, để làm được việc này chúng ta dùng phương thức (.reshape) hoặc
hàm np.reshape.

import numpy as np
A = np.array([[1, 2],[3, 4], [5, 6]])
print(np.reshape(A,(2, 3))) #hoặc print(A.reshape(2,3))
#hiển thị
#[[1 2 3]
# [4 5 6]]
Số chiều của mảng mới không nhất thiết phải bằng 2, nó có thể bằng bất kỳ giá
trị nào (lớn hơn hoặc bằng 1) nhưng phải đảm bảo tổng số phần tử của hai mảng là như
nhau.

import numpy as np
A = np.array([[1, 2],[3, 4], [5, 6]])
print(np.reshape(A,6)) #mảng 1 chiều
print(A.reshape(3,1,2)) #mảng 3 chiều
Có thể nhận thấy rằng nếu chuyển thành một mảng hai chiều mới, không nhất
thiết phải biết kích thước của mỗi chiều mà chỉ cần kích thước của một chiều. Kích
thước còn lại được suy ra từ việc tổng số phần tử của hai mảng là như nhau. Tương tự,
nếu chuyển thành một mảng ba chiều mới, ta chỉ cần biết hai trong ba kích thước. Kích
thước còn lại sẽ được python tự tính ra, và ta chỉ cần gán nó bằng -1.

import numpy as np
A = np.array([[1, 2],[3, 4], [5, 6]])
print(A.reshape(-1))
print(A.reshape(6,-1))
print(A.reshape(2,1,-1))
a. Thứ tự của phép toán reshape

Các phần tử trong mảng mới được sắp xếp như thế nào? Có hai cách sắp xếp
chúng ta cần lưu ý: mặc định là „C‟-order và một cách khác là „F‟-order.

129
 Trong „C‟ – oder, các thành phần của mảng nguồn được quét từ axis trong ra
ngoài (axis = 1 rồi mới tức axis = 0, tức từng hàng một), sau đó chúng được xếp vào
mảng đích cũng theo thứ tự đó.

Trong „F‟ – oder, các thành phần của mảng nguồn được quét từ axis ngoài vào
trong (từng cột một), sau đó chúng được sắp xếp vào mảng đích cũng theo thứ đó.

Ví dụ: Reshape ma trận A theo cách “F‟ – order.

import numpy as np
A = np.array([[1, 2],[3, 4], [5, 6]])
print(A.reshape(2, 3, order= 'F'))
# hiển thị:
#[[1 5 4]
# [3 2 6]]

6.6. Bài tập

Bài 6-1. Cho trước 1 danh sách với các phần tử, viết hàm theo yêu cầu:

Xóa 1 phần tử theo vị trí bất kỳ (đầu danh sách, cuối danh sách, giữa danh sách).

Xóa các phần tử theo vị trí bắt đầu và kết thúc.

Thêm mới 1 phần tử theo vị trí bất kỳ (đầu danh sách, cuối danh sách, giữa danh
sách)

Thêm các phần tử theo vị trí bắt đầu và vị trí kết thúc chèn.

Xóa 1 phần tử đầu và cuối của danh sách.

Bài 6-2. Viết chương trình chấp nhận một chuỗi số, phân tách bằng dấu phẩy từ giao
diện điều khiển, tạo ra một danh sách và một tuple chứa mọi số.

Ví dụ: Đầu vào được cung cấp là 34,67,55,33,12,98 thì đầu ra là:

['34', '67', '55', '33', '12', '98']

('34', '67', '55', '33', '12', '98')

Bài 6-3. Với số nguyên n nhất định, hãy viết chương trình để tạo ra một dictionary
chứa (i, i*i) như là số nguyên từ 1 đến n (bao gồm cả 1 và n) sau đó in ra dictionary
này. Ví dụ: Giả sử số n là 8 thì đầu ra sẽ là: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49,
8: 64}.

130
Bài 6-4. Viết một chương trình chấp nhận đầu vào là một câu, đếm chữ hoa, chữ
thường.

Giả sử đầu vào là: Learning with Python

Thì đầu ra là: Chữ hoa: 2, Chữ thường: 16

Bài 6-5. Viết một chương trình để in ra tuple chứa các số chẵn được lấy từ tuple
(1,2,3,4,5,6,7,8,9,10).

Bài 6-6. Viết chương trình tạo và in ra tuple chứa các giá trị bình phương của các số từ
1 đến n. Số nguyên dương n được nhập từ bàn phím.

Bài 6-7. Viết chương trình phân tích số nguyên n thành các thừa số nguyên tố. Ví dụ:
50=2x5x5. (Đưa các thừa số nguyên tố phân tích được vào trong list)

Bài 6-8. Viết chương trình tính tần suất các từ được nhập từ bàn phím. Kết quả được
xuất ra sau khi đã sắp xếp theo bảng chữ cái. Giả sử:

Đầu vào: The more danger, the more honor

Đầu ra: The:1 danger:1 honor:1 more:2 the:1

Bài 6-9. Viết chương trình nhập một chuỗi phân tách nhau bởi dấu phẩy và in từng từ
trong chuỗi theo thứ tự bảng chữ cái, phân tách nhau bằng dấu phẩy. Ví dụ:

Đầu vào: mary, peter, alice, jack

Đầu ra: alice, jack, mary, peter

Bài 6-10. Viết chương trình chấp nhận đầu vào là chuỗi các số nhị phân, phân tách
nhau bởi dấu phẩy, kiểm tra xem chúng có chia hết cho 5 không. Sau đó in các số chia
hết cho 5 thành dãy phân tách bởi dấu phẩy.

Ví dụ: Đầu vào: Nhập các số nhị phân: 1011,101,0110,010100,1001

Đầu ra: 101,010100

Bài 6-11. Cho trước một số tự nhiên n. Tạo một mảng có n phần tử mà các phần tử có
chỉ số chẵn (bắt đầu từ 0) là một cấp số cộng bắt đầu từ 2, công sai bằng -0.5; các phần
tử có chỉ số lẻ bằng -1.

Ví dụ: Với n=4, kết quả trả về là mảng [ 2. -1. 1.5 -1. ]. Với n=5, kết

131
quả trả về là mảng [ 2. -1. 1.5 -1. 1. ].

Bài 6-12. Cho mảng một chiều A bất kì, hiển thị lên màn hình các yêu cầu sau:

Đếm các số chính phương có trong mảng

Đếm số lượng số nguyên tố có trong mảng

Tính tổng và trung bình cộng các phần tử trong mảng

Sắp xếp mảng theo thứ tự giảm dần.

Bài 6-13. Cho ma trận A bất kỳ:

Viết hàm tính tổng các phần tử trên các cột có chỉ số chẵn của ma trận A

Viết hàm tính tổng các phần tử có cả chỉ số cột và hàng đều chẵn.

Trong mỗi hàng, ta định nghĩa độ biến động của nó là sự khác nhau giữa giá trị
lớn nhất và nhỏ nhất của các phần tử trong hàng đó. Viết hàm trả về độ biến động của
tất cả các hàng trong ma trận.

Bài 6-14. Hãy tạo ma trận A sau một cách nhanh nhất, không dùng cách thủ công ghi
từng phần tử.

1 5 9 2
 6 10 3 7 
 
11 4 8 12 
 
 
Gợi ý: Sử dụng np.arange(); Tìm quy luật của ma trận rồi dùng các phép
transpose, reshape thích hợp.

Bài 6-15. Frobenius norm của một ma trận được định nghĩa là căn bậc hai của tổng
bình phương các phần tử của ma trận. Frobenius norm của một ma trận A được kí hiệu
là A F .

A F
 A
i, j
2
ij

Viết hàm tính Frobenius norm của một ma trận bất kỳ.

132