Các phương thức thao tác Set trong Python

Python Tutorial | 27/07/2025 by Hoc Python

Set là một cấu trúc dữ liệu linh hoạt và mạnh mẽ. Để tận dụng tối đa khả năng của nó, bạn cần làm chủ các phương thức tích hợp sẵn để thêm, xóa, và kết hợp các phần tử.

Bài viết này sẽ là một cẩm nang toàn diện, giúp bạn tìm hiểu các phương thức chính của Set. Chúng ta sẽ đi sâu vào từng nhóm phương thức, từ những thao tác cơ bản nhất như thêm/xóa phần tử, cho đến các phép toán tập hợp phức tạp hơn. Nắm vững những phương thức này không chỉ giúp bạn viết code ngắn gọn mà còn mở ra nhiều cách giải quyết bài toán xử lý dữ liệu một cách thông minh và hiệu quả. Hãy cùng bắt đầu nhé!

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

Trong lập trình hướng đối tượng, phương thức (method) là các hàm được gắn liền với một đối tượng cụ thể. Nói một cách đơn giản, chúng là những "hành động" mà đối tượng đó có thể thực hiện.

Ví dụ, khi bạn tạo một đối tượng Set, nó sẽ có sẵn một bộ phương thức để giúp bạn tương tác với nó. Thay vì phải viết một hàm độc lập, bạn chỉ cần gọi phương thức đó thông qua đối tượng Set của mình bằng cú pháp ten_doi_tuong.ten_phuong_thuc().

Ví dụ:

# 'my_set' là đối tượng Set
my_set = {1, 2, 3}

# 'add()' là một phương thức của đối tượng Set
my_set.add(4)
print(my_set)
# Output: {1, 2, 3, 4}

Trong ví dụ này, add() là một phương thức giúp đối tượng my_set thực hiện hành động "thêm một phần tử".

Tại sao cần các phương thức này?

Các phương thức thao tác Set ra đời để giúp bạn thực hiện các công việc sau một cách hiệu quả và trực quan:

Thêm và xóa phần tử: Set là một cấu trúc dữ liệu có thể thay đổi (mutable), nghĩa là bạn có thể cập nhật nội dung của nó. Các phương thức như add(), remove(), hay clear() cho phép bạn dễ dàng thêm các phần tử mới hoặc loại bỏ những phần tử không cần thiết.

my_set = {"a", "b"}

# Thêm một phần tử
my_set.add("c")
print(f"Thêm 'c': {my_set}") # Output: Thêm 'c': {'a', 'c', 'b'}

# Xóa một phần tử
my_set.remove("b")
print(f"Xóa 'b': {my_set}") # Output: Xóa 'b': {'a', 'c'}

Thực hiện các phép toán tập hợp: Một trong những lợi thế lớn nhất của Set là khả năng thực hiện các phép toán tập hợp trong toán học. Các phương thức như union(), intersection(), difference() giúp bạn thực hiện những phép toán này một cách dễ dàng, giúp code của bạn ngắn gọn và dễ hiểu hơn nhiều so với việc dùng vòng lặp thủ công.

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# Thực hiện phép hợp (union)
set_hop = set1.union(set2)
print(f"Kết quả phép hợp: {set_hop}")
# Output: Kết quả phép hợp: {1, 2, 3, 4, 5}

Cập nhật Set gốc: Một số phương thức còn cho phép bạn thực hiện các phép toán và cập nhật Set gốc trực tiếp mà không cần tạo một Set mới. Ví dụ như các phương thức có đuôi _update().

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# Cập nhật set1 bằng phép giao với set2
set1.intersection_update(set2)
print(f"set1 sau khi cập nhật: {set1}")
# Output: set1 sau khi cập nhật: {3, 4}

Các phương thức này là những công cụ mạnh mẽ giúp bạn làm việc hiệu quả với các tập hợp dữ liệu.

Các phương thức thêm phần tử trong Python

Để thêm phần tử vào một Set, Python cung cấp hai phương thức chính là add() và update(). Mỗi phương thức phục vụ một mục đích khác nhau, tùy thuộc vào việc bạn muốn thêm một phần tử hay nhiều phần tử cùng lúc.

`add()`

Phương thức add() là cách cơ bản nhất để thêm một phần tử vào Set.

Chức năng: Thêm một phần tử duy nhất vào Set.

Đặc điểm:

Nếu phần tử bạn muốn thêm đã có trong Set, add() sẽ bỏ qua và không làm gì cả. Set vẫn giữ nguyên.
Phần tử được thêm phải là đối tượng bất biến (immutable), tức là không thể thay đổi sau khi tạo (ví dụ: số, chuỗi, tuple). Bạn không thể thêm list hoặc dictionary vào Set bằng add().

Ví dụ minh họa:

# Tạo một Set rỗng
programming_languages = set()

# Dùng add() để thêm từng phần tử
programming_languages.add("Python")
programming_languages.add("Java")
programming_languages.add("C++")
print(f"Set sau khi thêm 3 ngôn ngữ: {programming_languages}")
# Output: Set sau khi thêm 3 ngôn ngữ: {'Python', 'C++', 'Java'}

# Thêm một phần tử đã tồn tại
programming_languages.add("Python")
print(f"Set sau khi thêm lại 'Python': {programming_languages}")
# Output: Set sau khi thêm lại 'Python': {'Python', 'C++', 'Java'}
# Set không thay đổi vì 'Python' đã có.

`update()`

Phương thức update() mạnh mẽ hơn add() vì nó cho phép bạn thêm nhiều phần tử cùng lúc.

Chức năng: Thêm nhiều phần tử vào Set từ một đối tượng có thể lặp (iterable) khác như list, tuple, hoặc một Set khác.
Đặc điểm: update() sẽ duyệt qua từng phần tử của iterable đầu vào và thêm chúng vào Set. Các phần tử trùng lặp sẽ bị bỏ qua.

Ví dụ minh họa:

my_set = {"apple", "banana"}
print(f"Set ban đầu: {my_set}")
# Output: Set ban đầu: {'apple', 'banana'}

# Thêm nhiều phần tử từ một list
new_fruits = ["cherry", "grape", "apple"]
my_set.update(new_fruits)
print(f"Set sau khi update từ list: {my_set}")
# Output: Set sau khi update từ list: {'cherry', 'grape', 'banana', 'apple'}
# Lưu ý: 'apple' đã tồn tại nên không được thêm lại.

# Thêm nhiều phần tử từ một set khác
another_set = {"kiwi", "banana"}
my_set.update(another_set)
print(f"Set sau khi update từ set khác: {my_set}")
# Output: Set sau khi update từ set khác: {'cherry', 'grape', 'banana', 'kiwi', 'apple'}

Các phương thức xóa phần tử trong Python

Khi làm việc với Set, việc xóa các phần tử không mong muốn là một thao tác cơ bản. Python cung cấp bốn phương thức chính để thực hiện điều này, mỗi phương thức có một chức năng và cách hoạt động riêng biệt.

`remove()`

remove() dùng để xóa một phần tử cụ thể khỏi Set.

Đặc điểm chính: Nếu phần tử bạn muốn xóa không tồn tại trong Set, phương thức này sẽ gây ra lỗi KeyError.
Khi nào dùng: Khi bạn chắc chắn phần tử đó có trong Set và bạn muốn chương trình báo lỗi nếu có bất kỳ sai sót nào.

Ví dụ:

my_set = {"apple", "banana", "cherry"}

# Xóa một phần tử tồn tại
my_set.remove("banana")
print(f"Set sau khi remove 'banana': {my_set}")
# Output: Set sau khi remove 'banana': {'apple', 'cherry'}

# Cố gắng xóa một phần tử không tồn tại (sẽ gây lỗi)
try:
    my_set.remove("grape")
except KeyError as e:
    print(f"Lỗi: {e} - Phần tử không tồn tại trong Set.")
# Output: Lỗi: 'grape' - Phần tử không tồn tại trong Set.

`discard()`

discard() cũng dùng để xóa một phần tử cụ thể, nhưng nó an toàn hơn remove().

Đặc điểm chính: Nếu phần tử không tồn tại trong Set, phương thức này sẽ không làm gì cả và không gây lỗi.
Khi nào dùng: Khi bạn không chắc chắn phần tử đó có trong Set và bạn muốn code tiếp tục chạy mà không bị gián đoạn.

Ví dụ:

my_set = {"apple", "banana", "cherry"}

# Xóa một phần tử tồn tại
my_set.discard("banana")
print(f"Set sau khi discard 'banana': {my_set}")
# Output: Set sau khi discard 'banana': {'apple', 'cherry'}

# Cố gắng xóa một phần tử không tồn tại (không gây lỗi)
my_set.discard("grape")
print(f"Set sau khi discard 'grape': {my_set}")
# Output: Set sau khi discard 'grape': {'apple', 'cherry'}

`pop()`

pop() xóa và trả về một phần tử ngẫu nhiên từ Set.

Đặc điểm chính: Vì Set không có thứ tự, bạn không thể đoán trước phần tử nào sẽ bị xóa. Nếu Set rỗng, nó sẽ gây ra lỗi KeyError.
Khi nào dùng: Khi bạn muốn lấy và loại bỏ một phần tử bất kỳ khỏi Set. Ví dụ, để xử lý từng phần tử cho đến khi Set rỗng.

Ví dụ:

my_set = {"apple", "banana", "cherry"}

# Lấy và xóa một phần tử ngẫu nhiên
popped_item = my_set.pop()
print(f"Phần tử đã bị pop: {popped_item}")
print(f"Set còn lại: {my_set}")
# Output có thể khác nhau:
# Phần tử đã bị pop: apple
# Set còn lại: {'cherry', 'banana'}

# Khi Set rỗng (sẽ gây lỗi)
empty_set = set()
try:
    empty_set.pop()
except KeyError as e:
    print(f"Lỗi: {e} - Set rỗng.")
# Output: Lỗi: 'pop from an empty set' - Set rỗng.

`clear()`

clear() là phương thức đơn giản nhất, dùng để xóa tất cả các phần tử khỏi Set.

Đặc điểm chính: Nó biến Set thành một Set rỗng, tức là set().
Khi nào dùng: Khi bạn muốn xóa sạch toàn bộ nội dung của Set để bắt đầu lại.

Ví dụ:

my_set = {1, 2, 3, 4}
print(f"Set ban đầu: {my_set}")
# Output: Set ban đầu: {1, 2, 3, 4}

# Xóa tất cả các phần tử
my_set.clear()
print(f"Set sau khi clear: {my_set}")
# Output: Set sau khi clear: set()

Các phương thức phép toán tập hợp (Tạo Set mới) trong Python

Một trong những lợi thế lớn nhất của Set là khả năng thực hiện các phép toán tập hợp trong toán học. Các phương thức sau đây sẽ tạo ra một Set mới làm kết quả, không làm thay đổi Set gốc. Mỗi phương thức đều có một toán tử tương đương để viết code ngắn gọn hơn.

`union()`

Chức năng: Phép hợp tạo ra một Set mới chứa tất cả các phần tử duy nhất từ tất cả các Set tham gia.
Toán tử tương đương: Dấu gạch đứng |.

Ví dụ:

set_a = {1, 2, 3}
set_b = {3, 4, 5}

# Sử dụng phương thức union()
set_union_method = set_a.union(set_b)
print(f"Kết quả union() với set_a: {set_union_method}")
# Output: Kết quả union() với set_a: {1, 2, 3, 4, 5}

# Sử dụng toán tử |
set_union_operator = set_a | set_b
print(f"Kết quả toán tử |: {set_union_operator}")
# Output: Kết quả toán tử |: {1, 2, 3, 4, 5}

# Set gốc vẫn không thay đổi
print(f"Set a sau phép toán: {set_a}")
# Output: Set a sau phép toán: {1, 2, 3}

`intersection()`

Chức năng: Phép giao tạo ra một Set mới chứa chỉ các phần tử chung (có mặt trong tất cả các Set).
Toán tử tương đương: Dấu và &.

Ví dụ:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# Sử dụng phương thức intersection()
set_intersection_method = set_a.intersection(set_b)
print(f"Kết quả intersection(): {set_intersection_method}")
# Output: Kết quả intersection(): {3, 4}

# Sử dụng toán tử &
set_intersection_operator = set_a & set_b
print(f"Kết quả toán tử &: {set_intersection_operator}")
# Output: Kết quả toán tử &: {3, 4}

`difference()`

Chức năng: Phép hiệu tạo ra một Set mới chứa các phần tử chỉ có trong Set gọi phương thức, không có trong Set khác.
Toán tử tương đương: Dấu trừ -.

Ví dụ:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# set_a.difference(set_b) -> Tìm các phần tử chỉ có trong set_a
set_difference_method = set_a.difference(set_b)
print(f"Kết quả set_a.difference(set_b): {set_difference_method}")
# Output: Kết quả set_a.difference(set_b): {1, 2}

# Sử dụng toán tử -
set_difference_operator = set_a - set_b
print(f"Kết quả set_a - set_b: {set_difference_operator}")
# Output: Kết quả set_a - set_b: {1, 2}

# Chú ý: Thứ tự rất quan trọng!
set_b_minus_a = set_b.difference(set_a)
print(f"Kết quả set_b.difference(set_a): {set_b_minus_a}")
# Output: Kết quả set_b.difference(set_a): {5, 6}

`symmetric_difference()`

Chức năng: Phép hiệu đối xứng tạo ra một Set mới chứa các phần tử có trong một trong hai Set nhưng không có trong cả hai.
Toán tử tương đương: Dấu mũ ^.

Ví dụ:

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# Sử dụng phương thức symmetric_difference()
set_sym_diff_method = set_a.symmetric_difference(set_b)
print(f"Kết quả symmetric_difference(): {set_sym_diff_method}")
# Output: Kết quả symmetric_difference(): {1, 2, 5, 6}

# Sử dụng toán tử ^
set_sym_diff_operator = set_a ^ set_b
print(f"Kết quả toán tử ^: {set_sym_diff_operator}")
# Output: Kết quả toán tử ^: {1, 2, 5, 6}

Các phương thức kiểm tra mối quan hệ giữa các Set trong Python

Ngoài việc tạo Set mới, Python còn cung cấp các phương thức giúp bạn kiểm tra mối quan hệ giữa các Set, trả về giá trị True hoặc False.

`issubset()`

Chức năng: Kiểm tra xem một Set có phải là tập con của Set khác hay không. Một Set A được gọi là tập con của Set B nếu tất cả các phần tử của A đều có mặt trong B.

Ví dụ:

A = {1, 2}
B = {1, 2, 3, 4}
C = {1, 5}

print(f"A có phải là tập con của B không? {A.issubset(B)}") # Output: A có phải là tập con của B không? True
print(f"B có phải là tập con của A không? {B.issubset(A)}") # Output: B có phải là tập con của A không? False
print(f"C có phải là tập con của B không? {C.issubset(B)}") # Output: C có phải là tập con của B không? False

`issuperset()` ⊇

Chức năng: Kiểm tra xem một Set có phải là tập cha của Set khác hay không. Một Set A được gọi là tập cha của Set B nếu A chứa tất cả các phần tử của B.

Ví dụ:

A = {1, 2, 3, 4}
B = {1, 2}
C = {1, 5}

print(f"A có phải là tập cha của B không? {A.issuperset(B)}") # Output: A có phải là tập cha của B không? True
print(f"B có phải là tập cha của A không? {B.issuperset(A)}") # Output: B có phải là tập cha của A không? False
print(f"A có phải là tập cha của C không? {A.issuperset(C)}") # Output: A có phải là tập cha của C không? False

`isdisjoint()`

Chức năng: Kiểm tra xem hai Set có hoàn toàn không có phần tử chung nào hay không. Nếu không có phần tử chung nào, phương thức sẽ trả về True.

Ví dụ:

A = {1, 2}
B = {3, 4}
C = {2, 5}

print(f"A và B có rời nhau không? {A.isdisjoint(B)}") # Output: A và B có rời nhau không? True
print(f"A và C có rời nhau không? {A.isdisjoint(C)}") # Output: A và C có rời nhau không? False

Các phương thức phép toán tập hợp tại chỗ (Cập nhật Set gốc) trong Python

Các phương thức sau đây thực hiện các phép toán tập hợp và cập nhật trực tiếp Set ban đầu, thay vì tạo một Set mới.

`intersection_update()` ∩=

Chức năng: Cập nhật Set gốc bằng cách chỉ giữ lại các phần tử chung với Set khác.
Toán tử tương đương: &=.

Ví dụ:

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(f"Set A ban đầu: {A}") # Output: Set A ban đầu: {1, 2, 3, 4}
A.intersection_update(B)
print(f"Set A sau khi cập nhật giao với B: {A}") # Output: Set A sau khi cập nhật giao với B: {3, 4}

`difference_update()` -=

Chức năng: Cập nhật Set gốc bằng cách xóa đi các phần tử có trong Set khác.
Toán tử tương đương: -=.

Ví dụ:

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(f"Set A ban đầu: {A}") # Output: Set A ban đầu: {1, 2, 3, 4}
A.difference_update(B)
print(f"Set A sau khi cập nhật hiệu với B: {A}") # Output: Set A sau khi cập nhật hiệu với B: {1, 2}

`symmetric_difference_update()` ^=

Chức năng: Cập nhật Set gốc bằng kết quả của phép hiệu đối xứng với Set khác.
Toán tử tương đương: ^=.

Ví dụ:

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(f"Set A ban đầu: {A}") # Output: Set A ban đầu: {1, 2, 3, 4}
A.symmetric_difference_update(B)
print(f"Set A sau khi cập nhật hiệu đối xứng với B: {A}") # Output: Set A sau khi cập nhật hiệu đối xứng với B: {1, 2, 5, 6}

Kết bài

Nắm vững những công cụ này là rất quan trọng để bạn có thể làm việc hiệu quả với các tập hợp dữ liệu. Hãy tóm tắt lại các nhóm phương thức chính:

Thêm:

add(): Thêm một phần tử duy nhất.
update(): Thêm nhiều phần tử từ một iterable.

Xóa:

remove(): Xóa một phần tử, gây lỗi nếu không tìm thấy.
discard(): Xóa một phần tử, không gây lỗi nếu không tìm thấy.
pop(): Xóa và trả về một phần tử ngẫu nhiên.
clear(): Xóa tất cả các phần tử.

Phép toán tập hợp (Tạo Set mới):

union(), intersection(), difference(), symmetric_difference().

Kiểm tra mối quan hệ:

issubset(), issuperset(), isdisjoint().

Phép toán tập hợp tại chỗ (Cập nhật Set gốc):

intersection_update(), difference_update(), symmetric_difference_update().

Lời khuyên cuối cùng:

Chọn đúng công cụ: Việc lựa chọn phương thức phù hợp là chìa khóa. Nếu bạn muốn kiểm tra sự tồn tại an toàn, dùng discard(). Nếu bạn muốn lấy kết quả phép toán mà không thay đổi Set gốc, dùng union() thay vì union_update().
Sức mạnh của Set: Hãy tận dụng Set để giải quyết các bài toán liên quan đến tính duy nhất và các phép toán tập hợp. Các phương thức này giúp code của bạn không chỉ ngắn gọn mà còn hiệu quả hơn rất nhiều.