Change List Items trong Python

Python Tutorial | 18/07/2025 by Hoc Python

Thay đổi các Phần tử trong List (Change List Items) trong Python! Trong các bài trước, chúng ta đã làm quen với khái niệm List – một cấu trúc dữ liệu linh hoạt cho phép lưu trữ một tập hợp có thứ tự các mục. List là nền tảng cho nhiều ứng dụng trong Python, từ việc quản lý danh sách công việc hàng ngày đến xử lý dữ liệu phức tạp.

Một trong những đặc điểm nổi bật và mạnh mẽ nhất của List chính là tính chất "có thể thay đổi" (mutable) của nó. Điều này có nghĩa là, không giống như các kiểu dữ liệu "bất biến" (immutable) như chuỗi hay số, bạn hoàn toàn có thể thêm, xóa, hoặc sửa đổi các phần tử bên trong một List sau khi nó đã được tạo ra. Khả năng này mang lại sự linh hoạt đáng kinh ngạc, cho phép bạn cập nhật và điều chỉnh dữ liệu một cách dễ dàng trong suốt quá trình chạy chương trình.

Trong phần này, chúng ta sẽ đi sâu vào các kỹ thuật và phương pháp khác nhau để thay đổi nội dung của một List. Từ việc chỉnh sửa một phần tử cụ thể bằng chỉ số, đến việc thay thế hoặc chèn nhiều phần tử cùng lúc, bạn sẽ nắm vững cách điều khiển và cập nhật dữ liệu trong các List của mình một cách hiệu quả. Hãy cùng tìm hiểu nhé!

Giới thiệu về List và Tính chất "Có thể thay đổi" (Mutable) trong Python

Để hiểu cách thay đổi các phần tử trong List, trước hết chúng ta cần nắm vững hai khái niệm cốt lõi: List là gì và đặc tính "có thể thay đổi" (mutable) của nó.

Nhắc lại: List là gì?

Như chúng ta đã biết, List (danh sách) trong Python là một cấu trúc dữ liệu cơ bản, dùng để lưu trữ một tập hợp các mục (item) có thứ tự. Điều này có nghĩa là mỗi phần tử trong List đều có một vị trí xác định, được đánh số bằng chỉ mục (index) bắt đầu từ 0.

Đặc điểm chính của List:

Có thứ tự: Các phần tử được giữ theo một trình tự nhất định.
Có thể chứa nhiều kiểu dữ liệu: Một List có thể chứa số nguyên, chuỗi, boolean, số thực, và thậm chí cả các List khác.
Được bao quanh bởi dấu ngoặc vuông []: Các phần tử được phân cách bằng dấu phẩy.

Ví dụ:

# Một List chứa nhiều kiểu dữ liệu khác nhau
thong_tin_san_pham = ["Laptop HP", 1200, True, "mới về"]
print(f"List thông tin sản phẩm: {thong_tin_san_pham}")
# Output: List thông tin sản phẩm: ['Laptop HP', 1200, True, 'mới về']

# Một List các số nguyên
diem_thi = [8, 9, 7.5, 10]
print(f"List điểm thi: {diem_thi}")
# Output: List điểm thi: [8, 9, 7.5, 10]

List là "Mutable" (Có thể thay đổi)

Đây là một trong những tính chất quan trọng nhất của List, tạo nên sự linh hoạt và hữu ích của nó.

Giải thích ý nghĩa của "mutable":

Khi nói một kiểu dữ liệu là "mutable" (có thể thay đổi), điều đó có nghĩa là bạn có thể thay đổi nội dung hoặc cấu trúc của nó sau khi nó đã được tạo ra, mà không cần phải tạo ra một đối tượng mới hoàn toàn. Đối với List, điều này cụ thể có nghĩa là bạn có thể:

Thêm các phần tử mới vào List.
Xóa bỏ các phần tử hiện có trong List.
Sửa đổi (cập nhật) giá trị của các phần tử tại vị trí bất kỳ trong List.

Mọi thao tác này đều diễn ra trên chính đối tượng List ban đầu, không phải tạo ra một bản sao mới.

Ví dụ minh họa tính "mutable":

# Tạo một List ban đầu
danh_sach_cong_viec = ["mua sữa", "giặt đồ", "học Python"]
print(f"List ban đầu: {danh_sach_cong_viec}")
# Output: List ban đầu: ['mua sữa', 'giặt đồ', 'học Python']

# Sửa đổi một phần tử (công việc "giặt đồ" thành "đã giặt đồ")
danh_sach_cong_viec[1] = "đã giặt đồ"
print(f"Sau khi sửa đổi phần tử: {danh_sach_cong_viec}")
# Output: Sau khi sửa đổi phần tử: ['mua sữa', 'đã giặt đồ', 'học Python']

# Thêm một phần tử mới vào cuối List
danh_sach_cong_viec.append("gọi điện thoại")
print(f"Sau khi thêm phần tử: {danh_sach_cong_viec}")
# Output: Sau khi thêm phần tử: ['mua sữa', 'đã giặt đồ', 'học Python', 'gọi điện thoại']

# Xóa một phần tử
danh_sach_cong_viec.remove("mua sữa")
print(f"Sau khi xóa phần tử: {danh_sach_cong_viec}")
# Output: Sau khi xóa phần tử: ['đã giặt đồ', 'học Python', 'gọi điện thoại']

Như bạn thấy, biến danh_sach_cong_viec vẫn trỏ đến cùng một List trong bộ nhớ, nhưng nội dung của List đó đã thay đổi.

So sánh nhanh với các kiểu dữ liệu "Immutable" (Không thể thay đổi):

Ngược lại với List, một số kiểu dữ liệu khác trong Python là "immutable" (không thể thay đổi). Điều này có nghĩa là, một khi chúng được tạo ra, nội dung của chúng không thể bị sửa đổi. Nếu bạn thực hiện một thao tác có vẻ như là "thay đổi", trên thực tế, Python sẽ tạo ra một đối tượng mới và biến của bạn sẽ trỏ đến đối tượng mới đó.

Ví dụ về Immutable Data Types:

Chuỗi (Strings):

chuoi_goc = "Hello"
print(f"Chuỗi gốc: {chuoi_goc}")

# Cố gắng "thay đổi" ký tự đầu tiên
# chuoi_goc[0] = "J" # Lỗi! TypeError: 'str' object does not support item assignment

# Để "thay đổi" một chuỗi, bạn phải tạo chuỗi mới
chuoi_moi = "J" + chuoi_goc[1:]
print(f"Chuỗi mới: {chuoi_moi}")
# Output: Chuỗi mới: Jello
print(f"Chuỗi gốc vẫn là: {chuoi_goc}")
# Output: Chuỗi gốc vẫn là: Hello

Trong ví dụ trên, chuoi_goc vẫn không thay đổi. Biến chuoi_moi đã trỏ đến một đối tượng chuỗi hoàn toàn khác trong bộ nhớ.
Số (Numbers - int, float, v.v.):

so_goc = 5
print(f"Số gốc: {so_goc}") # Output: Số gốc: 5

# Cố gắng thay đổi giá trị
so_goc = so_goc + 1
print(f"Số sau khi thay đổi (thực chất là tạo mới): {so_goc}") # Output: Số sau khi thay đổi (thực chất là tạo mới): 6

Khi bạn gán so_goc = so_goc + 1, bạn không thay đổi giá trị 5 ban đầu. Thay vào đó, Python tính toán 5 + 1 = 6, tạo một đối tượng số 6 mới, và biến so_goc bây giờ trỏ đến đối tượng 6 đó. Giá trị 5 ban đầu vẫn tồn tại nhưng không còn được biến so_goc tham chiếu nữa.

Hiểu rõ sự khác biệt giữa "mutable" và "immutable" là rất quan trọng để tránh các lỗi logic tiềm ẩn và để viết mã hiệu quả hơn trong Python. Với List, tính "mutable" chính là sức mạnh cho phép chúng ta linh hoạt thao tác với các tập dữ liệu.

Cách thay đổi một phần tử cụ thể trong Python

Một trong những cách cơ bản và phổ biến nhất để sửa đổi List là thay đổi giá trị của một phần tử cụ thể tại một vị trí xác định. Điều này được thực hiện bằng cách sử dụng Indexing kết hợp với phép gán.

Sử dụng Indexing để thay đổi phần tử

Như đã tìm hiểu, Indexing là cách chúng ta xác định vị trí của một phần tử trong List thông qua các chỉ số (index) của nó. Chúng ta có hai loại chỉ số:

Chỉ số dương (Positive Indexing): Bắt đầu từ 0 cho phần tử đầu tiên, 1 cho phần tử thứ hai, v.v., đếm từ trái sang phải.
Chỉ số âm (Negative Indexing): Bắt đầu từ -1 cho phần tử cuối cùng, -2 cho phần tử kế cuối, v.v., đếm từ phải sang trái.

Để thay đổi giá trị của một phần tử, bạn chỉ cần truy cập phần tử đó bằng chỉ số của nó và sau đó sử dụng toán tử gán = để đặt một giá trị mới.

Cú pháp:

ten_list[chi_so] = gia_tri_moi

ten_list: Tên của List mà bạn muốn thay đổi.
chi_so: Chỉ số (dương hoặc âm) của phần tử bạn muốn cập nhật.
gia_tri_moi: Giá trị mới mà bạn muốn gán cho phần tử đó.

Ví dụ minh họa chi tiết

Thay đổi phần tử bằng chỉ số dương

Sử dụng chỉ số dương là cách phổ biến nhất để cập nhật một phần tử khi bạn biết vị trí của nó từ đầu List.

# Danh sách các môn học
mon_hoc = ["Toán", "Văn", "Anh", "Lịch Sử"]
print(f"List môn học ban đầu: {mon_hoc}")
# Output: List môn học ban đầu: ['Toán', 'Văn', 'Anh', 'Lịch Sử']

# Giả sử muốn thay đổi "Văn" (ở chỉ số 1) thành "Ngữ Văn"
mon_hoc[1] = "Ngữ Văn"
print(f"Sau khi thay đổi 'Văn' thành 'Ngữ Văn': {mon_hoc}")
# Output: Sau khi thay đổi 'Văn' thành 'Ngữ Văn': ['Toán', 'Ngữ Văn', 'Anh', 'Lịch Sử']

# Thay đổi "Lịch Sử" (ở chỉ số 3) thành "Lịch Sử & Địa Lý"
mon_hoc[3] = "Lịch Sử & Địa Lý"
print(f"Sau khi thay đổi 'Lịch Sử': {mon_hoc}")
# Output: Sau khi thay đổi 'Lịch Sử': ['Toán', 'Ngữ Văn', 'Anh', 'Lịch Sử & Địa Lý']

Thay đổi phần tử bằng chỉ số âm

Chỉ số âm rất hữu ích khi bạn muốn thay đổi các phần tử ở cuối List mà không cần biết chính xác độ dài của List đó.

# Danh sách các việc cần làm
viec_can_lam = ["dọn nhà", "mua sắm", "gọi điện thoại", "tập thể dục"]
print(f"List việc cần làm ban đầu: {viec_can_lam}")
# Output: List việc cần làm ban đầu: ['dọn nhà', 'mua sắm', 'gọi điện thoại', 'tập thể dục']

# Giả sử muốn thay đổi việc cuối cùng (ở chỉ số -1) từ "tập thể dục" thành "đọc sách"
viec_can_lam[-1] = "đọc sách"
print(f"Sau khi thay đổi việc cuối cùng: {viec_can_lam}")
# Output: Sau khi thay đổi việc cuối cùng: ['dọn nhà', 'mua sắm', 'gọi điện thoại', 'đọc sách']

# Thay đổi việc kế cuối (ở chỉ số -2) từ "gọi điện thoại" thành "viết báo cáo"
viec_can_lam[-2] = "viết báo cáo"
print(f"Sau khi thay đổi việc kế cuối: {viec_can_lam}")
# Output: Sau khi thay đổi việc kế cuối: ['dọn nhà', 'mua sắm', 'viết báo cáo', 'đọc sách']

Lưu ý quan trọng: Chỉ số phải tồn tại

Điều quan trọng cần nhớ là bạn chỉ có thể gán giá trị cho một chỉ số đã tồn tại trong List. Nếu bạn cố gắng gán giá trị cho một chỉ số vượt quá phạm vi hiện có của List (quá lớn với chỉ số dương, hoặc quá nhỏ với chỉ số âm), Python sẽ báo lỗi IndexError: list assignment index out of range.

Ví dụ về lỗi:

fruits = ["apple", "banana"]
print(f"List fruits: {fruits}")
# Output: List fruits: ['apple', 'banana']

# List này chỉ có 2 phần tử, với các chỉ số hợp lệ là 0, 1 hoặc -1, -2.

# Cố gắng gán giá trị cho chỉ số không tồn tại (chỉ số 2)
# fruits[2] = "cherry" # Điều này sẽ gây ra lỗi!
# Lỗi: IndexError: list assignment index out of range

# Cố gắng gán giá trị cho chỉ số âm không tồn tại (chỉ số -3)
# fruits[-3] = "grape" # Điều này cũng sẽ gây ra lỗi!
# Lỗi: IndexError: list assignment index out of range

Nếu bạn muốn thêm phần tử vào List (tại cuối hoặc một vị trí bất kỳ), bạn sẽ cần sử dụng các phương thức như append() hoặc insert(), thay vì cố gắng gán giá trị cho một chỉ số không tồn tại. Chúng ta sẽ khám phá các phương thức này trong phần tiếp theo.

Cách thay đổi nhiều phần tử (Range of Items) trong Python

Ngoài việc thay đổi từng phần tử riêng lẻ, Python cho phép bạn thay đổi một dãy (range) các phần tử cùng lúc trong một List bằng cách sử dụng kỹ thuật Slicing (cắt lát) kết hợp với phép gán.

Sử dụng Slicing (cắt lát) với phép gán

Slicing là một cách mạnh mẽ để chọn ra một "phần" hoặc một "lát cắt" của một List. Nó được sử dụng với cú pháp ten_list[start:end], nơi:

start: Chỉ số bắt đầu của lát cắt (phần tử tại chỉ số này được bao gồm).
end: Chỉ số kết thúc của lát cắt (phần tử tại chỉ số này không được bao gồm).

Khi bạn sử dụng slicing ở vế trái của phép gán (=), bạn có thể thay thế toàn bộ đoạn đó bằng một List (hoặc bất kỳ iterable nào) chứa các giá trị mới.

Cú pháp để thay đổi nhiều phần tử:

ten_list[start:end] = [cac_gia_tri_moi]

ten_list: Tên của List cần thay đổi.
start:end: Lát cắt (slice) của các phần tử bạn muốn thay thế.
[cac_gia_tri_moi]: Một List chứa các giá trị mới mà bạn muốn chèn vào vị trí của lát cắt đã chọn.

Ví dụ minh họa chi tiết

Thay thế một đoạn bằng một đoạn có cùng số lượng phần tử

Khi List mới có số lượng phần tử bằng với số lượng phần tử trong lát cắt gốc, List sẽ được cập nhật mà không thay đổi kích thước tổng thể.

# Danh sách các tháng trong quý
quy_1 = ["Tháng 1", "Tháng 2", "Tháng 3", "Tháng 4", "Tháng 5"]
print(f"List ban đầu: {quy_1}")
# Output: List ban đầu: ['Tháng 1', 'Tháng 2', 'Tháng 3', 'Tháng 4', 'Tháng 5']

# Giả sử "Tháng 4" và "Tháng 5" thực ra là "Tháng 4 (Mới)" và "Tháng 5 (Mới)"
# Lát cắt cần thay thế: từ chỉ số 3 đến (không bao gồm) chỉ số 5
# Tức là thay thế "Tháng 4", "Tháng 5"
quy_1[3:5] = ["Tháng 4 (Mới)", "Tháng 5 (Mới)"]
print(f"Sau khi thay thế 2 phần tử bằng 2 phần tử mới: {quy_1}")
# Output: Sau khi thay thế 2 phần tử bằng 2 phần tử mới: ['Tháng 1', 'Tháng 2', 'Tháng 3', 'Tháng 4 (Mới)', 'Tháng 5 (Mới)']

Thay thế một đoạn bằng một đoạn có số lượng phần tử khác nhau

Đây là một tính năng mạnh mẽ của List trong Python. Khi số lượng phần tử trong List mới khác với số lượng phần tử trong lát cắt gốc, List sẽ tự động điều chỉnh kích thước để phù hợp với sự thay đổi.

Trường hợp 1: Thay thế bằng nhiều phần tử hơn (List sẽ dài ra)

# Danh sách công việc
cong_viec = ["Đọc sách", "Viết báo cáo", "Kiểm tra email"]
print(f"List công việc ban đầu: {cong_viec}")
# Output: List công việc ban đầu: ['Đọc sách', 'Viết báo cáo', 'Kiểm tra email']

# Muốn thay thế "Viết báo cáo" (chỉ số 1) bằng 2 công việc mới: "Viết báo cáo Quý 1" và "Viết báo cáo Quý 2"
# Lát cắt chỉ bao gồm 1 phần tử: cong_viec[1:2]
cong_viec[1:2] = ["Viết báo cáo Quý 1", "Viết báo cáo Quý 2"]
print(f"Sau khi thay thế 1 phần tử bằng 2 phần tử mới: {cong_viec}")
# Output: Sau khi thay thế 1 phần tử bằng 2 phần tử mới: ['Đọc sách', 'Viết báo cáo Quý 1', 'Viết báo cáo Quý 2', 'Kiểm tra email']

Trường hợp 2: Thay thế bằng ít phần tử hơn (List sẽ ngắn lại)

# Danh sách các điểm dừng xe buýt
diem_dung = ["Điểm A", "Điểm B", "Điểm C", "Điểm D", "Điểm E"]
print(f"List điểm dừng ban đầu: {diem_dung}")
# Output: List điểm dừng ban đầu: ['Điểm A', 'Điểm B', 'Điểm C', 'Điểm D', 'Điểm E']

# Muốn thay thế "Điểm B", "Điểm C", "Điểm D" (3 phần tử) bằng chỉ "Điểm Mới" (1 phần tử)
# Lát cắt cần thay thế: diem_dung[1:4]
diem_dung[1:4] = ["Điểm Mới"]
print(f"Sau khi thay thế 3 phần tử bằng 1 phần tử mới: {diem_dung}")
# Output: Sau khi thay thế 3 phần tử bằng 1 phần tử mới: ['Điểm A', 'Điểm Mới', 'Điểm E']

Thay thế một đoạn bằng List rỗng (tương đương với xóa)

Khi bạn thay thế một lát cắt bằng một List rỗng ([]), các phần tử trong lát cắt đó sẽ bị xóa khỏi List. Đây là một cách hiệu quả để xóa nhiều phần tử cùng lúc.

# Danh sách các số
so_tu_nhien = [1, 2, 3, 4, 5, 6, 7]
print(f"List số tự nhiên ban đầu: {so_tu_nhien}")
# Output: List số tự nhiên ban đầu: [1, 2, 3, 4, 5, 6, 7]

# Xóa các số từ 3 đến 5 (chỉ số 2 đến không bao gồm 5)
so_tu_nhien[2:5] = []
print(f"Sau khi xóa các số từ 3 đến 5: {so_tu_nhien}")
# Output: Sau khi xóa các số từ 3 đến 5: [1, 2, 6, 7]

# Xóa tất cả các phần tử (xóa toàn bộ List)
full_list = ["a", "b", "c", "d"]
print(f"List đầy đủ ban đầu: {full_list}")
# Output: List đầy đủ ban đầu: ['a', 'b', 'c', 'd']
full_list[:] = [] # Slicing từ đầu đến cuối
print(f"Sau khi xóa toàn bộ List: {full_list}")
# Output: Sau khi xóa toàn bộ List: []

Việc sử dụng slicing với phép gán là một kỹ thuật rất linh hoạt, cho phép bạn thực hiện các thao tác thay đổi hàng loạt phần tử một cách hiệu quả.

Các phương thức phổ biến để thay đổi List trong Python

Ngoài việc sử dụng indexing và slicing với phép gán, Python cung cấp một số phương thức tích hợp sẵn cho List để thêm phần tử một cách linh hoạt. Các phương thức này rất tiện lợi và thường được sử dụng trong lập trình.

`append()`: Thêm một phần tử vào cuối List

Phương thức append() dùng để thêm một phần tử duy nhất vào vị trí cuối cùng của List hiện tại. Đây là cách đơn giản nhất để mở rộng List.

Cú pháp: ten_list.append(phan_tu_moi)

ten_list: List mà bạn muốn thêm phần tử vào.
phan_tu_moi: Phần tử (giá trị) bạn muốn thêm.

Ví dụ:

# Danh sách các số nguyên
numbers = [1, 2, 3]
print(f"List ban đầu: {numbers}")
# Output: List ban đầu: [1, 2, 3]

# Thêm số 4 vào cuối List
numbers.append(4)
print(f"Sau khi append(4): {numbers}")
# Output: Sau khi append(4): [1, 2, 3, 4]

# Thêm một chuỗi vào cuối List
fruits = ["apple", "banana"]
print(f"List hoa quả ban đầu: {fruits}")
# Output: List hoa quả ban đầu: ['apple', 'banana']
fruits.append("cherry")
print(f"Sau khi append('cherry'): {fruits}")
# Output: Sau khi append('cherry'): ['apple', 'banana', 'cherry']

# Bạn có thể append bất kỳ kiểu dữ liệu nào, kể cả một List khác
mixed_list = [10, "text"]
mixed_list.append([1, 2, 3]) # Thêm cả List [1, 2, 3] như một phần tử duy nhất
print(f"Sau khi append một List: {mixed_list}")
# Output: Sau khi append một List: [10, 'text', [1, 2, 3]]

`insert()`: Thêm một phần tử vào vị trí cụ thể (chỉ số)

Phương thức insert() cho phép bạn thêm một phần tử vào một vị trí (chỉ số) cụ thể trong List. Các phần tử từ vị trí đó trở đi sẽ bị đẩy sang phải để nhường chỗ cho phần tử mới.

Cú pháp: ten_list.insert(chi_so, phan_tu_moi)

ten_list: List mà bạn muốn thêm phần tử vào.
chi_so: Chỉ số mà bạn muốn chèn phần tử mới vào. Phần tử mới sẽ được đặt tại vị trí này.
phan_tu_moi: Phần tử (giá trị) bạn muốn thêm.

Ví dụ:

# Danh sách các thành phố
cities = ["Hà Nội", "Đà Nẵng", "TP. Hồ Chí Minh"]
print(f"List ban đầu: {cities}")
# Output: List ban đầu: ['Hà Nội', 'Đà Nẵng', 'TP. Hồ Chí Minh']

# Chèn "Huế" vào chỉ số 1 (sau "Hà Nội" và trước "Đà Nẵng")
cities.insert(1, "Huế")
print(f"Sau khi insert('Huế', 1): {cities}")
# Output: Sau khi insert('Huế', 1): ['Hà Nội', 'Huế', 'Đà Nẵng', 'TP. Hồ Chí Minh']

# Chèn "Cần Thơ" vào đầu List (chỉ số 0)
cities.insert(0, "Cần Thơ")
print(f"Sau khi insert('Cần Thơ', 0): {cities}")
# Output: Sau khi insert('Cần Thơ', 0): ['Cần Thơ', 'Hà Nội', 'Huế', 'Đà Nẵng', 'TP. Hồ Chí Minh']

# Chèn "Hải Phòng" vào một chỉ số lớn hơn độ dài List (sẽ tự động thêm vào cuối)
cities.insert(100, "Hải Phòng")
print(f"Sau khi insert vào chỉ số lớn: {cities}")
# Output: Sau khi insert vào chỉ số lớn: ['Cần Thơ', 'Hà Nội', 'Huế', 'Đà Nẵng', 'TP. Hồ Chí Minh', 'Hải Phòng']

`extend()`: Thêm các phần tử từ một iterable khác vào cuối List hiện tại

Phương thức extend() dùng để thêm tất cả các phần tử của một iterable (như một List khác, tuple, set, hoặc chuỗi) vào cuối List hiện tại. Không giống như append(), extend() không thêm iterable đó như một phần tử duy nhất, mà là "mở rộng" List gốc bằng cách thêm từng phần tử riêng lẻ từ iterable đó.

Cú pháp: ten_list.extend(iterable_khac)

ten_list: List mà bạn muốn mở rộng.
iterable_khac: Một đối tượng có thể lặp (như List, tuple, chuỗi) chứa các phần tử bạn muốn thêm.

Ví dụ:

# Danh sách các loại rau củ
vegetables = ["carrot", "potato", "onion"]
print(f"List rau củ ban đầu: {vegetables}")
# Output: List rau củ ban đầu: ['carrot', 'potato', 'onion']

# Thêm các loại rau lá từ một List khác
leafy_greens = ["spinach", "kale"]
vegetables.extend(leafy_greens)
print(f"Sau khi extend List rau lá: {vegetables}")
# Output: Sau khi extend List rau lá: ['carrot', 'potato', 'onion', 'spinach', 'kale']

# Thêm các ký tự từ một chuỗi (chuỗi cũng là một iterable)
name = ['J', 'a', 'c']
name.extend('k') # Thêm từng ký tự của 'k'
print(f"Sau khi extend chuỗi 'k': {name}")
# Output: Sau khi extend chuỗi 'k': ['J', 'a', 'c', 'k']

# Thêm các số từ một tuple
more_numbers = [10, 20]
tuple_numbers = (30, 40, 50)
more_numbers.extend(tuple_numbers)
print(f"Sau khi extend từ tuple: {more_numbers}")
# Output: Sau khi extend từ tuple: [10, 20, 30, 40, 50]

Kết bài

Trong bài viết này, chúng ta đã đi sâu vào cách thay đổi các phần tử trong List của Python, một tính năng cốt lõi nhờ vào đặc tính "mutable" (có thể thay đổi) của List. Chúng ta đã học được ba phương pháp chính để sửa đổi nội dung của một danh sách:

Gán trực tiếp qua Index: Sử dụng ten_list[chi_so] = gia_tri_moi để cập nhật một phần tử cụ thể. Đây là cách chính xác nhất khi bạn biết vị trí của phần tử cần thay đổi, sử dụng cả chỉ số dương và âm.

Gán qua Slicing (cắt lát): Dùng ten_list[start:end] = [cac_gia_tri_moi] để thay thế một hoặc nhiều phần tử bằng một tập hợp các giá trị mới. Kỹ thuật này linh hoạt đến mức có thể thay đổi số lượng phần tử của List, thậm chí dùng [] để xóa một đoạn.

Sử dụng các phương thức có sẵn:

append(): Thêm một phần tử vào cuối List.
insert(): Chèn một phần tử vào vị trí cụ thể trong List.
extend(): Thêm nhiều phần tử từ một iterable khác vào cuối List hiện tại.

Lưu ý quan trọng: Hãy luôn nhớ rằng List là mutable. Điều này có nghĩa là mọi thay đổi bạn thực hiện (thêm, xóa, sửa đổi) sẽ ảnh hưởng trực tiếp đến List gốc. Điều này khác biệt so với các kiểu dữ liệu immutable như chuỗi, nơi mọi thao tác "thay đổi" thực chất tạo ra một đối tượng mới.