Chapter 8

セット

集合について中学か高校で習ったことの復習です。

　　和集合 論理和　a　OR　b　　　a　または　b 　　　　　　 a.union(b) a | b

　　論理積 積集合 a AND b a かつ　b a.intersection(b) a & b

差集合　　　a セットから　b セットの要素を取り除く 　　　　　　　　　　a - b a.differrence(b)

　　対称差集合　　排他的論理和　　　EXOR 　　　　　　　　　入力値が同じなら出力値　０　偽 　　　　　　　　　入力値が異なれば出力値　１　真

　　　　　　　　　a ^ b a.symmetric_difference(b)　　　　　　　　

P195

●色のセットを２つ作る

###色のセットを２つ作る
color_setA = {"blue", "yellow", "red"}
color_setB = {"green", "blue", "black"}

P196

●セットの要素の個数

xxxxxxxxxx
###  セットの要素の個数
color_set = {"blue", "pink", "orange", "white", "black"}
a = len(color_set)
print(a)

●range()を使ってセットを作る

xxxxxxxxxx
###  range()を使ってセットを作る
num2set = set(range(0,20,2))  # 20までの2の倍数のセット
num3set = set(range(0,20,3))  # 20までの3の倍数のセット
print(num2set)
print(num3set)

P197

●空集合（空のセット）を作る

xxxxxxxxxx
###  空集合（空のセット）を作る
empty_set = set()
print(empty_set)

●リストからセットを作る（重複した要素が取り除かれる）

xxxxxxxxxx
###  リストからセットを作る（重複した要素が取り除かれる）
data = [101, 103, 103, 115, 167, 167, 189]
dataset = set(data)
print(dataset)

●セットをリストに変換する

xxxxxxxxxx
###  セットをリストに変換する
dataset = {101, 167, 103, 115, 189}
datalist = list(dataset)  # リストに変換する
print(datalist)

xxxxxxxxxx
datalist.sort()   # ソートする
print(datalist)

●文字列からセットを作る（重複した文字が取り除かれる）

xxxxxxxxxx
###  文字列からセットを作る（重複した文字が取り除かれる）
happyset = set("happy")
print(happyset)

P198

●空のセットに要素を追加していく

xxxxxxxxxx
###  文字列からセットを作る（重複した文字が取り除かれる）
fruits = set()
fruits.add("apple")
fruits.add("orange")
print(fruits)

●既存の要素を追加しても無視される

xxxxxxxxxx
###  既存の要素を追加しても無視される
print(fruits)
  
fruits.add("orange")  # 既に入っている"orange"を追加してみる
print(fruits)

●fruitsセットから"banana"を削除する

xxxxxxxxxx
###  fruitsセットから"banana"を削除する
fruits = {'banana', 'orange', 'apple'}
print(fruits)
      
fruits.remove("banana")
print(fruits)

P199

●discard()でセットの要素を削除する discard()でも指定した要素を削除できます。remove()とは違いdiscard() は削除しようとした要素がセットに含まれていない場合でもエラーに 　 ならず操作が無視されます。

​x
###  discard()でセットの要素を削除する
  
color_set = {"blue", "yellow", "red"} 
color_set.discard("green")
print(color_set)
​
color_set.discard("red")
print(color_set)

●既存のセットを空にする

xxxxxxxxxx
###  既存のセットを空にする
dataset = {0.1, 0.2, 0.5, 1.3, 1.6}
dataset.clear()
print(dataset)

●セットから要素を1個ずつ取り除く

xxxxxxxxxx
###  セットから要素を1個ずつ取り除く
color_set = {"red", "green", "blue"}
item = color_set.pop()    # 要素を1個取り除きます
item    # 取り出した要素が入っています
print(item)
​
print(color_set)    # "green"が取り除かれています
​

P200

セットにはfrozenset()で作るセットもあります。frozenset()で作るセットも set()と同じように作ります。 {} または　set()　で作ったセットはset型、frozenset()で作ったセットは frozenset型です。

●frozenset()のセットを作る

xxxxxxxxxx
### frozenset()のセットを作る
dataset = frozenset(["a", "b", "c"])
print(dataset)
​
print(type(dataset))

●frozenset型のセットにadd()で要素を追加するとエラーになる

xxxxxxxxxx
###  frozenset型のセットにadd()で要素を追加するとエラーになる
dataset = frozenset(["a", "b", "c"])
dataset.add("x")
print(dataset)

●frozenset型のセットの値は削除できない

xxxxxxxxxx
###  frozenset型のセットの値は削除できない
dataset.clear()

P201

●リストの要素を2倍にしてセットを作る

xxxxxxxxxx
###  リストの要素を2倍にしてセットを作る
numbers = [1, 2, 3, 4, 5, 6]
num_set = {num*2 for num in numbers}    # セット内包表記
print(num_set)

●リストの正の要素だけでセットを作る

xxxxxxxxxx
###  リストの正の要素だけでセットを作る
numbers = [-1.3, 1.2, -1.2, 1.1, 1.5, -1.1, 1.2, 1.1, 1.4]
num_set = {num for num in numbers if num>0 }
print(num_set)

============================================================

セットの集合演算

P203

●和集合：すべてのセットの要素を合わせたセットを作る

xxxxxxxxxx
### 和集合：すべてのセットの要素を合わせたセットを作る
a = {"リンゴ", "みかん", "桃", "いちご"}
b = {"いちご", "スイカ", "みかん", "バナナ"}
c = a | b    # 和集合を求める
print(c)

●セットa、b、cの和集合を求める

xxxxxxxxxx
###  セットa、b、cの和集合を求める
a = {"リンゴ", "みかん", "桃", "いちご"}
b = {"いちご", "スイカ"}
c = {"みかん", "バナナ"}
d = a | b | c    # 和集合を求める
print(d)

●union()を使って和集合を求める

xxxxxxxxxx
###  union()を使って和集合を求める
set1 = {1, 2, 3}
list1 = [2, 4, 6, 8]
list2 = [3, 6, 9]
data = set1.union(list1, list2)    # 和集合を求める
print(data)

P204

●積集合：a、bセットの共通した要素のセットcを作る

xxxxxxxxxx
###  積集合：a、bセットの共通した要素のセットcを作る
a = {"リンゴ", "みかん", "桃", "いちご"}
b = {"いちご", "スイカ", "みかん", "バナナ"}
c = a & b    # 積集合を求める
print(c)

P205 ●セットa、b、cの積集合を&演算子を使って求める

xxxxxxxxxx
###  セットa、b、cの積集合を&演算子を使って求める
a = {"リンゴ", "みかん", "桃", "いちご"}
b = {"いちご", "スイカ", "みかん", "バナナ"}
c = {"いちご", "リンゴ"}
d = a & b & c    # 積集合を求める
print(d)

●セットa、b、cの積集合をintersection()を使って求める

xxxxxxxxxx
###  セットa、b、cの積集合をintersection()を使って求める
d = a.intersection(b, c)    # 積集合を求める
print(d)

●差集合：aからbに含まれている要素を取り除いたセットを作る

xxxxxxxxxx
###  差集合：aからbに含まれている要素を取り除いたセットを作る
a = {"リンゴ", "みかん", "桃", "いちご"}
b = {"いちご", "スイカ", "みかん", "バナナ"}
c = a - b    # 差集合を求める
print(c)

●difference()を使って差集合を求める

xxxxxxxxxx
###  difference()を使って差集合を求める
c = a.difference(b)    # 差集合を求める
print(c)

P206

●対称差：a、bセットの片方だけに含まれている要素のセットを作る

xxxxxxxxxx
###  対称差：a、bセットの片方だけに含まれている要素のセットを作る
a = {"リンゴ", "みかん", "桃", "いちご"}
b = {"いちご", "スイカ", "みかん", "バナナ"}
c = a ^ b    # 対称差集合を求める
print(c)

●symmetric_difference()を使って対称差集合を求める

xxxxxxxxxx
###  symmetric_difference()を使って対称差集合を求める
c = a.symmetric_difference(b)    # 対称差集合を求める
print(c)

P207

集合演算結果でセットの内容を更新する

●セットの値を和集合で更新する

xxxxxxxxxx
###  セットの値を和集合で更新する
data = {"red", "blue"}
data2 = {"blue", "yellow"}
data3 = {"blue", "green"}
data.update(data2, data3)    # 和集合で更新する
print(data)

●|= 演算子を使って和集合の代入を書いた場合

xxxxxxxxxx
###  |= 演算子を使って和集合の代入を書いた場合
data = {"red", "blue"}
data2 = {"blue", "yellow"}
data3 = {"blue", "green"}
data |= data2    # 和集合で置き換える
data |= data3    # 和集合で置き換える
print(data)

●セットの値を積集合で置き換える

xxxxxxxxxx
###  セットの値を積集合で置き換える
data = {"red", "blue", "green", "yellow"}
data2 = {"blue", "black", "yellow"}
data.intersection_update(data2)    # 積集合で更新する
print(data)

P208

●&= 演算子を使って積集合の代入を書いた場合

xxxxxxxxxx
###  &= 演算子を使って積集合の代入を書いた場合
data = {"red", "blue", "green", "yellow"}
data2 = {"blue", "black", "yellow"}
data &= data2    # 積集合で置き換える
print(data)

●セットの値を差集合で置き換える

xxxxxxxxxx
###  セットの値を差集合で置き換える
data = {"red", "blue", "green", "yellow"}
data2 = {"blue", "black", "yellow"}
data.difference_update(data2)    # 差集合で更新する
print(data)

●-= 演算子を使って差集合の代入を書いた場合

xxxxxxxxxx
###  -= 演算子を使って差集合の代入を書いた場合
data = {"red", "blue", "green", "yellow"}
data2 = {"blue", "black", "yellow"}
data -= data2    # 差集合で置き換える
print(data)

●セットの値を対称差集合（排他的論理和）で置き換える

xxxxxxxxxx
###  セットの値を対称差集合で置き換える
data = {"red", "blue", "green", "yellow"}
data2 = {"blue", "black", "yellow"}
data.symmetric_difference_update(data2)    # 対称差集合で更新する
print(data)

P209

●^= 演算子を使って対称差集合の代入を書いた場合

xxxxxxxxxx
###  ^= 演算子を使って対称差集合の代入を書いた場合
data = {"red", "blue", "green", "yellow"}
data2 = {"blue", "black", "yellow"}
data ^= data2    # 対称差集合で置き換える
print(data)

２つのセットの要素が一致するするかどうか

●２つのセットの要素が一致するするかどうかは、== 演算子で比較する 　　ことができます。要素が一致すればTrue,一つでも異なっていれば 　　Falseが返されます。セットには要素の順はないので要素の並びは 　　関係ありません。

xxxxxxxxxx
###  ２つのセットの要素が一致するときTrue
a = {1, 2, 3}
b = {3, 2, 1}
c = {1, 2, 3, 4}
  
print(a == b)    # aとbが一致するときTrue
print(a == c)

P210

●２つのセットの要素が一致しないときTrue

xxxxxxxxxx
###  ２つのセットの要素が一致しないときTrue
a = {1, 2, 3}
b = {3, 2, 1}
c = {1, 2, 3, 4}
print("a != b", a != b)   # aとbが一致しないときTrue
​
print("a != c ",a != c)

●共通している要素があるかないかを確かめる

xxxxxxxxxx
###  共通している要素があるかないかを確かめる
a = {"earth", "wind", "fire"}
b = {"sky", "sea"}
c = {"fire", "water"}
a.isdisjoint(b)  # aとbには共通要素がない
​
print("a.isdisjoint(b)",a.isdisjoint(b))
print("a.isdisjoint(c)",a.isdisjoint(c))

p211

セットの包含関係

●aセットがbセットのサブセットかどうかを判定する

　　　　　aセットがbセットのサブセットかどうかはa.issubset(b)か 　　　　　a < b および a < =b の演算子で判定できます。

xxxxxxxxxx
###  aセットがbセットのサブセットかどうかを判定する
a = {"blue", "red"}
b = {"blue", "green", "red", "pink", "white"}
a.issubset(b)    # aはbのサブセットである
print(a.issubset(b) )
print(a<b)
print(a <= b)

　P212

●aセットがbセットのスーパーセットかどうかを判定する。 　　　 aセットがbセットのスーパーセットかどうかはa.issuperset(b)か 　　　 a >= b　演算子で判定できます

xxxxxxxxxx
###  aセットがbセットのスーパーセットかどうかを判定する
a = {1999, 2011, 2013, 2014, 2016, 2017}
b = {2011, 2013, 2014}
a.issuperset(b)    # aはbのスーパーセットである
print(a.issuperset(b))
print(a >= b)