Loại tập hợp tích hợp. Tập hợp là một tập hợp các giá trị duy nhất có thể thay đổi và lặp lại – 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 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ị. Tập hợp được triển khai bằng cách sử dụng bảng băm, do đó, giống như khoá của từ điển, các phần tử của tập hợp phải có thể băm. Bạn có thể sử dụng một giá trị làm phần tử của một tập hợp nếu và chỉ khi giá trị đó có thể được dùng làm khoá của từ điển.
Bạn có thể tạo 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ố tuỳ chọn, đối số này phải là một tập hợp có thể lặp lại. Việc 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 cố định.
Các toán tử in và not in kiểm tra xem một giá trị có (hoặc không) thuộc một tập hợp hay không:
s = set(["a", "b", "c"]) "a" in s # True "z" in s # False
Tập hợp có thể lặp lại, do đó có thể được dùng làm toán hạng của vòng lặp for, một câu lệnh liệt kê và nhiều hàm tích hợp sẵn hoạt động trên các tập hợp có thể lặp lại. Bạn có thể truy xuất chiều dài của tập hợp này bằng cách sử dụng hàm tích hợp len() và thứ tự lặp lại là thứ tự 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à đúng nếu và chỉ khi 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 bằng nhau hay không bằng nhau bằng cách sử dụng == và !=. Một tập hợp s bằng t nếu và chỉ khi t là một tập hợp chứa cùng các phần tử; thứ tự lặp lại không quan trọng. Cụ thể, 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 các tập hợp khác và việc so sánh hai tập hợp bằng <, <=, >, >= hoặc sắp xếp một trình tự 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
Toán tử | trên hai tập hợp trả về tập hợp hợp nhất 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])
Toán tử & trên hai tập hợp trả về giao 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()
Toán tử - trên hai tập hợp trả về sự khác biệt 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])
Toán tử ^ trên hai tập hợp trả về sự khác biệt đối xứng của hai tập hợp: một tập hợp chứa các phần tử được tìm thấy trong đúng 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 phép toán trên, các phần tử của tập hợp kết quả giữ nguyên thứ tự của hai tập hợp toán hạng, trong đó tất cả các phần tử được lấy từ bên trái được sắp xếp trước mọi phần tử chỉ xuất hiện ở bên phải.
Các chỉ định tăng cường tương ứng, |=, &=, -= và ^=, sẽ sửa đổi tập hợp bên trái.
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ư tất cả các giá trị có thể thay đổi trong Starlark, một tập hợp có thể được đóng băng và sau khi đóng băng, tất cả các thao tác tiếp theo nhằm cập nhật tập hợp đó sẽ không thành công.
Hội viên
- thêm
- clear
- difference
- difference_update
- loại bỏ
- giao lộ
- intersection_update
- isdisjoint
- issubset
- issuperset
- nhạc 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; việ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ố
| Thông số | Mô tả |
|---|---|
element
|
required Phần tử cần thêm. |
xóa
None set.clear()hiệu
set set.difference(*others)
Nếu s và t là tập hợp, thì s.difference(t) tương đương với s - t; tuy nhiên, lưu ý rằng toán tử - yêu cầu cả hai bên đều là tập hợp, trong khi phương thức difference cũng chấp nhận các trình tự và tập hợp.
Bạn có thể gọi difference mà không cần đối số nào; lệnh 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ố
| Thông số | Mô tả |
|---|---|
others
|
bắt buộc Tập hợp, trình tự các phần tử có thể băm hoặc tập hợp. |
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 việc gán tăng cường -= yêu cầu cả hai bên đều là tập hợp, trong khi phương thức difference_update cũng chấp nhận các trình tự và từ điển.
Bạn có thể gọi difference_update mà không cần đối số nào; việc này sẽ không làm thay đổi 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ố
| Thông số | Mô tả |
|---|---|
others
|
bắt buộc Tập hợp, trình tự các phần tử có thể băm hoặc tập hợp. |
hủy
None set.discard(element)Bạn có thể discard một giá trị không có trong tập hợp; việc này sẽ không làm thay đổi tập hợp. Nếu bạn muốn không xoá được một phần tử không có sẵn, hãy sử 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ố
| Thông số | Mô tả |
|---|---|
element
|
required Phần tử cần loại bỏ. Phải có thể băm. |
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, hãy lưu ý rằng toán tử & yêu cầu cả hai bên đều là tập hợp, trong khi phương thức intersection cũng chấp nhận các trình tự và tập hợp.
Bạn có thể gọi intersection mà không cần đối số nào; lệnh 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ố
| Thông số | Mô tả |
|---|---|
others
|
bắt buộc Tập hợp, trình tự các phần tử có thể băm hoặc tập hợp. |
intersection_update
None set.intersection_update(*others)Nếu s và t là tập hợp, thì s.intersection_update(t) tương đương với s &= t; tuy nhiên, lưu ý rằng việc gán tăng cường &= yêu cầu cả hai bên đều phải là tập hợp, trong khi phương thức intersection_update cũng chấp nhận các trình tự và từ điển.
Bạn có thể gọi intersection_update mà không cần đối số nào; việc này sẽ không làm thay đổi 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ố
| Thông số | Mô tả |
|---|---|
others
|
bắt buộc Tập hợp, trình tự các phần tử có thể băm hoặc tập hợp. |
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ố
| Thông số | Mô tả |
|---|---|
other
|
bắt buộc Một tập hợp, một trình tự các phần tử có thể băm hoặc một từ điển. |
issubset
bool set.issubset(other)
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ố
| Thông số | Mô tả |
|---|---|
other
|
bắt buộc Một tập hợp, một trình tự các phần tử có thể băm hoặc một từ điển. |
issuperset
bool set.issuperset(other)
Lưu ý rằng một tập hợp luôn được coi là tập hợp con 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ố
| Thông số | Mô tả |
|---|---|
other
|
bắt buộc Một tập hợp, một trình tự các phần tử có thể băm hoặc một từ điển. |
nhạc pop
unknown set.pop()
Không thành công nếu tập hợp này 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ẽ không thành công nếu phần tử không có trong tập hợp. Nếu bạn không muốn không xoá được phần tử không có sẵn, 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ố
| Thông số | Mô tả |
|---|---|
element
|
bắt buộc Phần tử cần xoá. Phải là một phần tử của tập hợp (và có thể băm). |
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 toán tử ^ yêu cầu cả hai bên đều là tập hợp, trong khi phương thức symmetric_difference cũng chấp nhận một trình tự hoặc từ điển.
Ví dụ:
set([1, 2]).symmetric_difference([2, 3]) # set([1, 3])
Thông số
| Thông số | Mô tả |
|---|---|
other
|
bắt buộc Một tập hợp, một trình tự các phần tử có thể băm hoặc một từ điển. |
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 "s ^= t; however, note that the ^=". Việc gán tăng cường yêu cầu cả hai bên đều phải là tập hợp, trong khi phương thức symmetric_difference_update cũng chấp nhận một trình tự 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ố
| Thông số | Mô tả |
|---|---|
other
|
bắt buộc Một tập hợp, một trình tự các phần tử có thể băm hoặc một từ điển. |
union
set set.union(*others)
Nếu s và t là tập hợp, thì s.union(t) tương đương với s | t; tuy nhiên, lưu ý rằng toán tử | yêu cầu cả hai bên đều là tập hợp, trong khi phương thức union cũng chấp nhận các trình tự và tập hợp.
Bạn có thể gọi union mà không cần đối số nào; lệnh 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ố
| Thông số | Mô tả |
|---|---|
others
|
bắt buộc Tập hợp, trình tự các phần tử có thể băm hoặc tập hợp. |
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, lưu ý rằng việc gán tăng cường |= yêu cầu cả hai bên đều là tập hợp, trong khi phương thức update cũng chấp nhận các trình tự và từ điển.
Bạn có thể gọi update mà không cần đối số nào; việc này sẽ không làm thay đổi tập hợp.
Thông số
| Thông số | Mô tả |
|---|---|
others
|
bắt buộc Tập hợp, trình tự các phần tử có thể băm hoặc tập hợp. |