|
TTKT
– ttkntc.blogspot.com TÀI
LIỆU THAM KHẢO KIỂM TRA CUỐI KÌ 2 Trường: __________________________________ Họ và tên:
________________________________ Lớp: ____________ |
Môn: Tin học Thời
gian: 45
phút Chương
trình: KNTT&CS Số
báo danh:
|
PHẦN I. LÝ THUYẾT TRỌNG TÂM
Kiến thức cơ bản
|
CÁC
HÀM CƠ BẢN |
|
|
range(START, STOP) |
Tạo dãy
kí tự số tự nhiên từ START (mặc định là 0 nếu không được truyền vào)
đến STOP-1 |
|
<LIST>
= [<OBJ>] |
Các phần tử trong danh sách có thể mang nhiều kiểu dữ liệu khác
nhau |
|
<Xâu> = ”<Dãy kí tự>” |
Có thể sử
dụng cặp dấu ngoặc kép đơn hoặc kép đôi, không thể thay đổi giá trị trực
tiếp trong xâu |
|
len() |
Hàm tính độ dài các phần tử của xâu hoặc danh sách |
|
<List>[<Chỉ số>] <String>[<Chỉ số>] |
Có thể
truy cập phần tử của xâu hoặc danh sách thông qua chỉ số. Chỉ số
kém độ dài danh sách 1 đơn vị |
|
for
<biến> in range(n): for
<biến> in range(len(<List/String>)): |
Gán lần lượt các giá trị từ 0 đến n – 1. Kết hợp với <List/Xâu>[<biến
đếm>] được đặt bên trong hàm for để sử dụng cho việc duyệt một danh sách/xâu
theo chỉ số. |
|
<List 1> + <List 2> <Xâu 1> + <Xâu 2> |
Phép ghép
nối (đa), phần được ghép nối sẽ dính liền. Có thể xảy ra lỗi kiểu
dữ liệu nếu ghép nối xâu với các kiểu dữ liệu khác (số nguyên, số thực,…) nên
cần chuyển tất cả về xâu trước khi thực hiện ghép nối. |
|
<List>
* k <Xâu>
* k |
Phép ghép nối (đơn) nhiều lần, phần được ghép nối sẽ dính liền
và ghép nối lặp lại theo số lần k |
|
<List 1> in <List 2> |
Toán tử in dùng để kiểm tra phần tử tồn tại trong
danh sách/xâu hay không, nếu có trả về True, ngược
lại trả về False |
|
CÁC CÂU LỆNH
LÀM VIỆC VỚI DANH SÁCH |
|
|
del <List>(<Chỉ số>) |
Xóa phần
tử trong một danh sách theo chỉ số. Phần tử sau phần tử được
xóa sẽ thay thế vào vị trí trống này. Chỉ số và độ dài bị giảm đi 1 |
|
<List>.remove(<Giá
trị>) |
Xóa duy nhất một phần tử đầu tiên trong danh sách có giá trị đã cho tính từ trái sang phải |
|
<List>.clear() |
Xóa tất
cả phần tử trong danh sách, đưa về danh sách trống rỗng |
|
<List>.append(<Phần
tử>) |
Thêm phần tử vào cuối danh sách |
|
<List>.insert(<Phần tử>,
<Chỉ số>) |
Thêm phần
tử vào danh sách theo chỉ số, phần tử được thêm sẽ chèn vào vị trí và
đẩy các phần tử ở vị trí này (nếu tồn tại) sang phải. Trên Python 3.2, nếu chỉ
số lớn hơn giới hạn của danh sách thì không xảy ra lỗi |
|
CÁC CÂU LỆNH
LÀM VIỆC VỚI XÂU |
|
|
<Xâu mẹ>.find(<Xâu con>, start) |
Tìm vị
trí xâu con từ vị trí start và trả về
chỉ số. Nếu không có start thì mặc
định tìm từ chỉ số 0. Nếu
không tim thấy thì trả về -1 |
|
<List>
= <Xâu>.split(“<Kí tự tách>”) |
Tách các phần tử trong xâu thành một danh sách theo kí tự tách |
|
<Xâu> = “<Ký tự nối>”.join(<List>) |
Ghép các
phần tử trong danh sách theo kí tự nối và đưa vào một xâu |
|
CẤU TRÚC CÂU
LỆNH RẼ NHÁNH IF |
|
|
if <Điều kiện>: |
Nếu điều
kiện True sẽ thực hiện khối lệnh
trong hàm |
|
elif <Điều kiện>: |
Tạo trường hợp khác với lệnh if |
|
else: |
Nếu điều
kiện là False sẽ thực hiện khối lệnh này |
|
CẤU TRÚC CÂU
LỆNH LẶP WHILE |
|
|
while <Điều kiện>: |
Vòng lặp
thực hiện khối lệnh cho đến khi điều kiện thành False |
Phạm vi của biến
- “Phạm vi của biến”
là phạm vi mà biến có thể sử dụng trong chương trình. Bắt đầu khi trình thông dịch
gặp lệnh khai báo biến
- Chia làm 2 loại:
|
Biến toàn cục (global) |
Được khai báo bên ngoài hàm, có hiệu lực bao quát chương
trình Không nên dùng ở các chương trình có hàm phức tạp vì tính
khó kiểm soát, dễ gây lỗi à Chỉ nên dùng khi ít thay đổi và cần dùng nhiều nơi |
|
Biến địa phương/ cục bộ (local) |
Có hiệu lực bên trong hàm được khai báo à không có hiệu lực bên ngoài. Có thể truy cập và đặt tên trùng tên biến toàn cục cho trước,
nhưng không thể sửa đổi giá trị toàn cục. Biến trong định nghĩa hàm có thể là tham số
hoặc biến cục bộ. Có thể sử dụng hàm “global <biến>“ để thay đổi giá trị biến toàn cục |
Lỗi trong Python
SyntaxError (Lỗi cú pháp)
Lỗi xảy ra khi trong
chương trình có câu lệnh viết sai cú pháp hoặc sai cấu trúc ngôn ngữ quy định.
Exception (Lỗi ngoại lệ):
Lỗi xảy ra khi trong
chương trình không thể thực hiện một câu lệnh nào đó (mặc dù cú pháp đúng)
trong quá trình thực thi.
NameError
>>> print(age)
Traceback
(most recent call last):
File "<stdin>", line 1, in
<module>
NameError:
name 'age' is not defined
Như bạn có thể thấy từ thông báo ở trên, biến age chưa
được khai báo. Bây giờ, hãy sửa lỗi này bằng cách khai báo nó và gán vào một
giá trị.
>>> age
= 25
>>> print(age)
25
Loại lỗi là NameError. Chúng ta đã
xử lý lỗi bằng cách khai báo tên biến.
IndexError
>>> n = [1, 2, 3, 4, 5]
>>> n[5]
Traceback (most recent call last):
File
"<stdin>", line 1, in <module>
IndexError: list index out of range
Trong ví dụ trên, Python
đã đưa ra lỗi IndexError, vì list chỉ có các phần tử từ 0 đến 4, vì vậy nó nằm
ngoài phạm vi.
TypeError
>>> 4 + '3'
Traceback (most recent call last):
File
"<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int'
and 'str'
Trong ví dụ trên, lỗi
TypeError (xảy ra khi chúng ta truyền vào không đúng kiểu dữ liệu) xuất
hiện bởi vì chúng ta không thể cộng một số cho một chuỗi. Giải pháp đầu tiên sẽ
là chuyển đổi chuỗi thành int hoặc float. Một giải pháp khác sẽ là chuyển đổi số
thành một chuỗi (kết quả sau đó sẽ là '43').
>>> 4 + int('3')
7
>>> 4 + float('3')
7.0
Lỗi đã được xóa và
chúng tôi nhận được kết quả như mong đợi.
ValueError
>>> int('12a')
Traceback (most recent call last):
File
"<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10:
'12a'
Trong trường hợp này,
chúng ta không thể chuyển đổi xâu đã cho thành một số, vì có ký tự a trong đó.
Chương trình xuất hiện lỗi ValueError (truyền vào đúng kiểu dữ liệu nhưng
giá trị thì không hợp lệ)
ZeroDivisionError
>>> 1/0
Traceback (most recent call last):
File
"<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
Lỗi ZeroDivisionError
sẽ xuất hiện vì chúng ta không thể chia một số cho số 0. Cần tìm nguyên nhân
gây lỗi và đưa ra phương pháp sửa lỗi.
Lỗi ngữ nghĩa (logic):
Lỗi xảy ra khi kết quả
của chương trình không đúng theo yêu cầu của bài toán (chương trình chạy không
lỗi nhưng sai kết quả mong muốn).
>>> ‘4’ + str(3)
‘43’
Để sửa lỗi này, đơn giản
ta chỉ cần chuyển tất cả thành int hoặc float, và thực hiện tính toán.
>>> float(‘4’) + float('3')
7.0
Đại lượng logic
Giá trị chân
lý: là các giá trị “Đúng”
hoặc “Sai”
Đại lượng
lôgic: là các đại lượng
nhận chỉ nhận giá trị là giá trị lôgic.
Biểu diễn giá trị
logic trên bit True à “1”, False à “0”: Có thể biểu diễn dữ liệu logic theo các cách
khác nhau miễn tạo ra hai trạng thái độc lập. Các biến, các hàm có thể mang giá
trị logic.
Lưu ý:
- Để ngắn gọn, thường
biểu diễn các giá trị lôgic “Đúng” và “Sai” tương ứng là 1 và 0.
- Các biến, các hàm
cũng có thể mang giá trị lôgic.
Phép toán logic: Các phép toán logic có thể coi là các “phép
toán logic trên các bit”, tức nhận về 1 hoặc 0. Thứ tự ưu tiên thực hiện: dấu
ngoặc à not à and, or, xor
|
p |
q |
p AND q |
p OR q |
NOT p |
p XOR q |
|
1 |
1 |
1 |
1 |
0 |
0 |
|
1 |
0 |
0 |
1 |
0 |
1 |
|
0 |
1 |
0 |
1 |
1 |
1 |
|
0 |
0 |
0 |
0 |
1 |
0 |
PHẦN II. VIẾT CHƯƠNG TRÌNH CƠ BẢN
Bài 1. Viết chương
trình tính và in ra màn hình tổng của các số hoặc chia hết cho 3 hoặc chia hết
cho 5 trong dãy số.
Yêu cầu: Dãy số nhập
vào từ bàn phím theo 2 cách:
- Cách 1: Nhập
và đưa từng số vào dãy.
- Cách 2: Nhập
các số trên cùng một hàng và cách nhau một khoảng trắng.
Đáp án
CÁCH 1
# Phần định nghĩa hàm
def TinhTong(ls):
# Tạo biến để
lưu trữ giá trị tổng
sum = 0
# Lặp qua tất
cả các giá trị trong danh sách
for i in ls:
if i % 3
== 0 or i % 5 == 0:
sum
= sum + int(i)
return sum
# Phần chương trình chính
N = int(input('Nhập số lượng số cần tính: '))
ls = []
# Vòng lặp yêu cầu nhập từng giá trị
for loop in range(N):
print('Nhập
số thứ', loop, ': ', end = ' ' )
Temp =
int(input())
ls.append(Temp)
# In ra kết quả
print('Các số đã nhập:', ls)
print('Tổng các số vừa nhập:', TinhTong(ls))
CÁCH 2
# Phần định nghĩa hàm
def TinhTong(ls):
# Tạo
variable (biến) để lưu trữ
sum = 0
# Lặp qua tất
cả các giá trị trong danh sách
for i in ls:
if
int(i) % 3 == 0 or int(i) % 5 == 0:
sum
= sum + int(i)
return sum
# Phần chương trình chính
N = input('Nhập các số trên cùng một hàng và cách nhau
bởi khoảng trắng: ')
# Tách các giá trị vừa nhập thành một danh sách
ls = N.split()
# In ra kết quả
print('Các số đã nhập:', ls)
print('Tổng các số vừa nhập:', TinhTong(ls))
Bài 2. Viết chương
trình nhập vào một số tự nhiên N. Tính và đưa ra màn hình tổng của các chữ số của
N.
|
Input |
Output |
|
N = “123895” |
28 |
Đáp án
# Phần định nghĩa hàm
def TongSo(s):
s = str(s) #
Chuyển số sang xâu
sum = 0 # Biến
lưu tổng
for i in s:
sum =
sum + int(i)
return sum
# Phần chương trình chính
N = int(input('Nhập vào số tự nhiên N: '))
# Gọi hàm tính tổng, lưu kết quả vào biến T
T = TongSo(N)
print('Tổng các chữ số của', N, 'là:', T)
Bài 3. Viết chương
trình nhập vào một xâu. Đếm và đưa ra màn hình số ký tự là chữ cái tiếng Anh
có trong xâu.
|
Input |
Output |
|
s = ‘Năm 2024 là năm
Giáp Thìn' |
11 |
Giải thích: Trong s các
chữ cái tiếng Anh gồm: N, m, l, n, m, G, i, p, T, h, n (tổng cộng 11). Sử dụng
bảng mã ASCII mở rộng quốc tế để tra cứu khi cần tại địa chỉ www.ttkt.is-a.dev/2025/04/tra-cuu-bang-ma-ascii-standard-chuan-0.html.
Đáp án
# Phần định nghĩa hàm
def EngChar(s): # Hàm có tên EngChar
c = 0 # Khởi
tạo biến đếm
for i in s:
# Kiểm
tra xem có phải là chữ cái tiếng Anh không
if 'a'
<= i <= 'z' or 'A' <= i <= 'Z':
c =
c + 1 # Tăng biến đếm nếu kết quả đúng
return c #
Trả về giá trị
# Phần chương trình chỉnh
S = input('Nhập xâu cần xác định số kí tự: ')
Char = EngChar(S) # Gọi hàm và lưu lại giá trị trả về
print() # Khoảng trắng xuống dòng
print('Xâu vừa nhập: "' + S + '"') # In lại
xâu vừa nhập
print('Số kí tự là:', Char) # In số kí tự
Bài 4. Viết chương
trình nhập vào một dãy các số tự nhiên. Tìm và xoá bớt các phần tử trùng nhau
trong dãy.
|
Input |
Output |
|
A = [1, 3, 2, 3, 2, 6, 5, 6] |
A = [1, 3, 2, 6, 5] |
Yêu cầu: Sử dụng hàm XoaTrung() để xử lý.
Đáp án
# Phần định nghĩa hàm
def XoaTrung(l):
Final = [] #
Danh sách để lưu kết quả
for i in l:
# Lặp qua từng phần tử trong dãy "l"
if
not(int(i) in Final): # nếu phần tử đó CHƯA có trong Final
# Đây
là mệnh đề đảo, tức nếu là False thì trả về True
Final.append(int(i)) # Thêm phần tử vào danh sách Fina;
return Final
# Trả về danh sách cuối cùng sau khi đã chỉnh sửa
# Phần chương trình chính
S = input('Nhập vào một dãy, cách nhau bởi khoảng trắng:
')
L = S.split() # Tách dãy vừa nhập thành một danh sách
có các xâu số
print(XoaTrung(L)) # Gọi hàm và in ra các phần tử
trùng nhau
Bài 5. Viết chương
trình nhập vào một dãy các số nguyên. Tách dãy số thành hai dãy, dãy 1 gồm các
số chẵn và dãy 2 gồm các số lẻ.
|
Input |
Output |
|
A = [1, 3, 2, 4, 3, 4, 5, 6] |
Le = [1, 3, 3, 5] Chan = [2, 4, 4, 6] |
Yêu cầu: Sử dụng hàm TachSo() để xử lý.
Câu lệnh pass được sử
dụng như một trình giữ chỗ cho mã trong tương lai. Khi câu lệnh pass được thực
thi, không có gì xảy ra, nhưng bạn tránh được lỗi khi không được phép sử dụng
mã rỗng. Mã rỗng không được phép trong vòng lặp, định nghĩa hàm, định nghĩa lớp
hoặc trong câu lệnh if.
Ngoài ra, có một từ khóa được gọi là global cho phép bạn thay
đổi giá trị biến bên ngoài phạm vi hiện tại của nó (ví dụ như trong một hàm – chương trình con). Từ khóa này được sử dụng để thực hiện thay đổi đối với biến toàn cục
từ một vị trí biến cục bộ.
Đáp án
# Phần định nghĩa hàm
def TachSo(ls):
# Lưu trực
tiếp vào biến ở chương trình chính bằng global
global Le
global Chan
for i in ls:
# Lặp qua lần lượt tất cả các số
i =
int(i)
if i %2
== 0: # Nếu đây là số chắn
Chan.append(i)
else: #
Nếu đây là số lẻ
Le.append(i)
pass # Không
bắt buộc, đọc hướng dẫn về lệnh này ở trên
# Phần chương trình chính
N = input('Nhập dãy các số nguyên, cách nhau bởi khoảng
trắng: ')
L = N.split() # Tách thành danh sách các xâu chứa số
Le = [] # Tạo biến cho chương trình con
Chan = [] # Tạo biến cho chương trình con
TachSo(L) # Gọi hàm và lưu giá trị vào các biến đã tạo
(vì có global)
# Phần in kết quả ra màn hình
print('Le =', Le) # In ra các số lẻ
print('Chan =', Chan) # In ra các số chẵn
Bài 6. Viết chương
trình nhập vào họ và tên đầy đủ của một người. Tách họ và tên đầy đủ để lấy ra
các phần họ, tên, họ lót.
|
Input |
Output |
|
S = ‘Nguyễn Hoàng
Văn Thái’ |
Họ: Nguyễn Tên: Thái Họ lót: Hoàng
Văn |
Yêu cầu: Sử dụng các
hàm TachHo(), TachTen(),
TachDem().
Slicing trong Python là một phương pháp đơn giản để trích xuất một phần
con từ các đối tượng có thể lặp như xâu và danh sách. Cú pháp cơ bản của
slicing là <tên biến>[<start>:<end>], trong đó start là chỉ số bắt đầu của phần con (mặc định là 0 nếu không chỉ định), end là chỉ số kết thúc, sẽ lấy kí tự ở chỉ số end - 1.
Ví dụ, nếu ta có một chuỗi S = "Python", biểu thức S[1:4] sẽ lấy các ký tự từ
chỉ số 1 đến 3, kết quả là "yth". Slicing cũng hỗ trợ chỉ số âm, cho phép lấy phần con từ cuối đối tượng
trở về đầu, ví dụ S[-3:]sẽ lấy ba ký tự cuối
cùng của chuỗi "Python", kết quả
là "hon". Tổng quát, slicing là một công cụ mạnh mẽ
giúp thao tác với các phần tử trong các đối tượng có thể lặp một cách linh hoạt
và hiệu quả.
Đáp án
# Phần định nghĩa hàm
def TachHo(s):
L =
s.split() # Tách tên thành từng từ
return L[0]
# Trả về từ đầu tiên là họ
def TachTen(s):
L =
s.split() # Tách tên thành từng từ
k = len(L) -
1 # Lấy chỉ số của từ cuối cùng
return L[k]
# Trả về từ cuối cùng là tên
def TachDem(s):
L =
s.split() # Tách tên thành từng từ
k = len(L) -
1 # Lấy chỉ số của từ cuối cùng
dem = L[1:k]
# Tạo một danh sách chỉ chứa tên đệm
xau = '' #
Biến tạm để lưu tên đệm
# Chuyển
danh sách thành xâu
for i in
dem: # Lặp qua từng từ
xau =
xau + i + ' ' # Thêm từ vào xâu
return xau #
Trả về xâu gồm tên đệm hoàn chỉnh
# Phần chương trình chính
Name = input('Nhập vào họ và tên của một người: ')
# Gọi hàm và lưu giá trị vào biến
Ho = TachHo(Name)
Dem = TachDem(Name)
Ten = TachTen(Name)
# In ra màn hình các kết quả
print('Họ:', Ho)
print('Tên đệm:', Dem)
print('Tên:', Ten)
Bài 7. Viết chương
trình nhập vào họ và tên đầy đủ của một người. Chuẩn hoá họ và tên cho đúng quy
định chính tả (giữa các từ chỉ có một khoảng trắng và chỉ viết hoa ký tự đầu của
mỗi từ).
|
Input |
Output |
|
HoTen = ‘ nguyen VAN aN ' |
‘Nguyễn Văn An’ |
Yêu cầu: Viết hàm ChuanHoa() để xử lý.
Đáp án
# Phần định nghĩa hàm
def ChuanHoa(s):
# Loại bỏ khoảng trắng dư thừa
L = s.split() # Tách xâu tên
thành từng từ
S = '' # Tạo xâu rỗng để dùng
chứa tên
for i in L: # Lặp qua từng từ
trong tên
S = S + i + ' ' # Thêm từng từ vào xâu S
# Tuy nhiên, từ vẫn chưa viết
hoa đúng cách
S = S.title() # Chỉ viết hoa
chữ đầu mỗi từ
return S # Trả về xâu S là tên
đã chuẩn hóa
# Phần chương trình chính
HoTen = input('Nhập họ tên: ')
N = ChuanHoa(HoTen)
print('Họ tên đã chuẩn hóa:', N)
Bài 8. Viết một chương trình bằng Python sử
dụng cấu trúc hàm (không có giá trị
trả về) để in ra mã ASCII (dưới dạng nhị phân) của từng
ký tự trong xâu: "Python
3!". Có
thể sử dụng các hàm có sẵn trong Python như bin(), ord() để chuyển đổi. Thí sinh không được pháp sử dụng
các thư viện bên ngoài.
Trong Python, khi định nghĩa hàm bằng từ
khóa def, ta có thể tạo ra hai loại hàm: hàm có giá trị trả về và hàm không có
giá trị trả về. Hàm có giá trị trả về sử dụng từ khóa return để trả kết
quả ra ngoài. Kết quả này có thể được gán vào biến, sử dụng trong phép tính, hoặc
truyền vào các hàm khác, giúp cho chương trình linh hoạt và dễ mở rộng. Ngược lại,
hàm không có giá trị trả về thường chỉ thực hiện một hành động như in kết quả
ra màn hình bằng lệnh print(), hoặc cập nhật biến
bên ngoài nếu có sử dụng lệnh chỉ báo global, và không trả lại bất kỳ
giá trị nào để sử dụng tiếp.
Ví dụ, nếu viết hàm tính tổng hai số và
dùng return, ta có thể lấy kết quả đó để tính toán tiếp. Nhưng nếu chỉ dùng print(), kết quả
sẽ chỉ được hiển thị mà không thể sử dụng lại trong chương trình chính. Do đó, hàm có return thường được
sử dụng khi cần xử lý dữ liệu nhiều bước, còn hàm in trực tiếp chỉ phù hợp khi
ta chỉ cần hiển thị kết quả ngay lập tức mà không cần những khâu xử lý rườm rà khác.
Đáp án
# Phần hàm chương trình
def findASCII(S): # Khởi tạo hàm
for i in S: # Duyệt từng kí tự
trong xâu S
print(bin(ord(i)), end =
"") # In ra mã nhị phan
# của từng kí tự trong
xâu, nối tiếp nhau
pass # Lệnh này không có chức
năng gì
# Chương trình chính
S = input('Nhập xâu cần duyệt: ') # Nhập xâu cần duyệt
findASCII(S) # Gọi hàm
Bài 9. Viết một hàm tính tổng chia hết có cấu trúc tch(ls, a, b) nhận vào một danh sách các số nguyên, và hai số
nguyên a,
b. Hàm này trả về tổng của các số
trong danh sách mà chia hết cho a hoặc chia hết cho b.
|
Input |
Output |
|
s = "1 3 5 7 9 10 12" a = 2 b = 5 |
27 |
Đáp án
# Phần hàm chương trình
def tch(ls, a, b):
# Chuyển kiểu dữ liệu để tránh
lỗi
a = int(a)
b = int(b)
s = 0 # Đây là biến lưu tổng
for n in ls: # Chạy từng số
trong ls
n = int(n) # Chuyển kiểu dữ
liệu để tránh lỗi
if n % a == 0 or n % b ==
0: # Kiểm tra
s = n + s # Cộng vào
biến tổng
return s # Trả về tổng
# Chương trình chính
print('Nhập các số cách nhau bởi khoảng trắng')
S = input() # Chờ người dùng nhập
L = S.split() # Tách từng số ra danh sách
a = int(input('Nhập số a: '))
b = int(input('Nhập số b: '))
# Chạy hàm và lưu lại kết quả
s = tch(L, a, b)
print('Kết quả:', s) # In ra kết quả
Bài 10. [VẬN DỤNG CAO] Viết hàm palindrome(s) nhận vào một
xâu s. Hàm trả về True nếu s là một palindrome (tức là khi đọc xuôi hay đọc
ngược đều giống nhau) sau khi đã bỏ qua các ký tự không phải chữ cái/số và phân
biệt chữ hoa/thường. Ngược lại trả về False.
|
Input |
Output |
|
s = "a man, a
plan, a canal: panama" |
True |
|
s = "Race a
car" |
False |
Trong Python, khi
làm việc với chuỗi, danh sách hoặc các kiểu dữ liệu có thể lặp, ta có thể sử dụng
kỹ thuật slicing để truy cập các phần tử theo chỉ số. Thông thường, các phần tử
được đánh số từ trái sang phải, bắt đầu từ 0. Tuy nhiên, Python cũng cho phép sử
dụng chỉ số âm để truy cập ngược, tức là từ phải sang trái. Cụ thể, chỉ
số -1 đại diện cho phần tử cuối cùng, -2 là phần tử kế cuối,
và tiếp tục giảm dần.
Ví dụ, với chuỗi s = "Python" mà khi truy cập s[-1], ta sẽ nhận được ký tự "n", tức là ký tự cuối cùng của
chuỗi. Cách truy cập ngược này rất tiện lợi khi muốn lấy phần tử cuối mà không
cần biết trước độ dài của chuỗi hoặc danh sách.
Đáp án
# Phần hàm chương trình
def stringText(s): # Tạo xâu s mới theo quy tắc
S = '' # Biến lưu xâu sau khi
tạo
for i in s: # Lấy từng kí tự rồi
viết ngược lại
if 'a' <= i <= 'z'
or 'A' <= i <= 'z':
S = S + i
return S
def backwards(s): # Dùng để tạo xâu đọc ngược lại
backwards = '' # Biến lưu xâu
sau khi tạo
for i in s: # Lấy từng kí tự rồi
viết ngược lại
if 'a' <= i <= 'z'
or 'A' <= i <= 'z':
backwards = i +
backwards
return backwards # Trả về xâu
thành phẩm
def palindromes(s, b): # Hàm kiểm tra palindromes
# Truyền vào 's' là xâu chính,
'b' là đọc ngược
if s == b:
return True
else:
return False
# Chương trình chính
s = input('Nhập xâu: ')
# Thực hiện chạy các hàm và lưu giá trị
s = stringText(s)
b = backwards(s)
check = palindromes(s, b)
# In ra kết quả
if check:
print('Đây là một
palindromes')
else:
print('Đây không là một
palindromes')
Bài 11. Viết một hàm Python tự động viết hoa chữ đầu của
mỗi câu trong xâu mà người dùng đưa vào. Sau đó trả lại xâu kết quả
|
Input |
Output |
|
s = "hello
world. " |
"Hello world.
" |
|
s = "i have a
lamborghini" |
"I have a lamborghini" |
Yêu cầu: Sử dụng hàm vietHoa() để xử lý.
Đáp án
# Phần hàm chương trình
def vietHoa(s):
S = s.capitalize()
return S
# Phần chương trình chính
S = input('Nhập xâu S: ')
S = vietHoa(S)
print(S)
Bài 12. Viết chương trình nhập vào một xâu S từ bàn
phím gồm các số tự nhiên, mỗi số cách nhau bởi một khoảng trống. Tính và in ra
màn hình tổng, trung bình cộng của các số vừa nhập từ bàn phím.
|
Input |
Output |
|
S = "2 4 0 -3
7" |
Tổng: 10 |
|
Trung bình: 2.0 |
Đáp án
S = input('Nhập các số tự nhiên, cách nhau bởi khoảng trắng: ')
L = S.split() # Tách xâu S ra từng giá trị, kiểu dữ liệu string
Sum = 0 # Hàm để lưu tổng
for i in L:
Sum = Sum + int(i)
print('Tổng:', Sum)
print('Trung bình:', Sum/len(L))
Bài 13. [VẬN DỤNG CAO] Cho hai chuỗi ransomNote và magazine, hãy trả về True nếu ransomNote có thể được tạo
ra bằng cách sử dụng các chữ cái từ magazine,
và trả về False nếu không thể. Mỗi chữ cái trong magazine chỉ có thể được sử dụng một lần trong ransomNote.
Đáp án
def RansomNote(r, m):
for char in r:
if char in m:
# Có thể thay thế giá
trị trong xâu bằng replace
m = m.replace(char,
"", 1)
else:
return False
return True
# Test chương trình với các ví dụ
print(RansomNote("a", "b")) # False
print(RansomNote("aa", "ab")) # False
print(RansomNote("aa", "aab")) # True
print(RansomNote("hello", "oellh")) # True
Bài 14. [VẬN DỤNG CAO] Hãy xây dựng một chương trình bằng ngôn ngữ lập trình Python, sử dụng cấu
trúc hàm có giá trị trả về. Không được sử dụng các hàm chuyển đổi có sẵn của
Python như bin(), int(..., 2) hoặc các thư viện hỗ trợ ngoài tương tự. Cần tự
triển khai thuật toán chuyển đổi. Chương trình cần bao gồm hai hàm chính với chức
năng như sau: một hàm có nhiệm vụ chuyển đổi một số tự nhiên sang dạng nhị
phân (dưới dạng chuỗi ký tự '0' và '1'); một hàm khác có nhiệm vụ chuyển đổi một
chuỗi biểu diễn số nhị phân về dạng số tự nhiên (hệ thập phân).
Đáp án
# Phần định nghĩa hàm
def DecToBin(N): # Hàm chuyển thập phân thành nhị phân
bin = '' # Biến lưu số nhị phân sau mỗi lần tính
while N > 0 and N != 0: # Lặp
cho đến khi điều kiện là False
b = N % 2 # Chia lấy phần dư và lưu vào biến tạm b
# Thêm số nhị phân vào xâu
bin đã khởi tạo ở trên
bin = str(b) + bin # Thêm số mới vào bên trái của xâu
N = N // 2 # Tiếp tục lấy
phần nguyên để chia cho đến hết
return bin # Trả về nhị phân
đã chuyển đổi
def BinToDec(N): # Hàm chuyển nhị phân thành thập phân
N = str(N) # Chuyển kiểu dữ liệu
chứa nhị phân thành xâu
L = len(N) - 1 # Lấy số mũ lớn
nhất
dec = 0 # Biến lưu số thập
phân sau mỗi lần tính
for i in range(len(N)): # Lặp
theo chỉ số độ dài của N
bin = int(N[i]) # Lấy kí tự
nhị phân thứ i và lưu tạm vào bin
# Áp dụng công thức chuyển
đổi thành số
v = bin * (2 ** (L - i)) #
Gía trị tại từng kí tự nhị phân
# Tức là số mũ theo vị trí
nhân với số nhị phân
dec = dec + v # Cộng với
giá trị của những kí tự khác
return dec # Trả về số thập
phân đã chuyển đổi
# Phần chương trình chính
print('1. Chuyển hệ thập phân sang nhị phân') # Hướng dẫn
print('2. Chuyển hệ nhị phân sang thập phân') # Hướng dẫn
C = int(input('Nhập lựa chọn của bạn: ')) # Chờ nhập lựa chọn
print() # Khoảng trắng xuống dòng
# Phần if/else xử lý các tình huống
if C == 1: # Nếu lựa chọn bằng 1
print('Lựa chọn: 1')
N = int(input('Nhập số cần
chuyển: '))
r = DecToBin(N) # Gọi hàm và
lưu giá trị vào biến
print('Kết quả:', r) # In kết
quả bằng cách gọi biến
if C == 2: # Nếu lựa chọn bằng 2
print('Lựa chọn: 2')
N = int(input('Nhập số cần
chuyển: '))
r = BinToDec(N) # Gọi hàm và
lưu giá trị vào biến
print('Kết quả:', r) # In kết
quả bằng cách gọi biến
else: # Nếu lựa chọn khác với 1 và 2
print('Lựa chọn không hợp lệ')
Bài 15. Em hãy viết chương trình Python sử dụng cấu
trúc hàm để tính số tiền bạn Hoa phải trả khi mua thiệp mừng năm mới. Yêu cầu người
dùng nhập vào giá tiền 1 thiệp và số thiệp bạn Hoa mua là các số nguyên được nhập
vào từ bàn phím. Biết rằng giá tiền mua mỗi tấm thiệp thì bằng nhau.
Bài 16. Hoàn thiện chương trình dưới đây, chương trình
nhập từ bàn phím 3 số thực a, b, c đưa ra thông điệp “Cả ba số đều dương” nếu cả
ba số đều dương.
|
Chương trình |
Kết quả |
|
a = …. (input(“a=”)) b = …. (input(“b=”)) c = …. (input(“c=”)) if ….: print(“Cả
ba số đều dương”) |
Với các giá trị nhập vào: a = 8 b = 4 c = 5 Cả ba số đều dương |
Đáp án
a
= int((input(“a=”))
b
= int((input(“b=”))
c
= int((input(“c=”))
if
a > 0 and b > 0 and c > 0:
print(“Cả ba số đều dương”)
Bài 17. [VẬN DỤNG CAO] Viết một chương trình sử dụng cấu trúc hàm để tính giai thừa của một số
nguyên dương mà không sử dụng bất kỳ thư viện có sẵn nào. Hàm phải có khả năng nhận
vào một số nguyên và trả về giai thừa của số đó.
|
Input |
Output |
|
5 |
120 |
Đáp án
# Phần định nghĩa hàm
def factorial(N):
kq = 1
N = N
if N == 0: # Nếu 0! = 1
return kq
for i in range(1, N + 1):
kq = i * kq
return kq
# Phần chương trình chính
N = int(input('Nhập số: '))
F = factorial(N)
print('Kết quả:', F)
Bài 18. [VẬN DỤNG CAO] Viết chương trình Python sử dụng cấu trúc hàm để
in ra dãy số Fibonacci với số lượng phần tử do người dùng nhập vào.
Dãy số Fibonacci là một dãy số bắt đầu với
hai số đầu tiên là 0 và 1, các số tiếp theo được tính bằng tổng của hai số liền trước đó. Ví dụ:
0, 1, 1, 2, 3, 5,
8, 13, 21, 34,... (ví dụ như số thứ 4 là 2, được tạo bởi tổng của số thứ 2 và số thứ 3). Chương trình cần yêu cầu người dùng nhập vào một số nguyên dương n, đại diện cho
số lượng phần tử của dãy cần hiển thị. Sau đó, chương trình sẽ sử dụng hàm để
tính và in ra n số đầu tiên của dãy Fibonacci tương ứng.
Đáp án
# Phần định nghĩa hàm
# Hàm tìm giá trị dãy fibonacci
def fibonacci(n):
a = 'null' # Số liền trước của
số b
b = 'null' # Số liền trước hiện
tại
l = []
while len(l) <= n:
if a == 'null' and b ==
'null':
l.append(0)
b = 0
else:
if a == 'null':
l.append(1)
b = 1
a = 0
else:
l.append(a + b)
b = l[len(l)-1]
a = l[len(l)-2]
return l
# Hàm in ra dãy fibonacci
def display(L):
for i in range(len(L)):
if len(L) - 1 == i:
print(L[i])
else:
print(L[i], end = ',
')
# Phần chương trình chính
N = input('Nhập độ dài dãy fibonacci cần in: ')
L = fibonacci(int(N))
# Gọi hàm in kết quả
display(L)
Bài 19. [VẬN DỤNG CAO] Viết một chương trình Python sử dụng cấu trúc hàm để thực hiện phép cộng
hai số nhị phân do người dùng nhập vào dưới dạng chuỗi ký tự, trong đó chương
trình không được sử dụng bất kỳ hàm chuyển đổi có sẵn nào như int(), bin() hay
các thư viện hỗ trợ chuyển đổi hệ cơ số, mà thay vào đó phải tự định nghĩa các
hàm riêng biệt để xử lý toàn bộ quá trình: bao gồm một hàm chuyển đổi từ chuỗi
nhị phân sang số thập phân bằng cách duyệt từng chữ số và tính tổng theo trọng
số của từng vị trí, một hàm chuyển đổi từ số thập phân về chuỗi nhị phân bằng
phương pháp chia lấy dư thủ công, một hàm thực hiện phép cộng hai số nhị phân bằng
cách kết hợp hai bước chuyển đổi, đảm bảo người dùng có thể nhập dữ liệu,
chương trình xử lý và in ra kết quả cuối cùng là tổng hai số nhị phân dưới dạng
nhị phân.
|
Input |
Output |
|
Nhập số nhị phân thứ
nhất: 1011 Nhập số nhị phân thứ
hai: 110 |
10001 |
Đáp án
# Phần định nghĩa hàm
def DecToBin(N): # Hàm chuyển thập phân thành nhị phân
bin = '' # Biến lưu số nhị phân sau mỗi lần tính
while N > 0 and N != 0: # Lặp
cho đến khi điều kiện là False
b = N % 2 # Chia lấy phần dư và lưu vào biến tạm b
# Thêm số nhị phân vào xâu
bin đã khởi tạo ở trên
bin = str(b) + bin # Thêm số mới vào bên trái của xâu
N = N // 2 # Tiếp tục lấy
phần nguyên để chia cho đến hết
return bin # Trả về nhị phân
đã chuyển đổi
def BinToDec(N): # Hàm chuyển nhị phân thành thập phân
N = str(N) # Chuyển kiểu dữ liệu
chứa nhị phân thành xâu
L = len(N) - 1 # Lấy số mũ lớn
nhất
dec = 0 # Biến lưu số thập
phân sau mỗi lần tính
for i in range(len(N)): # Lặp
theo chỉ số độ dài của N
bin = int(N[i]) # Lấy kí tự
nhị phân thứ i và lưu tạm vào bin
# Áp dụng công thức chuyển
đổi thành số
v = bin * (2 ** (L - i)) #
Gía trị tại từng kí tự nhị phân
# Tức là số mũ theo vị trí
nhân với số nhị phân
dec = dec + v # Cộng với
giá trị của những kí tự khác
return dec # Trả về số thập
phân đã chuyển đổi
def add_decimal(a, b):
return a + b
# Phần chương trình chính
A = input('Nhập A: ')
B = input('Nhập B: ')
A = BinToDec(A)
B = BinToDec(B)
Sum = DecToBin(add_decimal(A, B))
print(Sum)
Bài 20. Viết hàm với đầu
vào là một danh sách A chứa các số nguyên và đầu ra là danh sách B chứa các số
nguyên trong danh sách A là bội của 3.
Đáp án
# Phần viết hàm
def LCM3(A):
B = []
for n in A:
if n % 3 == 0:
B.append(n)
return B
# Phần chương trình
A = [1, 3, 5, 7, 8, 9, 2]
print(LCM3(A))
Bài 21. Viết hàm với đầu
vào là hai số nguyên dương M, N và đầu ra là một danh sách chứa các ước chung của
M, N.
Đáp án
# Phần viết hàm
def rn(A, B):
if A >= B:
n = A
else:
n = B
return n
def uocchung(m, n, min):
r = []
for i in range(1, min):
if m % i == 0 and n % i ==
0:
r.append(i)
return r
# Phần chương trình\
m = 3
n = 9
min = rn(n, m)
print(uocchung(m, n, min))
PHẦN II. GỠ LỖI CHƯƠNG TRÌNH
Bài 1. Chương trình Python sau dùng để tính tổng các số dương trong
danh sách. Tìm lỗi (nếu có) và sửa lại. Giải thích lỗi đó.
|
Input |
Output (mong đợi) |
|
ds = [1, 2, -3, 4,
-5, 6] |
13 |
# Function define
def tinh_tong_so_duong(A):
tong = 0
for i in A:
if i > 0:
tong = tong + i
else:
tong = 0
return tong
# Main program
ds = [1, 2, -3, 4, -5, 6]
print("Tổng số dương:", tinh_tong_so_duong(ds))
Đáp án
- Chương trình gặp lỗi
logic ở dòng thứ 8, nếu có một số âm trong danh sách có thể khiến toàn bộ biến tong bị đặt lại thành 0
- Sửa: bỏ khối lệnh else
Bài 2. Đoạn code sau dùng để tìm
và trả về danh sách các chỉ số (index) của giá trị K trong danh
sách A. Tìm lỗi logic và sửa lại (nếu có).
|
Input |
Output (mong đợi) |
|
danh_sach = [1, 3,
1, 5, 1, 8] |
[0, 2, 4] |
def tim_chi_so(A, K):
ket_qua = []
for i in range(len(A)):
if A[i] == K:
ket_qua.append(i)
return ket_qua
# Main program
danh_sach = [1, 3, 1, 5, 1, 8]
k_can_tim = 1
print(tim_chi_so(danh_sach, k_can_tim))
Đáp án
- Đoạn chương trình
trên đã hoạt động đúng và không có lỗi nào về logic.
Bài 3. Đoạn code sau dùng để tính
giai thừa của một số nguyên không âm n. Nó đang chứa một lỗi logic tinh vi. Tìm và sửa lỗi.
|
Input |
Output (mong đợi) |
|
0 |
1 |
|
5 |
120 |
def giai_thua (n):
if n < 0:
return "Không xác định"
ket_qua = 0
i = n
while i > 1:
ket_qua = ket_qua * i
i = i - 1
return ket_qua
print("Giai thừa của 0:", giai_thua(0))
print("Giai thừa của 5:", giai_thua(5))
Đáp án
- Đoạn chương trình
trên bị lỗi logic tại dòng lệnh thứ 4. Bởi lẽ, một số khi nhân cho 0 thì vẫn bằng
0 nên có thể khiến kết quả bị sai.
- Thay thế ket_qua = 0 thành ket_qua = 1
Bài 4. Đoạn chương trình dưới
đây có một số lỗi cần được chỉnh sửa để hoạt động chính xác. Hãy phân tích mã nguồn, nhận diện nguyên nhân gây lỗi
và sửa chữa để chương trình có thể thực thi đúng như mong muốn.
m, n = 10, 4
def f(a, m, n):
k = n + m + a
return k
f(5)
Đáp án
- Lỗi TypeError xảy ra khi gọi hàm f(5) do không truyền đủ tham số mà hàm cần. Có thể
khắc phục bằng cách truyền thêm tham số, ví dụ f(3, 5, 7)
Bài 5. [VẬN DỤNG CAO] Đoạn chương trình dưới đây hỗ trợ chuyển đổi số từ hệ nhị phân sang hệ
thập phân. Chức năng chính của chương trình là nhận vào một số nhị phân dưới dạng
chuỗi, sau đó thực hiện tính toán và trả về kết quả là giá trị thập phân tương ứng.
Tuy nhiên, chương trình có thể gặp phải một số vấn đề và lỗi khi xử lý một số
trường hợp cụ thể. Hãy kiểm tra chương trình, tìm ra lỗi nếu có và sửa lại mã
nguồn sao cho đúng.
def BinToDec(N):
N = str(N)
L = len(N) - 1
dec = 0
for i in range(len(N)):
i = int(N[i])
dec = dec + i * (2 ** (L -
i))
return dec
N = int(input('Nhập số cần chuyển: '))
r = BinToDec(N)
print('Kết quả:', r)
Đáp án
- Chương trình đang
gán lại
i = int(N[i]), tức là biến chỉ số i bị thay đổi thành giá trị số nhị phân, sau đó lại
dùng i trong (L - i) nên bị sai logic. Ví dụ: nếu i = 0 thì sau dòng i = int(N[i]), i trở
thành giá trị (0 hoặc 1), không còn là chỉ số nữa ⇒ L - i cho ra sai bét.
- Ngoài ra, khi nhập
ví dụ: 0101, Python sẽ tự động chuyển thành số thập phân
không lưu chữ số đầu là 0, hoặc sẽ báo lỗi nếu có ký tự không hợp lệ. Bạn cần
nhập dưới dạng xâu để đảm bảo giữ nguyên giá trị nhị phân.
- Mã nguồn đã sửa:
def BinToDec(N):
N = str(N)
L = len(N) - 1
dec = 0
for i in range(len(N)):
bit = int(N[i])
dec = dec + bit * (2 ** (L - i))
return dec
N = input('Nhập số nhị phân cần
chuyển: ')
if not all(c in '01' for c in N):
print("Lỗi: Chỉ được nhập các ký tự 0
hoặc 1.")
else:
r = BinToDec(N)
print('Kết quả:', r)
Bài 6. [VẬN DỤNG CAO] Đây là một chương trình dùng để kiểm tra xem một xâu do người dùng nhập
vào có phải là một palindromes hay không. Hãy
phát hiện các lỗi logic trong chương trình và đề xuất phương án để chỉnh sửa
chúng.
Palindromes, hay còn gọi là chuỗi đối xứng,
là những chuỗi có đặc điểm đặc biệt: khi đọc từ trái sang phải hay từ phải sang
trái đều giống nhau. Nói cách khác, một chuỗi được xem là palindrome nếu nó
không thay đổi khi đảo ngược thứ tự các ký tự. Các từ như "madam",
"level" hay "radar" là ví dụ đơn giản về palindrome vì khi
viết ngược lại, chúng vẫn giữ nguyên. Trong lập trình Python, ta có thể kiểm
tra một chuỗi có phải là palindrome hay không bằng cách so sánh chuỗi đó với
chính phiên bản đảo ngược của nó.
# Phần hàm chương trình
def stringText(s): # Tạo xâu s mới theo quy tắc
s = ''
for i in s: # Lấy từng kí tự rồi
viết ngược lại
if 'a' <= i <= 'z'
or 'A' <= i <= 'z':
s = s + i
return s
def backwards(s): # Dùng để tạo xâu đọc ngược lại
backwards = '' # Hàm lưu xâu
sau khi tạo
for i in s: # Lấy từng kí tự rồi
viết ngược lại
if 'a' <= i <= 'z'
or 'A' <= i <= 'z':
backwards = i +
backwards
return backwards # Trả về xâu
thành phẩm
def palindromes(s, b): # Hàm kiểm tra palindromes
# Truyền vào 's' là xâu chính,
'b' là đọc ngược
if s == b:
return True
else:
return False
# Chương trình chính
s = input('Nhập xâu:')
s = stringText(s)
b = backwards(s)
check = palindromes(s, b)
print(check)
Đáp án
- Ở dòng lệnh thứ 3, người
viết đã gán s = ‘’ khiến dữ liệu xâu s bị ghi đè, sau đó khi hàm for duyệt thì sẽ không
cho ra kết quả như mong đợi. Đây là lỗi Logic.
- Khắc phục: có thể đổi
biến lưu xâu thành tên khác, ví dụ đổi dòng 3 thành final = ‘’ , dòng 6 thành final = final + i và return final
Bài 7. Xét đoạn chương
trình dùng để tách các ký tự chữ cái thường trong danh sách A và đưa vào danh
sách B. Tìm các dòng có lỗi, đưa ra mã lỗi và hướng khắc phục lỗi đó.
|
Dòng |
Chương trình |
Dòng lỗi |
Mã lỗi |
Phương án khắc phục |
|
1 |
A = ['a', '1', 'c', 'd', '-4'] |
|||
|
2 |
B = [] |
|||
|
4 |
for i in range(len(A)) |
4 |
SyntaxError |
for i in range(len(A)): |
|
5 |
if a <=
A[i] <= z: |
5 |
NameError |
if
‘a’ <= A[i] <= ‘z’: |
|
6 |
B.append(A[i]) |
|||
|
7 |
print(‘Kết quả:’, B) |
Bài 8. Xét đoạn chương
trình in ra màn hình các số nguyên không âm trong xâu s trên một hàng và các số
cách nhau một khoảng trắng. Tìm các dòng có lỗi, đưa ra mã lỗi và hướng khắc phục
lỗi đó.
|
Dòng |
Chương trình |
Dòng lỗi |
Mã lỗi |
Phương án khắc phục |
|
1 |
s = '3 -3 5 0 9 8 -2 7' |
|||
|
2 |
A = s.split() |
|||
|
4 |
for i in range(A): |
4 |
TypeError |
for i in A: |
|
5 |
if i >=
0: |
5 |
TypeError |
if int(i) >= 0: |
|
6 |
print(i,
end = '') |
6 |
Logic |
print(i, end = ‘ ‘) |