Tìm hiểu Set trong Python

Python Tutorial | 25/07/2025 by Hoc Python

Trong lập trình, việc lựa chọn cấu trúc dữ liệu phù hợp là một yếu tố then chốt để viết code hiệu quả. Bạn đã quen thuộc với List và Tuple, nhưng Python còn cung cấp một cấu trúc mạnh mẽ khác: Set (tập hợp).Set được thiết kế đặc biệt để xử lý các tập hợp dữ liệu mà bạn muốn đảm bảo không có bất kỳ phần tử nào bị trùng lặp. Bài viết này sẽ đưa bạn đi tìm hiểu Set từ những khái niệm cơ bản nhất, cách tạo Set, các đặc điểm độc đáo của nó, cho đến những thao tác và ứng dụng mạnh mẽ nhất. Hãy cùng tìm hiểu cách Set có thể giúp bạn giải quyết các bài toán liên quan đến dữ liệu duy nhất một cách cực kỳ hiệu quả nhé!

Set là gì?

Set trong Python là một cấu trúc dữ liệu dùng để lưu trữ một tập hợp các phần tử. Đặc điểm cơ bản và quan trọng nhất của Set là:

Chứa các phần tử duy nhất (Unique): Một Set không thể có hai phần tử giống hệt nhau. Khi bạn cố gắng thêm một phần tử đã tồn tại vào Set, nó sẽ không thay đổi.
Không có thứ tự (Unordered): Các phần tử trong Set không được sắp xếp theo một thứ tự cụ thể nào cả. Điều này có nghĩa là bạn không thể truy cập các phần tử bằng chỉ số (index) như my_set[0].

Bạn có thể tạo một Set bằng cách đặt các phần tử bên trong cặp dấu ngoặc nhọn {} hoặc sử dụng hàm set().

Ví dụ:

# Tạo một Set với các phần tử trùng lặp
my_set = {1, 2, 3, 2, 4, 1}
print(f"Set sau khi được tạo: {my_set}")
# Output: Set sau khi được tạo: {1, 2, 3, 4}
# Lưu ý: Các phần tử trùng lặp (1 và 2) đã tự động bị loại bỏ.

# Set không có thứ tự, nên thứ tự in ra có thể khác nhau

Điểm khác biệt chính (Set vs List & Tuple)

Để hiểu rõ hơn về Set, hãy so sánh nó với List và Tuple:

Đặc điểm	List	Tuple	Set
Thứ tự	Có thứ tự (Ordered)	Có thứ tự (Ordered)	Không có thứ tự (Unordered)
Trùng lặp	Cho phép trùng lặp	Cho phép trùng lặp	Không cho phép trùng lặp
Thay đổi	Có thể thay đổi (Mutable)	Bất biến (Immutable)	Có thể thay đổi (Mutable)
Cú pháp	`[item1, item2, ...]`	`(item1, item2, ...)`	`{item1, item2, ...}` hoặc `set()`
Truy cập	Bằng chỉ số (`my_list[0]`)	Bằng chỉ số (`my_tuple[0]`)	Không thể bằng chỉ số

Tóm lại:

List: Dùng để lưu trữ bộ sưu tập có thứ tự, có thể thay đổi và cho phép trùng lặp.
Tuple: Dùng để lưu trữ bộ sưu tập có thứ tự, bất biến và cho phép trùng lặp.
Set: Dùng để lưu trữ bộ sưu tập duy nhất, không có thứ tự và có thể thay đổi.

Khi nào dùng Set?

Set là một công cụ mạnh mẽ và tối ưu cho các trường hợp sau:

Loại bỏ các phần tử trùng lặp: Đây là ứng dụng phổ biến và trực quan nhất của Set. Nếu bạn có một danh sách chứa nhiều phần tử bị lặp và chỉ muốn giữ lại các giá trị duy nhất, việc chuyển List đó sang Set là cách nhanh nhất.

Ví dụ:

my_list_with_duplicates = [1, 5, 2, 8, 5, 1, 9, 2, 8]
unique_elements = set(my_list_with_duplicates)
print(f"List gốc: {my_list_with_duplicates}")
print(f"Các phần tử duy nhất: {unique_elements}")
# Output:
# List gốc: [1, 5, 2, 8, 5, 1, 9, 2, 8]
# Các phần tử duy nhất: {1, 2, 5, 8, 9}

Kiểm tra sự tồn tại của phần tử một cách nhanh chóng: Do cách tổ chức dữ liệu bên trong, việc kiểm tra xem một phần tử có tồn tại trong Set hay không (if element in my_set:) nhanh hơn đáng kể so với List hoặc Tuple, đặc biệt với các tập hợp dữ liệu lớn.

Ví dụ:

inventory = {"apple", "banana", "orange", "grape"}

if "apple" in inventory:
    print("Táo có trong kho.") # Output: Táo có trong kho.

if "mango" in inventory:
    print("Xoài có trong kho.")
else:
    print("Xoài không có trong kho.") # Output: Xoài không có trong kho.

Thực hiện các phép toán tập hợp: Set được xây dựng dựa trên lý thuyết tập hợp trong toán học. Điều này cho phép bạn thực hiện các phép toán như hợp (union), giao (intersection), hiệu (difference) một cách dễ dàng và hiệu quả.

Ví dụ:

group_a = {"An", "Bình", "Cúc"}
group_b = {"Bình", "Dũng", "An"}

# Tìm những người có cả ở nhóm A và B (phép giao)
in_both_groups = group_a.intersection(group_b)
print(f"Những người có trong cả hai nhóm: {in_both_groups}") # Output: Những người có trong cả hai nhóm: {'An', 'Bình'}

Set là một cấu trúc dữ liệu mạnh mẽ, giúp giải quyết các bài toán liên quan đến dữ liệu duy nhất và các phép toán tập hợp một cách tự nhiên và hiệu quả trong Python.

Khởi tạo Set trong Python

Có nhiều cách để tạo một Set trong Python, tùy thuộc vào việc bạn muốn tạo một Set rỗng hay một Set đã có sẵn các phần tử từ ban đầu.

Tạo Set rỗng

Cú pháp: my_set = set()

Ví dụ:

empty_set = set()
print(f"Set rỗng được tạo: {empty_set}")
print(f"Kiểu dữ liệu: {type(empty_set)}")
# Output:
# Set rỗng được tạo: set()
# Kiểu dữ liệu: <class 'set'>

Tại sao không dùng {}? Đây là một lưu ý rất quan trọng và thường gây nhầm lẫn cho người mới học. Khi bạn sử dụng cú pháp {}, Python sẽ mặc định hiểu đó là một Dictionary (từ điển) rỗng, chứ không phải một Set rỗng. Để tạo một Set rỗng, bạn phải sử dụng hàm set().

# Dùng {} để tạo một Dictionary rỗng
empty_dict = {}
print(f"Đối tượng được tạo bằng {{}}: {empty_dict}")
print(f"Kiểu dữ liệu: {type(empty_dict)}")
# Output:
# Đối tượng được tạo bằng {}: {}
# Kiểu dữ liệu: <class 'dict'>

Tạo Set với các phần tử

Cú pháp: my_set = {item1, item2, ...}

Giải thích: Bạn chỉ cần đặt các phần tử bên trong dấu ngoặc nhọn {} và phân tách chúng bằng dấu phẩy ,. Python sẽ tự động tạo một Set và loại bỏ mọi phần tử trùng lặp.

Ví dụ:

Set số:

numbers = {1, 5, 3, 2, 5, 1}
print(f"Set số: {numbers}")
# Output: Set số: {1, 2, 3, 5}
# Các số 1 và 5 trùng lặp đã bị loại bỏ.

Set chuỗi:

fruits = {"apple", "banana", "apple", "cherry"}
print(f"Set chuỗi: {fruits}")
# Output: Set chuỗi: {'apple', 'banana', 'cherry'}
# 'apple' trùng lặp đã bị loại bỏ.

Set hỗn hợp: Một Set có thể chứa các kiểu dữ liệu khác nhau, miễn là các phần tử đó là bất biến (immutable). Vì vậy, bạn có thể có số, chuỗi, và Tuple trong Set, nhưng không thể có List hay Dictionary.

mixed_set = {1, "hello", (1, 2, 3)}
print(f"Set hỗn hợp: {mixed_set}")
# Output: Set hỗn hợp: {(1, 2, 3), 1, 'hello'}

# Ví dụ lỗi khi cố gắng thêm List hoặc Dictionary
try:
    invalid_set = {1, ["list"]}
except TypeError as e:
    print(f"Lỗi: {e}")
    # Output: Lỗi: unhashable type: 'list'

Tạo Set từ List hoặc Tuple

Cú pháp: my_set = set(iterable)

Giải thích: Bạn có thể truyền một đối tượng có thể lặp (iterable) như List, Tuple, hoặc thậm chí là một chuỗi vào hàm set(). Python sẽ duyệt qua các phần tử của đối tượng đó và tạo một Set mới, tự động loại bỏ các phần tử trùng lặp và không giữ lại thứ tự ban đầu.

Ví dụ:

Từ List:

my_list = [10, 20, 10, 30, 20, 40]
my_set_from_list = set(my_list)
print(f"List gốc: {my_list}")
print(f"Set từ List: {my_set_from_list}")
# Output:
# List gốc: [10, 20, 10, 30, 20, 40]
# Set từ List: {40, 10, 20, 30}

Từ Tuple:

my_tuple = ("a", "b", "c", "a")
my_set_from_tuple = set(my_tuple)
print(f"Tuple gốc: {my_tuple}")
print(f"Set từ Tuple: {my_set_from_tuple}")
# Output:
# Tuple gốc: ('a', 'b', 'c', 'a')
# Set từ Tuple: {'a', 'b', 'c'}

Từ chuỗi:

my_string = "hello"
my_set_from_string = set(my_string)
print(f"Chuỗi gốc: {my_string}")
print(f"Set từ chuỗi: {my_set_from_string}")
# Output:
# Chuỗi gốc: hello
# Set từ chuỗi: {'e', 'o', 'l', 'h'}
# Các chữ cái trùng lặp 'l' đã bị loại bỏ.

Việc tạo Set rất đơn giản. Hãy nhớ rằng {} chỉ dùng để tạo Set có phần tử, còn set() dùng để tạo Set rỗng hoặc chuyển đổi từ các iterable khác.

Đặc điểm của Set trong Python

Để sử dụng Set hiệu quả, bạn cần nắm vững ba đặc điểm cốt lõi của nó. Những đặc điểm này phân biệt Set với List và Tuple, đồng thời quyết định cách bạn tương tác với nó.

Không có thứ tự (Unordered)

Giải thích: Khác với List và Tuple, các phần tử trong Set không được lưu trữ theo một thứ tự cố định. Khi bạn tạo một Set, Python sắp xếp các phần tử theo một cách riêng để tối ưu hóa việc tìm kiếm, nhưng thứ tự này không được đảm bảo và có thể thay đổi giữa các lần chạy.
Hệ quả: Vì không có thứ tự, bạn không thể truy cập các phần tử bằng chỉ số (index) hoặc sử dụng kỹ thuật cắt lát (slicing). Nếu bạn cố gắng làm điều này, Python sẽ báo lỗi.

Ví dụ minh họa:

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

# Truy cập bằng chỉ số sẽ gây lỗi
try:
    print(my_set[0])
except TypeError as e:
    print(f"Lỗi: {e}")
    # Output: Lỗi: 'set' object is not subscriptable

# Cắt lát cũng sẽ gây lỗi
try:
    print(my_set[:2])
except TypeError as e:
    print(f"Lỗi: {e}")
    # Output: Lỗi: 'set' object is not subscriptable

Không chứa phần tử trùng lặp (No Duplicates)

Giải thích: Đây là đặc điểm nổi bật nhất của Set. Mỗi phần tử trong Set là duy nhất. Nếu bạn cố gắng thêm một phần tử đã tồn tại vào Set, thao tác đó sẽ bị bỏ qua và Set sẽ không thay đổi. Tính chất này khiến Set trở thành công cụ hoàn hảo để loại bỏ các phần tử trùng lặp trong một danh sách dữ liệu.

Ví dụ minh họa:

# Tạo một Set với các phần tử trùng lặp
numbers = {1, 2, 3, 2, 1, 4}
print(f"Set gốc: {numbers}") # Output: Set gốc: {1, 2, 3, 4}
# Các số 1 và 2 trùng lặp đã tự động bị loại bỏ.

# Thêm một phần tử đã tồn tại
numbers.add(3)
print(f"Set sau khi thêm số 3: {numbers}") # Output: Set sau khi thêm số 3: {1, 2, 3, 4}
# Số 3 đã có, nên Set không thay đổi.

# Thêm một phần tử mới
numbers.add(5)
print(f"Set sau khi thêm số 5: {numbers}") # Output: Set sau khi thêm số 5: {1, 2, 3, 4, 5}
# Số 5 là mới, nên đã được thêm vào.

Có thể thay đổi (Mutable)

Giải thích: Mặc dù các phần tử bên trong Set không có thứ tự và không thể truy cập bằng chỉ số, bản thân đối tượng Set lại có thể thay đổi (mutable). Điều này có nghĩa là bạn có thể thêm hoặc xóa các phần tử khỏi một Set sau khi nó đã được tạo.
Lưu ý quan trọng: Mặc dù Set có thể thay đổi, nhưng các phần tử bên trong Set phải là các đối tượng bất biến (immutable). Đây là lý do bạn có thể thêm số, chuỗi, hoặc Tuple vào Set, nhưng không thể thêm List hay Dictionary. Python cần các phần tử bên trong Set phải "bất biến" để tính toán mã băm (hash) và quản lý việc tìm kiếm hiệu quả.

Ví dụ minh họa

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

# Thêm một phần tử mới (hợp lệ)
my_set.add("cherry")
print(f"Set sau khi thêm 'cherry': {my_set}") # Output: Set sau khi thêm 'cherry': {'apple', 'banana', 'cherry'}

# Thêm một Tuple (hợp lệ vì Tuple là immutable)
my_set.add(("grape", "orange"))
print(f"Set sau khi thêm Tuple: {my_set}") # Output: Set sau khi thêm Tuple: {'apple', 'banana', 'cherry', ('grape', 'orange')}

# Cố gắng thêm một List (sẽ gây lỗi vì List là mutable)
try:
    my_set.add(["kiwi", "melon"])
except TypeError as e:
    print(f"Lỗi: {e}")
    # Output: Lỗi: unhashable type: 'list'

Việc nắm vững ba đặc điểm này sẽ giúp bạn hiểu rõ vai trò và cách sử dụng Set trong các tình huống lập trình khác nhau, đặc biệt là khi so sánh với List và Tuple.

Các Thao tác Phổ biến với Set trong Python

Set là một cấu trúc dữ liệu có thể thay đổi (mutable), do đó, bạn có thể thực hiện nhiều thao tác để quản lý các phần tử của nó. Dưới đây là các thao tác phổ biến nhất mà bạn sẽ sử dụng.

Thêm phần tử

add(): Dùng để thêm một phần tử duy nhất vào Set. Nếu phần tử đó đã tồn tại, add() sẽ không làm gì cả.

my_set = {"apple", "banana"}
my_set.add("cherry")
print(f"Set sau khi add 'cherry': {my_set}")
# Output: Set sau khi add 'cherry': {'cherry', 'apple', 'banana'}

my_set.add("apple")
print(f"Set sau khi add 'apple' (đã tồn tại): {my_set}")
# Output: Set sau khi add 'apple' (đã tồn tại): {'cherry', 'apple', 'banana'}

update(): Dùng để thêm nhiều phần tử từ một đối tượng có thể lặp (iterable) khác như List, Tuple, hoặc Set.

my_set = {"a", "b"}
another_list = ["c", "d", "a"]
my_set.update(another_list)
print(f"Set sau khi update từ list: {my_set}")
# Output: Set sau khi update từ list: {'c', 'b', 'd', 'a'}

Xóa phần tử

remove(): Xóa một phần tử cụ thể khỏi Set. Nếu phần tử không tồn tại, phương thức này sẽ gây ra lỗi KeyError.

my_set = {"a", "b", "c"}
my_set.remove("b")
print(f"Set sau khi remove 'b': {my_set}")
# Output: Set sau khi remove 'b': {'a', 'c'}

try:
    my_set.remove("d")
except KeyError as e:
    print(f"Lỗi: {e}")
    # Output: Lỗi: 'd'

discard(): Xóa một phần tử cụ thể khỏi Set. Phương thức này tương tự như remove(), nhưng nếu phần tử không tồn tại, nó sẽ không gây ra lỗi.

my_set = {"a", "b", "c"}
my_set.discard("c")
print(f"Set sau khi discard 'c': {my_set}")
# Output: Set sau khi discard 'c': {'a', 'b'}

my_set.discard("d")
print(f"Set sau khi discard 'd' (không tồn tại): {my_set}")
# Output: Set sau khi discard 'd' (không tồn tại): {'a', 'b'}

pop(): Xóa và trả về một phần tử ngẫu nhiên khỏi Set. Vì Set không có thứ tự, bạn không thể biết trước phần tử nào sẽ bị xóa.

my_set = {"apple", "banana", "cherry"}
popped_element = my_set.pop()
print(f"Phần tử bị pop: {popped_element}")
print(f"Set sau khi pop: {my_set}")
# Output có thể khác nhau:
# Phần tử bị pop: banana
# Set sau khi pop: {'apple', 'cherry'}

clear(): Xóa tất cả các phần tử, biến Set thành một Set rỗng.

my_set = {1, 2, 3}
my_set.clear()
print(f"Set sau khi clear: {my_set}")
# Output: Set sau khi clear: set()

Kiểm tra sự tồn tại

Sử dụng toán tử in để kiểm tra xem một phần tử có tồn tại trong Set hay không. Thao tác này cực kỳ hiệu quả về mặt hiệu suất.

my_set = {"a", "b", "c"}
print(f"Kiểm tra 'b' có trong set không? {'b' in my_set}")
# Output: Kiểm tra 'b' có trong set không? True

print(f"Kiểm tra 'd' có trong set không? {'d' in my_set}")
# Output: Kiểm tra 'd' có trong set không? False

Các phép toán tập hợp (Set Operations)

Set được thiết kế đặc biệt để thực hiện các phép toán tập hợp trong toán học.

Hợp (Union): Kết hợp tất cả các phần tử từ hai Set.

Cú pháp: set1 | set2 hoặc set1.union(set2)

Ví dụ:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(f"Phép hợp: {union_set}")
# Output: Phép hợp: {1, 2, 3, 4, 5}

Giao (Intersection): Trả về các phần tử chung của hai Set.

Cú pháp: set1 & set2 hoặc set1.intersection(set2)

Ví dụ:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2)
print(f"Phép giao: {intersection_set}")
# Output: Phép giao: {3}

Hiệu (Difference): Trả về các phần tử chỉ có trong Set thứ nhất mà không có trong Set thứ hai.

Cú pháp: set1 - set2 hoặc set1.difference(set2)

Ví dụ:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2)
print(f"Phép hiệu (set1 - set2): {difference_set}")
# Output: Phép hiệu (set1 - set2): {1, 2}

Hiệu đối xứng (Symmetric Difference): Trả về các phần tử có trong một trong hai Set, nhưng không có trong cả hai.

Cú pháp: set1 ^ set2 hoặc set1.symmetric_difference(set2)

Ví dụ:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_diff_set = set1.symmetric_difference(set2)
print(f"Hiệu đối xứng: {symmetric_diff_set}")
# Output: Hiệu đối xứng: {1, 2, 4, 5}

Kiểm tra tập con/tập cha:

issubset(): Kiểm tra xem một Set có phải là tập con của Set khác không.
issuperset(): Kiểm tra xem một Set có phải là tập cha của Set khác không.

Ví dụ:

set1 = {1, 2}
set2 = {1, 2, 3}
print(f"set1 có phải là tập con của set2 không? {set1.issubset(set2)}")
# Output: set1 có phải là tập con của set2 không? True
print(f"set2 có phải là tập cha của set1 không? {set2.issuperset(set1)}")
# Output: set2 có phải là tập cha của set1 không? True

Các hàm tích hợp sẵn (Built-in Functions) thường dùng với Set trong Python

Ngoài các phương thức (methods) riêng của Set, bạn cũng có thể sử dụng nhiều hàm tích hợp sẵn (built-in functions) của Python để thao tác và phân tích dữ liệu trong Set. Các hàm này không phải là phương thức của Set mà là các hàm chung của Python có thể hoạt động với nhiều loại iterable (đối tượng có thể lặp), bao gồm cả Set.

Dưới đây là một số hàm built-in phổ biến và hữu ích khi làm việc với Set:

`len()`

Khái niệm: Hàm len() (viết tắt của "length") trả về số lượng phần tử có trong một Set.
Cú pháp: len(ten_set)

Ví dụ minh họa:

my_set = {"apple", "banana", "cherry"}
print(f"Set: {my_set}")

# Lấy độ dài của Set
set_length = len(my_set)
print(f"Số lượng phần tử trong Set: {set_length}") # Output: Số lượng phần tử trong Set: 3

empty_set = set()
print(f"Độ dài của Set rỗng: {len(empty_set)}") # Output: Độ dài của Set rỗng: 0

`min()` và `max()`

Khái niệm:

Hàm min() trả về phần tử có giá trị nhỏ nhất.
Hàm max() trả về phần tử có giá trị lớn nhất.
Lưu ý quan trọng: Các hàm này chỉ hoạt động nếu tất cả các phần tử trong Set có thể so sánh được với nhau (ví dụ: tất cả là số, hoặc tất cả là chuỗi). Bạn không thể tìm min() hoặc max() của một Set chứa hỗn hợp các kiểu dữ liệu không thể so sánh.
Cú pháp: min(ten_set) và max(ten_set)

Ví dụ minh họa:

scores = {85, 92, 78, 95, 88}
print(f"Set điểm số: {scores}")

# Tìm điểm số cao nhất và thấp nhất
highest_score = max(scores)
lowest_score = min(scores)
print(f"Điểm số cao nhất: {highest_score}") # Output: Điểm số cao nhất: 95
print(f"Điểm số thấp nhất: {lowest_score}") # Output: Điểm số thấp nhất: 78

`sum()`

Khái niệm: Hàm sum() trả về tổng của tất cả các phần tử trong Set.

Lưu ý quan trọng: Hàm này chỉ hoạt động với Set chứa các giá trị số (integers, floats, v.v.).

Cú pháp: sum(ten_set)

Ví dụ minh họa:

sales_figures = {100, 250, 150, 300}
print(f"Set doanh số: {sales_figures}")

# Tính tổng doanh số
total_sales = sum(sales_figures)
print(f"Tổng doanh số: {total_sales}") # Output: Tổng doanh số: 800

`sorted()`

Khái niệm: Hàm sorted() tạo và trả về một List mới chứa tất cả các phần tử của Set đã được sắp xếp theo thứ tự tăng dần (mặc định). Set gốc không bị thay đổi.

Lưu ý quan trọng:

Giống như min() và max(), các phần tử trong Set phải có thể so sánh được với nhau.
Hàm này luôn trả về một List, không phải một Set, vì Set không có thứ tự.

Cú pháp: sorted(ten_set, reverse=False)

reverse (tùy chọn): Nếu đặt là True, List sẽ được sắp xếp theo thứ tự giảm dần. Mặc định là False.

Ví dụ minh họa:

unsorted_numbers = {3, 1, 4, 1, 5, 9, 2}
print(f"Set chưa sắp xếp: {unsorted_numbers}")

# Sắp xếp Set và nhận về một List mới
sorted_list_asc = sorted(unsorted_numbers)
print(f"Set đã sắp xếp (dưới dạng List): {sorted_list_asc}")
# Output: Set đã sắp xếp (dưới dạng List): [1, 2, 3, 4, 5, 9]

# Sắp xếp giảm dần
sorted_list_desc = sorted(unsorted_numbers, reverse=True)
print(f"List đã sắp xếp giảm dần: {sorted_list_desc}")
# Output: List đã sắp xếp giảm dần: [9, 5, 4, 3, 2, 1]

# Set gốc vẫn không thay đổi
print(f"Set gốc sau khi sắp xếp: {unsorted_numbers}")
# Output: Set gốc sau khi sắp xếp: {1, 2, 3, 4, 5, 9}

Các hàm tích hợp sẵn này là những công cụ mạnh mẽ để phân tích và trích xuất thông tin từ Set một cách hiệu quả, giúp bạn làm việc dễ dàng hơn với cấu trúc dữ liệu độc đáo này.

Kết bài

Set là một công cụ hữu ích để giải quyết những bài toán đặc thù. Việc lựa chọn đúng cấu trúc dữ liệu (List, Tuple, Set hay Dictionary) ngay từ đầu là một kỹ năng quan trọng giúp bạn viết code hiệu quả và dễ bảo trì hơn. Hãy luôn xem xét tính chất của dữ liệu và yêu cầu của bài toán để đưa ra quyết định phù hợp nhất.