集合運算

集合運算

1、交集

集合中，設A、B兩個集合，有全部屬於集合 A 且 屬於集合B的元素所組成的集合，叫作集合A與集合B 的交集（intersection）

In [1]: s1 = {1, 2, 3}

In [2]: s2 = {2, 3, 4}

In [3]: s1.intersection(s2)    # 返回結果集， 原地不作修改的函數，交集是有一個交換率的
Out[3]: {2, 3}

In [4]: s1
Out[4]: {1, 2, 3}

In [5]: s2
Out[5]: {2, 3, 4}

In [6]: s2.intersection(s1)
Out[6]: {2, 3}

In [7]:

 

In [8]: s1.intersection_update(s2)  # 原地修改，並返回None

In [9]: s1
Out[9]: {2, 3}

In [10]: s2
Out[10]: {2, 3, 4}

In [15]: s1 = {1, 2, 3}

In [16]: s2
Out[16]: {2, 3, 4}

In [17]: s1 & s2        # 交集運算重載符
Out[17]: {2, 3}

In [18]: s2 & s1
Out[18]: {2, 3}

In [19]:

2、差集

集合A 和 集合B，當集合C中的元素僅僅存在於A中，但不存在於B中，而且A中存在、B中不存在的元素，所有存在於C中，那麼C是A的差集

In [22]: s1
Out[22]: {1, 2, 3}

In [23]: s2
Out[23]: {2, 3, 4}

In [24]: s1.difference(s2)
Out[24]: {1}

In [25]: s2.difference(s1)
Out[25]: {4}

差集 是不具有交換率的

In [27]: s1.difference_update(s2)

In [28]: s1
Out[28]: {1}

In [29]: s1 = {1, 2, 3}

In [30]: s1 - s2           # - 是差集的運算重載符
Out[30]: {1}

In [31]: s2 - s1
Out[31]: {4}

In [32]:

3、對稱差集

集合A 與 集合B：一個元素，要麼在A中，要麼在B中

In [32]: s1
Out[32]: {1, 2, 3}

In [33]: s2
Out[33]: {2, 3, 4}

In [34]: s1.symmetric_difference(s2)
Out[34]: {1, 4}

In [35]: s2.symmetric_difference(s1)
Out[35]: {1, 4}

對稱差集也是有交換率的

In [36]: s1.symmetric_difference_update(s2)

In [37]: s1
Out[37]: {1, 4}

In [38]: s2
Out[38]: {2, 3, 4}

In [39]: s1.symmetric_difference_update(s2)

In [40]: s1
Out[40]: {1, 2, 3}

In [41]: s2
Out[41]: {2, 3, 4}

In [42]: s1 ^ s2         # 對稱差集的運算重載符
Out[42]: {1, 4}

In [43]:

4、並集

若集合A 和 集合B，則A和B的並集是：全部A中的元素 和 全部B中的元素，而沒有其餘元素的集合。

In [43]: s1.union(s2)
Out[43]: {1, 2, 3, 4}

In [44]: s1
Out[44]: {1, 2, 3}

In [45]: s2
Out[45]: {2, 3, 4}

In [46]: s2.union(s1)
Out[46]: {1, 2, 3, 4}

In [47]:

並集也具備交換率。

In [1]: s1 = {1, 2, 3}

In [2]: s2 = {2, 3, 4}

In [3]: s1.update(s2)

In [4]: s1
Out[4]: {1, 2, 3, 4}

In [5]: s1 = {1, 2, 3}

In [6]: s1.update(s2)

In [7]: s1
Out[7]: {1, 2, 3, 4}

In [8]: s1 | s2
Out[8]: {1, 2, 3, 4}

In [9]: s1
Out[9]: {1, 2, 3, 4}

In [10]: s1 = {1, 2, 3}

In [11]: s1 | s2                   # | 是 並集的運算重載符
Out[11]: {1, 2, 3, 4}

5、補集

補集通常指絕對補集，設 S 是一個集合，A是S的一個子集，由S中全部不屬於A的元素 組成的集合，叫作子集A 在S中的絕對補集（簡稱補集 或 餘集）

在程序語言中，沒有補集運算

由於在程序中，沒法定義出絕對全集，因此沒法求出絕對補集

 

6、集合相關的判斷

In [12]: s1 = {1, 2, 3, 4}

In [13]: s2 = {2, 3}

若是一個集合s2，每個元素都在集s1中，且集合s1 可能包含s2 中沒有的元素，則集合s1 就是s2的一個超集，s2 就是 s1的一個子集。

In [12]: s1 = {1, 2, 3, 4}

In [13]: s2 = {2, 3}

In [14]: 

In [14]: s2.issubset(s1)
Out[14]: True

In [15]: s1.issubset(s2)
Out[15]: False

In [16]: s1.issuperset(s2)
Out[16]: True

In [17]: s2.issuperset(s1)
Out[17]: False

In [18]: def _issubest(s1, s2):
    ...:     for x in s1:
    ...:         if x not in s2:
    ...:             return False
    ...:     return True
    ...:         

In [19]: s1
Out[19]: {1, 2, 3, 4}

In [20]: s2
Out[20]: {2, 3}

In [21]: _issubest(s1, s2)
Out[21]: False

In [22]: _issubest(s2, s1)
Out[22]: True

In [23]: 

In [23]: def _issuperset(s1, s2):
    ...:     for x in s2:
    ...:         if x not in s1:
    ...:             return False
    ...:     return True
    ...:     

In [24]: _issuperset(s1, s2)
Out[24]: True

 

In [25]: s1
Out[25]: {1, 2, 3, 4}

In [26]: s2
Out[26]: {2, 3}

In [27]: s1.isdisjoint(s2)
Out[27]: False

In [28]: s3 = {1, 2}

In [29]: s4 = {3, 4}

In [30]: s3.isdisjoint(s4)
Out[30]: True

isdisjoint 判斷兩個集合 是否有交集， 若是有交集 返回False， 若是沒有交集 返回True。

6、集合的應用

• 去重
• 運算快

    有一個API，須要經過權限認證，而且 須要有必定的權限才能夠訪問

    例如：要求知足權限A，B，C中任意一項，有一個用戶具備權限B，C，D 那麼此用戶是否有權限訪問API呢？

如何判斷？

In [31]: s1 = {'A', 'B', 'C'}

In [32]: s2 = {'B', 'C', 'D'}

In [33]: if not s1.isdisjoint(s2):
    ...:     print('get api success')
    ...:     
get api success

In [34]:

    有一個任務列表， 存儲所有的人物，有一個列表，存儲已經完成的任務，找出未完成的任務

怎麼辦？

7、集合的限制

集合的元素 必須可 hash

In [34]: hash(b'abc')
Out[34]: -4664515049651371347

In [35]: hash(1)    # 測試是否可哈希
Out[35]: 1

In [36]: hash('a')
Out[36]: -4794389817845320130

In [37]: hash([1, 2])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-37-4b420d0158ba> in <module>()
----> 1 hash([1, 2])

TypeError: unhashable type: 'list'

In [38]: hash({1, 2})
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-38-42051ea12b27> in <module>()
----> 1 hash({1, 2})

TypeError: unhashable type: 'set'

In [39]: hash(bytearray(b'abc'))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-39-3d8516aba17b> in <module>()
----> 1 hash(bytearray(b'abc'))

TypeError: unhashable type: 'bytearray'

In [40]:

In [40]: a = 1

In [41]: a.__hash__()
Out[41]: 1

In [42]: l = [1, 2]

In [43]: l.__hash__()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-43-43badc6ed4b1> in <module>()
----> 1 l.__hash__()

TypeError: 'NoneType' object is not callable

In [44]: help(hash)

Help on built-in function hash in module builtins:

hash(obj, /)
    Return the hash value for the given object.
    
    Two objects that compare equal must also have the same hash value, but the
    reverse is not necessarily true.
~

(END)