List trong Python: tạo, chỉ số, append, sort và duyệt list

List là dãy có thứ tự và thay đổi được

List là kiểu tập hợp được dùng nhiều nhất trong Python. Nếu bạn cần giữ một dãy giá trị có thứ tự và có thể thay đổi (thêm, xóa, sắp xếp, cập nhật), list gần như luôn là lựa chọn đúng.

Bạn tạo list bằng dấu ngoặc vuông:

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "two", 3.0, True]
empty = []

print(fruits)
print(numbers)
print(mixed)
print(empty)

List chứa được mọi thứ, kể cả list khác. Trên thực tế, phần lớn list chỉ chứa một loại dữ liệu, như danh sách người dùng hay danh sách số, vì như vậy dễ suy luận nhất.

Chỉ số

Mỗi phần tử (element) có một vị trí, bắt đầu từ 0. Truy cập bằng dấu ngoặc vuông:

fruits = ["apple", "banana", "cherry"]

print(fruits[0])    # 'apple'
print(fruits[1])    # 'banana'
print(fruits[-1])   # 'cherry' - negative indexes count from the end
print(fruits[-2])   # 'banana'

Truy cập một chỉ số (index) không tồn tại sẽ gây ra IndexError. Nếu có khả năng vượt phạm vi, hãy kiểm tra độ dài trước hoặc bọc phép truy cập trong try.

Cắt list (slicing)

Slicing trả về một khoảng phần tử. Cú pháp là list[start:stop:step], giống như với chuỗi:

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])      # [2, 3, 4]
print(nums[:3])       # [0, 1, 2] - from the start
print(nums[7:])       # [7, 8, 9] - to the end
print(nums[::2])      # [0, 2, 4, 6, 8] - every other item
print(nums[::-1])     # reversed copy

Hai điều nên nhớ kỹ:

• Slicing luôn trả về một list mới. Sửa phần được cắt ra không ảnh hưởng đến list gốc.
• Chỉ số stop không được tính: nums[2:5] cho các chỉ số 2, 3 và 4, không có 5.

Cách append, extend và insert phần tử

Ba phương thức "thêm vào list" làm những việc khác nhau, và nhầm lẫn giữa chúng là nguồn bug rất hay gặp:

items = ["a", "b", "c"]

items.append("d")       # add ONE item to the end
items.insert(0, "z")    # insert ONE item at a specific index
items.extend(["e", "f"])  # add EACH item from another iterable

print(items)

• append(x) thêm x như một phần tử duy nhất, kể cả khi x là một list. items.append([1, 2]) thêm chính list đó thành một phần tử.
• extend(iterable) thêm từng phần tử lấy từ iterable. items.extend([1, 2]) thêm hai phần tử.
• insert(i, x) chèn vào một chỉ số cụ thể, đẩy mọi phần tử từ vị trí i trở đi lùi về sau một vị trí.

+= với một list ở vế phải hoạt động như extend:

items = ["a", "b"]
items += ["c", "d"]
print(items)

Còn để xóa:

items = ["a", "b", "c", "b", "d"]

items.remove("b")       # removes the first occurrence of "b"
print(items)

last = items.pop()      # removes and returns the last item
print(last, items)

second = items.pop(0)   # remove and return the item at index 0
print(second, items)

Nếu bạn remove() một thứ không có trong list, Python sẽ báo ValueError. Nếu cần "xóa nếu có", hãy kiểm tra bằng in trước hoặc dùng try.

Bạn cũng có thể xóa theo chỉ số bằng del:

items = [10, 20, 30, 40, 50]
del items[1]
print(items)

Độ dài, kiểm tra phần tử, đếm

nums = [4, 8, 15, 16, 23, 42, 16]

print(len(nums))         # 7
print(16 in nums)        # True
print(nums.count(16))    # 2
print(nums.index(23))    # 4 - index of the first 23

in là cách dễ đọc để kiểm tra list có chứa một giá trị hay không. Nếu bạn sẽ hỏi câu đó nhiều lần trên một list lớn, hãy dùng set: kiểm tra phần tử trong set là O(1), còn trong list là O(n).

Sắp xếp

Có hai cách, và chọn cách nào là điều quan trọng:

nums = [5, 2, 9, 1, 7]

# In place - modifies the list, returns None.
nums.sort()
print(nums)    # [1, 2, 5, 7, 9]

# Returns a new sorted list, leaves the original alone.
original = [5, 2, 9, 1, 7]
sorted_nums = sorted(original)
print(sorted_nums, original)

Cả hai đều nhận reverse=True để sắp xếp giảm dần:

nums = [5, 2, 9, 1, 7]
nums.sort(reverse=True)
print(nums)    # [9, 7, 5, 2, 1]

Và một hàm key để tùy chỉnh thứ tự:

words = ["banana", "apple", "kiwi", "strawberry"]
words.sort(key=len)
print(words)    # ['kiwi', 'apple', 'banana', 'strawberry']

key được áp dụng cho từng phần tử, và kết quả của nó là thứ được đem ra so sánh. Các trường hợp hay gặp: sắp xếp theo độ dài, theo một thuộc tính cụ thể, hoặc theo dạng chữ thường của chuỗi.

Đảo ngược

Ba kiểu, tùy theo nhu cầu:

items = [1, 2, 3, 4]

# In place - modifies the list, returns None.
items.reverse()
print(items)

# Slicing - returns a new reversed list.
original = [1, 2, 3, 4]
copy = original[::-1]
print(copy, original)

# reversed() - returns a lazy iterator.
for n in reversed([1, 2, 3, 4]):
    print(n)

Dùng cách tại chỗ khi không cần list gốc. Dùng slicing khi muốn một bản sao mới. Dùng reversed() khi chỉ cần lặp theo chiều ngược mà không tạo ra list mới.

Cái bẫy tham chiếu chung

List thay đổi được (mutable), còn biến là tham chiếu. Nghĩa là hai biến có thể cùng trỏ vào một list:

a = [1, 2, 3]
b = a
b.append(4)

print(a)    # [1, 2, 3, 4] - a changed too!

b = a không sao chép list; nó chỉ khiến b thành tên thứ hai của cùng một list. Nếu muốn một bản sao, hãy yêu cầu rõ ràng:

a = [1, 2, 3]
b = a.copy()   # or list(a), or a[:]
b.append(4)

print(a, b)    # [1, 2, 3]  [1, 2, 3, 4]

Lập trình viên Python nào cũng dính lỗi này ít nhất một lần. Nhớ rằng: = giữa hai list không sao chép.

Lặp và tạo list

Bạn đã biết mẫu cơ bản từ trang về vòng lặp for:

scores = [45, 72, 33, 90, 58, 61]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print(passing)

Cách này dễ đọc và lúc nào cũng ổn. Khi đã quen tay, list comprehension tương đương làm đúng việc đó trên một dòng:

scores = [45, 72, 33, 90, 58, 61]
passing = [s for s in scores if s >= 60]
print(passing)

Chúng ta sẽ tìm hiểu kỹ comprehension ở trang sau nữa.

Cheat sheet nhanh

Những phương thức đáng biết, xem nhanh:

• append(x): thêm vào cuối
• extend(iter): thêm từng phần tử từ một iterable
• insert(i, x): chèn vào chỉ số i
• pop() / pop(i): xóa và trả về
• remove(x): xóa lần xuất hiện đầu tiên của x
• sort() / sort(key=...) / sort(reverse=True)
• reverse()
• index(x): vị trí của x đầu tiên
• count(x): số lần x xuất hiện
• copy(): sao chép nông (shallow copy)

Tiếp theo

List là công cụ chủ lực. Tiếp theo, chúng ta sẽ xem tuple, người anh em không thay đổi được của list, và khi nào chọn tuple là quyết định tốt hơn.