Set trong Python: phần tử duy nhất, hợp, giao và hiệu

Set là một túi không thứ tự chứa các phần tử duy nhất

List và tuple quan tâm đến thứ tự, còn set thì không. List cho phép phần tử trùng chồng chất, còn set lặng lẽ bỏ chúng đi. Set, hay tập hợp, là cấu trúc dữ liệu phù hợp khi bạn có hai nhu cầu cụ thể:

1. Bạn muốn các phần tử không trùng nhau, vậy thôi.
2. Bạn muốn kiểm tra một phần tử có trong tập hay không thật nhanh.

Viết set bằng dấu ngoặc nhọn:

colors = {"red", "green", "blue"}
print(colors)

with_dupes = {"red", "green", "red", "blue", "green"}
print(with_dupes)   # {"red", "green", "blue"}

Các giá trị "red" và "green" bị trùng trong set thứ hai đơn giản là biến mất. Đó không phải lỗi, mà chính là mục đích của set.

Tạo set

Hai cách bạn sẽ thực sự dùng:

# Literal with curly braces.
primes = {2, 3, 5, 7, 11}

# From any iterable.
letters = set("banana")
print(letters)

numbers = set([1, 2, 2, 3, 3, 3])
print(numbers)

# Empty set - must use set(), not {}
empty = set()
print(empty, type(empty))

Điểm cuối cùng khiến ai cũng vấp ít nhất một lần: {} tạo ra một từ điển rỗng, không phải set rỗng. Cú pháp này buộc phải thuộc về một trong hai, và dict đã thắng.

Thêm và xóa phần tử

tags = {"python", "docs"}

tags.add("beginner")
print(tags)

tags.update(["seo", "tutorial", "python"])  # adds multiple, ignores dupes
print(tags)

tags.remove("seo")       # raises KeyError if the item isn't there
tags.discard("missing")  # same as remove, but silent if not present
print(tags)

popped = tags.pop()      # removes and returns an arbitrary item
print("popped:", popped, "remaining:", tags)

Khác biệt quan trọng là remove và discard: remove đòi phần tử phải có mặt; discard thì không quan tâm. Hãy chọn tùy theo việc thiếu phần tử đó có nên được coi là lỗi hay không.

Kiểm tra thành viên nhanh

Đây là lúc set thực sự chứng tỏ giá trị. x in some_set chạy trong thời gian hằng số, dù set lớn đến đâu. x in some_list phải duyệt qua cả list, nên sẽ chậm khi list lớn.

# Imagine this list has 1,000,000 items.
known_users = set(range(1_000_000))

# Each check is near-instant.
for user_id in [42, 999_999, 1_000_001]:
    if user_id in known_users:
        print(f"{user_id}: known")
    else:
        print(f"{user_id}: unknown")

Quy tắc kinh nghiệm: bất cứ khi nào bạn thấy mình viết if x in some_list bên trong một vòng lặp và list có hơn vài chục phần tử, hãy chuyển list đó thành set trước.

Toán tập hợp

Đây là phần set trở nên thật sự thú vị. Bạn có thể kết hợp các set bằng những toán tử giống hệt các phép toán tập hợp trong toán học:

frontend = {"html", "css", "javascript", "react"}
backend = {"python", "sql", "javascript", "docker"}

# Union: everything from both.
all_skills = frontend | backend
print(all_skills)

# Intersection: what's in both.
shared = frontend & backend
print(shared)

# Difference: in frontend but not backend.
only_frontend = frontend - backend
print(only_frontend)

# Symmetric difference: in one or the other, but not both.
unique_skills = frontend ^ backend
print(unique_skills)

Mỗi toán tử cũng có dạng phương thức (.union(), .intersection(), .difference(), .symmetric_difference()). Toán tử thì gọn hơn; còn dạng phương thức nhận bất kỳ iterable nào, không chỉ một set khác.

Loại bỏ phần tử trùng trong list

Một trong những công dụng phổ biến nhất của set, kể cả ngoài "logic tập hợp":

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_visitors = list(set(visits))
print(unique_visitors)

Một dòng, hết trùng lặp. Có một điều cần lưu ý: thứ tự không được giữ nguyên. Nếu bạn cần vừa không trùng lặp vừa giữ thứ tự ban đầu, hãy dùng dict.fromkeys():

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_in_order = list(dict.fromkeys(visits))
print(unique_in_order)

Trong Python hiện đại, dict giữ nguyên thứ tự chèn, và dict.fromkeys tạo một dict lấy các phần tử của iterable làm khóa, về bản chất là một set có thứ tự.

Tập con và tập cha

Kiểm tra xem một set có nằm trong set khác hay không:

known = {"python", "bash", "sql"}
required = {"python", "bash"}

print(required.issubset(known))     # True - required is inside known
print(known.issuperset(required))   # True
print(required <= known)            # same as issubset, with an operator
print(known >= required)            # same as issuperset

Những phép kiểm tra này hay xuất hiện trong việc kiểm tra quyền ("người dùng này có đủ mọi vai trò cần thiết không?").

Những gì có thể nằm trong set

Chỉ những phần tử hashable. Đó là một thuật ngữ kỹ thuật, nhưng trên thực tế nó có nghĩa là:

• Những thứ bất biến thì hashable: số, chuỗi, tuple chứa các phần tử hashable, frozenset.
• Những thứ khả biến thì không: list, dict và các set khác không thể làm phần tử của set.

ok = {1, "hello", (1, 2), 3.14}
print(ok)

# {[1, 2]}  # TypeError - lists aren't hashable

Nếu bạn cần một set chứa các set, hãy dùng frozenset, phiên bản bất biến của set.

Duyệt set không theo thứ tự

Lặp qua một set sẽ trả về các phần tử không theo thứ tự nào được đảm bảo:

for item in {"a", "b", "c", "d"}:
    print(item)

Chạy đoạn đó vài lần, bạn sẽ thấy thứ tự thay đổi. Nếu thứ tự quan trọng, set không phải cấu trúc phù hợp: hãy sắp xếp nội dung khi cần dùng, hoặc dùng list.

Khi nào không nên dùng set

Nếu có bất kỳ điều nào sau đây đúng, list hoặc dict có lẽ sẽ hợp hơn:

• Bạn quan tâm đến thứ tự.
• Bạn cần lưu các phần tử trùng nhau.
• Mỗi phần tử đi kèm dữ liệu liên quan (hãy dùng dict với phần tử đó làm khóa).

Đi tiếp

Set lo chuyện không trùng lặp và kiểm tra thành viên. Từ điển, sẽ học ở bài tiếp theo, xử lý mô hình rộng hơn là "tra một giá trị theo khóa", có lẽ là cấu trúc dữ liệu hữu ích nhất trong Python ngoài list.