集合(set) ：目錄

集合(set)介紹
- 集合 v.s. 字典
- 使用集合的時機
- 集合理論
建立集合【使用 set()】
- 建立集合
- 空集合
轉換其他類型【使用 set()】
- 字串 → 集合（丟棄任何重複的字元）
- 串列 → 集合
- Tuple → 集合
- 字典 → 集合
使用 in 來測試值
- 集合【字典 = {鍵：{集合 = 一系列的值}}】
- 集合 v.s. 字典
- 由「集合」尋找「鍵」【使用 for, in, items(), if, print()】
- 由「集合」尋找「鍵」，但有排除條件
結合與運算子
- 交集【使用 & 或 intersection()】
- 將「集合」存在「變數」內，節省打字次數
- 聯集【使用 | 或 union()】
- 差集【使用 - 或 difference()】
以上，是最常見的集合運算子
- 互斥【使用 ^ 或 symmetric_difference()】
- 子集合【使用 <= 或 issubset()】
- 真子集(proper subset)【使用 < 】
- 超集合(superset)【使用 >= 或 issuperset()】
- 真超集合【使用 > 】

集合(set)介紹

集合 v.s. 字典

集合，就像是被移除值，只留下鍵的字典
跟字典一樣，每一個鍵都必須是獨一無二
跟字典的鍵一樣，集合是無序的

使用集合的時機

使用集合的時機：只想要知道某個東西是否存在，其他都無所謂
使用字典的時機：想要將某些資訊指派給鍵來作為它的值

集合理論

聯集
交集
null 或空集合：是指含有零個元素的集合

建立集合【使用 set()】

建立集合

建立集合，可以使用 set()函式，或是將一或多個以逗號分隔的值包在大括號裡面

集合名稱 = {值1, 值2, 值3, 值4, 值5}
集合名稱
{值1, 值2, 值3, 值4, 值5}

>>> even_numbers = {0, 2, 4, 6, 8}
>>> even_numbers
{0, 2, 4, 6, 8}

>>> odd_numbers = {1, 3, 5, 7, 9}
>>> odd_numbers
{1, 3, 5, 7, 9}

空集合

空串列：[]
空字典：{} → 在 Python 中，字典可優先取用大括號
空集合：set()

集合名稱 = set()
集合名稱
set()

>>> empty_set = set()
>>> empty_set
set()

轉換其他類型【使用 set()】

可能會用串列、字串、tuple 或字典來建立集合，並丟棄任何重複的值

字串 → 集合（丟棄任何重複的字元）

set( '字元1字元2字元3字元1' )
{'字元1', '字元2', '字元3'}

>>> set( 'letters' )
{'s', 'r', 'e', 'l', 't'}

串列 → 集合

set( [字串1, 字串2, 字串3, 字串4] )
{ 字串1, 字串2, 字串3, 字串4 }

>>> set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] )
{'Dasher', 'Mason-Dixon', 'Dancer', 'Prancer'}

Tuple → 集合

set( (字串1, 字串2, 字串3, 字串4) )
{ 字串1, 字串2, 字串3, 字串4 }

>>> set( ('Ummagumma', 'Echoes', 'Atom Heart Mother') )
{'Atom Heart Mother', 'Echoes', 'Ummagumma'}

字典 → 集合

set( {鍵1:值1, 鍵2:值2, 鍵3:值3} )
{ 鍵1, 鍵2, 鍵3 }

>>> set( {'apple': 'red', 'orange': 'orange', 'cherry': 'red'} )
{'apple', 'cherry', 'orange'}

使用 in 來測試值

集合【字典 = {鍵：{集合 = 一系列的值}}】

這是集合最常用到的。建立一個「字典」，其中每個「鍵」都是一種名稱，它對應的「值」是它的材料「集合」。
字典 = {
鍵1(名稱1) : {值1, 值2},
鍵2(名稱2) : {值1, 值3},
鍵3(名稱3) : {值1, 值3, 值4}
鍵4(名稱4) : {值2, 值5, 值6}
鍵5(名稱5) : {值1, 值7}
}

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

值1：vodka
值2：vermouth
值3：kahlua
值4：cream
值5：rye
值6：bitters
值7：orange juice

集合 v.s. 字典

集合：集合名稱 = {值1, 值2, 值3, 值4} → 一系列的值
字典：字典名稱 = {鍵1:值1, 鍵2:值2, 鍵3:值3} → 一或多個「鍵:值」對

由「集合」尋找「鍵」【使用 for, in, items(), if, print()】

for name, contents in 字典名稱.items():
if '值1' in contents:
print(name)

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}


>>> for name, contents in drinks.items():
    if 'vodka' in contents:
        print(name)


martini
black russian
white russian
screwdriver

由「集合」尋找「鍵」，但有排除條件

【方法一】使用 for, in, items(), if, print(), not

>>> for name, contents in 字典名稱.items(): 
    if '值1' in contents and not ('值2' in contents or '值4' in contents): 
    print(name)

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}


>>> for name, contents in drinks.items():
    if 'vodka' in contents and not ('vermouth' in contents or 'cream' in contents):
        print(name)


black russian
screwdriver

【方法二】使用 &, for, in, items(), if, print(), not

>>> for name, contents in 字典名稱.items(): 
    if '值1' in contents and not contents & {'值2', '值4'}:
    print(name)

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}


>>> for name, contents in drinks.items():
    if 'vodka' in contents and not contents & {'vermouth', 'cream'}:
        print(name)


black russian
screwdriver

結合與運算子

運算子，有一些會使用特殊的標點符號，有一些會使用特殊函數，有些同時使用兩者。

交集【使用 & 或 intersection()】

& 運算子會產生一個集合，裡面存有你所比較的兩個串列內都有的項目。如果 contents 裡面沒有任何那些材料，& 會回傳一個空集合，它會被視為 False

方法一：【使用 & 】

& 符號來取得交集（兩組集合共有的項目）

值1：vodka 值2：vermouth 值3：kahlua 值4：cream 值5：rye 值6：bitters 值7：orange juice

字典 = {
鍵1(名稱1) : {值1, 值2},
鍵2(名稱2) : {值1, 值3},
鍵3(名稱3) : {值1, 值3, 值4}
鍵4(名稱4) : {值2, 值5, 值6}
鍵5(名稱5) : {值1, 值7}
}

for name, contents in 字典名稱.items(): 
if contents & {'值2', '值7'}: 
print(name)

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> for name, contents in drinks.items():
    if contents & {'vermouth', 'orange juice'}:
        print(name)


martini
manhattan
screwdriver

變數1 = 字典名稱1['鍵1']
變數2 = 字典名稱2['鍵2']
變數1 & 變數2
{'值1', '值3'}

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> bruss & wruss
{'vodka', 'kahlua'}

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 & 集合名稱2
值2

>>> a = {1, 2}
>>> b = {2, 3}

>>> a & b
{2}

方法二：【使用 intersection() 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1.intersection(集合名稱2)
值2

>>> a = {1, 2}
>>> b = {2, 3}

>>> a.intersection(b)
{2}

將「集合」存在「變數」內，節省打字次數

字典 = {
鍵1(名稱1) : {值1, 值2},
鍵2(名稱2) : {值1, 值3},
鍵3(名稱3) : {值1, 值3, 值4}
鍵4(名稱4) : {值2, 值5, 值6}
鍵5(名稱5) : {值1, 值7}
}

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

值1：vodka 值2：vermouth 值3：kahlua 值4：cream 值5：rye 值6：bitters 值7：orange juice

將兩種的材料「集合」存在「變數」內，節省之後範例的打字次數
變數1 = 字典['鍵1']
變數2 = 字典['鍵2']

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

聯集【使用 | 或 union()】

方法一：【使用 | 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 | 集合名稱2
{值1, 值2, 值3}

>>> a = {1, 2}
>>> b = {2, 3}

>>> a | b
{1, 2, 3}

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> bruss | wruss
{'vodka', 'cream', 'kahlua'}

方法二：【使用 union() 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1.union(集合名稱2)
{值1, 值2, 值3}

>>> a = {1, 2}
>>> b = {2, 3}

>>> a.union(b)
{1, 2, 3}

差集【使用 - 或 difference()】

取得方式：屬於第一個集合，但不屬於第二個集合的成員

方法一：【使用 - 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 - 集合名稱2
{值1}

>>> a = {1, 2}
>>> b = {2, 3}

>>> a - b
{1}

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> bruss - wruss
set()

>>> wruss - bruss
{'cream'}
>>>

方法二：【使用 difference() 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1.difference(集合名稱2)
{值1}

>>> a = {1, 2}
>>> b = {2, 3}

>>> a.difference(b)
{1}

以上，是最常見的集合運算子

到目前為止，最常見的集合運算子是「聯集」、「交集」、「差集」。
為了完整起見，接下來會討論其他的集合運算子，但可能永遠都不會用到它們

互斥【使用 ^ 或 symmetric_difference()】

互斥或只屬於其中一個集合的項目

方法一：【使用 ^ 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 ^ 集合名稱2
{值1, 值3}

>>> a = {1, 2}
>>> b = {2, 3}

>>> a ^ b
{1, 3}

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> bruss ^ wruss
{'cream'}

方法二：【使用 symmetric_difference() 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1.symmetric_difference(集合名稱2)
{值1, 值3}

>>> a = {1, 2}
>>> b = {2, 3}

>>> a.symmetric_difference(b)
{1, 3}

子集合【使用 <= 或 issubset()】

可以用 <= 或 issubset() 來檢查「某個集合」是否為「另一個集合」的子集合（第一個集合的「所有成員」都屬於第二個集合）

方法一：【使用 <= 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 <= 集合名稱2
False

>>> a = {1, 2}
>>> b = {2, 3}

>>> a <= b
False

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> bruss <= wruss
True

方法二：【使用 issubset() 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1.issubset(集合名稱2)
False

>>> a = {1, 2}
>>> b = {2, 3}

>>> a.issubset(b)
False

方法三：子集合 —「所有的集合」都是「它自己」的子集合

集合名稱1 = {值1, 值2}
集合名稱1 <= 集合名稱1
集合名稱1.issubset(集合名稱1)
True

>>> a = {1, 2}
>>> b = {2, 3}

>>> a <= a
True

>>> a.issubset(a)
True

真子集(proper subset)【使用 < 】

要讓真子集（proper subset）成立，「第二個集合」必須擁有「第一個集合」的所有成員，此外還要有其他的成員

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 < 集合名稱2
False

>>> a = {1, 2}
>>> b = {2, 3}

>>> a < b
False
>>> a < a
False

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> bruss < wruss
True

超集合(superset)【使用 >= 或 issuperset()】

超集合（superset）是子集合的相反
「第二個集合」的所有成員都是「第一個集合」的成員

方法一：【使用 >= 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 >= 集合名稱2
False

>>> a = {1, 2}
>>> b = {2, 3}

>>> a >= b
False

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> wruss >= bruss
True

方法二：【使用 issuperset() 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1.issuperset(集合名稱2)
False

>>> a = {1, 2}
>>> b = {2, 3}

>>> a.issuperset(b)
False

方法三：超集合 —「所有的集合」都是「它自己」的超集合

集合名稱1 = {值1, 值2}
集合名稱1 = {值1, 值2}
集合名稱1 >= 集合名稱1
集合名稱1.issuperset(集合名稱1)
True

>>> a = {1, 2}
>>> b = {2, 3}

>>> a >= a
True
>>> a.issuperset(a)
True

真超集合【使用 > 】

集合名稱1 = {值1, 值2}
集合名稱2 = {值3, 值2}
集合名稱1 > 集合名稱2
False

>>> a = {1, 2}
>>> b = {2, 3}

>>> a > b
False

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'vodka', 'kahlua', 'cream'},
    'manhattan': {'vermouth', 'rye', 'bitters'},
    'screwdriver': {'vodka', 'orange juice'}
}

>>> bruss = drinks['black russian']
>>> wruss = drinks['white russian']

>>> wruss > bruss
True

集合無法成為自己的真超集合

集合名稱1 = {值1, 值2}
集合名稱1 > 集合名稱1
False

>>> a = {1, 2}
>>> b = {2, 3}

>>> a > a
False

集合(set) ：目錄

集合(set)介紹

集合 v.s. 字典

使用集合的時機

集合理論

建立集合【使用 set()】

建立集合

空集合

轉換其他類型【使用 set()】

字串 → 集合（丟棄任何重複的字元）

串列 → 集合

Tuple → 集合

字典 → 集合

使用 in 來測試值

集合【字典 = {鍵：{集合 = 一系列的值}}】

集合 v.s. 字典

由「集合」尋找「鍵」【使用 for, in, items(), if, print()】

由「集合」尋找「鍵」，但有排除條件

【方法一】使用 for, in, items(), if, print(), not

【方法二】使用 &, for, in, items(), if, print(), not

結合與運算子

交集【使用 & 或 intersection()】

方法一：【使用 & 】

方法二：【使用 intersection() 】

將「集合」存在「變數」內，節省打字次數

聯集【使用 | 或 union()】

方法一：【使用 | 】

方法二：【使用 union() 】

差集【使用 - 或 difference()】

方法一：【使用 - 】

方法二：【使用 difference() 】

以上，是最常見的集合運算子

互斥【使用 ^ 或 symmetric_difference()】

方法一：【使用 ^ 】

方法二：【使用 symmetric_difference() 】

子集合【使用 <= 或 issubset()】

方法一：【使用 <= 】

方法二：【使用 issubset() 】

方法三：子集合 —「所有的集合」都是「它自己」的子集合

真子集(proper subset)【使用 < 】

超集合(superset)【使用 >= 或 issuperset()】

方法一：【使用 >= 】

方法二：【使用 issuperset() 】

方法三：超集合 —「所有的集合」都是「它自己」的超集合

真超集合【使用 > 】

results matching ""

No results matching ""