Cách method xử lý List trong Python

Python Tutorial | 22/07/2025 by Hoc Python

List không chỉ là nơi lưu trữ dữ liệu, chúng còn đi kèm với một bộ sưu tập các phương thức (methods) mạnh mẽ, cho phép bạn thực hiện hàng loạt thao tác trực tiếp trên chính List đó. Từ việc thêm, xóa, sửa đổi phần tử cho đến sắp xếp hay tìm kiếm, các phương thức này là những công cụ không thể thiếu giúp bạn thao tác với dữ liệu một cách hiệu quả và gọn gàng. Hãy cùng tìm hiểu những "hành động" mà List có thể thực hiện nhé!

Phương thức (Method) là gì?

Trong lập trình hướng đối tượng nói chung và trong Python nói riêng, một phương thức (method) là một hàm (function) "thuộc về" một đối tượng. Nói cách khác, đó là một hành động mà đối tượng đó có thể thực hiện trên chính nó hoặc với dữ liệu của nó.

Khi nói về List, các phương thức là những hàm đặc biệt được gắn liền với đối tượng List. Bạn gọi một phương thức bằng cách sử dụng dấu chấm (.) sau tên List, theo sau là tên phương thức và cặp dấu ngoặc đơn (), có thể có hoặc không có đối số bên trong.

Ví dụ:

my_list = [10, 20, 30]
my_list.append(40) # append() là một phương thức của đối tượng List 'my_list'
print(my_list)     # Output: [10, 20, 30, 40]

Trong ví dụ này, append() là một phương thức của my_list (một đối tượng List). Phương thức này thực hiện hành động "thêm một phần tử vào cuối List".

Tại sao cần dùng phương thức List?

Các phương thức của List là những công cụ vô cùng hữu ích và cần thiết vì chúng cung cấp cách hiệu quả và Pythonic để thực hiện các thao tác phổ biến trên List mà không cần phải viết lại logic từ đầu.

Những lợi ích chính:

Thực hiện các thao tác phổ biến một cách dễ dàng: List đi kèm với các phương thức được thiết kế để giải quyết những nhu cầu thường gặp như:

Thêm phần tử: append(), extend(), insert()
Xóa phần tử: remove(), pop(), clear()
Sửa đổi/Sắp xếp: sort(), reverse()
Tìm kiếm và đếm: count(), index() Việc này giúp bạn tiết kiệm thời gian và công sức viết code.

Code ngắn gọn và dễ đọc hơn: Thay vì phải viết vòng lặp dài dòng để thêm hoặc xóa một phần tử, bạn chỉ cần gọi một phương thức duy nhất. Điều này làm cho code của bạn gọn gàng và dễ hiểu hơn nhiều.

Ví dụ: Để thêm phần tử vào cuối List:

Không dùng phương thức (cách phức tạp): Bạn sẽ không làm được dễ dàng nếu không có phương thức append().
Dùng phương thức:

my_list = [1, 2]
my_list.append(3) # Cực kỳ đơn giản và trực quan

Hiệu suất tối ưu: Các phương thức List được triển khai bằng C (ở cấp độ Python nội bộ) và được tối ưu hóa cao về hiệu suất. Điều này có nghĩa là chúng thường chạy nhanh hơn nhiều so với việc bạn tự viết các vòng lặp Python để thực hiện cùng một thao tác, đặc biệt với các List lớn.

Ví dụ: Để nối một List khác vào cuối:

Cách hiệu quả (dùng phương thức):

list_a = [1, 2]
list_b = [3, 4]
list_a.extend(list_b) # Rất nhanh và hiệu quả

Cách ít hiệu quả (không dùng phương thức):

# Cách này dài dòng và kém hiệu quả hơn cho việc nối đơn giản
list_a = [1, 2]
list_b = [3, 4]
for item in list_b:
    list_a.append(item)

Các phương thức List là những công cụ không thể thiếu, giúp bạn thao tác với dữ liệu List một cách mạnh mẽ, hiệu quả và theo đúng phong cách Python.

Các Phương Thức Thêm Phần tử trong Python

List trong Python rất linh hoạt vì bạn có thể dễ dàng thêm các phần tử mới vào chúng sau khi đã tạo. Dưới đây là ba phương thức chính để làm điều đó:

`append()`

Mục đích: Phương thức append() được dùng để thêm một phần tử duy nhất vào cuối của List. Nó mở rộng List bằng cách thêm mục mới vào vị trí cuối cùng.

Cú pháp:

ten_list.append(phan_tu)

ten_list: List mà bạn muốn thêm phần tử vào.
phan_tu: Phần tử (có thể là bất kỳ kiểu dữ liệu nào: số, chuỗi, List khác, v.v.) mà bạn muốn thêm vào List.

Ví dụ minh họa:

# Ví dụ 1: Thêm số vào cuối List
numbers = [1, 2, 3]
print(f"List ban đầu: {numbers}") # Output: List ban đầu: [1, 2, 3]

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

# Ví dụ 2: Thêm một chuỗi vào cuối List
fruits = ["apple", "banana"]
print(f"List trái cây ban đầu: {fruits}") # Output: List trái cây ban đầu: ['apple', 'banana']

fruits.append("cherry") # Thêm 'cherry' vào cuối
print(f"List trái cây sau khi append('cherry'): {fruits}") # Output: List trái cây sau khi append('cherry'): ['apple', 'banana', 'cherry']

# Ví dụ 3: Append một List khác (List lồng nhau)
my_list = [10, 20]
sub_list = [30, 40]
my_list.append(sub_list) # Thêm sub_list như MỘT phần tử duy nhất vào cuối
print(f"List sau khi append một sub_list: {my_list}") # Output: List sau khi append một sub_list: [10, 20, [30, 40]]

`extend()`

Mục đích: Phương thức extend() được dùng để thêm tất cả các phần tử của một iterable (ví dụ: một List khác, tuple, chuỗi) vào cuối List hiện có. Khác với append(), extend() sẽ "giải nén" các phần tử từ iterable và thêm từng phần tử riêng lẻ.

Cú pháp:

ten_list.extend(iterable)

ten_list: List mà bạn muốn thêm các phần tử vào.
iterable: Đối tượng có thể lặp (List, tuple, set, chuỗi) chứa các phần tử mà bạn muốn thêm.

Ví dụ minh họa:

# Ví dụ 1: Extend với một List khác
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(f"List1 ban đầu: {list1}") # Output: List1 ban đầu: [1, 2, 3]

list1.extend(list2) # Thêm từng phần tử của list2 vào cuối list1
print(f"List1 sau khi extend(list2): {list1}") # Output: List1 sau khi extend(list2): [1, 2, 3, 4, 5, 6]

# Ví dụ 2: Extend với một tuple
colors = ["red", "green"]
new_colors = ("blue", "yellow")
print(f"Colors ban đầu: {colors}") # Output: Colors ban đầu: ['red', 'green']

colors.extend(new_colors) # Thêm từng phần tử của tuple vào List
print(f"Colors sau khi extend(tuple): {colors}") # Output: Colors sau khi extend(tuple): ['red', 'green', 'blue', 'yellow']

# Ví dụ 3: Extend với một chuỗi (chuỗi cũng là iterable)
letters = ['a', 'b']
word = "cd"
print(f"Letters ban đầu: {letters}") # Output: Letters ban đầu: ['a', 'b']

letters.extend(word) # Thêm từng ký tự của chuỗi vào List
print(f"Letters sau khi extend('cd'): {letters}") # Output: Letters sau khi extend('cd'): ['a', 'b', 'c', 'd']

`insert()`

Mục đích: Phương thức insert() cho phép bạn thêm một phần tử vào một vị trí cụ thể (chỉ số) trong List, thay vì chỉ ở cuối. Khi một phần tử được chèn, tất cả các phần tử ở vị trí đó trở đi sẽ bị dịch sang phải một vị trí.

Cú pháp:

ten_list.insert(vi_tri, phan_tu)

ten_list: List mà bạn muốn chèn phần tử vào.
vi_tri: Chỉ số mà tại đó bạn muốn chèn phần tử. Các phần tử hiện có từ chỉ số này sẽ bị đẩy lùi.
phan_tu: Phần tử bạn muốn chèn.

Ví dụ minh họa:

# Ví dụ 1: Chèn vào giữa List
my_list = ["apple", "banana", "cherry"]
print(f"List ban đầu: {my_list}") # Output: List ban đầu: ['apple', 'banana', 'cherry']

my_list.insert(1, "orange") # Chèn 'orange' vào chỉ số 1
print(f"List sau khi insert(1, 'orange'): {my_list}") # Output: List sau khi insert(1, 'orange'): ['apple', 'orange', 'banana', 'cherry']

# Ví dụ 2: Chèn vào đầu List (chỉ số 0)
scores = [85, 90, 75]
print(f"Scores ban đầu: {scores}") # Output: Scores ban đầu: [85, 90, 75]

scores.insert(0, 100) # Chèn 100 vào chỉ số 0
print(f"Scores sau khi insert(0, 100): {scores}") # Output: Scores sau khi insert(0, 100): [100, 85, 90, 75]

# Ví dụ 3: Chèn vào chỉ số lớn hơn độ dài List (sẽ chèn vào cuối)
items = ['a', 'b']
items.insert(100, 'c') # Chỉ số 100 lớn hơn độ dài (2), nên 'c' sẽ được chèn vào cuối
print(f"Items sau khi insert vào chỉ số lớn: {items}") # Output: Items sau khi insert vào chỉ số lớn: ['a', 'b', 'c']

Các Phương Thức Xóa Phần tử trong Python

Python cung cấp nhiều phương thức để xóa phần tử khỏi List, tùy thuộc vào việc bạn muốn xóa theo giá trị hay theo vị trí.

`remove()`

Mục đích: Phương thức remove() được sử dụng để xóa lần xuất hiện đầu tiên của một phần tử có giá trị cụ thể khỏi List. Nó tìm kiếm giá trị bạn cung cấp từ đầu List và xóa ngay khi tìm thấy.
Lưu ý: Nếu phần tử với giá trị được chỉ định không tồn tại trong List, Python sẽ gây ra lỗi ValueError.

Cú pháp:

ten_list.remove(gia_tri)

ten_list: List mà bạn muốn xóa phần tử.
gia_tri: Giá trị của phần tử mà bạn muốn xóa.

Ví dụ minh họa:

# Ví dụ 1: Xóa một số khỏi List
numbers = [1, 2, 3, 2, 4]
print(f"List ban đầu: {numbers}") # Output: List ban đầu: [1, 2, 3, 2, 4]

numbers.remove(2) # Xóa lần xuất hiện đầu tiên của số 2
print(f"List sau khi remove(2): {numbers}") # Output: List sau khi remove(2): [1, 3, 2, 4]

# Ví dụ 2: Xóa một chuỗi khỏi List
fruits = ["apple", "banana", "cherry", "apple"]
print(f"List trái cây ban đầu: {fruits}") # Output: List trái cây ban đầu: ['apple', 'banana', 'cherry', 'apple']

fruits.remove("apple") # Xóa lần xuất hiện đầu tiên của 'apple'
print(f"List trái cây sau khi remove('apple'): {fruits}") # Output: List trái cây sau khi remove('apple'): ['banana', 'cherry', 'apple']

# Ví dụ 3: Xóa phần tử không tồn tại (gây lỗi)
try:
    numbers.remove(99) # Số 99 không có trong List
except ValueError as e:
    print(f"Lỗi khi remove: {e}") # Output: Lỗi khi remove: list.remove(x): x not in list

`pop()`

Mục đích: Phương thức pop() được dùng để xóa phần tử tại một chỉ số cụ thể khỏi List và trả về phần tử đó. Nếu bạn không cung cấp chỉ số nào, pop() sẽ mặc định xóa và trả về phần tử cuối cùng của List.
Lưu ý: Nếu chỉ số được chỉ định không hợp lệ (ngoài phạm vi của List), Python sẽ gây ra lỗi IndexError.

Cú pháp:

phan_tu_da_xoa = ten_list.pop(chi_so) # Xóa theo chỉ số
# Hoặc
phan_tu_cuoi = ten_list.pop() # Xóa phần tử cuối cùng

ten_list: List mà bạn muốn xóa phần tử.
chi_so (tùy chọn): Chỉ số của phần tử cần xóa.

Ví dụ minh họa:

# Ví dụ 1: Pop phần tử tại chỉ số cụ thể
students = ["Alice", "Bob", "Charlie", "David"]
print(f"List sinh viên ban đầu: {students}") # Output: List sinh viên ban đầu: ['Alice', 'Bob', 'Charlie', 'David']

removed_student = students.pop(1) # Xóa phần tử tại chỉ số 1 ('Bob')
print(f"Sinh viên đã xóa: {removed_student}") # Output: Sinh viên đã xóa: Bob
print(f"List sinh viên sau khi pop(1): {students}") # Output: List sinh viên sau khi pop(1): ['Alice', 'Charlie', 'David']

# Ví dụ 2: Pop phần tử cuối cùng (không có chỉ số)
scores = [85, 90, 78]
print(f"List điểm số ban đầu: {scores}") # Output: List điểm số ban đầu: [85, 90, 78]

last_score = scores.pop() # Xóa và trả về phần tử cuối cùng (78)
print(f"Điểm số cuối cùng đã xóa: {last_score}") # Output: Điểm số cuối cùng đã xóa: 78
print(f"List điểm số sau khi pop(): {scores}") # Output: List điểm số sau khi pop(): [85, 90]

# Ví dụ 3: Pop chỉ số không hợp lệ (gây lỗi)
try:
    scores.pop(5) # Chỉ số 5 nằm ngoài phạm vi List
except IndexError as e:
    print(f"Lỗi khi pop: {e}") # Output: Lỗi khi pop: pop index out of range

`clear()`

Mục đích: Phương thức clear() xóa tất cả các phần tử khỏi List, làm cho List trở thành một List rỗng. List vẫn tồn tại, nhưng không còn chứa bất kỳ phần tử nào.

Cú pháp:

ten_list.clear()

ten_list: List mà bạn muốn xóa sạch.

Ví dụ minh họa:

# Ví dụ: Xóa sạch tất cả phần tử trong List
shopping_cart = ["milk", "bread", "eggs"]
print(f"Giỏ hàng ban đầu: {shopping_cart}") # Output: Giỏ hàng ban đầu: ['milk', 'bread', 'eggs']

shopping_cart.clear() # Xóa tất cả phần tử
print(f"Giỏ hàng sau khi clear(): {shopping_cart}") # Output: Giỏ hàng sau khi clear(): []

Các Phương Thức Sắp xếp và Đảo ngược trong Python

Python cung cấp các phương thức tiện lợi để sắp xếp hoặc đảo ngược thứ tự các phần tử trong List của bạn.

`sort()`

Mục đích: Phương thức sort() sắp xếp các phần tử của List trực tiếp tại chỗ (in-place), nghĩa là nó thay đổi thứ tự của List gốc. Mặc định, nó sắp xếp theo thứ tự tăng dần.

Cú pháp:

ten_list.sort() # Sắp xếp tăng dần
# Hoặc
ten_list.sort(reverse=True) # Sắp xếp giảm dần

ten_list: List bạn muốn sắp xếp.
reverse=True (tùy chọn): Nếu đặt là True, List sẽ được sắp xếp theo thứ tự giảm dần.

Ví dụ minh họa:

# Ví dụ 1: Sắp xếp số tăng dần
numbers = [3, 1, 4, 1, 5, 9, 2]
print(f"List số ban đầu: {numbers}") # Output: List số ban đầu: [3, 1, 4, 1, 5, 9, 2]

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

# Ví dụ 2: Sắp xếp chuỗi giảm dần
fruits = ["orange", "apple", "banana", "cherry"]
print(f"List trái cây ban đầu: {fruits}") # Output: List trái cây ban đầu: ['orange', 'apple', 'banana', 'cherry']

fruits.sort(reverse=True) # Sắp xếp giảm dần
print(f"List trái cây sau khi sort(reverse=True): {fruits}") # Output: List trái cây sau khi sort(reverse=True): ['orange', 'cherry', 'banana', 'apple']

# Lưu ý: sort() thay đổi List gốc và trả về None
# Bạn không nên gán kết quả của sort() vào một biến mới nếu muốn List đã sắp xếp.

`reverse()`

Mục đích: Phương thức reverse() đảo ngược thứ tự các phần tử của List trực tiếp tại chỗ (in-place). Nó không sắp xếp các phần tử mà chỉ thay đổi vị trí của chúng theo thứ tự ngược lại so với ban đầu.

Cú pháp:

ten_list.reverse()

ten_list: List bạn muốn đảo ngược.

Ví dụ minh họa:

# Ví dụ 1: Đảo ngược List số
my_sequence = [1, 2, 3, 4, 5]
print(f"List ban đầu: {my_sequence}") # Output: List ban đầu: [1, 2, 3, 4, 5]

my_sequence.reverse() # Đảo ngược thứ tự
print(f"List sau khi reverse(): {my_sequence}") # Output: List sau khi reverse(): [5, 4, 3, 2, 1]

# Ví dụ 2: Đảo ngược List chuỗi
alphabet = ['a', 'b', 'c', 'd']
print(f"List chữ cái ban đầu: {alphabet}") # Output: List chữ cái ban đầu: ['a', 'b', 'c', 'd']

alphabet.reverse() # Đảo ngược thứ tự
print(f"List chữ cái sau khi reverse(): {alphabet}") # Output: List chữ cái sau khi reverse(): ['d', 'c', 'b', 'a']

# Lưu ý: reverse() cũng thay đổi List gốc và trả về None

Các Phương Thức Tìm kiếm và Đếm trong Python

List trong Python cung cấp các phương thức tiện lợi để tìm kiếm và đếm sự xuất hiện của các phần tử.

count()

Mục đích: Phương thức count() dùng để đếm số lần xuất hiện của một phần tử có giá trị cụ thể trong List. Nó sẽ duyệt qua toàn bộ List và trả về tổng số lần giá trị đó được tìm thấy.

Cú pháp:

so_lan_xuat_hien = ten_list.count(gia_tri)

ten_list: List mà bạn muốn đếm phần tử trong đó.
gia_tri: Giá trị của phần tử mà bạn muốn đếm.

Ví dụ minh họa:

# Ví dụ 1: Đếm số lần xuất hiện của một số
numbers = [1, 2, 3, 2, 4, 2, 5]
print(f"List ban đầu: {numbers}") # Output: List ban đầu: [1, 2, 3, 2, 4, 2, 5]

count_of_2 = numbers.count(2) # Đếm số lần xuất hiện của 2
print(f"Số lần số 2 xuất hiện: {count_of_2}") # Output: Số lần số 2 xuất hiện: 3

# Ví dụ 2: Đếm số lần xuất hiện của một chuỗi
fruits = ["apple", "banana", "cherry", "apple", "grape"]
print(f"List trái cây ban đầu: {fruits}") # Output: List trái cây ban đầu: ['apple', 'banana', 'cherry', 'apple', 'grape']

count_of_apple = fruits.count("apple")
print(f"Số lần 'apple' xuất hiện: {count_of_apple}") # Output: Số lần 'apple' xuất hiện: 2

# Ví dụ 3: Đếm phần tử không tồn tại (trả về 0)
count_of_orange = fruits.count("orange")
print(f"Số lần 'orange' xuất hiện: {count_of_orange}") # Output: Số lần 'orange' xuất hiện: 0

`index()`

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

Cú pháp:

chi_so = ten_list.index(gia_tri, bat_dau, ket_thuc)

ten_list: List mà bạn muốn tìm kiếm phần tử trong đó.
gia_tri: Giá trị của phần tử mà bạn muốn tìm chỉ số.
bat_dau (tùy chọn): Chỉ số bắt đầu tìm kiếm.
ket_thuc (tùy chọn): Chỉ số kết thúc tìm kiếm (không bao gồm chỉ số này).

Ví dụ minh họa

# Ví dụ 1: Tìm chỉ số của một số
scores = [80, 90, 75, 90, 88]
print(f"List điểm số ban đầu: {scores}") # Output: List điểm số ban đầu: [80, 90, 75, 90, 88]

index_of_90 = scores.index(90) # Tìm chỉ số của lần xuất hiện đầu tiên của 90
print(f"Chỉ số của 90: {index_of_90}") # Output: Chỉ số của 90: 1

# Ví dụ 2: Tìm chỉ số của một chuỗi
letters = ['a', 'b', 'c', 'a', 'd']
print(f"List chữ cái ban đầu: {letters}") # Output: List chữ cái ban đầu: ['a', 'b', 'c', 'a', 'd']

index_of_c = letters.index('c')
print(f"Chỉ số của 'c': {index_of_c}") # Output: Chỉ số của 'c': 2

# Ví dụ 3: Tìm chỉ số trong một phạm vi cụ thể
# Tìm 90 bắt đầu từ chỉ số 2
index_of_90_from_2 = scores.index(90, 2)
print(f"Chỉ số của 90 (bắt đầu từ index 2): {index_of_90_from_2}") # Output: Chỉ số của 90 (bắt đầu từ index 2): 3

# Ví dụ 4: Tìm phần tử không tồn tại (gây lỗi)
try:
    scores.index(100) # Số 100 không có trong List
except ValueError as e:
    print(f"Lỗi khi index: {e}") # Output: Lỗi khi index: 100 is not in list

Kết bài

Bạn đã làm quen với các phương thức (methods) xử lý List trong Python rồi! Đây là những công cụ vô cùng tiện lợi giúp bạn thao tác với dữ liệu List một cách hiệu quả và trực quan.

Bạn đã tìm hiểu các nhóm phương thức chính:

Thêm phần tử: append(), extend(), insert().
Xóa phần tử: remove(), pop(), clear().
Sắp xếp và Đảo ngược: sort(), reverse().
Tìm kiếm và Đếm: count(), index().

Một lưu ý quan trọng: Hầu hết các phương thức này đều thực hiện thao tác "tại chỗ" (in-place), nghĩa là chúng thay đổi trực tiếp List gốc và trả về None.