TRƯỜNG THPT VĨNH ĐỊNH

Giáo viên : Lê Thanh Phú

Bộ môn : Tin học

Quảng Trị, tháng 01 năm 2022

PYTHON CƠ BẢN

MỤC LỤC
CHỦ ĐỀ 1: LÀM QUEN PYTHON ............................................................................................................3
CHỦ ĐỀ 2: CHƯƠNG TRÌNH GIẢI BÀI TOÁN ĐƠN GIẢN .......................................................................5
CHỦ ĐỀ 3: CÂU LỆNH RẼ NHÁNH .......................................................................................................10
CHỦ ĐỀ 4 – CÂU LỆNH LẶP .................................................................................................................12
CHỦ ĐỀ 5: KIỂU DANH SÁCH – LIST ....................................................................................................14
CHỦ ĐỀ 5: KIỂU DỮ LIỆU XÂU.............................................................................................................17
CHỦ ĐỀ 6: KIỂU DỮ LIỆU TỆP..............................................................................................................21
CHỦ ĐỀ 7: CHƯƠNG TRÌNH CON ........................................................................................................23
CHỦ ĐỀ 8: MỘT SỐ THỨ CĂN BẢN KHÁC KHI BỒI DƯỠNG HSG ........................................................25
1. Số nguyên tố: ..............................................................................................................................25
2. Ước/ Bội:.....................................................................................................................................25
3. Sắp xếp:.......................................................................................................................................26
4. Tìm kiếm nhị phân: .....................................................................................................................28
5. Heap: ...........................................................................................................................................29
6. Dict – Python: .............................................................................................................................29
7. Set – Python: ...............................................................................................................................30
8. Một số Trick khác:.......................................................................................................................31
CHỦ ĐỀ 9: TĂNG TỐC CHƯƠNG TRÌNH PYTHON ...............................................................................32
CHỦ ĐỀ 10: TẠO TEST VỚI PYTHON ...................................................................................................34
CHỦ ĐỀ 11: CHẤM PYTHON TRONG THEMIS .....................................................................................36

Giáo viên: Lê Thanh Phú 2|Trang

PYTHON CƠ BẢN

CHỦ ĐỀ 1: LÀM QUEN PYTHON

1. Công cụ lập trình:
Có nhiều phần mềm giúp chúng ta viết và chạy chương trình viết bằng Python như:
• Pycharm
• Atom
• Thony
• Vscode
• …
Mỗi phần mềm đều có ưu nhược điểm riêng, cách cài đặt và viết chương trình cũng khác
nhau. Pycharm hỗ trợ code rất tốt tuy nhiên lại quá nặng, khi chạy chiếm tầm 1GB Ram nên máy
tính mà 4GB ram thì rất hay Lag. Atom giao diện đẹp, thư viện tiện ích phong phú tuy nhiên công cụ
debug lại không đáp ứng được để dạy và học phần tìm và sửa lỗi. Thony thì rất nhẹ, khi chạy chiếm
chỉ tầm 40MB bộ nhớ, tuy nhiên tiện ích rất ít và công cụ debug còn quá đơn giản.
Dễ cài đặt, dễ sử dụng, chuyên nghiệp, hỗ trợ tốt khi code, hỗ trợ tốt debug, phù hợp với
chuyên đề F và các kỳ thi HSG theo tôi vẫn là VScode. Khi chạy chiếm tầm 300MB bộ nhớ, tạo một
thư mục và code tất cả bài vào rất tiện lợi. Đặc biệt lên lớp 12 dùng vscode code luôn HTML5 và CSS.
Hiện tại công cụ hỗ trợ lập trình cài đặt đơn giản, được sử dụng chính thức cho các kỳ thi là
Thonny. Nên nếu bạn nào bắt đầu học hoặc tham gia bồi dưỡng HSG thì nên sử dụng Thonny.
2. Tải và cài đặt phần mềm:
a) Cài đặt Thonny cho Window:
• Truy cập trang https://thonny.org/ vào mục Download Version 4.0.1 for Windows và chọn bản
phù hợp với máy tính của bạn:

• Chạy file vừa tải về để cài đặt.

b) Một số tuỳ chọn cho Thonny:
- Chọn giao diện tối để ít nhức mỏi mắt khi code:
• Mở Thonny, vào Tools chọn Option, chọn Theme & Font
• UI Theme: Chọn Clean Dark
• Syntax: Chọn Tomorrow Night
- Gợi ý code và tự động hoàn thiện code khi gõ:
• Mở Thonny, vào Tools chọn Option, chọn Editor
• Tick chọn vào hai mục sau:
o Automatically show parameter infor after typing ‘(‘
o Automatically propose completions while typing

Giáo viên: Lê Thanh Phú 3|Trang

PYTHON CƠ BẢN

3. Chương trình Python đầu tiên

• Mở Thonny, gõ chương trình sau để thử:

• Lưu lại với tên: Vidu.py

• Nhấn F5 để chạy chương trình. Kết quả thực hiện chương trình sẽ được hiển thị ở khung
Shell ngay bên dưới.

Giáo viên: Lê Thanh Phú 4|Trang

PYTHON CƠ BẢN

CHỦ ĐỀ 2: CHƯƠNG TRÌNH GIẢI BÀI TOÁN ĐƠN GIẢN

1. Ví dụ:
Sau đây là chương trình đơn giản giải bài toán tính và thông báo diện tích hình tròn:
Chương trình Giải thích

Khai báo thư viện toán học

Nhập bán kính vào từ bàn phím

Tính diện tích hình tròn
Thông báo kết quả diện tích

2. Các phần cụ thể:

a) Phần khai báo thư viện:
Qua ví dụ trên ta thấy phần đầu tiên và rất quan trọng trong lập trình là khai báo thư viện.
Việc khai báo thư viện giúp ta khai thác được các chương trình có sẵn trong thư viện. Hiện Python
có hệ thống thư viện khổng lồ về rất nhiều lĩnh vực.
Sau đây xin giới thiệu đến các bạn thư viện math, chứa rất nhiều modul sử dụng cho các tác
vụ toán học. Một số hàm toán học tiêu biểu:
Hàm Công dụng
math.pi Hằng số pi = 3.141592653589793
math.sqrt(x) Trả về số thực là căn bậc hai của số thực dương x. Nếu ta gọi hàm này
với số âm sẽ báo lỗi
math.trunc(x) Trả về phần nguyên của số thực x. Ví dụ: math.trunc(5.6) = 5
math.floor(x) Làm tròn xuống số nguyên gần nhất. Ví dụ: math.floor(5.9) = 5
math.ceil(x) Làm tròn lên số nguyên gần nhất. Ví dụ: math.ceil(5.3) = 6
math.fabs(x) Trả về giá trị tuyệt đối của số x.
math.gcd(x, y) Trả về ước chung lớn nhất của hai số nguyên x và y.
math.pow(x, y) Trả về số thực là giá trị xy. Hàm này có sai số khá lớn nên hạn chế sử
dụng. Nếu muốn tính xy của hai số nguyên thì nên dùng: x**y
math.sin(x) Trả về giá trị lượng giác sin(x)
math.cos(x) Trả về giá trị lượng giác cos(x)
math.tan(x) Trả về giá trị lượng giác tan(x)
math.asin(x) Trả về số đo U của góc có sin(U) = x.
Dùng khi muốn tìm số đo góc. Lưu ý đơn vị là radian.
math.degrees(x) Đổi đơn vị x radian sang độ. Ví dụ: math.degrees(math.pi) = 180 độ.
math.radians(x) Đổi đơn vị x độ sang radian. Ví dụ: math.radians(180) = 3.14159…
math.log2(x) Trả về logarit cơ số 2 của x.
math.log10(x) Trả về logarit cơ số 10 của x.
math.comb(n, k) Trả về C(k,n) là tổ hợp chập k của n. Có thể dùng để đếm số cách chọn
ra k vật trong n vật. Ví dụ: math.comb(7, 5) = 21
… …
Còn rất nhiều thư viện hữu ích khác, các bạn sẽ lần lượt tìm hiểu theo quá trình học.

Giáo viên: Lê Thanh Phú 5|Trang

PYTHON CƠ BẢN

b) Phần xử lý chính:
Phần xử lý của bài toán tính toán đơn giản thông thường có ba bước như trong ví dụ trên.
• Nhập thông tin cần thiết vào cho máy tính
• Tính toán giải quyết bài toán
• Thông báo kết quả của bài
Phần Nội dung cơ bản
- Để nhập thông tin vào từ bàn phím Python hỗ trợ cho ta hàm input()
- Hàm input() mặc định trả về một chuỗi kí tự được nhập vào từ bàn phím. Sau đây
là một số ví dụ:
Thao tác nhập Lệnh Python
Một chuỗi kí tự hoten = input()
một số nguyên x = int(input())
- Lệnh trên dùng hàm int() để chuyển xâu số
nguyên được nhập vào bởi hàm input() thành số
một số thực x = float(input())
Nhập
hai số nguyên trên hai x = int(input())
thông tin
dòng y = int(input())
Hai số nguyên cách nhau x,y = map(int, input().split())
dấu cách Trong lệnh trên:
input().split() sẽ tách chuỗi nhập thành hai
xâu số nguyên dựa vào dấu cách.
map(int, ..) sẽ chuyển hai xâu số thành 2 số
Hai số thực cách nhau dấu x,y = map(float, input().split())
cách
Ba số nguyên x,y,z = map(int, input().split())
- Python cung cấp lệnh gán để tính toán: tên biến = biểu thức
- Ví dụ tính diện tích hình chữ nhật: s = a*b
- Để viết được các biểu thức tính toán, Python cung cấp một số loại phép toán:
1. Phép toán số học: Các ví dụ dưới đây thì ta coi a = 5 và b = 7.
Phép
Mô Tả Ví Dụ
toán

+ Phép toán cộng các giá trị lại với nhau a + b = 12

Tính toán - Phép toán trừ các giá trị lại với nhau a - b = -2

* Phép toán nhân các giá trị lại với nhau a * b = 42

/ Phép toán chia cho ra số thực a / b = 0.71428…

// Phép toán chia lấy phần nguyên a // b = 0

% Phép toán chia lấy phần dư a%b=5

** Phép toán mũ. a**b = ab a ** b = 78125

Giáo viên: Lê Thanh Phú 6|Trang

PYTHON CƠ BẢN

2, Phép toán Quan hệ.

Dạng phép toán này dùng để so sánh các giá trị với nhau kết quả của nó sẽ trả
về là True nếu đúng và False nếu sai. Và nó thường được dùng trong các câu lệnh điều
kiện.
Trong Python thì nó cũng tồn tại 6 dạng phép toán quan hệ cơ bản như sau:
(trong các ví dụ dưới đây thì ta coi a có giá trị là 5 và b có giá trị là 7).
Phép
Chú Thích Ví Dụ
toán

So sánh giá trị của các đối số xem có bằng nhau

== hay không.Nếu bằng nhau thì kết quả trả về sẽ a == b // False
là True và ngược lại sẽ là False.

So sánh giá trị của các đối số xem có khác nhau

hay không.
!= a != b //True
Nếu khác nhau thì kết quả trả về sẽ là True và
ngược lại sẽ là False.

Dấu < đại diện cho phép toán nhỏ hơn, nếu đối
< số 1 nhỏ hơn đối số 2 thì kết quả sẽ trả về là True a < b //True
và ngược lại sẽ là False.

Dấu > đại diện cho phép toán lớn hơn, nếu đối số
> 1 lớn hơn đối số 2 thì kết quả sẽ trả về là True và a > b //False
ngược lại sẽ là False.

Dấu > đại diện cho phép toán nhỏ hơn hoặc bằng,
<= nếu đối số 1 nhỏ hơn hoặc bằng đối số 2 thì kết a <= b //True
quả sẽ trả về là True và ngược lại sẽ là False.

Dấu > đại diện cho phép toán lớn hơn hoặc bằng,
>= nếu đối số 1 lớn hơn hoặc bằng đối số 2 thì kết a>= b //False
quả sẽ trả về là True và ngược lại sẽ là False.
3, Phép toán gán.
Phép toán gán là phép toán dùng đế gán giá trị của một đối tượng cho một đối tượng
khác. Và trong Python thì nó cũng được thể hiện giống như các ngôn ngữ khác. Và
dưới đây là 8 phép toán nằm trong dạng này mà Python hỗ trợ.
Phép
Chú Thích Ví Dụ
toán

Phép toán này dùng để gán giá

c = a (lúc này c sẽ có giá trị =
= trị của một đối tượng cho một
5)
giá trị

Phép toán này cộng rồi gắn giá

+= c += a (giống với c = c + a)
trị cho đối tượng

Phép toán này trừ rồi gắn giá trị

-= c -= a (giống với c = c - a)
cho đối tượng

Giáo viên: Lê Thanh Phú 7|Trang

PYTHON CƠ BẢN

Phép toán này trừ rồi gắn giá trị

*= c *= a (giống với c = c * a)
cho đối tượng

Phép toán này chia rồi gắn giá trị

/= c /= a (giống với c = c / a)
cho đối tượng

Phép toán này chia hết rồi gắn

% c %= a (giống với c = c % a)
giá trị cho đối tượng

Phép toán này lũy thừa rồi gắn

**= c **= a (giống với c = c ** a)
giá trị cho đối tượng

Phép toán này chia làm tròn rồi

//= c //= a (giống với c = c // a)
gắn giá trị cho đối tượng
4, Phép toán logic.
Phép toán logic trong Python hoàn toàn giống như các ngôn ngữ khác. Nó gồm
có 3 kiểu cơ bản như sau:
Phép
Chú Thích
toán

Nếu 2 vế của phép toán này đều là True thì kết quả sẽ là True và
and
ngược lại nếu 1 trong 2 vế là False thì kết quả trả về sẽ là False.

Nếu 1 trong 2 vế là True thì kết quả trả về sẽ là True và ngược lại
or
nếu cả 2 vế là False thì kết quả trả về sẽ là False.

Đây là dạng phủ định, nếu biểu thức là True thì nó sẽ trả về là False
not
và ngược lại.
5, Phép toán bitwise.
Phép toán này thực hiện trên các bit của các giá trị. Hãy tưởng tượng mình có
2 biến a = 12 và b = 15 nhưng nếu chúng ta convert chúng sang hệ nhị phân thì 2 biến
này sẽ có giá trị như sau: a = 00001100 và b = 00001111.
Phép toán Ví Dụ

& (a & b) = 12 (00001100)

| (a | b) = 14 (00001111)

^ (a ^ b) = 3 (00000011)

~ (-a) = -13 (00001101)

<< a<<a = 49152

>> a>>a = 0
6, Phép toán khai thác.
Phép toán này thường được dùng để kiểm tra xem 1 đối số có nằm trong 1 tập
hợp đối số hay không (list). Trong Python hỗ trợ chúng ta 2 dạng phép toán như sau:
Giả sử: a = 4, b = [1,5,7,6,9]

Giáo viên: Lê Thanh Phú 8|Trang

PYTHON CƠ BẢN

Phép
Chú Thích Ví Dụ
toán

Nếu 1 đối số thuộc một tập đối số nó sẽ trả

in a in b //False
về True và ngược lại/

Nếu 1 đối số không thuộc một tập đối số nó

not in a not in b //True
sẽ trả về True và ngược lại/
- Để in thông tin Python cung cấp lệnh print()
- Lệnh này cho phép in một hoặc nhiều giá trị ra màn hình. Các giá trị trong một lệnh
in sẽ được in cách nhau một dấu cách.
- Một số ví dụ:
Lệnh in Ý nghĩa
print(12) in số 12 ra màn hình
print(15, “hoà bình”) in số 15 và chuỗi kí tự “hoà bình”
kết quả trên màn hình: 15 hoà bình
print(“số chẵn:”, 2) số chẵn: 2
Thông báo
print(format(s, ‘.3f’)) in kết quả s ra màn hình, làm tròn 3 chữ số
kết quả
thập phân
print(‘chào’ + ‘bạn’) chàobạn
print(‘chào’, ‘bạn’) chào bạn
print(‘chào’, end = ‘ ‘) - end = ‘ ‘ là để in xong nhưng không xuống
print(‘bạn’)
dòng mà chỉ in thêm một dấu cách
- kết quả: chào bạn
print(‘chào’) in ra hai dòng:
print(‘bạn’) chào
bạn
3. Ví dụ:
- VD1: Chương trình nhập vào hai cạnh hình chữ nhập cách nhau dấu cách và tính diện tích
a, b = map(int, input().split())
s = a*b
print(s)
- VD2: Chương trình nhập vào bán kính, tính và thông báo diện tích hình tròn. Kết quả làm tròn 5
chữ số thập phân:
import math
r = int(input())
s = math.pi * r * r
print(format(s, '.5f'))

Giáo viên: Lê Thanh Phú 9|Trang

PYTHON CƠ BẢN

CHỦ ĐỀ 3: CÂU LỆNH RẼ NHÁNH

1. Câu lệnh if – else
- Cú pháp cơ bản:
if điều kiện:
câu lệnh 1
else:
câu lệnh 2
- Nếu điều kiện đúng thì thực hiện câu lệnh 1 còn không sẽ thực hiện câu lệnh 2.
- Trường hợp sau: Nếu điều kiện đúng thì thực hiện hai câu lệnh. Python sử dụng thụt lề để xác định
lệnh cùng khối với nhau. Nên lệnh 1 và lệnh 2 phải cùng thụt lề như nhau.
if điều kiện:
lệnh 1
lệnh 2
- Trường hợp sau điều kiện đúng chỉ thực hiện câu lệnh 1 do hai lệnh này không cùng khối lệnh:
if điều kiện:
lệnh 1
lệnh 2
- Lệnh sau sẽ báo lỗi IndentationError do cấp độ thụt lề không xác định
if điều kiện:
lệnh 1
lệnh 2
2. Một số ví dụ:
Ví dụ Ý nghĩa, kết quả
a = 33 b lớn hơn a
b = 45
if b > a:
print("b lớn hơn a")
a,b = 68, 33 a = 68 và b = 33 nên sẽ in ra:
if b > a:
print("b lớn hơn a") b không lớn hơn a
else:
print("b không lớn hơn a")
a = 200 Sử dụng elif để kiểm tra điều kiện
b = 33
if b > a:
print("b lớn hơn a")
elif a == b:
print("b bằng a")
else:
print("b bé hơn a")
a = 34 Lệnh in kết hợp if then để kiểm tra
b = 68
print("A") if a > b else print("B")
if a > b and c > a: Biểu thức điều kiện với phép toán và
print("Thử hai điều kiện")
if a > b or a > c: Biểu thức điều kiện với phép toán hoặc
print("Chỉ cần một trong hai đúng")
if x > 10: Sử dụng if lồng nhau
print("Lớn hơn 10,")
if x > 20:
print("và lớn hơn 20!")

Giáo viên: Lê Thanh Phú 10 | T r a n g

PYTHON CƠ BẢN
else:
print("Nhưng không lớn hơn 20.")
a, b = 33, 45 Lệnh in thứ hai cùng khối với lệnh if
if b > a:
print("b lớn hơn a") nên sau khi thực hiện xong lệnh if sẽ
print("Chào bạn") thực hiện lệnh print(“Chào bạn)
a = int(input()) - Nhập số nguyên a vào từ bàn phím
if a >= 0:
if a == 0: - Sử dụng if lồng nhau để kiểm tra
print("Zero") thuộc loại số nào.
else:
print("Số dương")
else:
print("Số âm")
a = int(input()) Tương đương ví dụ trên
if a == 0:
print("Zero")
elif a > 0:
print("Số dương")
else:
print("Số âm")

Giáo viên: Lê Thanh Phú 11 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 4 – CÂU LỆNH LẶP

1. Lặp với số lần biết trước:
- Khác với C++ hay Pascal, Python xác định lặp lại lần lượt từng đối tượng của một danh sách theo
thứ tự của chúng trong danh sách.
for x in danhsach:
Lệnh xử lý
- Python 3 cung cấp hàm range() để tạo ra danh sách các số nằm trong một phạm vi:
• range(u, v) sẽ tạo ra một danh sách các số từ u đến v-1
• range(u, v, w) sẽ tạo ra một danh sách các số từ u đến v-1, số sau cách số trước w đơn
vị
- Một số ví dụ về lệnh lặp for:
Ví dụ Ý nghĩa, kết quả
for x in [0, 1, 2]: - Lặp lại 3 lần
print(x) - x lần lượt nhận giá trị 0, 1, 2.
for x in range(2, 6): - range(2,6) trả về một đoạn gồm các số
print(x)
nguyên từ 2 đến 5.
- x lần lượt nhận giá trị 2, 3, 4, 5
for x in range(2, 10, 2): range(2,10,2) trả về một đoạn gồm các
print(x)
số nguyên [2, 4, 6, 8]
s = 0 - i lần lượt nhận giá trị 7, 6,
for i in range(7, 3, -1): 5, 4 (Lặp lùi)
s += i
print(s)
fruits = ["Táo", "Chuối", "Đào"] x lần lượt nhận giá trị trong một danh sách cho
for x in fruits:
print(x) trước

for x in "banana": Duyệt qua lần lượt các chữ cái của chuỗi
print(x)
“banana”
L = ["a", "b", "c"] Lệnh break giúp dừng vòng lặp sau khi in a và
for x in L:
print(x) b ra màn hình.
if x == "b":
break
L = ["a", "b", "c"] Chỉ in a, không in b. Vì nếu x = ‘b’ thì đã ngắt
for x in L:
if x == "b": vòng lặp
break
print(x)
L = ["a", "b", "c"] Lệnh continue giúp bỏ qua 2 lệnh phía dưới
for x in L:
if x == "b": và chuyển sang lần lặp tiếp theo.
continue Kết quả sẽ in ra a và c
print(x)
s = s + x

2. Lặp với số lần chưa biết trước:

- Cú pháp lệnh while:
While điều kiện:
Khối lệnh lặp
- Ý nghĩa: Khi nào điều kiện còn đúng thì khối lệnh lặp vẫn còn được thực hiện
Giáo viên: Lê Thanh Phú 12 | T r a n g
PYTHON CƠ BẢN

Ví dụ Ý nghĩa, kết quả

i = 1 Sẽ in ra màn hình 5 dòng lần lượt 5 số:
while i < 6: 1
print(i) 2
i += 1 3
4
5
x = 1 - sẽ in ra màn hình 4 số cách nhau dấu cách:
while x <= 10: 1 4 7 10
print(x, end = “ “)
x += 3
i = 1 In ra màn hình ba số 1, 2, 3 trên ba dòng. Vì
while i < 6: khi i = 3 thì đã ngắt vòng lặp
print(i)
if i == 3:
break
i += 1
i = 0 - Chỉ in ra màn hình các số 1, 2, 4, 5, 6.
while i < 6: - Không in số 3 vì khi i = 3 thì thực hiện lệnh
i += 1
continue để bỏ qua các lệnh còn lại cùng khối
if i == 3:
continue lặp
print(i)

Giáo viên: Lê Thanh Phú 13 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 5: KIỂU DANH SÁCH – LIST

1. Khái niệm, khai báo:
- List là một danh sách các phần tử có cùng kiểu hoặc khác kiểu được đánh số. Phần tử đầu tiên
được đánh chỉ số là 0. Mục tiêu dùng một biến duy nhất để lưu nhiều đối tượng.
- Ví dụ: a = [7, 4, 9.8, ‘Chào’, ‘Phú’] dùng một biến a để quản lý và lưu trữ 5 đối tượng. Phần tử đầu
tiên có thể truy cập thông qua chỉ số: a[0] = 7. Phần tử thứ 5: a[4] = ‘Phú’
2. Một số thao tác với List:
Công việc cần thực hiện Lệnh tương ứng
Khởi tạo a là một list trống chưa có phần tử a = []
Khởi tạo list gồm 5 phần tử: a = [0, 0, 0, 0, 0] a = [0]*5
Khởi tạo list gồm 6 phần tử: b = [i for i in range(1,7)]
b = [1, 2, 3, 4, 5, 6]
Nhập vào list gồm các số nguyên cách nhau a = [int(x) for x in input().split()]
dấu cách trên cùng một dòng
Nhập vào list gồm các số nguyên cách nhau a = list(map(int, input().split()))
dấu cách trên cùng một dòng (Cách 2)
a = list(map(float, input().split()))
Nhập một list gồm các số thực trên một dòng
Nhập một list gồm n số nguyên, mỗi số trêna = []
for i in range(n):
một dòng.
a.append(int(input()))
in list a, mỗi phần tử một dòng for x in a:
print(x)
in list a trên một dòng, các phần tử cách for x in a:
print(x, end=' ')
nhau một dấu cách
in list a gồm các số nguyên trên một dòng, print(' '.join(str(x) for x in a))
các phần tử cách nhau một dấu cách (cách 2
nhanh hơn)
in list a gồm các chuỗi kí tự trên một dòng, print(' '.join(x for x in a))
các phần tử cách nhau một dấu cách
Sao chép list a từ phần tử a[2] đến hết b = a[2:]
Sao chép list a từ phần tử a[0] đến phần tử b = a[:4]
a[3]
Sao chép list a từ phần tử a[3] đến a[6] b = a[3:7]
Sao chép list a chỉ lấy a[2], a[4], a[6] b = a[2:7:2]
Số lượng phần tử trong list n = len(a)
Duyệt các phần tử trong list từ đầu đến cuối for x in a:
print(x)
Thêm một phần tử vào list a.append(x)
Thêm phần tử x vào vị trí u a.insert(u, x)
Xoá phần tử cuối cùng khỏi list a.pop()
Xoá phần tử đầu tiên trong list có giá trị là x a.remove(x)
Xoá hết toàn bộ list a.clear()
Đếm có bao nhiêu phần tử có giá trị là x có a.count(x)
mặt trong list
Trả về True nếu x có mặt trong list a x in a
Trả về giá trị phần tử lớn nhất trong list max(a)
Trả về giá trị phần tử nhỏ nhất trong list min(a)
Trả về tổng của List sum(a)

Giáo viên: Lê Thanh Phú 14 | T r a n g

PYTHON CƠ BẢN

Trả về vị trí phần tử nhỏ nhất trong list a.index(min(a))

Đảo ngược toàn bộ list a.reverse()
Sắp xếp list tăng dần a.sort()
Sắp xếp list giảm dần a.sort(reverse=True)

3. Ví dụ minh hoạ:
Bài tập Code minh hoạ
Lập trình nhập vào một số nguyênn = int(input())
a = list(map(int, input().split()))
dương N và dãy số nguyên A gồm N phần tử.
amax = max(a)
Tìm phần tử lớn nhất của dãy số nguyên cùng
print(amax, end=' ')
for i in range(n):
vị trí của nó. (0 < n < 10000; |Ai| < 10^9). Nếu
có nhiều phần tử cùng có giá trị lớn nhất thìif a[i] == amax:
print(i+1)
đáp án là phần tử có vị trí bé nhất. break
Dữ liệu nhập Kết quả Hoặc cách hai như sau:
5 12 2 n = int(input())
a = list(map(int, input().split()))
1 12 -4 -3 12 print(max(a), a.index(max(a)) + 1)
Lập trình nhập vào N và dãy số A n = int(input())
a = [int(x) for x in input().split()]
gồm N phần tử (5 < N < 1000). Em hãy sắp a.sort()
xếp dãy A thành dãy số không giảm và print(*a)
thông báo dãy A ra màn hình sau khi đã sắp
Hoặc cách 2: nhanh hơn ở thao tác in:
xếp.
Dữ liệu nhập Kết quả n = int(input())
a = list(map(int, input().split()))
5 12345 a.sort()
13254 print(' '.join(str(x) for x in a))

4. Mảng hai chiều:

- Ta có thể tạo list mà mỗi phần tử là một list để thành ra tương đương mảng hai chiều
- Sau đây minh hoạ thao tác nhập và in:
m, n = map(int, input().split())
a = [[]*n for i in range(m)]
for x in range(m):
a[x] = list(map(int, input().split()))
#in mảng hai chiều
print(m, n)
for x in range(m):
print(*a[x])
Bài tập Code minh hoạ
Cho mảng hai chiều kích thước NxN (N n = int(input())
dòng và N cột). Lập trình nhập vào mảng a = []
for i in range(n):
này, tìm và thông báo ra màn hình các số u = list(map(int,input().split()))
lớn nhất trên mỗi hàng. (1 < N < 15) a.append(u)
Dữ liệu nhập Kết quả for i in range(n):
print(max(a[i]))
3 3
123 6
456 9
789

Giáo viên: Lê Thanh Phú 15 | T r a n g

PYTHON CƠ BẢN

Lập trình nhập vào mảng hai chiều gồm m m, n = map(int, input().split())
a = [[]*n for i in range(m)]
dòng n cột chỉ gồm các số nguyên. Tính
for i in range(m):
tổng các phần tử trên mỗi cột và thông báo a[i] = list(map(int, input().split()))
các tổng này ra màn hình. (1 < m, n < 100) for j in range(n):
sum = 0
Dữ liệu nhập Kết quả
for i in range(m):
23 5 sum += a[i][j]
123 7 print(sum)
456 9

Giáo viên: Lê Thanh Phú 16 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 5: KIỂU DỮ LIỆU XÂU

1. Khái niệm:
- Kiểu xâu trong Python là một dãy kí tự nằm giữa hai dấu ngoặc đơn hoặc ngoặc kép. Ví dụ: “Chào
bạn”, ‘Ban oi’, ‘QuangTri2022’ …
- Có thể xem xâu kí tự là một danh sách kí tự liên tiếp nhau được đánh số thứ tự bắt đầu từ 0. Ví dụ:
với s = ‘THPTVinhDinh’ thì s[0] = ‘T’, s[4] = ‘V’, s[7] = ‘h’.
- Nhập vào một xâu kí tự dùng hàm input(). Ví dụ: s = input()
- Để in một xâu kí tự ra màn hình ra dùng hàm print(). Ví dụ: print(s)
- Duyệt qua từng kí tự trong chuỗi lần lượt từ đầu đến hết ta có thể sử dụng vòng lặp for:
for x in s:
print(s)
Hoặc duyệt theo chỉ số:
for i in range(len(s)):
print(s[i])
- Để tìm kiếm một xâu kí tự có xuất hiện trong xâu khác hay không: dùng toán tử in
if 'quang' in 'quangtri':
print('có xuất hiện')
- Để tìm vị trí xuất hiện một xâu kí tự trong xâu khác dùng hàm find(). Hàm này trả về vị trí xuất hiện
đầu tiên, nếu không xuất hiện sẽ trả về -1. Ví dụ sau cho ra đáp án: Co xuat hien tai vi tri 5
s = 'QuangTri_2022'
if s.find('Tri') > -1:
print('Co xuat hien tai vi tri', s.find('Tri'))
- Lệnh tách xâu con dựa vào kí tự quy định. Ví dụ sau sẽ tách xâu s = ‘Quang Tri 2022’ ra thành một
danh sách: a = ['Quang', 'Tri', '2022']
s = 'Quang Tri 2022'
a = s.split(' ')
- Ví dụ sau tương tự nhưng tách căn cứ vào dấu phẩy:
s = 'Quang,Tri,2022'
a = s.split(',')
2. Một số thao tác khác trên xâu kí tự:
Các thao tác sau minh hoạ trên xâu s = ‘chao’
Thao tác Ý nghĩa
s = ‘ban’ + ‘Toi’ Thao tác nối hai xâu thành 1. S = ‘banToi’
s = s*3 Lặp lại xâu s 3 lần. s = ‘chaochaochao’
s = s.capitalize() In hoa kí tự đầu tiên của S, các kí tự khác giữ nguyên.
s = s.title() In hoa kí tự đầu tiên mỗi từ. s = ‘chao ban’ → ‘Chao Ban’
s = s.lower() Chuyển toàn bộ xâu s về thành kí tự thường
s = s.upper() Chuyển toàn bộ xâu s về thành kí tự in hoa
x = s.count(‘p’) Đếm xem trong xâu s có bao nhiêu kí tự ‘p’
s.isalnum() Trả về True nếu xâu s chỉ chứa kí tự chữ cái và chữ số
s.isalpha() Trả về True nếu xâu s chỉ chứa kí tự chữ cái và không rỗng
s.isdecimal() Trả về True nếu xâu s chỉ chứa kí tự số và không rỗng
s.islower() Trả về True nếu xâu s chứa ít nhất 1 kí tự thường và không
chứa kí tự in HOA
s.isupper() Tương tự hàm trên

Giáo viên: Lê Thanh Phú 17 | T r a n g

PYTHON CƠ BẢN
s.find(x) Trả về vị trí đầu tiên/cuối cùng xuất hiện xâu x. Nếu không xuất
s.rfind(x) hiện thì trả về -1.
s = s.lstrip() Xoá hết kí tự trắng bên trái/phải/cả hai bên xâu s
s = s.rstrip() Ví dụ: s = s.lstrip() sẽ xoá kí tự trắng có bên trái xâu s
s = s.trip()
s = s.zfill(x) Thêm vào kí tự không bên trái để xâu s có độ dài x
s = ‘15’, s = s.zfill(4) → s = ‘0015’
s = s.swapcase() Đổi kí tự hoa thành thường và thường thành hoa.
x = int(s) int() giúp chuyển xâu số sang thành số
s = str(x) str() chuyển số x sang thành một xâu
ord(s[i]) Lấy ra mã ascii của kí tự s[i]
chr(x) Lấy ra kí tự có mã ascii là x
r = s[:x] Sao chép x kí tự đầu tiên của xâu s
r = s[x:] Sao chép xâu s từ vị trí x đến hết xâu
r = s[3:6] Sao chép các kí tự từ vị trí 3 đến 5 của xâu s
s = s[:x] + s[x+1:] Xoá kí tự ở vị trí x của xâu s
s = s.replace('h', '') Xoá hết kí tự ‘h’ của xâu s

3. Một số ví dụ vận dụng:

Bài tập Code tương ứng
Lập trình nhập vào một xâu kí tự, đếm s = input()
và thông báo ra màn hình số lượng kí tự A có print(s.count('A'))
mặt trong xâu.
Một xâu được gọi là xâu chuẩn nếu: s = input()
không có kí tự trắng dư thừa đầu và cuối xâu; while s.find(' ') > -1:
không có hai kí tự trắng liền nhau. Em hãy lập s = s.replace(' ', ' ')
s = s.strip()
trình nhập vào một xâu và in ra màn hình xâu print(s)
sau khi đã chuẩn hóa
Dữ liệu nhập Kết quả
Chao ban Chao ban
Lập trình nhập vào một xâu họ tên a = input().split(' ')
chuẩn và thông báo ra màn hình tên của xâu print(a[len(a) - 1])
vừa nhập.
Hoặc:
Dữ liệu nhập Kết quả a = input().split(' ')
Le Thanh Huy Huy a.reverse()
print(a[0])

4. Biểu thức chính quy: RegEx

- RegEx viết tắt của Regular Expression, là một chuỗi các ký tự tạo thành một mẫu tìm kiếm. RegEx
có thể được sử dụng để kiểm tra xem một chuỗi có chứa mẫu tìm kiếm được chỉ định hay không.
- RegEx là một công cụ rất mạnh khi thực hiện thao tác tìm kiếm trên chuỗi kí tự.
- Để sử dụng ReGex cần khai báo thư viện: import re
- Một số hàm mạnh trong thư viện ReGex:
• split(): Trả về một list chứa các chuỗi con của chuỗi ban đầu được tách ra theo kí tự chỉ
định
• search(): Hàm tìm kiếm theo chuỗi chỉ định
Giáo viên: Lê Thanh Phú 18 | T r a n g
PYTHON CƠ BẢN

• findall(): Trả về một list chứa các chuỗi con khớp theo yêu cầu thao tác
• sub(): Thay thế các chuỗi con xuất hiện trong chuỗi gốc bằng các chuỗi được chỉ định
* Những kí tự có ý nghĩa đặc biệt được sử dụng trong các hàm ReGex:
Kí tự Ý nghĩa Ví dụ

[] Tập hợp các kí tự "[a-m]"

\ Báo hiệu một chuỗi đặc biệt "\d"

. Khớp với một kí tự bất kỳ "he..o"

Ví dụ: “hello” sẽ khớp khi tìm “he..o”

^ Bắt đầu bởi chuỗi cần tìm "^hello"

$ Kết thúc bởi chuỗi cần tìm "planet$"

* khớp với một hoặc nhiều kí tự bất kỳ "he*o"

+ Khớp với một hoặc nhiều kí tự trước dấu +. "he.+o"

Ví dụ: “helo”, “helllo” sẽ khớp “he.+o”

? Khớp với một hoặc không kí tự trước dấu +. "he.?o"

Ví dụ: “helo”, “heo” sẽ khớp “he.?o” còn “hello”thì không

{x} Khớp chính xác x lần kí tự trước cặp {} "he.{2}o"

Ví dụ: “hello” khớp còn “helo” hoặc “helllo” thì không.

| Khớp với một trong số các điều kiện cần tìm. "an|nam"
Ví dụ: “an|nam” sẽ khớp với chuỗi kí tự chứa “an”, “nam” hoặc cả 2
* Một số chuỗi đặc biệt được sử dụng trong ReGex:
Kí tự Ý nghĩa Ví dụ

\A Khớp nếu bắt đầu bằng chuỗi cần tìm "\AThe"

\b Khớp với các từ có “ain” xuất hiện ở đầu từ "\bain"

Khớp với các từ có “ain” xuất hiện ở cuối từ "ain\b"

\B Khớp với các từ có “ain” xuất hiện nhưng không phải ở đầu từ r"\Bain"
Khớp với các từ có “ain” xuất hiện nhưng không phải ở cuối từ r"ain\B"

\d Trả về match khi chuỗi chứa kí tự chữ số "\d"

\D Trả về match khi chuỗi Không chứa kí tự chữ số "\D"

\s Trả về match khi chuỗi chứa kí tự trắng (Dấu cách) "\s"

\S Trả về match khi chuỗi Không chứa kí tự dấu cách "\S"

\w Trả về match khi chuỗi chứa kí tự chữ số, chữ cái, hoặc dấu gạch "\w"
dưới

Giáo viên: Lê Thanh Phú 19 | T r a n g

PYTHON CƠ BẢN

\W Trả về match khi chuỗi Không chứa kí tự chữ số, chữ cái, hoặc dấu "\W"
gạch dưới

* Kiểu tập hợp được sử dụng trong ReGex:

Ví dụ Ý nghĩa

[arn] Trả về khớp nếu chuỗi chứa kí tự a, r hoặc n.

[a-n] Trả về khớp cho bất kỳ kí tự nào từ a đến z

[^arn] Trả về khớp cho bất kỳ kí tự nào ngoại trừ kí tự a, r hoặc n.

[0123] Trả về khớp cho bất kỳ kí tự nào thuộc tập 0,1,2,3

[0-9] Trả về khớp cho bất kỳ kí tự nào thuộc tập 0 đến 9

[0-5][0-9] Trả về khớp cho bất kỳ cặp kí tự nào từ 00 and 59

[a-zA-Z] Trả về khớp cho bất kỳ kí tự nào thuộc tập kí tự in hoa và thường

* Ứng dụng ReGex trong giải bài:

Bài tập Chương trình

Cho xâu S gồm nhiều từ cách nhau dấu cách. Tìm a = re.findall(‘^a.*b$’, s)
và in tất cả từ bắt đầu bằng ‘P’ kết thúc bằng ‘u’. print(a)

Cho xâu chứa kí tự và số, số không chứa số 0 ở import re

đầu. Tách các số ra khỏi xâu và in ra số lớn nhất. s = input()
so = re.findall('\d+', s)
Vd: Anh1chi8abc12cd24 print(max([int(x) for x in so]))
--> 24
Hàm findall('\d+', s) giúp ta tìm tất cả
đoạn liên tiếp chứa kí tự số.

Bạn hãy lập trình sắp xếp các số trong xâu đó tăng import re
dần nhưng vẫn giữ nguyên các kí tự chữ cái. s = input()
kt = re.findall('\D+', s)
Vd: Anh24chi12abc1cd8 so = re.findall('\d+', s)
-> Anh1chi8abc12cd24
Hàm findall(‘\D’, s) giúp ta tìm tất cả def cmp(u):
đoạn liên tiếp không chứa kí tự số. return (len(u), u)

so.sort(key=cmp)

a = []
for i in range(min(len(kt),
len(so))):
a.append(kt[i])
a.append(so[i])
if len(kt) > len(so):
a.append(kt[len(kt) - 1])
print(''.join(a))

Giáo viên: Lê Thanh Phú 20 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 6: KIỂU DỮ LIỆU TỆP

1. Một số khái niệm:
Về cơ bản, cũng như trong hầu hết các ngôn ngữ lập trình, quá trình làm việc với tệp tin
thường bao gồm 3 giai đoạn sau:
• Mở tệp tin
• Thực hiện các hoạt động đọc, ghi dữ liệu
• Đóng tệp tin để đảm bảo dữ liệu không bị hỏng hóc, mất mát
* Mở tệp:
- Để mở một file, chúng ta sử dụng hàm open với cú pháp:
Biến tệp = open("tên tệp","chế độ mở", encoding="kiểu mã hóa")
- Trong đó:
• Chế độ mở: ‘r’ để đọc, ‘w’ để ghi, ‘a’ mở để ghi thêm dữ liệu vào cuối
• Kiểu mã hoá: Nếu đọc ghi tệp văn bản tiếng Việt không dấu thì không cần tham số này. Nếu
đọc ghi tệp tiếng Việt có dấu thì dùng ‘utf-8’
- Ví dụ 1: Mở tệp Baitap1.inp để đọc dữ liệu
f = open("Baitap1.inp", "r")
- Ví dụ 2: Mở tệp baitap2.inp để đọc văn bản tiếng Việt có dấu
f = open("Baitap2.inp", "r", encoding="utf-8")
- Ví dụ 3: Mở tệp baitap2.out để ghi kết quả
g = open("Baitap2.out", "w")
* Đọc/ghi dữ liệu:
- Đọc dữ liệu: Biếntệp.readline() để đọc một dòng
- Ghi dữ liệu: Biếntệp.write(x) để ghi x vào tệp
* Đóng tệp:
- Cú pháp: Biếntệp.close()
2. Làm việc với tệp trong các kỳ thi HSG:
- Khi vào ra tệp trong các kỳ thi, thao tác trên biến tệp rất dễ nhầm lẫn. Thay vào đó ta có thể sử
dụng tệp vào ra chuẩn. Để mở tệp thì trong phần đầu chương trình ta khai báo như sau:
import sys
sys.stdin = open("Baitap1.inp", "r")
sys.stdout = open("Baitap1.out", "w")
- Lệnh này chuyển hướng vào ra chuẩn thành vào ra tệp. Khi sử dụng tệp chuẩn này thì mọi thao tác
nhập, xuất thông tin giống như vào ra bàn phím màn hình mà ta đã học từ trước đến giờ.
- Python đọc dữ liệu từ tệp khá chậm, để đọc dữ liệu từ tệp nhanh ta chỉ cần khai báo thêm lệnh
sau: input = sys.stdin.readline
3. Một số ví dụ:
Bài tập Code tương ứng
Dòng họ Tula vốn giàu có thịnh vượng import sys
nhưng do nội chiến xảy ra họ phải chia ly. Các import math
sys.stdin = open("Timkhoa.inp", "r")
vị tiền bối cất châu báu vào một mật thất. Họ sys.stdout = open("Timkhoa.out", "w")
giao cho K (1 ≤ K ≤ 1000) người con mỗi người input = sys.stdin.readline
cất giữ một phần của mã số bí mật của kho k = int(input())
a = list(map(int, input().split()))
báu. Người thứ i giữ mã khoá x[i] (1 ≤ x[i] ≤ uc = a[0]
109). for x in a:
Yêu cầu: Khi nội chiến kết thúc, hãy giúp K uc = math.gcd(uc, x)
người con tìm mã khoá để mở kho báu biết print(uc)

Giáo viên: Lê Thanh Phú 21 | T r a n g

PYTHON CƠ BẢN

rằng mã khoá là một số nguyên dương lớn

nhất M mà tất cả mã số của K người con đều
chia hết.
TIMKHOA.INP TIMKHOA.OUT
6 6
48 54 6 36 6 12
Ở vương quốc NONAME người ta đưa import sys
sys.stdin = open("HOHANG.inp", "r")
ra một quy tắc đặt tên kỳ lạ: Mỗi dòng họ sys.stdout = open("HOHANG.out", "w")
chọn một dãy kí tự độ dài n chỉ gồm các kí input = sys.stdin.readline
tự in hoa trong bảng chữ cái tiếng Anh. Khi T = int(input())
for i in range(T):
đó để đặt tên cho một người trong dòng n = int(input())
họ thì chỉ cần thay đổi thứ tự của các kí tự s = input().rstrip()
r = input().rstrip()
với nhau. if sorted(s) == sorted(r):
Yêu cầu: Cho biết hai xâu tên của hai print(1)
người trong vương quốc, hãy kiểm tra xem else:
print(0)
hai người này có cùng dòng họ hay không.
HOHANG.INP HOHANG.OUT Code trên sử dụng đọc dữ liệu theo dòng nên sẽ
3 0 đọc cả dấu ‘\n’ ở cuối dòng. Nếu dữ liệu là xâu kí
3 0 tự thì thêm lệnh rstrip() để loại kí tự này trước
LLQ 1
khi xử lý: s = input().rstrip()
KHQ
3
FDF
GDD
3
KWE
EKW
Cho tệp danh sách gồm nhiều dòng, mỗi import sys
sys.stdin = open("TEPSO.inp", "r")
dòng là một dãy số nguyên dương gồm 3 sys.stdout = open("TEPSO2.out", "w")
số. Em hãy lập trình đọc thông tin từ danh while True:
try:
sách này, tính tổng của mỗi dãy số và in kết x,y,z = map(int,input().split())
quả ra màn hình. print(x + y + z)
except:
TEPSO.INP TEPSO.OUT break
535 13
234 9 Do tệp không biết bao nhiêu dòng nên
543 12 dùng while để đọc. Lệnh try giúp bắt lỗi khi đọc
hết tệp để break kết thúc vòng lặp.

Giáo viên: Lê Thanh Phú 22 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 7: CHƯƠNG TRÌNH CON

1. Lý thuyết:
- Kỹ thuật lập trình dẫn đến việc tổ chức chương trình kiểu cấu trúc modul hóa, tức là chia chương
trình thành nhiều modul hay gọi là các chương trình con nhỏ hơn. Nó đem lại cho người lập trình
các lợi ích:
•Thay các đoạn trình giống nhau bằng một chương trình con, làm cho mã chương trình ngắn
hơn, sáng sủa và dễ bảo dưỡng.
• Đưa các chương trình con đã kiểm tra vào thư viện (library) để khi lập trình mới thì chỉ cần
liên kết tới thư viện đó.
• Những chương trình lớn được thiết kế dạng cấu trúc tốt có thể trao cho các nhóm và người
lập trình khác nhau lập trình, đôi khi có thể thuê người làm thêm viết các chương trình con
không quá phức tạp.
- Python hỗ trợ hai loại chương trình con:
• Hàm trả về giá trị
• Hàm không trả về giá trị
- Cú pháp:
def <tên hàm>(<danh sách tham số>):
Dãy lệnh của hàm
Return [giá trị trả về]
- Trong đó:
• Danh sách tham số: có thể có hoặc không
• Giá trị trả về : Tuỳ theo chương trình con, nếu không cần trả về giá trị thì không cần cái
này.
- Lời gọi chương trình con: Một chương trình con có thể được thực hiện với nhiều giá trị khác nhau
do chương trình truyền vào thông qua lời gọi hàm.
2. Một số ví dụ:
Bài tập Code tương ứng
Xây dựng hàm yêu cầu người dùng nhập def chaomung():
ten = input("Bạn tên gì: ")
họ tên rồi đưa ra lời chào.
print("Chào bạn", ten)
Hàm này không có tham số, nên muốn sử return
dụng hàm này sẽ gọi:
chaomung()
Xây dựng hàm trả về giá trị là tổng hai số def tong(u, v):
s = u + v
nguyên.
return s
Hàm này có tham số nên khi gọi phải đầy
đủ hai tham số như khai báo. Ví dụ:
s = tong(3, 5)
Hoặc
print(tong(a, b))
Hãy mô tả hàm Fact(n) để tính giá trị n import sys
sys.stdin = open("Fact.inp", "r")
giai thừa. (0 < N < 200)
sys.stdout = open("Fact.out", "w")
Cho một danh sách có dòng đầu tiên là input = sys.stdin.readline
số M, m dòng tiếp theo mỗi dòng là một số
nguyên dương N. Lập trình đọc dữ liệu từ def Fact(n):
gt = 1
danh sách, tính giai thừa của m số đó và for i in range(1, n+1):
thông báo kết quả. gt *= i
Fact.INP Fact.OUT return gt
3 2
Giáo viên: Lê Thanh Phú 23 | T r a n g
PYTHON CƠ BẢN

2 24 m = int(input())
for i in range(m):
4
n = int(input())
print(Fact(n))
Viết chương trình con Prime(x) để kiểm import sys
sys.stdin = open("NTO.inp", "r")
tra x có phải là số nguyên tố hay không.
sys.stdout = open("NTO.out", "w")
Vận dụng chương trình con vừa viết lập input = sys.stdin.readline
trình nhập vào dãy số nguyên a[1], a[2]…,
a[n], đếm có bao nhiêu cặp thoả mãn điều def Prime(x):
if x <= 1:
kiện a[i] + a[j] (𝑖 ≤ 𝑗) là một số nguyên tố. return 0
NTO.INP NTO.OUT for i in range(2, int(x**0.5)+1):
4 5 if x % i == 0:
return 0
1234 return 1

n = int(input())
a = list(map(int, input().split()))
dem = 0
for i in range(n):
for j in range(i, n):
if Prime(a[i]+a[j]) == 1:
dem += 1
print(dem)
Viết chương trình con chuanHoa(s) có import sys
nhiệm vụ xoá đi các kí tự trắng dư thừa có sys.stdin = open("CHUAN.inp", "r")
sys.stdout = open("CHUAN.out", "w")
mặt trong xâu s.
Vận dụng chương trình con vừa viết để def chuanHoa(s):
đọc thông tin của các bạn học sinh, tách lấy while s.find(' ') > -1:
s = s.replace(' ', ' ')
và in ra màn hình họ đệm cùng tên của các s = s.strip()
bạn học sinh này đã chuẩn hoá và in hoa return s
mỗi đầu từ.
while True:
CHUAN.INP CHUAN.OUT
try:
Le thanh phu Thanh Phu s = input()
Tran HUNG son Hung Son s = chuanHoa(s)
vt = s.find(' ')
s = s[vt+1:]
s = s.lower()
s = s.title()
print(s)
except:
break

Giáo viên: Lê Thanh Phú 24 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 8: MỘT SỐ THỨ CĂN BẢN KHÁC KHI BỒI DƯỠNG HSG
1. Số nguyên tố:
Bài toán Chương trình tương ứng
Kiểm tra số nguyên tố def Prime(x):
if x <= 1:
- Thuật toán duyệt căn return 0
for i in range(2, int(x**0.5)+1):
if x % i == 0:
return 0
return 1
Kiểm tra số nguyên tố def Prime6k(x):
if x <= 1:
- Thuật toán 6k return 0
if (x == 2) or (x == 3):
return 1
if (x % 2 == 0) or (x % 3 == 0):
return 0
k, can = 5, int(math.sqrt(x))
for k in range(5, can, 6):
if (x % k == 0) or (x % (k+2) == 0):
return 0
return 1
Kiểm tra số nguyên tố https://ideone.com/j2OQOJ
- Thuật toán Rabin Miller
- Thuật này phức tạp chỉ dành
cho các bạn đam mê tìm hiểu
Sàng eratos: def eratos(m):
e = [0, 0] + [1]*m
- Tạo sàng eratos có giới hạn can = int(math.sqrt(m))
m for i in range(2, can):
if e[i] == 1:
for j in range(i*i, m, i):
e[j] = 0
return e

2. Ước/ Bội:
Ước chung lớn nhất: import math
- Tìm UCLN của hai số a và b a, b = map(int, input().split())
uc = math.gcd(a, b)
Bội chung nhỏ nhất import math
- Tìm BCNN của hai số a, b a, b = map(int, input().split())
bc = (a // math.gcd(a, b)) * b
Ước chung lớn nhất: import math
- Tìm UCLN của a[1..n] a = list(map(int, input().split()))
uc = 0
for x in a:
uc = math.gcd(uc, x)
print(uc)
Bội chung nhỏ nhất: import math
- Tìm BCNN của a[1..n] a = list(map(int, input().split()))
bc = 1
for x in a:
bc = (bc // math.gcd(bc, x)) * x
print(bc)

Giáo viên: Lê Thanh Phú 25 | T r a n g

PYTHON CƠ BẢN

3. Sắp xếp:
Thao tác Lệnh tương ứng
Sắp xếp list tăng dần theo giá trị a.sort()
- List xâu thì tăng dần theo thứ tự từ
điển
Giảm dần a.sort(reverse=True)
Sắp xếp xâu tăng dần s = ''.join(sorted(s))
- Vì xâu không có hàm sort nên dùng sorted(s) sẽ tạo
ra một list kí tự tăng dần.
- ‘’.join() giúp nối list kí tự này lại thành xâu
Sắp xếp xâu giảm dần s = ''.join(sorted(s, reverse=True))
Sắp xếp list tăng dần theo một điều kiện def tongcs(u):
đặc biệt: Ví dụ sum = 0
while u > 0:
• theo tổng chữ số tăng dần sum += (u % 10)
• Cùng tổng chữ số thì giá trị tăng dần u //= 10
[12, 20, 4, 21]→[20, 12, 21,4] return sum

def cmp(u):
return (tongcs(u), u)

a.sort(key=cmp)
Cho một dãy số nguyên gồm n phần n = int(input())
tử A[1]..A[n]. Hãy Sắp xếp dãy số theo a = list(input().split())
thứ tự không giảm rồi in dãy số ra màn def cmp(u):
hình. return (len(u), u)
Ràng buộc:
a.sort(key=cmp)
• 1 <= n <= 100000 print(' '.join(x for x in a))
• 1 <= A[i] <= 10^25
- Do a[i] <= 10^25 nên phải dùng xâu để lưu trữ. Tức
mỗi phần tử của list là một xâu. Vậy phải viết hàm so
sánh, vì sort mặc định sẽ theo thứ tự từ điển.
- Hàm này trước hết sẽ so sánh theo độ dài, ngắn hơn
là số bé hơn (Vì không có số 0 ở đầu), nếu dài bằng nhau
thì số nào bé hơn sẽ bé hơn.
n = int(input())
Có n con virut, con thứ i có sức phá hoại
a = []
là a[i] và khả năng phát tán là b[i]. Hãy
for i in range(n):
sắp xếp các con virut theo thứ tự sức u, v = map(int, input().split())
phá hoại bằng hoặc tăng dần. Nếu cùng a.append([u, v])
sức phá hoại thì sắp xếp theo khả năng
def cmp(u):
phát tán tăng dần. return (u[0], u[1])
Nhập Xuất
4 11 a.sort(key=cmp)
for x in a:
51 13
print(x[0], x[1])
11 17
13 51

Giáo viên: Lê Thanh Phú 26 | T r a n g

PYTHON CƠ BẢN

17
Có n con virut, con thứ i có sức phá hoại n = int(input())
là a[i] và khả năng phát tán là b[i] và khả a = []
for i in range(n):
năng bị tiêu diệt là c[i]. Hãy sắp xếp các u,v,z = map(int,input().split())
con virut theo thứ tự khả năng bị tiêu a.append([u, v, z])
diệt không giảm. Nếu cùng khả năng bị
def cmp(u):
tiêu diệt thì sắp xếp theo khả năng phát return (u[2], -u[1], -u[0])
tán không tăng. Nếu giống nhau cả khả
năng bị tiêu diệt và khả năng phát tán a.sort(key=cmp)
for x in a:
thì sắp xếp theo khả năng phá hoại
print(x[0], x[1], x[2])
không tăng.
Ví dụ: con virut (2, 5, 1) sẽ xếp trước con Hàm so sánh cmp(u):
virut (2, 4, 1); con virut (2, 4, 1) sẽ xếp - Đầu tiên so sánh theo u[2] là khả năng bị tiêu diệt bé
trước con virut (1, 4, 1). hơn đứng trước tức không giảm
- Nếu cùng u[2] thì so sánh theo -u[1] là khả năng phát
Nhập Xuất
tán bé hơn đứng trước, mà -u[1] bé hơn trước tương
4 671 đương với u[1] lớn hơn xếp trước, tức là không giảm.
111 311 - Nếu cùng hai cái đầu thì sẽ so sánh theo -u[0] bé hơn
799 111 xếp trước.
311 799
671
Tèo đã viết được một số lớn trên import functools
một cuộn giấy dài và muốn khoe với n = int(input())
anh trai Tí về thành quả vừa đạt a = []
được. Tuy nhiên, khi Tèo vừa ra khỏi for i in range(n):
s = input()
phòng để gọi anh trai thì cô em Mì a.append(s)
chạy vào phòng và xé rách cuộn giấy
def cmp(u, v):
thành một số mảnh. Kết quả là trên if u+v > v+u:
mỗi mảnh có một hoặc vài kí số theo return -1
thứ tự đã viết. if u+v == v+u:
return 0
Bây giờ Tèo không thể nhớ chính return 1
xác mình đã viết số gì. Tèo chỉ nhớ
a.sort(key=functools.cmp_to_key(cmp))
rằng đó là một số rất lớn. Để làm hài print(''.join(x for x in a))
lòng cậu em trai, Tí quyết định truy
- Theo quy định: Hàm so sánh cmp(u,v) phải trả về -1,
tìm số nào là lớn nhất mà Tèo đã có
0, 1:
thể viết lên cuộn giây trước khi bị xé.
• -1: Nếu u sắp xếp trước v
Bạn hãy giúp Tí làm việc này. • 1: Nếu u sắp xếp sau v
Ràng buộc: • 0 thì sếp đâu cũng giống nhau
• 0 < n < 5050 - Hàm trên so sánh để quyết định xâu u xếp trước xâu
v khi nào:
• Số chữ số trên mỗi mảnh giấy
• u xếp trước tạo ra xâu số: u+v
không quá 100.
• u xếp sau tạo ra xâu số: v+u
Nhập Xuất

Giáo viên: Lê Thanh Phú 27 | T r a n g

PYTHON CƠ BẢN

4 66220004 - Hai xâu u+v và v+u có cùng độ dài nên xâu nào bé hơn
theo thứ tự từ điển thì số tạo thành bé hơn.
2
20
004
66

4. Tìm kiếm nhị phân:

- Có thư viện bisect cung cấp hai hàm tìm kiếm nhị phân rất hay:
• u = bisect.bisect_left(a, x) : Trả về vị trí bé nhất trong a thoả mãn 𝑎[𝑢] ≥ 𝑥. Nếu
tất cả phần tử trong a đều bé hơn x thì sẽ trả về u = len(a) + 1.
• u = bisect.bisect_right(a, x) : Trả về vị trí bé nhất trong a thoả mãn 𝑎[𝑢] > 𝑥.
Nếu tất cả phần tử trong a đều bé hơn x thì sẽ trả về u = len(a) + 1.

Thao tác Lệnh tương ứng

Bạn được cho hai dãy số nguyên A và B, import bisect
mỗi dãy có N phần tử. Nhiệm vụ của bạn n = int(input())
a = list(map(int, input().split()))
là đếm xem có bao nhiêu phần tử của b = list(map(int, input().split()))
dãy A xuất hiện trong dãy B. (𝑁 ≤ 105 ) b.sort()
Nhập Xuất dem = 0
for x in a:
5 4 u = bisect.bisect_left(b, x)
23145 if u < len(b) and b[u] == x:
dem += 1
12348 print(dem)
Nhân dịp tết trung thu, Nam được bố import bisect
n, x = map(int, input().split())
mẹ cho đi dự lễ hội đêm trăng rằm. a = list(map(int, input().split()))
a.sort()
Tại lễ hội này nam đã tích cực tham #a[i] + a[j] <= X --> a[j] <= X - a[i]
gia các trò chơi và giành được X điểm qua = 0
for i in range(n):
thưởng. Nam dùng X điểm thưởng j = bisect.bisect_right(a, x - a[i]) - 1
if i < j and j < n:
này để đổi quà. Ban tổ chức có N món qua = max(qua, a[i] + a[j])
print(qua)
quà khác nhau, món thứ i có giá trị
A[i] điểm. Với số điểm X Nam quyết
định sẽ đổi hai món quà khác nhau có
tổng giá trị lớn nhất có thể nhưng
không vượt quá X. Bạn hãy xác định
giúp Nam tổng giá trị quà Nam đổi
được là bao nhiêu. (𝑁 ≤ 105 )
Nhập Xuất
6 18 15
5 3 10 2 4 9

Giáo viên: Lê Thanh Phú 28 | T r a n g

PYTHON CƠ BẢN

5. Heap:
- Heap là loại cấu trúc dữ liệu dạng cây, và tất cả các node trong cây đó được sắp xếp theo một thứ
tự nhất định, có thể là theo chiều tăng dần hoặc giảm dần.
- Python cung cấp thư viện heapq để thao tác với heap: Mặc định là heap min
• heapq.heapify(a) Chuyển list a thành heap
• u = heapq.heappop(hp) Lấy phần tử nhỏ nhất ra khỏi heap
• heapq.heappush(hp, u) Đưa phần tử u vào heap
- Ví dụ:
Bài tập Chương trình
Có n đống sỏi được đánh số từ 1 đến import heapq
n = int(input())
n, đống thứ i có a[i] viên sỏi. Ta có thể a = list(map(int, input().split()))
ghép hai đống sỏi với nhau thành một hp = []
đống với chi phí là tổng số sỏi của hai for x in a:
heapq.heappush(hp, x)
đống đó. chiphi = 0
Yêu cầu: Tìm cách ghép n đống sỏi while len(hp) > 1:
u = heapq.heappop(hp)
thành 1 đống duy nhất với tổng chi phí v = heapq.heappop(hp)
ghép nhỏ nhất. chiphi += (u + v)
heapq.heappush(hp, u+v)
Nhập Xuất
print(chiphi)
3 16
282

6. Dict – Python:
- Nếu từng dùng mảng đánh dấu trong Pascal thì thấy rằng đây là cách làm tuyệt vời giúp ta kiểm
tra sự tồn tại của một số rất nhanh trong O(1). Tuy nhiên mảng đánh dấu lại hạn chế bởi vì giới hạn
khai báo của mảng.
- Trong Python cung cấp kiểu Dictionary giúp ta lưu trữ nhiều phần tử, mỗi phần tử là một cặp [key
: value] tức giúp đánh dấu giá trị của key là value.
- Ví dụ: c = {1: 'Phu', ‘ab’: 5} giúp ta đánh dấu c[1] = ‘Phu’ và c[‘ab’] = 5.
- Kiểu Dict này trong Python linh động và mạnh hơn mảng đánh dấu rất nhiều.
- Một số thao tác:
• Khởi tạo một Dict rỗng: c = {}
• Thêm phần tử (Đánh dấu) c[1] = ‘Phú’
• Truy cập phần tử x trong dict c.get(x)
• Loại bỏ phần tử x khỏi dict del c[x]
• Xoá hết, làm rỗng dict c.clear()
• Lấy ra giá trị và xoá x khỏi dict u = c.pop(x)
- Bài tập ví dụ:
Bài tập Chương trình
Cho danh sách n số nguyên dương có n = int(input())
a = list(map(int, input().split()))
giá trị không quá một triệu. Lập trình tìm c = {}
số nguyên dương nhỏ nhất chưa có mặt for x in a:
trong danh sách trên. c[x] = 1
lim = max(a) + 1
Nhập Xuất for i in range(1, lim + 1):
if c.get(i) == None:

Giáo viên: Lê Thanh Phú 29 | T r a n g

PYTHON CƠ BẢN

5 2 print(i)
break
53164
Cho số nguyên dương n và dãy n = int(input())
a = list(map(int, input().split()))
A gồm n số nguyên dương. Ta gọi c = {}
một số a[i] là có bạn nếu tồn tại một for x in a:
if c.get(x) != None:
vị trí j khác i và a[j] = a[i]. Hãy đếm số c[x] += 1
lượng số có bạn trong dãy số trên. else:
c[x] = 1
Nhập Xuất dem = 0
9 3 for x in c:
if c.get(x) > 1:
12 5 1 7 10 6 1 1 3 dem += c.get(x)
print(dem)
- Bạn nào đam mê tìm hiểu có thể tìm đọc thêm: Defaultdict trong thư viện collections. Defaultdict
tương tự như dict nhưng nhanh hơn và ít bị bug hơn.

7. Set – Python:
- Set trong Python là một tập các giá trị không có thứ tự. Mỗi giá trị trong set là duy nhất, không thể
lặp lại và bất biến (tức bạn không thể thay đổi giá trị các phần tử trong set). Tuy nhiên chúng ta có
thể thêm, xóa các phần tử trong set.
- Sử dụng set khi nào:
• Khi muốn quản lý một tập các đối tượng phân biệt, không lưu trùng lặp
• Thêm một phần tử tập nhanh: O(1)
• Xoá phần tử khỏi tập nhanh: O(1)
• Kiểm tra nhanh một đối tượng có thuộc tập đang lưu hay không: O(1)
- Một số thao tác
Thao tác Ví dụ
Khởi tạo set: #set rỗng:
- Sử dụng dấu {} hoặc set() S = set()
#một set kiểu numbers
- Nếu có phần tử trùng nhau thì sẽ bị loại S1 = {5,7,8,6}
bỏ chỉ giữ lại một #một set kiểu string
s2 = {"hello", "hi", "xin chao"}
#set với kiểu dữ liệu hỗn hợp
s3 = {"hello", 5, (1,5,7)}
Thêm phần tử S.add(5)
- <tên set>.add(phần tử)
Xoá phần tử: khuyên dùng discard để nếu S.discard(x)
xoá mà không có x trong set sẽ không bị lỗi.
- remove(x)
- discard(x)
Xoá toàn bộ set S.clear()
- clear()
Kiểm tra phần tử có trong set: if x in S:
- in print(‘Có’)
- not in

Giáo viên: Lê Thanh Phú 30 | T r a n g

PYTHON CƠ BẢN

- Ví dụ:
Bài tập Chương trình
Sắn nhận được một vài tin nhắn từ n = int(input())
những người bạn. Một người có thể a = list(input().split())
s = set()
nhắn nhiều tin. Hãy giúp Sắn liệt kê danh kq = []
sách những người bạn đã gửi tin, mỗi for x in a:
người chỉ một lần và theo thứ tự thời if x not in s:
kq.append(x)
gian gửi sớm nhất s.add(x)
Nhập Xuất print(' '.join(x for x in kq))
5 mi hue cuc duc
mi hue mi cuc duc

8. Một số Trick khác:

Bài tập Chương trình
- Cho một List, lấy ra 4 số bé nhất, 3 import heapq
số lớn nhất a = list(map(int, input().split()))
print(heapq.nsmallest(4, a))
- Độ phức tạp: O(nlogn) print(heapq.nlargest(3, a))

Kết quả:
[1, 2, 4, 4]
[9, 8, 8]
- Cho một list, lấy ra 3 phần tử có số import collections
lần xuất hiện nhiều nhất a = list(map(int, input().split()))
b = collections.Counter(a)
- Độ phức tạp: O(nlogn) print(b.most_common(3))

Kết quả:
[(5, 6), (1, 5), (2, 4)]
- Sinh hoán vị độ dài 3: import itertools
(1, 2, 3) a = [1,2,3]
b = list(itertools.permutations(a))
(1, 3, 2) for x in b:
(2, 1, 3) print(x)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
- Sinh tổ hợp chập 2 của 3: import itertools
(1, 2) a = [1, 2, 3]
b = list(itertools.permutations(a, 2))
(1, 3) for x in b:
(2, 1) print(x)
(2, 3)
(3, 1)
(3, 2)

Giáo viên: Lê Thanh Phú 31 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 9: TĂNG TỐC CHƯƠNG TRÌNH PYTHON

- Bản Python dành cho Window và phần mềm chấm Themis mới nhất 1.98 là bản Python 3.x đang
sử dụng chế độ thông dịch nên việc thực hiện chương trình là rất chậm so với ngôn ngữ khác như
Pascal hay C++.
- Tuy nhiên ta có thể tăng tốc chương trình bằng một số trick để chương trình chạy nhanh hơn, tránh
quá giới hạn thời gian.
- Các ví dụ sau được thực hiện trên máy tính có cấu hình: CPU i3 10105f, DDRAM4 8GB, SSD 256.
Tính thời gian bằng thư viện time của Python.
- Bài tập: Đọc từ tệp input 106 số nguyên dương có giá trị không quá 109. Lọc ra danh sách số chẵn
và ghi vào tệp output, các số cách nhau dấu cách.
1. Sử dụng chương trình con và biến cục bộ:
- Sử dụng chương trình con làm chương trình chạy nhanh hơn
- Sử dụng biến cục bộ cho tốc độ xử lý nhanh hơn
Chương trình chậm Chương trình nhanh hơn
import sys, time import sys, time

sys.stdin = open("vidu.inp", "r") def xuly():

sys.stdout = open("vidu.out", "w") sys.stdin = open("vidu.inp", "r")
n = int(input()) sys.stdout = open("vidu.out", "w")
a = [] n = int(input())
for i in range(n): a = []
a.append(int(input())) for i in range(n):
for x in a: a.append(int(input()))
if x % 2 == 0: for x in a:
print(x, end=' ') if x % 2 == 0:
print(x, end=' ')
xuly()
Time xử lý (xấp xỉ): 1.19s Time xử lý: 1.07s
2. Nhập mảng nhanh hơn:
- Khi đã biết kích thước mảng thì nên khai báo sẵn thay vì dùng append
Chương trình nhanh hơn
import sys, time

def xuly():
sys.stdin = open("vidu.inp", "r")
sys.stdout = open("vidu.out", "w")
n = int(input())
a = [0]*n
for i in range(n):
a[i] = int(input())
for x in a:
if x % 2 == 0:
print(x, end=' ')
xuly()
Time xử lý: 1.05s

Giáo viên: Lê Thanh Phú 32 | T r a n g

PYTHON CƠ BẢN

3. Đọc ghi dữ liệu nhanh hơn:

- Để đọc dữ liệu nhanh hơn: Ta nên sử dụng sys.stdin.readline thay vì sử dụng hàm input()
mặc định. Để sử dụng ta chỉ cần thêm vào lệnh input = sys.stdin.readline sau khi mở tệp.
Lưu ý: Khi thêm lệnh này cần hết sức cẩn thận vì sẽ đọc nguyên dòng và đọc cả kí tự xuống dòng là
‘\n’ ở cuối. Nếu đọc số thì không sao, đọc xâu thì cần loại nó đi bằng cách input().replace('\n', '').
- Để ghi dữ liệu nhanh hơn: Hạn chế ghi nhiều lần: bằng cách nối thành một xâu rồi ghi một lần.
Chương trình nhanh hơn
import sys, time

def xuly():
sys.stdin = open("vidu.inp", "r")
sys.stdout = open("vidu.out", "w")
input = sys.stdin.readline Lệnh thêm vào để đọc nhanh hơn
n = int(input())
a = [0]*n
for i in range(n):
a[i] = int(input())
b = []
for x in a:
if x % 2 == 0:
b.append(x)
s = ' '.join(str(x) for x in b) Nối thành xâu để hạn chế lệnh in
print(s) nhiều lần

xuly()
Time xử lý: 0.38s
- Chỉ với 3 thao tác tối ưu như trên, từ một chương trình bị quá thời gian (1.19s) đã giảm xuống
trong thời gian cho phép (0.38s) và giành trọn vẹn điểm của bài.
4. Một số trick khác:
- Bạn có thể google với từ khoá: Python performance
- Để đọc thêm một số kỹ thuật tối ưu code Python
5. Bàn thêm:
- Bạn phải chấp nhận thực tế rằng dù tối ưu đi chăng nữa thì nó vẫn còn quá chậm so với các ngôn
ngữ khác. Nên có thể sẽ chấp nhận TLE ở một số bài tập khi tham gia thi HSG.
- Các bạn khác nếu muốn mục tiêu đạt giải Nhất hoặc tham gia các kỳ thi cao hơn thì lời khuyên của
tôi là các bạn nên học thêm C++.

Giáo viên: Lê Thanh Phú 33 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 10: TẠO TEST VỚI PYTHON

1. Thư viện random:
- Python có thư viện random mà bạn có thể sử dụng để tạo ra các số ngẫu nhiên.
- Một số thao tác:
• random.randint(u, v) Trả về một số nguyên ngẫu nhiên trong đoạn [u, v]
• random.random() Trả về một số thực thuộc đoạn [0, 1]
• random.uniform(2, 6) Trả về số thực thuộc đoạn [2, 6]
• random.choice(a) Lấy ngẫu nhiên một phần tử thuộc list a
• random.sample(a, k=3) Tạo một list gồm 3 phần tử ngẫu nhiên từ list a
• random.shuffle(a) Xáo trộn ngẫu nhiên list a
• random.getrandbits(2) Tạo một số ngẫu nhiên có 2 bit
• …
2. Template tạo test:
import sys, random, os, shutil

name = 'Tenbai'

def taoinput(itest)
sys.stdout = open(name + '.inp', 'w')
#dãy lệnh tạo ra input
sys.stdout.close()

def xuli(itest):
sys.stdin = open(name + '.inp')
sys.stdout = open(name + '.out', 'w')
#dãy lệnh bài làm
sys.stdin.close()
sys.stdout.close()

#Di chuyển 2 tệp vào đúng thư mục test

def movefile(itest):
num = '0' * (3 - len(str(itest))) + str(itest)
newpath = name + '/Test' + num
shutil.rmtree(newpath, ignore_errors=True)
os.makedirs(newpath)
shutil.move(name + '.inp', newpath + "/" + name + '.inp')
shutil.move(name + '.out', newpath + "/" + name + '.out')

#Phần chính: gọi tạo ra 20 test

for itest in range(1, 21):
taoinput()
xuli(itest)
movefile(itest)

Giáo viên: Lê Thanh Phú 34 | T r a n g

PYTHON CƠ BẢN

3. Ví dụ minh hoạ:
- Bài tập: TONG.*
Viết chương trình tính tổng hai số nguyên a và b được đọc từ tệp tong.inp.
Kết quả lưu vào tệp tong.out.
Ràng buộc: 60% test có: 0 ≤ 𝑎, 𝑏 ≤ 105 ; 40% test có: 0 ≤ 𝑎, 𝑏 ≤ 1012
import sys, random, os, shutil
name = 'Tong'

def ghiinput(gioihan):
a = random.randint(0, gioihan)
b = random.randint(0, gioihan)
print(a, b)

def taoinput(itest):
sys.stdout = open(name + '.inp', 'w')
if itest <= 12:
ghiinput(10**5)
else:
ghiinput(10**12)
sys.stdout.close()

def xuli(itest):
sys.stdin = open(name + '.inp')
sys.stdout = open(name + '.out', 'w')
a, b = map(int, input().split())
print(a + b)
sys.stdin.close()
sys.stdout.close()

# Di chuyển 2 tệp vào đúng thư mục test

def movefile(itest):
num = '0' * (3 - len(str(itest))) + str(itest)
newpath = name + '/Test' + num
shutil.rmtree(newpath, ignore_errors=True)
os.makedirs(newpath)
shutil.move(name + '.inp', newpath + "/" + name + '.inp')
shutil.move(name + '.out', newpath + "/" + name + '.out')

# Phần chính: gọi tạo ra 20 test

for itest in range(1, 21):
taoinput(itest)
xuli(itest)
movefile(itest)

Giáo viên: Lê Thanh Phú 35 | T r a n g

PYTHON CƠ BẢN

CHỦ ĐỀ 11: CHẤM PYTHON TRONG THEMIS

Themis là phần mềm được sử dụng chính thức cho các kỳ thi HSG hiện nay. Tại thời điểm
biết bài này, bản mới nhất là 1.9.8 build 2806. Bản này có hạn chế là bộ thông dịch để chấm Python
đi kèm phần mềm đang bị lỗi thiếu thư viện nên khi chấm Python sẽ báo lỗi.
Để chấm được Python bằng themis ta phải:
• Bước 1: Mở thư mục cài đặt themis, thường thì vào C:\Program Files
(x86)\Themis\PYTHON và xoá hết các thứ trong thư mục này.
• Bước 2: Sao chép trình dịch khác thay thế vào đây.
Để chấm Python nhanh tương tự chấm Pascal hay C++ ta nên thay thế bằng trình biên dịch
PyPy:
• Lên trang chủ PyPy.org tải về bản mới nhất PyPy3x:

• Giải nén file vừa tải về được một thư mục, sao chép toàn bộ các thứ trong thư mục này
• Dán vào mục C:\Program Files (x86)\Themis\PYTHON

- Nhận xét: Sử dụng PyPy cho tốc độ chấm ngang ngữa Pascal và C++. Tuy nhiên thực tế vẫn có chậm
hơn. Khi ra đề bài cho các kỳ thi mọi người nên code thử bài làm bằng C++ và Python, sau đó tiến
hành chấm thử trên Themis để xác định được một giới hạn thời gian chung phù hợp cho bài tập.
Khỏi tách riêng hay có thời gian riêng cho Python.

Giáo viên: Lê Thanh Phú 36 | T r a n g