Biểu tượng chim cắt của Kestrel Exams KESTREL EXAMSLUYỆN TẬP ĐỂ ĐẠT
Bản dịch này do AI thực hiện và chưa được người bản ngữ kiểm duyệt. Nếu có khác biệt, bản tiếng Anh là bản chính. Mã nguồn được giữ nguyên bằng tiếng Anh. Ứng dụng luyện tập và tài liệu cho các kỳ thi chứng chỉ của Hoa Kỳ chỉ có bằng tiếng Anh. Read in English
PythonĐọc trong 10 phútMã đã được kiểm chứng

Các mẫu dùng danh sách: comprehension, đếm, sắp xếp và zip

Khi đã biết danh sách (list) và từ điển (dictionary), phần lớn bài tập được chấm điểm chỉ là vài mẫu quen thuộc được trình bày theo cách khác: tìm phần tử lớn nhất, giữ lại một số phần tử và biến đổi chúng, đếm, sắp xếp, ghép hai danh sách theo vị trí, và xử lý một bảng bản ghi. Bài hướng dẫn này trình bày từng mẫu, cách dùng vòng lặp (loop) trước, cách viết ngắn sau. Mọi đoạn mã đều đã được chạy trên CPython 3.11.

Luyện tập chủ đề này trong ứng dụng miễn phí →Tất cả bài hướng dẫn Python

Những mẫu quen thuộc, không phải câu đố#

Đầu bếp không nghĩ ra cách thái hành mới cho mỗi công thức. Họ có vài động tác, thái, đánh, trộn, và món nào cũng là những động tác đó theo thứ tự khác nhau.

Chương trình xử lý danh sách cũng vậy. Gần như mọi bài tập đều được ghép từ sáu động tác: tìm phần tử tốt nhất, giữ lại và biến đổi, đếm, sắp xếp, ghép cặp, và xử lý một bảng bản ghi. Nhận ra động tác thì mã sẽ theo sau. Mỗi mục dưới đây trình bày vòng lặp dài trước, vì đó là thứ bạn phải dò từng bước (trace) được, rồi đến cách viết ngắn của Python, vì đó là thứ bạn sẽ được yêu cầu đọc.

Tìm phần tử lớn nhất, và vị trí của nó#

Python có max và min, nhưng bài thi thường yêu cầu bạn tự làm bằng tay, vì mẫu quan trọng hơn đáp án. Hãy bắt đầu bằng cách giả định phần tử đầu tiên là tốt nhất, rồi để từng phần tử còn lại thách thức nó:

temps = [-4, -9, -1, -7]

highest = temps[0]
day = 0
for i in range(1, len(temps)):
    if temps[i] > highest:
        highest = temps[i]
        day = i
print("Warmest:", highest, "on day", day)

print(max(temps), min(temps))
words = ["fig", "banana", "kiwi"]
print(max(words), max(words, key=len))
Warmest: -1 on day 2
-1 -9
kiwi banana

Có hai chi tiết quan trọng. Bắt đầu từ temps[0], không phải từ 0, giúp mã vẫn đúng khi mọi giá trị đều âm. Và nhớ cả chỉ số (index) lẫn giá trị sẽ trả lời được câu hỏi “ngày nào?”. Các hàm có sẵn cho cùng đáp án, và max còn nhận một key: với key=len, nó so sánh độ dài thay vì so sánh chính các từ.

List comprehension: giữ lại và biến đổi trong một dòng#

Hãy hình dung một băng chuyền. Các món hàng lần lượt đi tới; một công nhân kiểm tra từng món, bỏ đi một số, và biến đổi những món đạt yêu cầu trước khi cho vào một thùng mới. List comprehension (cú pháp rút gọn) chính là băng chuyền đó được viết thành một dòng:

new_list = [ what_to_put_in   for item in old_list   if keep_this_one ]

Hãy đọc là: “tạo một danh sách gồm thứ này, với mỗi phần tử trong danh sách cũ, nhưng chỉ khi điều kiện đúng”. Phần if là không bắt buộc. Đây là cách dùng vòng lặp và cách dùng comprehension đặt cạnh nhau:

prices = [4, 15, 8, 22, 9]

cheap_with_tax = []
for p in prices:
    if p < 10:
        cheap_with_tax.append(p * 1.1)
print(cheap_with_tax)

cheap_with_tax = [p * 1.1 for p in prices if p < 10]
print(cheap_with_tax)
print(prices)
[4.4, 8.8, 9.9]
[4.4, 8.8, 9.9]
[4, 15, 8, 22, 9]

Cả hai đều tạo ra cùng một danh sách. Comprehension ngắn hơn và, một khi bạn đọc được, rõ ràng hơn. Nó luôn tạo một danh sách mới; bản gốc không bị đụng đến. Còn hai dạng nữa bạn sẽ gặp:

words = ["apple", "Kiwi", "banana", "Fig"]

lengths = [len(w) for w in words]
print(lengths)

capitalised = [w for w in words if w[0].isupper()]
print(capitalised)

labels = ["long" if len(w) > 4 else "short" for w in words]
print(labels)
[5, 4, 6, 3]
['Kiwi', 'Fig']
['long', 'short', 'long', 'short']

Hãy để ý vị trí của từng if. if ở cuối dùng để lọc: các phần tử không đạt bị loại, nên danh sách mới có thể ngắn hơn. if…else ở đầu chọn một giá trị cho mọi phần tử, nên danh sách mới luôn dài bằng danh sách cũ.

Đếm bằng từ điển và get#

Để đếm mỗi thứ xuất hiện bao nhiêu lần, hãy dùng từ điển: khóa (key) là các thứ đó, giá trị (value) là số đếm của chúng. Cái bẫy nằm ở lần đầu tiên bạn gặp một thứ, vì nó chưa có số đếm:

colors = ["red", "blue", "red"]
counts = {}
for color in colors:
    counts[color] = counts[color] + 1
Traceback (most recent call last):
  File "main.py", line 4, in <module>
    counts[color] = counts[color] + 1
                    ~~~~~~^^^^^^^
KeyError: 'red'

counts["red"] + 1 đòi một khóa chưa tồn tại. Cách sửa là get, nhận một giá trị mặc định để dùng khi thiếu khóa:

colors = ["red", "blue", "red", "green", "red", "blue"]
counts = {}
for color in colors:
    counts[color] = counts.get(color, 0) + 1
print(counts)
print(max(counts, key=counts.get))
{'red': 3, 'blue': 2, 'green': 1}
red

Hãy đọc counts.get(color, 0) + 1 là “số đếm đến lúc này, hoặc 0 nếu đây là lần đầu, cộng một”. Dòng cuối tìm màu xuất hiện nhiều nhất bằng max(counts, key=counts.get): nó xem xét mọi khóa và so sánh chúng theo giá trị.

sorted và sort, cùng với key#

Có hai cách sắp xếp, và nhầm lẫn giữa chúng là một trong những lỗi (bug) phổ biến nhất trong Python:

sorted(lst)lst.sort()
Đây là gìmột hàm (function) có sẵnmột phương thức (method) của danh sách
Danh sách gốckhông đổiđược sắp xếp ngay tại chỗ (in place)
Trả vềmột danh sách mới đã sắp xếpNone
Dùng được vớimọi thứ bạn có thể lặp qua: danh sách, tuple (bộ giá trị), chuỗi (string), tập hợp (set), từ điển (cho ra các khóa)chỉ danh sách
scores = [72, 95, 88, 61]

ordered = sorted(scores)
print(ordered, scores)

scores.sort(reverse=True)
print(scores)

scores = scores.sort()
print(scores)
[61, 72, 88, 95] [72, 95, 88, 61]
[95, 88, 72, 61]
None

Dòng cuối là cái bẫy: scores = scores.sort() sắp xếp danh sách rồi thay nó bằng None mà sort trả về. Hãy dùng dạng này hoặc dạng kia, đừng bao giờ dùng cả hai trên một dòng.

Cả hai đều nhận reverse=True và một key: một hàm được áp dụng cho từng phần tử để quyết định thứ tự. key=len sắp xếp theo độ dài. key=str.lower sắp xếp văn bản không phân biệt chữ hoa chữ thường (nếu không, mọi chữ hoa đều xếp trước mọi chữ thường). Để sắp xếp theo một giá trị bên trong mỗi phần tử, lambda, một hàm rất nhỏ viết trong một dòng, cho biết cần dùng phần nào:

names = ["bea", "Al", "Christopher", "dee"]
print(sorted(names))
print(sorted(names, key=str.lower))
print(sorted(names, key=len))

prices = {"pen": 1.5, "notebook": 4.25, "backpack": 30.0, "eraser": 0.75}
for name, price in sorted(prices.items(), key=lambda pair: pair[1]):
    print(name, price)
['Al', 'Christopher', 'bea', 'dee']
['Al', 'bea', 'Christopher', 'dee']
['Al', 'bea', 'dee', 'Christopher']
eraser 0.75
pen 1.5
notebook 4.25
backpack 30.0

lambda pair: pair[1] có nghĩa là “với một phần tử tên là pair, hãy dùng phần thứ hai của nó”. sorted(prices.items(), ...) biến từ điển thành các cặp (name, price), nên đoạn này sắp xếp các sản phẩm theo giá.

Ghép cặp: zip và enumerate#

Khi hai danh sách khớp nhau theo từng vị trí, chẳng hạn tên và điểm tương ứng, zip đi qua cả hai cùng lúc như hai bên của một dây khóa kéo, đưa cho bạn từng cặp một. enumerate đưa cho bạn từng phần tử cùng với vị trí của nó:

names = ["Ana", "Ben", "Cy", "Dee"]
scores = [91, 78, 85]

for name, score in zip(names, scores):
    print(name, score)

lookup = dict(zip(names, scores))
print(lookup)

for place, name in enumerate(names, start=1):
    print(place, name)
Ana 91
Ben 78
Cy 85
{'Ana': 91, 'Ben': 78, 'Cy': 85}
1 Ana
2 Ben
3 Cy
4 Dee

zip dừng khi danh sách ngắn hơn hết phần tử, và không báo gì cả: Dee không có điểm, nên Dee cứ thế biến mất khỏi các cặp. Đó thường là dấu hiệu dữ liệu bị sai, nên hãy kiểm tra độ dài khi điều đó quan trọng; từ Python 3.10, zip(names, scores, strict=True) gây ra ValueError thay vì âm thầm bỏ phần tử. dict(zip(...)) biến thẳng hai danh sách thành một từ điển, và enumerate(..., start=1) đánh số từ 1 thay vì 0.

Danh sách các từ điển: một bảng bản ghi#

Danh sách các từ điển là phiên bản Python của một bảng tính: mỗi từ điển là một hàng (một bản ghi), và các khóa là tiêu đề cột. Mọi mẫu ở trên đều dùng được với nó:

students = [
    {"name": "Ana", "score": 91, "year": 1},
    {"name": "Ben", "score": 78, "year": 2},
    {"name": "Cy", "score": 85, "year": 1},
]

total = 0
for s in students:
    total = total + s["score"]
print("Average:", round(total / len(students), 1))

first_years = [s["name"] for s in students if s["year"] == 1]
print("First years:", first_years)

best = max(students, key=lambda s: s["score"])
print("Top:", best["name"])

for s in sorted(students, key=lambda s: s["name"], reverse=True):
    print(s["name"], s["score"])
Average: 84.7
First years: ['Ana', 'Cy']
Top: Ana
Cy 85
Ben 78
Ana 91

Mỗi dòng là một trong các động tác đã nêu. Vòng lặp với s["score"] truy cập vào từng hàng theo tên cột. Comprehension giữ lại một số hàng và lấy ra một trường. max và sorted dùng lambda để cho biết cần so sánh cột nào. Cấu trúc này, một danh sách các bản ghi, là thứ bạn nhận được khi chương trình đọc tệp (file) CSV hoặc dữ liệu từ web, và đó là lý do các môn học dành thời gian cho nó.

Một câu để mang vào phòng thi

Bắt đầu tìm kiếm từ phần tử đầu tiên; tạo danh sách mới bằng [expr for x in items if condition]; đếm bằng d.get(key, 0) + 1; dùng sorted() để có danh sách mới và .sort() để thay đổi một danh sách, đừng bao giờ viết x = x.sort(); và nhớ rằng zip dừng ở danh sách ngắn hơn.

Những chỗ dễ sai#

  • Bắt đầu tìm giá trị lớn nhất từ 0. Nếu mọi giá trị đều âm, 0 sẽ thắng và kết quả sai. Hãy bắt đầu từ phần tử đầu tiên.
  • counts[key] += 1 với một khóa mới. KeyError. Hãy dùng counts.get(key, 0) + 1.
  • scores = scores.sort(). sort trả về None, nên danh sách bị mất. Hãy viết scores.sort() hoặc scores = sorted(scores).
  • Đặt if dùng để lọc ở đầu comprehension. Ở đầu, nó cần có else và dùng để chọn một giá trị; muốn loại bỏ phần tử thì if phải đặt ở cuối.
  • Mong zip báo lỗi khi độ dài không bằng nhau. Nó âm thầm dừng ở danh sách ngắn hơn.
  • Sắp xếp các từ lẫn chữ hoa chữ thường và mong có thứ tự như trong cuốn từ điển. Chữ hoa được xếp trước. Hãy dùng key=str.lower.
  • Truy cập bản ghi bằng một khóa viết sai, chẳng hạn s["Score"]. Khóa phân biệt chữ hoa chữ thường; như vậy sẽ gây ra KeyError.

Luyện tập#

Hãy trả lời từng câu trên giấy trước khi xem lời giải. Mọi đáp án có liên quan đến việc chạy mã đều đã được kiểm tra bằng cách chạy thật.

  1. Hãy viết một list comprehension cho ra bình phương của các số chẵn trong nums = [3, 8, 12, 5, 6].
  2. ["pass" if s >= 70 else "fail" for s in [65, 90, 70]] tạo ra gì, và kết quả dài bao nhiêu?
  3. Hãy đếm mỗi chữ cái xuất hiện bao nhiêu lần trong "mississippi" bằng từ điển và get.
  4. Hãy tự tìm từ ngắn nhất trong một danh sách bằng tay (không dùng min), rồi tìm bằng min và một key.
  5. Sau đoạn mã này, a và b chứa gì? a = [3, 1, 2], b = sorted(a), a = a.sort().
  6. Cho một danh sách các bản ghi như {"name": "Ana", "score": 91}, hãy viết một dòng cho ra tên của sinh viên có điểm cao nhất.

Lời giải#

  1. Lọc bằng if ở cuối, và bình phương ở đầu:
    nums = [3, 8, 12, 5, 6]
    evens_squared = [n * n for n in nums if n % 2 == 0]
    print(evens_squared)
    [64, 144, 36]
  2. ['fail', 'pass', 'pass'], ba phần tử. if…else ở đầu chọn một giá trị cho mọi phần tử, nên danh sách mới luôn dài bằng danh sách cũ.
  3. Mỗi chữ cái bắt đầu từ giá trị mặc định 0 của get:
    word = "mississippi"
    counts = {}
    for ch in word:
        counts[ch] = counts.get(ch, 0) + 1
    print(counts)
    {'m': 1, 'i': 4, 's': 4, 'p': 2}
  4. Bắt đầu với từ đầu tiên và để mỗi từ phía sau thách thức nó:
    words = ["planet", "sun", "comet", "moon"]
    shortest = words[0]
    for w in words[1:]:
        if len(w) < len(shortest):
            shortest = w
    print(shortest)
    print(min(words, key=len))
    sun
    sun
  5. b là [1, 2, 3], một danh sách mới. a là None: a.sort() đã sắp xếp danh sách ngay tại chỗ và trả về None, rồi giá trị đó được gán cho a.
  6. max(students, key=lambda s: s["score"])["name"]. max so sánh các bản ghi theo điểm và trả về toàn bộ bản ghi, rồi ["name"] lấy tên của bản ghi đó.

Danh sách kiểm tra trước khi thi#

Đây là các kỹ năng mà môn lập trình nhập môn kiểm tra ở chủ đề này. Chỉ đánh dấu một mục khi bạn làm được mà không cần nhìn tài liệu.

  • ☐  Tôi tìm được phần tử lớn nhất hoặc nhỏ nhất, cùng vị trí của nó, bằng một vòng lặp bắt đầu từ phần tử đầu tiên.
  • ☐  Tôi viết và đọc được list comprehension, với bộ lọc ở cuối và với if-else ở đầu.
  • ☐  Tôi đếm được các phần tử bằng từ điển và get(key, 0), và tìm được phần tử xuất hiện nhiều nhất.
  • ☐  Tôi giải thích được sự khác nhau giữa sorted() và .sort(), và sắp xếp được với reverse=True và một key.
  • ☐  Tôi dùng được zip và enumerate, và nói được zip làm gì với các danh sách có độ dài khác nhau.
  • ☐  Tôi lặp qua, lọc, tổng hợp và sắp xếp được một danh sách các từ điển.

Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí

12 câu hỏi luyện tập về comprehension, zip, sorted, enumerate và đếm bằng get. Miễn phí, dùng được khi không có mạng, không cần tài khoản.

Luyện tập các mẫu dùng danh sách →

Câu hỏi thường gặp#

List comprehension trong Python là gì?

Cách viết một dòng để tạo danh sách mới từ một danh sách có sẵn: [expression for item in items if condition]. Cách này tương đương với một vòng lặp for thêm phần tử vào một danh sách rỗng, kèm một bộ lọc không bắt buộc. Danh sách gốc không bị thay đổi.

sort() và sorted() trong Python khác nhau thế nào?

list.sort() sắp xếp danh sách ngay tại chỗ và trả về None. sorted() dùng được với mọi thứ bạn có thể lặp qua và trả về một danh sách mới đã sắp xếp, giữ nguyên bản gốc. Viết x = x.sort() sẽ thay danh sách bằng None.

Làm thế nào để đếm số lần xuất hiện bằng từ điển trong Python?

Lặp qua các phần tử và viết counts[item] = counts.get(item, 0) + 1. get trả về 0 ở lần đầu tiên gặp một phần tử, nhờ đó tránh được KeyError mà counts[item] + 1 sẽ gây ra.

Điều gì xảy ra nếu bạn zip hai danh sách có độ dài khác nhau?

Theo mặc định, zip dừng ở cuối danh sách ngắn hơn, âm thầm bỏ qua các phần tử dư trong danh sách dài hơn, không gây ra lỗi nào. Từ Python 3.10, zip(a, b, strict=True) gây ra ValueError khi độ dài khác nhau.

Làm thế nào để sắp xếp một danh sách các từ điển theo một giá trị?

Hãy truyền một hàm key chọn ra giá trị đó: sorted(records, key=lambda r: r["score"]). Thêm reverse=True để xếp lớn nhất trước. Cùng key đó cũng dùng được với max và min.

Làm thế nào để tìm giá trị lớn nhất trong danh sách mà không dùng max?

Lưu phần tử đầu tiên làm giá trị tốt nhất đến lúc này, rồi lặp qua các phần tử còn lại và thay giá trị tốt nhất mỗi khi gặp phần tử lớn hơn. Bắt đầu từ phần tử đầu tiên thay vì 0 giúp kết quả vẫn đúng với số âm. Hãy theo dõi cả chỉ số nếu bạn cần biết vị trí.

Đề xuất chỉnh sửa

Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.