Làm quen với List trong Python

Python Tutorial | 17/07/2025 by Hoc Python

Thử tưởng tượng bạn muốn lưu danh sách tất cả học sinh trong một lớp, hoặc danh sách các mặt hàng trong giỏ hàng khi mua sắm online. Sẽ thật bất tiện nếu phải tạo ra hàng chục, hàng trăm biến riêng lẻ, đúng không? Đây chính là lúc List trở thành một "trợ thủ" đắc lực! List là một trong những cấu trúc dữ liệu mạnh mẽ và linh hoạt nhất của Python, cho phép bạn tổ chức và quản lý một tập hợp các phần tử theo một thứ tự nhất định. Nó giống như một chiếc hộp đa năng mà bạn có thể chứa đủ loại đồ vật, sắp xếp chúng, thêm mới, bớt đi hoặc thay đổi tùy ý.

Trong bài viết này, chúng ta sẽ cùng tìm hiểu List từ những khái niệm cơ bản nhất: cách tạo List, truy cập các phần tử, đến các thao tác thêm, xóa, sửa và sử dụng các phương thức hữu ích khác. Hãy sẵn sàng để làm quen và tận dụng tối đa sức mạnh của List trong các chương trình Python của bạn!

List là gì và tại sao chúng ta cần nó?

Khái niệm: List (Danh sách)

Trong Python, List (Danh sách) là một trong những kiểu dữ liệu cơ bản và linh hoạt nhất để bạn lưu trữ nhiều thông tin cùng một lúc. Nó giống như một "container" (thùng chứa) đặc biệt có thể đựng nhiều thứ khác nhau.

Hãy nhớ hai đặc điểm chính của List:

Có thứ tự: Các phần tử trong List được sắp xếp theo một thứ tự nhất định. Mỗi phần tử có một vị trí (gọi là chỉ số - index), và thứ tự này không thay đổi trừ khi bạn chủ động sắp xếp lại hoặc thêm/bớt phần tử.
Có thể thay đổi (Mutable): Điều này có nghĩa là sau khi bạn đã tạo một List, bạn hoàn toàn có thể thêm, xóa hoặc thay đổi giá trị của các phần tử bên trong nó.

List cho phép bạn lưu trữ nhiều mục (phần tử) trong một biến duy nhất, thay vì phải tạo ra hàng tá biến riêng lẻ. Các phần tử trong List có thể là bất kỳ kiểu dữ liệu nào trong Python: số nguyên, chuỗi, số thực, Boolean, và thậm chí là các List khác!

Tầm quan trọng

List đóng vai trò cực kỳ quan trọng trong lập trình vì nó giúp bạn tổ chức và quản lý dữ liệu một cách hiệu quả khi bạn có nhiều mục liên quan.

Hãy tưởng tượng bạn cần lưu trữ tên của 30 học sinh trong một lớp. Nếu không có List, bạn sẽ phải làm thế này:

hoc_sinh_1 = "An"
hoc_sinh_2 = "Binh"
hoc_sinh_3 = "Hoa"
# ... và tiếp tục đến hoc_sinh_30

Cách này rất cồng kềnh, dễ gây lỗi và gần như không thể quản lý được nếu số lượng học sinh lớn hoặc thay đổi. List giải quyết vấn đề này một cách thanh lịch:

danh_sach_hoc_sinh = ["An", "Binh", "Hoa", "Lan", "Hung"]
print(f"Danh sách học sinh: {danh_sach_hoc_sinh}")
# Kết quả: Danh sách học sinh: ['An', 'Binh', 'Hoa', 'Lan', 'Hung']

Bây giờ, tất cả tên học sinh đều nằm gọn trong một biến duy nhất danh_sach_hoc_sinh. Điều này giúp bạn:

Dễ dàng quản lý: Chỉ cần thao tác với một biến thay vì nhiều biến.
Linh hoạt: Có thể dễ dàng thêm học sinh mới, xóa học sinh cũ, hoặc cập nhật thông tin.
Thực hiện các thao tác hàng loạt: Duyệt qua từng học sinh, tìm kiếm tên, sắp xếp danh sách một cách tự động.

Ví dụ thực tế về ứng dụng của List:

Danh sách mua sắm: gio_hang = ["sữa", "bánh mì", "trứng", "rau củ"]

Danh sách điểm số: diem_thi = [8.5, 7.0, 9.2, 6.5]

Danh sách các công việc cần làm: todo_list = ["Học Python", "Đi siêu thị", "Tập thể dục"]

Danh sách người dùng online: nguoi_dung_truc_tuyen = ["Alice", "Bob", "Charlie"]

Chuỗi các sự kiện theo thời gian: lich_trinh = ["Sáng: Họp", "Trưa: Ăn trưa", "Chiều: Viết báo cáo"]

# Ví dụ tổng hợp về List chứa các kiểu dữ liệu khác nhau
thong_tin_khoa_hoc = ["Lập trình Python", 2025, True, 4.5, ["Giảng viên A", "Giảng viên B"]]
print(f"Tên khóa học: {thong_tin_khoa_hoc[0]}")
print(f"Năm học: {thong_tin_khoa_hoc[1]}")
print(f"Đang mở đăng ký: {thong_tin_khoa_hoc[2]}")
print(f"Đánh giá trung bình: {thong_tin_khoa_hoc[3]}")
print(f"Danh sách giảng viên: {thong_tin_khoa_hoc[4]}")

# Kết quả:
# Tên khóa học: Lập trình Python
# Năm học: 2025
# Đang mở đăng ký: True
# Đánh giá trung bình: 4.5
# Danh sách giảng viên: ['Giảng viên A', 'Giảng viên B']

Tạo và truy cập List cơ bản trong Python

Cách tạo một List

Cú pháp: Để tạo một List trong Python, bạn chỉ cần đặt các phần tử của mình bên trong một cặp ngoặc vuông [], và phân tách các phần tử đó bằng dấu phẩy ,.
Phần tử đa dạng: Một trong những điểm mạnh của List là nó có thể chứa các phần tử với kiểu dữ liệu khác nhau trong cùng một List. Bạn có thể có số nguyên, chuỗi, số thực, giá trị Boolean, và thậm chí là các List khác lồng vào nhau!
List rỗng: Bạn cũng có thể tạo một List không chứa phần tử nào, gọi là List rỗng, bằng cách sử dụng cặp ngoặc vuông trống [].

Ví dụ:

# List chứa các số nguyên
list_so_nguyen = [10, 20, 30, 40]
print(f"List số nguyên: {list_so_nguyen}")

# List chứa các chuỗi
list_mon_an = ["Phở", "Bún chả", "Bánh mì"]
print(f"List món ăn: {list_mon_an}")

# List chứa các kiểu dữ liệu khác nhau
my_diverse_list = [1, "hello", 3.14, True, ["nested", "list"]]
print(f"List đa dạng: {my_diverse_list}")

# Một List rỗng
empty_list = []
print(f"List rỗng: {empty_list}")

Truy cập các phần tử trong List (Indexing)

Khái niệm: Vì List là một kiểu dữ liệu có thứ tự, mỗi phần tử bên trong nó được gán một vị trí duy nhất gọi là chỉ số (index). Python sử dụng chỉ số bắt đầu từ 0 cho phần tử đầu tiên, 1 cho phần tử thứ hai, và cứ thế tiếp tục.
Truy cập phần tử: Để lấy giá trị của một phần tử cụ thể, bạn sử dụng cú pháp ten_list[chi_so].

Chỉ số âm: Python cũng cho phép bạn sử dụng chỉ số âm để truy cập các phần tử từ cuối List.

-1 là chỉ số của phần tử cuối cùng.
-2 là chỉ số của phần tử gần cuối, và cứ thế.

Ví dụ:

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

# Truy cập phần tử đầu tiên (chỉ số 0)
print(f"Phần tử đầu tiên: {fruits[0]}")  # Kết quả: apple

# Truy cập phần tử thứ ba (chỉ số 2)
print(f"Phần tử thứ ba: {fruits[2]}")   # Kết quả: cherry

# Truy cập phần tử cuối cùng (chỉ số -1)
print(f"Phần tử cuối cùng: {fruits[-1]}") # Kết quả: kiwi

# Truy cập phần tử thứ hai từ cuối (chỉ số -2)
print(f"Phần tử thứ hai từ cuối: {fruits[-2]}") # Kết quả: orange

# Lỗi nếu chỉ số nằm ngoài phạm vi
# print(fruits[5]) # Sẽ gây lỗi IndexError: list index out of range

Cắt lát List (Slicing)

Mục đích: Cắt lát (slicing) cho phép bạn lấy ra một phần (một "lát cắt") của List, tạo thành một List mới mà không làm thay đổi List gốc. Điều này cực kỳ hữu ích khi bạn chỉ cần làm việc với một tập hợp con của dữ liệu.

Cú pháp: ten_list[start:end:step]

start: Là chỉ số của phần tử bắt đầu lát cắt (phần tử này được bao gồm). Nếu bỏ qua, mặc định là 0 (bắt đầu từ đầu List).
end: Là chỉ số của phần tử kết thúc lát cắt (phần tử này không được bao gồm). Nếu bỏ qua, mặc định là hết List.
step: Là bước nhảy giữa các phần tử. Mặc định là 1 (lấy từng phần tử một). Bạn có thể dùng step=2 để lấy cách một phần tử, step=-1 để đảo ngược List, v.v.

Ví dụ:

numbers = [10, 20, 30, 40, 50, 60, 70, 80, 90]

# Lấy các phần tử từ chỉ số 1 đến trước chỉ số 4
print(f"numbers[1:4]: {numbers[1:4]}")   # Kết quả: [20, 30, 40]

# Lấy các phần tử từ đầu đến trước chỉ số 3
print(f"numbers[:3]: {numbers[:3]}")    # Kết quả: [10, 20, 30]

# Lấy các phần tử từ chỉ số 3 đến hết List
print(f"numbers[3:]: {numbers[3:]}")    # Kết quả: [40, 50, 60, 70, 80, 90]

# Lấy toàn bộ List (tạo một bản sao)
print(f"numbers[:]: {numbers[:]}")      # Kết quả: [10, 20, 30, 40, 50, 60, 70, 80, 90]

# Lấy các phần tử với bước nhảy 2 (bắt đầu từ đầu)
print(f"numbers[::2]: {numbers[::2]}")   # Kết quả: [10, 30, 50, 70, 90]

# Lấy các phần tử từ chỉ số 1 đến trước chỉ số 7 với bước nhảy 3
print(f"numbers[1:7:3]: {numbers[1:7:3]}") # Kết quả: [20, 50] (20 ở index 1, 50 ở index 4)

# Đảo ngược List bằng slicing (step = -1)
print(f"numbers[::-1]: {numbers[::-1]}") # Kết quả: [90, 80, 70, 60, 50, 40, 30, 20, 10]

Thao tác với List: Thêm, Xóa, Sửa phần tử trong Python

Vì List là kiểu dữ liệu có thể thay đổi (mutable), bạn có thể dễ dàng chỉnh sửa nội dung của nó sau khi đã tạo. Điều này làm cho List trở nên linh hoạt và mạnh mẽ cho việc quản lý dữ liệu động.

Thay đổi phần tử (Update)

Khái niệm: Thay đổi (hoặc cập nhật) phần tử nghĩa là bạn có thể sửa đổi giá trị của một phần tử cụ thể tại một vị trí (chỉ số) nào đó trong List. Phần tử cũ sẽ bị ghi đè bằng giá trị mới.
Cú pháp: Để thay đổi một phần tử, bạn chỉ cần truy cập nó bằng chỉ số và gán một giá trị mới cho nó: ten_list[chi_so] = gia_tri_moi.

Ví dụ:

colors = ["red", "green", "blue"]
print(f"List gốc: {colors}")

# Thay đổi phần tử ở chỉ số 1 (ban đầu là "green") thành "yellow"
colors[1] = "yellow"
print(f"List sau khi thay đổi: {colors}") # Kết quả: ['red', 'yellow', 'blue']

# Thay đổi phần tử cuối cùng (chỉ số -1)
colors[-1] = "purple"
print(f"List sau khi thay đổi cuối cùng: {colors}") # Kết quả: ['red', 'yellow', 'purple']

Thêm phần tử

Python cung cấp nhiều phương thức để thêm phần tử vào List tùy thuộc vào vị trí bạn muốn thêm hoặc số lượng phần tử bạn muốn thêm.

.append(phan_tu):

Mục đích: Thêm một phần tử duy nhất vào cuối cùng của List. Đây là cách phổ biến nhất để thêm phần tử.

Ví dụ:

 Thêm phần tử
Python cung cấp nhiều phương thức để thêm phần tử vào List tùy thuộc vào vị trí bạn muốn thêm hoặc số lượng phần tử bạn muốn thêm.

.append(phan_tu):

Mục đích: Thêm một phần tử duy nhất vào cuối cùng của List. Đây là cách phổ biến nhất để thêm phần tử.

Ví dụ:

.insert(chi_so, phan_tu):

Mục đích: Thêm một phần tử duy nhất vào một vị trí cụ thể trong List. Các phần tử phía sau vị trí đó sẽ bị đẩy dịch sang phải.
chi_so: Là chỉ số nơi bạn muốn chèn phần tử vào.
phan_tu: Là giá trị của phần tử bạn muốn thêm.

Ví dụ:

numbers = [1, 2, 3, 4]
print(f"List gốc: {numbers}")

numbers.insert(1, 99) # Chèn 99 vào chỉ số 1 (vị trí thứ hai)
print(f"Sau .insert(1, 99): {numbers}") # Kết quả: [1, 99, 2, 3, 4]

numbers.insert(0, "start") # Chèn vào đầu List
print(f"Sau .insert(0, 'start'): {numbers}") # Kết quả: ['start', 1, 99, 2, 3, 4]

numbers.insert(100, "end") # Nếu chỉ số lớn hơn độ dài List, nó sẽ được thêm vào cuối
print(f"Sau .insert(100, 'end'): {numbers}") # Kết quả: ['start', 1, 99, 2, 3, 4, 'end']

.extend(iterable):

Mục đích: Thêm nhiều phần tử từ một đối tượng có thể lặp (như một List, Tuple, Set, hoặc chuỗi khác) vào cuối List hiện tại.
Lưu ý: Khác với append chỉ thêm một phần tử duy nhất (kể cả khi phần tử đó là một List khác, nó sẽ thêm List đó như một phần tử lồng vào), extend sẽ "mở rộng" List bằng cách thêm từng phần tử của iterable vào.

Ví dụ:

list_a = [1, 2, 3]
list_b = [4, 5]
list_c = ["x", "y"]
print(f"List A gốc: {list_a}")

list_a.extend(list_b) # Thêm các phần tử của list_b vào list_a
print(f"Sau .extend(list_b): {list_a}") # Kết quả: [1, 2, 3, 4, 5]

list_a.extend(list_c) # Thêm các phần tử của list_c vào list_a
print(f"Sau .extend(list_c): {list_a}") # Kết quả: [1, 2, 3, 4, 5, 'x', 'y']

# Sự khác biệt giữa append và extend
my_items = [1, 2]
my_items.append([3, 4]) # Thêm [3, 4] như MỘT phần tử
print(f"Sau .append([3,4]): {my_items}") # Kết quả: [1, 2, [3, 4]]

my_items = [1, 2] # Reset
my_items.extend([3, 4]) # Thêm 3 VÀ 4 riêng lẻ
print(f"Sau .extend([3,4]): {my_items}") # Kết quả: [1, 2, 3, 4]

Xóa phần tử

Có nhiều cách để xóa phần tử khỏi List, tùy thuộc vào việc bạn muốn xóa theo chỉ số hay theo giá trị.

del ten_list[chi_so]:

Mục đích: Xóa phần tử tại một vị trí (chỉ số) cụ thể. Đây là một câu lệnh (statement) chứ không phải phương thức.

Ví dụ:

data_del = ["A", "B", "C", "D"]
print(f"List gốc: {data_del}")

del data_del[1] # Xóa phần tử ở chỉ số 1 ("B")
print(f"Sau del data_del[1]: {data_del}") # Kết quả: ['A', 'C', 'D']

del data_del[-1] # Xóa phần tử cuối cùng ("D")
print(f"Sau del data_del[-1]: {data_del}") # Kết quả: ['A', 'C']

.remove(gia_tri):

Mục đích: Xóa phần tử đầu tiên mà nó tìm thấy có giá trị khớp với giá trị bạn cung cấp.
Lưu ý: Nếu giá trị không tồn tại trong List, phương thức này sẽ gây ra lỗi ValueError.

Ví dụ:

data_remove = ["apple", "banana", "cherry", "banana", "kiwi"]
print(f"List gốc: {data_remove}")

data_remove.remove("banana") # Xóa phần tử "banana" ĐẦU TIÊN tìm thấy
print(f"Sau .remove('banana'): {data_remove}") # Kết quả: ['apple', 'cherry', 'banana', 'kiwi']

# data_remove.remove("grape") # Nếu bỏ comment, dòng này sẽ gây lỗi ValueError

.pop(chi_so):

Mục đích: Xóa phần tử tại một vị trí (chỉ số) cụ thể VÀ trả về phần tử đã bị xóa đó.
Không có chỉ số: Nếu bạn gọi .pop() mà không cung cấp chỉ số, nó sẽ mặc định xóa và trả về phần tử cuối cùng của List.
Lưu ý: Gây lỗi IndexError nếu chỉ số nằm ngoài phạm vi List.

Ví dụ:

data_pop = ["alpha", "beta", "gamma", "delta"]
print(f"List gốc: {data_pop}")

# Xóa phần tử ở chỉ số 2 ("gamma") và lưu nó vào biến
removed_value = data_pop.pop(2)
print(f"Phần tử đã xóa: {removed_value}") # Kết quả: gamma
print(f"List sau .pop(2): {data_pop}") # Kết quả: ['alpha', 'beta', 'delta']

# Xóa phần tử cuối cùng
last_item = data_pop.pop()
print(f"Phần tử cuối đã xóa: {last_item}") # Kết quả: delta
print(f"List sau .pop(): {data_pop}") # Kết quả: ['alpha', 'beta']

.clear():

Mục đích: Xóa tất cả các phần tử khỏi List, làm cho nó trở thành một List rỗng.

Ví dụ:

my_shopping_list = ["milk", "eggs", "bread"]
print(f"List trước khi xóa: {my_shopping_list}") # Kết quả: ['milk', 'eggs', 'bread']

my_shopping_list.clear() # Xóa tất cả phần tử
print(f"List sau .clear(): {my_shopping_list}") # Kết quả: []

Các phương thức List hữu ích khác trong Python

Ngoài các thao tác cơ bản, Python cung cấp nhiều phương thức (methods) tích hợp sẵn để làm việc với List một cách tiện lợi.

Tìm kiếm và đếm

.index(gia_tri):

Mục đích: Phương thức này tìm kiếm một giá trị cụ thể trong List và trả về chỉ số của phần tử đầu tiên mà nó tìm thấy khớp với giá trị đó.
Lưu ý: Nếu giá trị bạn tìm kiếm không có trong List, .index() sẽ gây ra lỗi ValueError.
Ví dụ:

numbers = [10, 20, 30, 20, 40, 50]
print(f"List gốc: {numbers}")

# Tìm chỉ số của phần tử có giá trị 30
print(f"Chỉ số của 30: {numbers.index(30)}") # Kết quả: 2

# Tìm chỉ số của phần tử có giá trị 20 (chỉ trả về chỉ số của phần tử đầu tiên tìm thấy)
print(f"Chỉ số của 20: {numbers.index(20)}") # Kết quả: 1

# Nếu bạn cố gắng tìm một giá trị không có trong List, nó sẽ gây lỗi
# print(f"Chỉ số của 100: {numbers.index(100)}") # Sẽ gây lỗi ValueError

.count(gia_tri):

Mục đích: Phương thức này trả về số lần xuất hiện của một giá trị cụ thể trong List.

Ví dụ:

my_list_with_duplicates = [1, 2, 3, 2, 4, 2, 5, 1]
print(f"List gốc: {my_list_with_duplicates}")

# Đếm số lần xuất hiện của số 2
print(f"Số lần số 2 xuất hiện: {my_list_with_duplicates.count(2)}") # Kết quả: 3

# Đếm số lần xuất hiện của số 1
print(f"Số lần số 1 xuất hiện: {my_list_with_duplicates.count(1)}") # Kết quả: 2

# Đếm số lần xuất hiện của một giá trị không có trong List (trả về 0)
print(f"Số lần số 9 xuất hiện: {my_list_with_duplicates.count(9)}") # Kết quả: 0

Sắp xếp và đảo ngược

Việc sắp xếp và đảo ngược thứ tự các phần tử là thao tác rất phổ biến khi làm việc với dữ liệu.

.sort():

Mục đích: Sắp xếp các phần tử của List ngay tại chỗ (in-place), nghĩa là nó thay đổi chính List gốc chứ không tạo ra List mới.
Mặc định: Sắp xếp theo thứ tự tăng dần (số nhỏ nhất đến lớn nhất, chữ cái A-Z).
Sắp xếp giảm dần: Bạn có thể thêm đối số reverse=True để sắp xếp theo thứ tự giảm dần.

Ví dụ:

unsorted_numbers = [3, 1, 4, 1, 5, 9, 2]
print(f"List số ban đầu: {unsorted_numbers}")

unsorted_numbers.sort() # Sắp xếp tăng dần
print(f"List số sau khi .sort() (tăng dần): {unsorted_numbers}") # Kết quả: [1, 1, 2, 3, 4, 5, 9]

unsorted_numbers.sort(reverse=True) # Sắp xếp giảm dần
print(f"List số sau khi .sort(reverse=True) (giảm dần): {unsorted_numbers}") # Kết quả: [9, 5, 4, 3, 2, 1, 1]

# Sắp xếp chuỗi
another_list = ["banana", "apple", "cherry", "date"]
print(f"List chuỗi ban đầu: {another_list}")
another_list.sort()
print(f"List chuỗi sau khi .sort(): {another_list}") # Kết quả: ['apple', 'banana', 'cherry', 'date']

sorted(list):

Mục đích: Hàm sorted() là một hàm tích hợp sẵn của Python (không phải phương thức của List). Nó nhận một List (hoặc bất kỳ iterable nào) làm đối số và trả về một List MỚI đã được sắp xếp, mà không làm thay đổi List gốc.
Lưu ý: Cũng có thể dùng reverse=True để sắp xếp giảm dần.

Ví dụ:

original_numbers = [3, 1, 4, 1, 5, 9]
print(f"List gốc: {original_numbers}")

sorted_new_list = sorted(original_numbers) # Tạo một List mới đã sắp xếp
print(f"List mới sau sorted(): {sorted_new_list}") # Kết quả: [1, 1, 3, 4, 5, 9]
print(f"List gốc (không thay đổi): {original_numbers}") # Kết quả: [3, 1, 4, 1, 5, 9]

sorted_desc = sorted(original_numbers, reverse=True)
print(f"List mới sau sorted(reverse=True): {sorted_desc}") # Kết quả: [9, 5, 4, 3, 1, 1]

.reverse():

Mục đích: Đảo ngược thứ tự các phần tử trong List ngay tại chỗ (in-place), không sắp xếp theo giá trị. Phần tử đầu tiên sẽ thành cuối cùng, và ngược lại.

Ví dụ:

my_items = ["A", "B", "C", "D"]
print(f"List ban đầu: {my_items}")

my_items.reverse() # Đảo ngược thứ tự
print(f"List sau .reverse(): {my_items}") # Kết quả: ['D', 'C', 'B', 'A']

Các hàm tích hợp sẵn với List

Python cung cấp một số hàm hữu ích có thể được sử dụng với List (và các kiểu dữ liệu khác).

len(list):

Mục đích: Trả về số lượng phần tử (độ dài) của List.

Ví dụ:

data_len = [10, 20, 5, 30]
print(f"List: {data_len}")
print(f"Số lượng phần tử trong List: {len(data_len)}") # Kết quả: 4

sum(list):

Mục đích: Trả về tổng của tất cả các phần tử trong List.
Lưu ý: Chỉ hoạt động với List chứa các giá trị là số (số nguyên hoặc số thực).

Ví dụ:

data_sum = [10, 20, 5, 30]
print(f"List: {data_sum}")
print(f"Tổng các phần tử: {sum(data_sum)}") # Kết quả: 65

# my_string_list = ["a", "b"]
# print(sum(my_string_list)) # Sẽ gây lỗi TypeError

min(list):

Mục đích: Trả về phần tử nhỏ nhất trong List.
Lưu ý: Các phần tử trong List phải có thể so sánh được với nhau (ví dụ: tất cả là số, hoặc tất cả là chuỗi).

Ví dụ:

data_min = [10, 20, 5, 30]
print(f"List: {data_min}")
print(f"Phần tử nhỏ nhất: {min(data_min)}") # Kết quả: 5

string_list = ["apple", "banana", "cherry"]
print(f"Chuỗi nhỏ nhất: {min(string_list)}") # Kết quả: apple

max(list):

Mục đích: Trả về phần tử lớn nhất trong List.
Lưu ý: Tương tự min(), các phần tử phải có thể so sánh được.

Ví dụ:

data_max = [10, 20, 5, 30]
print(f"List: {data_max}")
print(f"Phần tử lớn nhất: {max(data_max)}") # Kết quả: 30

string_list = ["apple", "banana", "cherry"]
print(f"Chuỗi lớn nhất: {max(string_list)}") # Kết quả: cherry

Kết bài

Bạn đã trải qua một hành trình khám phá đầy đủ về List trong Python! Từ việc hiểu List là gì và tại sao nó lại quan trọng đến vậy, đến cách tạo và truy cập các phần tử, cũng như thực hiện các thao tác thêm, xóa, sửa đổi, và sử dụng các phương thức hữu ích khác như tìm kiếm, sắp xếp và đếm.

Hãy luôn ghi nhớ những điểm chính sau về List:

List là kiểu dữ liệu có thứ tự và có thể thay đổi: Điều này mang lại sự linh hoạt tối đa trong việc quản lý tập hợp dữ liệu.
Sử dụng chỉ số (indexing) và cắt lát (slicing): Đây là những công cụ mạnh mẽ để bạn truy cập và trích xuất các phần tử hoặc tập hợp con của List.
Thao tác linh hoạt: Các phương thức như .append(), .insert(), .extend(), del, .remove(), .pop(), và .clear() cho phép bạn thay đổi nội dung của List một cách dễ dàng.
Các phương thức tiện ích: .index(), .count(), .sort(), sorted(), .reverse(), len(), sum(), min(), max() giúp bạn xử lý dữ liệu trong List hiệu quả hơn rất nhiều.

List không chỉ là một khái niệm cơ bản mà còn là một trong những cấu trúc dữ liệu được sử dụng nhiều nhất trong Python. Nắm vững List sẽ mở ra cánh cửa cho bạn để xử lý các tác vụ phức tạp, xây dựng các chương trình dữ liệu động và giải quyết vô vàn bài toán thực tế.