Set (tập hợp) trong Python

Set (tập hợp) trong Python

Phan Nhật Chánh

Chánh12 tháng 05, 2021

10 min read
·
•••views
·
•••likes

Trong phần này chúng ta tìm hiểu về cấu trúc dữ liệu tiếp theo của Python là Set. Ở chương trình Toán tiểu học hay trung học gì đó bạn đã được học, làm quen với toán tập hợp và nó cũng được sử dụng trong ngôn ngữ Python.

Set (hay còn gọi là Tập hợp) là một tập hợp các phần tử riêng biệt không có thứ tự, các phần tử trong một tập hợp là duy nhất tức là không được trùng nhau. Cũng tương tự như các dữ liệu có cấu trúc list, tuple, dict, bạn có thể duyệt qua các phần tử trong tập hợp, có thể thêm hoặc xóa đi các phần tử và thực hiện các phép toán trên một tập hợp như: phép hợp, phép giao, hiệu của hai tập hợp, đối xứng, tập hợp con,...

Khai báo một Set

Để khai báo một Tập hợp, chúng ta sử dụng cặp dấu ngoặc nhọn {} để tạo một tập hợp.

Tạo một tập hợp rỗng
# cú pháp
st = {}
# hoặc
st = set()
Tạo một tập hợp rỗng
# cú pháp
st = {}
# hoặc
st = set()
Tạo một tập hợp có chứa các phần tử
fruits = {'banana', 'orange', 'mango', 'lemon'}
Tạo một tập hợp có chứa các phần tử
fruits = {'banana', 'orange', 'mango', 'lemon'}

Đếm độ dài các phần tử của một Set

Cũng tương tự như list, tuple, dict để đếm độ dài của một tập hợp, ta sử dụng phương thức len()len()

fruits = {'banana', 'orange', 'mango', 'lemon'}
len(fruits) # 4
fruits = {'banana', 'orange', 'mango', 'lemon'}
len(fruits) # 4

Truy cập các phần tử của Set

Để truy cập các phần tử trong một tập hợp, chúng ta sử dụng các vòng lặp để truy cập các phần tử. Chúng ta sẽ thấy điều này tại đây.

Kiểm tra tồn tại của Set

Để kiểm tra xem một phần tử có tồn tại trong danh sách hay không, ta sử dụng in.

st = {'item1', 'item2', 'item3', 'item4'}
print("Does set st contain item3? ", 'item3' in st) # True
 
fruits = {'banana', 'orange', 'mango', 'lemon'}
'mango' in fruits # True
st = {'item1', 'item2', 'item3', 'item4'}
print("Does set st contain item3? ", 'item3' in st) # True
 
fruits = {'banana', 'orange', 'mango', 'lemon'}
'mango' in fruits # True

Thêm phần tử vào một Set

Khi một tập hợp được tạo, chúng ta không thể thay đổi bất kỳ phần tử nào nhưng chúng ta có thể thêm các phần tử bổ sung mới vào một tập hợp.

  • Thêm một phần tử bằng add()add()
fruits = {'banana', 'orange', 'mango', 'lemon'}
fruits.add('lime')
print (fruits) # {'mango', 'banana', 'lemon', 'lime', 'orange'}
fruits = {'banana', 'orange', 'mango', 'lemon'}
fruits.add('lime')
print (fruits) # {'mango', 'banana', 'lemon', 'lime', 'orange'}
  • Thêm nhiều phần tử bằng update()update()
st = {'item1', 'item2', 'item3', 'item4'}
st.update(['item5','item6','item7'])
st = {'item1', 'item2', 'item3', 'item4'}
st.update(['item5','item6','item7'])
Ví dụ
fruits = {'banana', 'orange', 'mango', 'lemon'}
vegetables = ('tomato', 'potato', 'cabbage','onion', 'carrot')
fruits.update(vegetables)
 
# {'mango', 'banana', 'lemon', 'carrot', 'orange', 'potato', 'cabbage', 'onion', 'tomato'}
print (fruits)
Ví dụ
fruits = {'banana', 'orange', 'mango', 'lemon'}
vegetables = ('tomato', 'potato', 'cabbage','onion', 'carrot')
fruits.update(vegetables)
 
# {'mango', 'banana', 'lemon', 'carrot', 'orange', 'potato', 'cabbage', 'onion', 'tomato'}
print (fruits)

Xóa các phần tử khỏi một Set

Chúng ta có thể xóa một phần tử khỏi một tập hợp bằng cách sử dụng phương thức remove(). Nếu phần tử không được tìm thấy thì phương thức remove() sẽ thông báo lỗi. Vì vậy, tốt nhất là bạn nên kiểm tra xem phần tử đó có tồn tại trong một tập hợp đã cho hay không. Tuy nhiên, phương thức discard() không gây ra bất kỳ lỗi nào.

st = {'item1', 'item2', 'item3', 'item4'}
st.remove('item2')
print (st) # {'item3', 'item4', 'item1'}
st = {'item1', 'item2', 'item3', 'item4'}
st.remove('item2')
print (st) # {'item3', 'item4', 'item1'}
Ví dụ
fruits = {'banana', 'orange', 'mango', 'lemon'}
fruits.pop()  # loại bỏ phần tử cuối cùng khỏi tập hợp
print (fruits) # {'banana', 'lemon', 'orange'}
Ví dụ
fruits = {'banana', 'orange', 'mango', 'lemon'}
fruits.pop()  # loại bỏ phần tử cuối cùng khỏi tập hợp
print (fruits) # {'banana', 'lemon', 'orange'}

Làm rỗng một Set

Nếu chúng ta muốn xóa hoặc làm rỗng môt tập hợp, chúng ta sử dụng phương thức clear()clear().

fruits = {'banana', 'orange', 'mango', 'lemon'}
fruits.clear()
print(fruits) # set()
fruits = {'banana', 'orange', 'mango', 'lemon'}
fruits.clear()
print(fruits) # set()

Xóa một Set

Nếu chúng ta muốn xóa hoàn toàn một tập hợp bào đó, chúng ta có thể sử dụng toán tử del.

fruits = {'banana', 'orange', 'mango', 'lemon'}
del fruits
print (fruits) # NameError: name 'fruits' is not defined
fruits = {'banana', 'orange', 'mango', 'lemon'}
del fruits
print (fruits) # NameError: name 'fruits' is not defined

Chuyển List thành Set

Chúng ta có thể chuyển đổi một List thành một Set. Khi đó Set (tập hợp) sẽ được thiết lập để hiển thị các phần tử ngẫu nhiên và loại bỏ các phần tử trong một tập hợp trùng nhau.

lst = ['item1', 'item2', 'item3', 'item4', 'item1']
st = set(lst)
print (st) # {'item2', 'item3', 'item4', 'item1'}
# Thứ tự là ngẫu nhiên 
# bởi vì các phần tử trong set là không có thứ tự 
# và không được trung lập.
lst = ['item1', 'item2', 'item3', 'item4', 'item1']
st = set(lst)
print (st) # {'item2', 'item3', 'item4', 'item1'}
# Thứ tự là ngẫu nhiên 
# bởi vì các phần tử trong set là không có thứ tự 
# và không được trung lập.

Ví dụ

fruits = ['banana', 'orange', 'mango', 'lemon','orange', 'banana']
fruits = set(fruits)
print (fruits) # {'mango', 'banana', 'lemon', 'orange'}
fruits = ['banana', 'orange', 'mango', 'lemon','orange', 'banana']
fruits = set(fruits)
print (fruits) # {'mango', 'banana', 'lemon', 'orange'}

Phép hợp 2 Set

Chúng ta có thể nối hai tập hợp lại với nhau bằng cách sử dụng phương thức union()union() hoặc phương thức update()update().

  • Phương thức union()union() sẽ trả về một tập hợp mới
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item5', 'item6', 'item7', 'item8'}
st3 = st1.union(st2)
print (st3) # {'item5', 'item3', 'item2', 'item4', 'item8', 'item1', 'item6', 'item7'}
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item5', 'item6', 'item7', 'item8'}
st3 = st1.union(st2)
print (st3) # {'item5', 'item3', 'item2', 'item4', 'item8', 'item1', 'item6', 'item7'}

Ví dụ

fruits = {'banana', 'orange', 'mango', 'lemon'}
vegetables = {'tomato', 'potato', 'cabbage','onion', 'carrot'}
print(fruits.union(vegetables)) 
# {'mango', 'banana', 'lemon', 'carrot', 'orange', 'potato', 'cabbage', 'onion', 'tomato'}
fruits = {'banana', 'orange', 'mango', 'lemon'}
vegetables = {'tomato', 'potato', 'cabbage','onion', 'carrot'}
print(fruits.union(vegetables)) 
# {'mango', 'banana', 'lemon', 'carrot', 'orange', 'potato', 'cabbage', 'onion', 'tomato'}
  • Phương thức update()update() sẽ thêm các phần tử của tập hợp A vào tập hợp B
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item5', 'item6', 'item7', 'item8'}
st1.update(st2) # phần tử st2 sẽ thêm vào phần tử st1
print (st1) # {'item5', 'item3', 'item2', 'item4', 'item8', 'item1', 'item6', 'item7'}
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item5', 'item6', 'item7', 'item8'}
st1.update(st2) # phần tử st2 sẽ thêm vào phần tử st1
print (st1) # {'item5', 'item3', 'item2', 'item4', 'item8', 'item1', 'item6', 'item7'}
Ví dụ
fruits = {'banana', 'orange', 'mango', 'lemon'}
vegetables = {'tomato', 'potato', 'cabbage','onion', 'carrot'}
fruits.update(vegetables)
print(fruits) # {'mango', 'banana', 'lemon', 'carrot', 'orange', 'potato', 'cabbage', 'onion', 'tomato'}
Ví dụ
fruits = {'banana', 'orange', 'mango', 'lemon'}
vegetables = {'tomato', 'potato', 'cabbage','onion', 'carrot'}
fruits.update(vegetables)
print(fruits) # {'mango', 'banana', 'lemon', 'carrot', 'orange', 'potato', 'cabbage', 'onion', 'tomato'}

Phép giao giữa 2 tập hợp

Phương thức intersection()intersection() trả về một tập hợp với các phần tử giao nhau (các phần tử này có tồn tại trong cả hai tập hợp). Hãy Xem ví dụ:

st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item3', 'item2'}
st1.intersection(st2) # {'item2', 'item3'}
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item3', 'item2'}
st1.intersection(st2) # {'item2', 'item3'}
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_numbers =  {0, 2, 4, 6, 8, 10}
whole_numbers.intersection(even_numbers) # {0, 2, 4, 6, 8, 10}
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.intersection(dragon)  # {'n', 'o'}
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_numbers =  {0, 2, 4, 6, 8, 10}
whole_numbers.intersection(even_numbers) # {0, 2, 4, 6, 8, 10}
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.intersection(dragon)  # {'n', 'o'}

SubSet và Super Set

Một tập hợp có thể là một tập hợp con hoặc siêu tập hợp của các tập hợp khác:

  • Tập hợp con: issubset()issubset()
  • Siêu tập hợp: issuperset()issuperset()
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
st2.issubset(st1) # True, st2 là tập con của st1
st1.issuperset(st2) # True, st1 là tập cha của st2
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
st2.issubset(st1) # True, st2 là tập con của st1
st1.issuperset(st2) # True, st1 là tập cha của st2
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_numbers =  {0, 2, 4, 6, 8, 10}
print (whole_numbers.issubset(even_numbers)) # False, bởi vì whole_numbers là một super set
print (whole_numbers.issuperset(even_numbers)) # True
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.issubset(dragon)  # False
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_numbers =  {0, 2, 4, 6, 8, 10}
print (whole_numbers.issubset(even_numbers)) # False, bởi vì whole_numbers là một super set
print (whole_numbers.issuperset(even_numbers)) # True
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.issubset(dragon)  # False

Phép trừ giữa hai Set

st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
st2.difference(st1) # set()
st1.difference(st2) # {'item1', 'item4'} => Loại bỏ các phần tử trùng nhau của st1 và st2
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
st2.difference(st1) # set()
st1.difference(st2) # {'item1', 'item4'} => Loại bỏ các phần tử trùng nhau của st1 và st2
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_numbers =  {0, 2, 4, 6, 8, 10}
whole_numbers.difference(even_numbers) # {1, 3, 5, 7, 9}
 
python = {'p', 'y', 't', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.difference(dragon) # {'p', 'y', 't'}  - kết quả là không có thứ tự (đặc trưng của tập hợp)
dragon.difference(python) # {'a', 'd', 'g', 'r'}
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_numbers =  {0, 2, 4, 6, 8, 10}
whole_numbers.difference(even_numbers) # {1, 3, 5, 7, 9}
 
python = {'p', 'y', 't', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.difference(dragon) # {'p', 'y', 't'}  - kết quả là không có thứ tự (đặc trưng của tập hợp)
dragon.difference(python) # {'a', 'd', 'g', 'r'}

Hiệu đối xứng của hai Set

Phương thức symmetric_difference()symmetric_difference() trả về các phần tử khác biệt đối xứng giữa hai tập hợp. Có nghĩa là nó trả về một tập hợp chứa tất cả các phần tử từ cả hai tập hợp, ngoại trừ các phần tử có trong cả hai tập hợp, theo toán học: (A\B) ∪∪ (B\A)

st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
# nghĩa là (A\B)∪(B\A)
st2.symmetric_difference(st1) # {'item1', 'item4'}
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
# nghĩa là (A\B)∪(B\A)
st2.symmetric_difference(st1) # {'item1', 'item4'}
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
some_numbers = {1, 2, 3, 4, 5}
whole_numbers.symmetric_difference(some_numbers) # {0, 6, 7, 8, 9, 10}
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.symmetric_difference(dragon)  # {'a', 'd', 'g', 'h', 'p', 'r', 't', 'y'}
Ví dụ
whole_numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
some_numbers = {1, 2, 3, 4, 5}
whole_numbers.symmetric_difference(some_numbers) # {0, 6, 7, 8, 9, 10}
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.symmetric_difference(dragon)  # {'a', 'd', 'g', 'h', 'p', 'r', 't', 'y'}

Điểm chung của 2 Sets

Nếu hai tập hợp không có một hoặc nhiều các phần tử chung thì chúng ta gọi chúng là các tập hợp rời rạc. Chúng ta có thể kiểm tra xem hai tập hợp là chung hay rời nhau bằng cách sử dụng phương thức isdisjoint()isdisjoint().

st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
st2.isdisjoint(st1) # False
st1 = {'item1', 'item2', 'item3', 'item4'}
st2 = {'item2', 'item3'}
st2.isdisjoint(st1) # False
Ví dụ
even_numbers = {0, 2, 4 ,6, 8}
odd_numbers =  {1, 3, 5, 7, 9}
even_numbers.isdisjoint(odd_numbers) # True, Vì không có điểm chung của 2 set
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.isdisjoint(dragon)  # False, Vì có điểm chung {'o', 'n'} của 2 Set
Ví dụ
even_numbers = {0, 2, 4 ,6, 8}
odd_numbers =  {1, 3, 5, 7, 9}
even_numbers.isdisjoint(odd_numbers) # True, Vì không có điểm chung của 2 set
 
python = {'p', 'y', 't', 'h', 'o','n'}
dragon = {'d', 'r', 'a', 'g', 'o','n'}
python.isdisjoint(dragon)  # False, Vì có điểm chung {'o', 'n'} của 2 Set

Như vậy, bạn đã cơ bản tìm hiểu được như thế nào là Set (tập hợp) trong ngôn ngữ Python. Bây giờ hãy thực hiện một số bài tập dưới đây để cũng cố lại nội dung đã tìm hiểu.

Bài tập

Cho một Set (tập hợp) như sau:
it_companies = {'Facebook', 'Google', 'Microsoft', 'Apple', 'IBM', 'Oracle', 'Amazon'}
A = {19, 22, 24, 20, 25, 26}
B = {19, 22, 20, 25, 26, 24, 28, 27}
age = [22, 19, 24, 25, 26, 24, 25, 24]
Cho một Set (tập hợp) như sau:
it_companies = {'Facebook', 'Google', 'Microsoft', 'Apple', 'IBM', 'Oracle', 'Amazon'}
A = {19, 22, 24, 20, 25, 26}
B = {19, 22, 20, 25, 26, 24, 28, 27}
age = [22, 19, 24, 25, 26, 24, 25, 24]
  1. Tìm chiều dài của tập hợp it_companies
  2. Thêm phần tử Twitter vào tập hợp it_companies
  3. Chèn một số phần tử khác vào tập hợp it_companies
  4. Xóa một phần tử khỏi tập hợp it_companies
  5. Sự khác biệt giữa remove()remove() and discard()discard() là gì?
  6. Nối tập hợp A và tập hợp B.
  7. Tìm giao điểm giữa tập hợp A và tập hợp B.
  8. A có phải là một tập hợp con của B hay không?
  9. A và B có phải là tập hợp rời rạc không?
  10. Nối tập hợp A với tập hợp B và tập hợp B với tập hợp A.
  11. Hiển thị các phần tử khác biệt đối xứng giữa tập hợp A và tập hợp B?
  12. Xóa 2 tập hợp A và B.
  13. Chuyển đổi list age thành một tập hợp và so sánh độ dài của danh sách và tập hợp, cái nào lớn hơn?
  14. Giải thích sự khác biệt giữa các kiểu dữ liệu sau: string, list, tuple và set.
  15. I am a teacher and I love to inspire and teach people. Có bao nhiêu từ duy nhất đã được sử dụng trong câu? Bạn có thể sử dụng các vòng lặp hoặc bạn cũng có thể làm điều đó theo cách thủ công.
•••
Series
Python cơ bản