Đặt các hoạt động (ví dụ: xác định tập hợp, tập hợp sản phẩm và tập hợp con) với loại tập hợp của Python

Kinh doanh

Python cung cấp một kiểu dữ liệu dựng sẵn, tập hợp, xử lý các tập hợp.

Tập hợp kiểu là tập hợp các phần tử không trùng lặp (các phần tử không cùng giá trị, các phần tử duy nhất) và có thể thực hiện các phép toán thiết lập như tập hợp, tập hợp sản phẩm và tập hợp khác biệt.

Trong phần này, các thao tác cơ bản trong hoạt động tập hợp kiểu tập hợp được giải thích bằng mã mẫu.

  • Tạo các đối tượng tập hợp:{},set()
  • đặt ký hiệu bao gồm
  • Số phần tử trong tập hợp:len()
  • Thêm một phần tử vào một tập hợp:add()
  • Xóa một phần tử khỏi một tập hợp:discard(),remove(),pop(),clear()
  • Wasset (sáp nhập, liên hiệp):nhà điều hành |,union()
  • Bộ sản phẩm (bộ phận chung, nút giao, nút giao thông):& amp; nhà điều hành,intersection()
  • bổ sung tương đối:-nhà điều hành,difference()
  • bộ chênh lệch đối xứng:toán tử ^,symmetric_difference()
  • tập hợp con hay không:& lt; = toán tử,issubset()
  • Bộ trên hay không:& gt; = toán tử,issuperset()
  • Xác định xem chúng có nguyên tố lẫn nhau hay không:isdisjoint()

Loại tập hợp là loại có thể thay đổi, có thể thêm và xóa các phần tử, và cũng có một loại tập hợp số có cùng hoạt động tập hợp và các phương thức khác như loại tập hợp nhưng không thể thay đổi (không thể sửa đổi bằng cách thêm, xóa hoặc sửa đổi các phần tử bằng cách khác ).

Tạo đối tượng tập hợp::{},set()

Được tạo bởi dấu ngoặc nhọn {}

Các đối tượng thuộc kiểu tập hợp có thể được tạo bằng cách đặt các phần tử trong dấu ngoặc nhọn {}.

Nếu có các giá trị trùng lặp, chúng sẽ bị bỏ qua và chỉ các giá trị duy nhất còn lại dưới dạng phần tử.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

Có thể có nhiều loại khác nhau dưới dạng phần tử. Tuy nhiên, không thể đăng ký các đối tượng có thể cập nhật như kiểu danh sách. Tuples được cho phép.

Ngoài ra, vì các loại tập hợp không có thứ tự, thứ tự mà chúng được tạo ra sẽ không được lưu trữ.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Các kiểu khác nhau, chẳng hạn như int và float, được coi là trùng lặp nếu giá trị của chúng tương đương nhau.

s = {100, 100.0}

print(s)
# {100}

Vì dấu ngoặc nhọn {} được coi là một kiểu từ điển, một đối tượng kiểu tập hợp trống (tập hợp trống) có thể được tạo bằng cách sử dụng hàm tạo được mô tả tiếp theo.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Được tạo bởi phương thức khởi tạo set ()

Các đối tượng của kiểu tập hợp cũng có thể được tạo bằng phương thức khởi tạo set ().

Việc chỉ định một đối tượng có thể lặp lại, chẳng hạn như danh sách hoặc bộ làm đối số sẽ tạo ra một đối tượng tập hợp có các phần tử chỉ là giá trị duy nhất, với các phần tử trùng lặp bị loại trừ.

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

Các kiểu frozenset bất biến được tạo bằng hàm tạo frozenset ().

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

Nếu đối số bị bỏ qua, một đối tượng kiểu tập hợp trống (tập hợp trống) sẽ được tạo.

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

Các phần tử trùng lặp có thể bị xóa khỏi danh sách hoặc bộ dữ liệu bằng cách sử dụng set (), nhưng thứ tự của danh sách ban đầu không được giữ nguyên.

Để chuyển đổi một loại tập hợp thành một danh sách hoặc bộ, hãy sử dụng list (), tuple ().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

Xem bài viết sau để biết thông tin về cách loại bỏ các phần tử trùng lặp trong khi bảo toàn thứ tự, chỉ trích xuất các phần tử trùng lặp và xử lý các phần tử trùng lặp trong một mảng hai chiều (danh sách các danh sách).

đặt ký hiệu bao gồm

Cũng như các cách hiểu theo danh sách, có các cách hiểu được thiết lập. Chỉ cần thay dấu ngoặc vuông [] bằng dấu ngoặc nhọn {} trong phần hiểu danh sách.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

Xem bài viết sau để biết thêm thông tin về ký hiệu hiểu danh sách.

Số phần tử trong tập hợp:len()

Có thể lấy số phần tử trong một tập hợp bằng hàm len () cài sẵn.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

Nếu bạn muốn đếm số phần tử trong mỗi danh sách có phần tử có giá trị trùng lặp, v.v., hãy xem bài viết sau.

Thêm một phần tử vào một tập hợp:add()

Để thêm một phần tử vào một tập hợp, hãy sử dụng phương thức add ().

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Xóa một phần tử khỏi một tập hợp:discard(),remove(),pop(),clear()

Để xóa một phần tử khỏi một tập hợp, hãy sử dụng các phương thức discard (), remove (), pop () và clear ().

Phương thức discard () xóa phần tử được chỉ định trong đối số. Nếu một giá trị không tồn tại trong tập hợp được chỉ định, thì không có gì được thực hiện.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

Phương thức remove () cũng xóa phần tử được chỉ định trong đối số, nhưng lỗi KeyError được trả về nếu một giá trị không tồn tại trong tập hợp được chỉ định.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Phương thức pop () loại bỏ các phần tử khỏi một tập hợp và trả về giá trị của chúng. Không thể chọn giá trị nào để loại bỏ. Tập hợp trống sẽ dẫn đến lỗi KeyError.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

Phương thức clear () loại bỏ tất cả các phần tử và làm cho tập hợp trống.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (sáp nhập, liên hiệp):nhà điều hành |,union()

Tập hợp liên minh (hợp nhất, liên hiệp) có thể nhận được bằng dấu | toán tử hoặc phương thức union ().

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

Nhiều đối số có thể được chỉ định cho một phương thức. Ngoài kiểu tập hợp, danh sách và bộ giá trị có thể được chuyển đổi thành kiểu tập hợp bởi set () cũng có thể được chỉ định làm đối số. Điều tương tự cũng áp dụng cho các toán tử và phương thức tiếp theo.

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

Bộ sản phẩm (bộ phận chung, nút giao, nút giao thông):& amp; nhà điều hành,intersection()

Bộ sản phẩm (phần chung, phần giao nhau và phần giao nhau) có thể nhận được bằng & amp; toán tử hoặc phương thức giao ().

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

bổ sung tương đối:-nhà điều hành,difference()

Tập hợp khác biệt có thể được lấy bằng toán tử – hoặc phương thức chênh lệch ().

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

bộ chênh lệch đối xứng:toán tử ^,symmetric_difference()

Tập hợp sai lệch đối xứng (tập hợp các phần tử chỉ chứa một trong hai) có thể nhận được bằng toán tử ^ hoặc đối xứng_difference ().

Tương đương với phép tách biệt (XOR) độc quyền trong các phép toán logic.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

tập hợp con hay không:& lt; = toán tử,issubset()

Để xác định xem một tập hợp có phải là một tập hợp con của một tập hợp khác hay không, hãy sử dụng toán tử & lt; = hoặc phương thức Issubset ().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Cả toán tử & lt; = và phương thức Issubset () đều trả về true cho các tập hợp tương đương.

Để xác định xem đó có phải là tập hợp con đúng hay không, hãy sử dụng toán tử & lt; =, trả về giá trị false cho các tập hợp tương đương.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Bộ trên hay không:& gt; = toán tử,issuperset()

Để xác định xem một tập hợp này có phải là tập hợp thay thế của tập hợp khác hay không, hãy sử dụng toán tử & gt; = hoặc Issuperset ().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Cả toán tử & gt; = và phương thức Issuperset () đều trả về true cho các tập hợp tương đương.

Để xác định xem nó có phải là tập siêu đúng hay không, hãy sử dụng toán tử & gt; =, trả về giá trị false cho các tập tương đương.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Xác định xem chúng có nguyên tố lẫn nhau hay không:isdisjoint()

Để xác định xem hai tập hợp có nguyên tố với nhau hay không, hãy sử dụng phương thức isdisjoint ().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True