set

Loại tập hợp tích hợp. Tập hợp là một tập hợp có thể lặp lại, có thể thay đổi gồm các giá trị riêng biệt – các phần tử của tập hợp. Tên loại của một tập hợp là "set".

Tập hợp cung cấp các thao tác có thời gian không đổi để chèn, xoá hoặc kiểm tra sự hiện diện của một giá trị. Các tập hợp được triển khai bằng bảng băm, do đó, giống như các khoá của một từ điển, các phần tử của một tập hợp phải có thể băm. Bạn có thể dùng một giá trị làm phần tử của một tập hợp nếu và chỉ khi bạn có thể dùng giá trị đó làm khoá của một từ điển.

Bạn có thể tạo các tập hợp bằng hàm tích hợp set(). Hàm này trả về một tập hợp mới chứa các phần tử riêng biệt của đối số không bắt buộc (phải là một đối tượng có thể lặp lại). Gọi set() mà không có đối số sẽ tạo một tập hợp trống. Tập hợp không có cú pháp theo nghĩa đen.

Các thao tác in và not in kiểm tra xem một giá trị có nằm trong một tập hợp hay không:

s = set(["a", "b", "c"])
"a" in s  # True
"z" in s  # False

Một tập hợp có thể lặp lại và do đó có thể được dùng làm toán hạng của một vòng lặp for, một biểu thức danh sách và nhiều hàm tích hợp hoạt động trên các đối tượng có thể lặp lại. Bạn có thể truy xuất độ dài của tập hợp này bằng hàm tích hợp sẵn len() và thứ tự lặp lại là thứ tự mà các phần tử được thêm vào tập hợp lần đầu tiên:

s = set(["z", "y", "z", "y"])
len(s)       # prints 2
s.add("x")
len(s)       # prints 3
for e in s:
    print e  # prints "z", "y", "x"

Một tập hợp được dùng trong ngữ cảnh Boolean là true nếu và chỉ nếu tập hợp đó không trống.

s = set()
"non-empty" if s else "empty"  # "empty"
t = set(["x", "y"])
"non-empty" if t else "empty"  # "non-empty"

Bạn có thể so sánh các tập hợp để biết chúng có bằng nhau hay không bằng cách sử dụng == và !=. Một tập hợp s bằng với t khi và chỉ khi t là một tập hợp chứa các phần tử giống nhau; thứ tự lặp lại không quan trọng. Cụ thể, một tập hợp không bằng danh sách các phần tử của tập hợp đó. Các tập hợp không được sắp xếp theo thứ tự so với các tập hợp khác và việc cố gắng so sánh hai tập hợp bằng cách sử dụng <, <=, >, >= hoặc sắp xếp một chuỗi tập hợp sẽ không thành công.

set() == set()              # True
set() != []                 # True
set([1, 2]) == set([2, 1])  # True
set([1, 2]) != [1, 2]       # True

Thao tác | trên hai tập hợp sẽ trả về hợp của hai tập hợp: một tập hợp chứa các phần tử có trong một hoặc cả hai tập hợp ban đầu.

set([1, 2]) | set([3, 2])  # set([1, 2, 3])

Thao tác & trên hai tập hợp sẽ trả về giao điểm của hai tập hợp: một tập hợp chỉ chứa các phần tử có trong cả hai tập hợp ban đầu.

set([1, 2]) & set([2, 3])  # set([2])
set([1, 2]) & set([3, 4])  # set()

Thao tác - trên hai tập hợp sẽ trả về hiệu số của hai tập hợp: một tập hợp chứa các phần tử có trong tập hợp bên trái nhưng không có trong tập hợp bên phải.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 2])

Thao tác ^ trên hai tập hợp sẽ trả về hiệu đối xứng của hai tập hợp: một tập hợp chứa các phần tử chỉ có trong một trong hai tập hợp ban đầu, nhưng không có trong cả hai.

set([1, 2]) ^ set([2, 3])  # set([1, 3])
set([1, 2]) ^ set([3, 4])  # set([1, 2, 3, 4])

Trong mỗi thao tác trên, các phần tử của tập hợp kết quả vẫn giữ nguyên thứ tự từ hai tập hợp toán hạng, với tất cả các phần tử được lấy từ phía bên trái được sắp xếp trước mọi phần tử chỉ có ở phía bên phải.

Các phép gán tăng cường tương ứng (|=, &=, -= và ^=) sẽ sửa đổi tập hợp bên trái tại chỗ.

s = set([1, 2])
s |= set([2, 3, 4])     # s now equals set([1, 2, 3, 4])
s &= set([0, 1, 2, 3])  # s now equals set([1, 2, 3])
s -= set([0, 1])        # s now equals set([2, 3])
s ^= set([3, 4])        # s now equals set([2, 4])

Giống như mọi giá trị có thể thay đổi trong Starlark, một tập hợp có thể được cố định và sau khi được cố định, mọi thao tác tiếp theo cố gắng cập nhật tập hợp đó sẽ không thành công.

Hội viên

• thêm
• xoá
• khác biệt
• difference_update
• loại bỏ
• intersection
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• xoá
• symmetric_difference
• symmetric_difference_update
• union
• update

thêm

None set.add(element)

Bạn có thể add một giá trị đã có trong tập hợp; thao tác này sẽ không làm thay đổi tập hợp.

Nếu bạn cần thêm nhiều phần tử vào một tập hợp, hãy xem update hoặc thao tác gán tăng cường |=.

Thông số

xóa

None set.clear()

hiệu

set set.difference(*others)

Nếu s và t là các tập hợp, thì s.difference(t) tương đương với s - t; tuy nhiên, lưu ý rằng thao tác - yêu cầu cả hai bên phải là các tập hợp, trong khi phương thức difference cũng chấp nhận các chuỗi và từ điển.

Bạn có thể gọi difference mà không cần đối số; thao tác này sẽ trả về một bản sao của tập hợp.

Ví dụ:

set([1, 2, 3]).difference([2])             # set([1, 3])
set([1, 2, 3]).difference([0, 1], [3, 4])  # set([2])

Thông số

difference_update

None set.difference_update(*others)

Nếu s và t là các tập hợp, thì s.difference_update(t) tương đương với s -= t; tuy nhiên, lưu ý rằng phép gán tăng cường -= yêu cầu cả hai phía phải là các tập hợp, trong khi phương thức difference_update cũng chấp nhận các chuỗi và từ điển.

Bạn có thể gọi difference_update mà không có đối số nào; thao tác này sẽ giữ nguyên tập hợp.

Ví dụ:

s = set([1, 2, 3, 4])
s.difference_update([2])             # None; s is set([1, 3, 4])
s.difference_update([0, 1], [4, 5])  # None; s is set([3])

Thông số

hủy

None set.discard(element)

Bạn được phép discard một giá trị không có trong tập hợp; thao tác này sẽ không làm thay đổi tập hợp. Nếu bạn muốn thất bại khi cố gắng xoá một phần tử không có, hãy dùng remove. Nếu bạn cần xoá nhiều phần tử khỏi một tập hợp, hãy xem difference_update hoặc thao tác gán tăng cường -=.

Ví dụ:

s = set(["x", "y"])
s.discard("y")  # None; s == set(["x"])
s.discard("y")  # None; s == set(["x"])

Thông số

giao điểm

set set.intersection(*others)

Nếu s và t là các tập hợp, thì s.intersection(t) tương đương với s & t; tuy nhiên, lưu ý rằng thao tác & yêu cầu cả hai bên phải là các tập hợp, trong khi phương thức intersection cũng chấp nhận các chuỗi và từ điển.

Bạn có thể gọi intersection mà không cần đối số; thao tác này sẽ trả về một bản sao của tập hợp.

Ví dụ:

set([1, 2]).intersection([2, 3])             # set([2])
set([1, 2, 3]).intersection([0, 1], [1, 2])  # set([1])

Thông số

intersection_update

None set.intersection_update(*others)

Nếu s và t là các tập hợp, thì s.intersection_update(t) tương đương với s &= t; tuy nhiên, lưu ý rằng phép gán tăng cường &= yêu cầu cả hai phía phải là các tập hợp, trong khi phương thức intersection_update cũng chấp nhận các chuỗi và từ điển.

Bạn có thể gọi intersection_update mà không có đối số nào; thao tác này sẽ giữ nguyên tập hợp.

Ví dụ:

s = set([1, 2, 3, 4])
s.intersection_update([0, 1, 2])       # None; s is set([1, 2])
s.intersection_update([0, 1], [1, 2])  # None; s is set([1])

Thông số

isdisjoint

bool set.isdisjoint(other)

Ví dụ:

set([1, 2]).isdisjoint([3, 4])  # True
set().isdisjoint(set())         # True
set([1, 2]).isdisjoint([2, 3])  # False

Thông số

issubset

bool set.issubset(other)

Xin lưu ý rằng một tập hợp luôn được coi là một tập hợp con của chính nó.

Ví dụ:

set([1, 2]).issubset([1, 2, 3])  # True
set([1, 2]).issubset([1, 2])     # True
set([1, 2]).issubset([2, 3])     # False

Thông số

issuperset

bool set.issuperset(other)

Xin lưu ý rằng một tập hợp luôn được coi là một siêu tập hợp của chính nó.

Ví dụ:

set([1, 2, 3]).issuperset([1, 2])     # True
set([1, 2, 3]).issuperset([1, 2, 3])  # True
set([1, 2, 3]).issuperset([2, 3, 4])  # False

Thông số

nhạc pop

unknown set.pop()

Thất bại nếu tập hợp trống.

Ví dụ:

s = set([3, 1, 2])
s.pop()  # 3; s == set([1, 2])
s.pop()  # 1; s == set([2])
s.pop()  # 2; s == set()
s.pop()  # error: empty set

xoá

None set.remove(element)

remove sẽ thất bại nếu phần tử không có trong tập hợp. Nếu bạn không muốn thất bại khi cố gắng xoá một phần tử không có mặt, hãy sử dụng discard. Nếu bạn cần xoá nhiều phần tử khỏi một tập hợp, hãy xem difference_update hoặc thao tác gán tăng cường -=.

Thông số

symmetric_difference

set set.symmetric_difference(other)

Nếu s và t là các tập hợp, thì s.symmetric_difference(t) tương đương với s ^ t; tuy nhiên, lưu ý rằng thao tác ^ yêu cầu cả hai bên phải là các tập hợp, trong khi phương thức symmetric_difference cũng chấp nhận một chuỗi hoặc một dict.

Ví dụ:

set([1, 2]).symmetric_difference([2, 3])  # set([1, 3])

Thông số

symmetric_difference_update

None set.symmetric_difference_update(other)

Nếu s và t là các tập hợp, thì s.symmetric_difference_update(t) tương đương với phép gán tăng cường `s ^= t; however, note that the ^=` yêu cầu cả hai phía phải là các tập hợp, trong khi phương thức symmetric_difference_update cũng chấp nhận một chuỗi hoặc một từ điển.

Ví dụ:

s = set([1, 2])
s.symmetric_difference_update([2, 3])  # None; s == set([1, 3])

Thông số

union

set set.union(*others)

Nếu s và t là các tập hợp, thì s.union(t) tương đương với s | t; tuy nhiên, lưu ý rằng thao tác | yêu cầu cả hai bên phải là các tập hợp, trong khi phương thức union cũng chấp nhận các chuỗi và từ điển.

Bạn có thể gọi union mà không cần đối số; thao tác này sẽ trả về một bản sao của tập hợp.

Ví dụ:

set([1, 2]).union([2, 3])                    # set([1, 2, 3])
set([1, 2]).union([2, 3], {3: "a", 4: "b"})  # set([1, 2, 3, 4])

Thông số

cập nhật

None set.update(*others)

Ví dụ:

s = set()
s.update([1, 2])          # None; s is set([1, 2])
s.update([2, 3], [3, 4])  # None; s is set([1, 2, 3, 4])

Nếu s và t là các tập hợp, thì s.update(t) tương đương với s |= t; tuy nhiên, xin lưu ý rằng phép gán tăng cường |= yêu cầu cả hai phía phải là các tập hợp, trong khi phương thức update cũng chấp nhận các chuỗi và từ điển.

Bạn có thể gọi update mà không có đối số nào; thao tác này sẽ giữ nguyên tập hợp.

Thông số