集合（set）是一個無序的不重復元素序列。1,2,3,4,1,2,3 = 1,2,3,4
1). 使用大括號 { } 或者 set() 函數創建集合;
2). 注意：
創建一個空集合必須用 set() 而不是 { }
{ } 是用來創建一個空字典。
# 1. 集合的創建
s = {1, 2, 3, 1, 2, 3} # {1, 2, 3}
print(s, type(s))
## 注意點1: 集合的元素必須時不可變數據類型。
# s = {1, 2, 3, [1, 2, 3]}
# print(s, type(s))
## 注意點2:空集合不能使用{}, 而要使用set()
# s = {}
# print(s, type(s)) ##{} <class 'dict'>
s = set()
print(s, type(s))
集合本來就是無序的不重復的元素序列。所以連接操作、重復操作、索引、切片對他都無效。
# 不支持+,*, index, slice(因為集合無序不重復的)
# 支持in和not in
print(1 in {1, 2, 3, 4})
# 4-1). 增加
# add: 添加單個元素
# update: 添加多個元素
s = {1, 2, 3}
s.add(100)
print(s)
s = {1, 2, 3}
s.update({4, 5, 6})
print(s)
# remove: 如果元素存在，刪除，否則報錯
# discard: 如果元素存在，刪除，否則do nothing
# pop: 隨機刪除一個元素
# 刪除元素，集合為空則報錯
s = {1, 2, 3}
s.remove(3)
print(s)
s = {1, 2, 3}
s.discard(100)
print(s)
s = {1, 66, 2,99, 78, 3}
s.pop()
print(s)
# 3-3). 查看
# 差集: s1 - s2
# 交集: s1 & s2
# 對稱差分: s1 ^ s2
# 並集: s1 | s2
s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 - s2) # {3}
print(s1 & s2) # {1, 2}
s1 = {1, 2, 3}
s2 = {1, 2, 4}
print(s1 ^ s2) # {3, 4}, {1, 2, 3, 4} - {1, 2} = {3,4}
print(s1 | s2) # {1, 2, 3, 4}
print(s1.issubset(s2)) # False
print(s1.isdisjoint(s2)) # False
注意：
issubset() 方法用於判斷集合的所有元素是否都包含在指定集合中，如果是則返回 True，否則返回 False。
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z) ##True
isdisjoint() 方法用於判斷兩個集合是否包含相同的元素，如果沒有返回 True，否則返回 False。。
s1 = {1, 3}
s2 = {1, 2, 3}
print(s1.isdisjoint(s2)) ### False
## 可以拷貝 但是不能增刪改
s = frozenset({1, 2, 3})
print(s, type(s))
隨機生成N個數字（1到1000之間），並按照從大到小的順序排列：
import random
N = int(input("請輸入N："))
s = set()
print(s,type(s))
for i in range(N):
num = random.randint(1,1000)
s.add(num)
print(sorted(s,reverse=True))
字典是另一種可變容器模型，且可存儲任意類型對象。
鍵一般是唯一的，如果重復最後的一個鍵值對會替換前面的，值不需要唯一。
# key-value對或者鍵值對
d = {"name":"westos", "age":18, "city":"西安"}
print(d, type(d))
d = {}
print(d, type(d))
輸出：
{'name': 'westos', 'age': 18, 'city': '西安'} <class 'dict'>
{} <class 'dict'>
不支持+,*, index, slice(因為集合無序不重復的)
支持in和not in
d = {“name”:“westos”, “age”:18, “city”:“西安”}
print(‘name’ in d) # True， 判斷是否為所有key值得成員
print(“westos” in d) # False
"""
查看所有: keys, values, items
查看局部: d[key], d.get(key), d.get(key, default-value)
"""
d = {"name":"westos", "age":18, "city":"西安"}
print(d.keys()) # 查看字典所有的key值
print(d.values()) # 查看字典所有的value值
print(d.items()) # 查看字典所有的key-value值(item元素)
print(d['name']) # 查看key為name對應的value值
# print(d['province']) # 查看key對應的vlaue值，如果不存在會報錯。
print(d.get('province')) # 查看key對應的vlaue值， 如果存在則返回，如果不在在則返回None.
print(d.get('province', "陝西")) # 查看key對應的vlaue值， 如果存在則返回，如果不在在則返回默認值.
d = {"name":"westos", "age":18}
d['city'] = "西安" # key不存在就添加
print(d)
d['city'] = "北京" # key存在則修改value值
print(d)
d = {"name":"westos", "age":18}
d.setdefault('city', "西安") # key不存在就添加
print(d)
d.setdefault('city', "北京") # key存在，則do nothing
print(d)
d = {"name":"westos", "age":18}
d.pop('name')
print(d) ##{'age': 18}
d = {"name":"westos", "age":18}
del d['name']
print(d) ##{'age': 18}
d = {"name":"westos", "age":18, "city":"西安"}
##默認情況下，字典只會遍歷key值
for item in d:
print(item)
# 如果遍歷字典的key和value呢?(特別特別重要)
for key,value in d.items(): # [('name', 'westos'), ('age', 18), ('city', '西安')]
print(f"key={key}, value={value}")
#默認字典，設置默認value
#默認字典，設置默認value
d = defaultdict(int)
d['views'] += 1
d['transfer'] += 1
print(d)
#
d = defaultdict(list)
d['allow_users'].append('westos')
d['deny_users'].extend(['user1', 'user2'])
print(d)
d = defaultdict(set)
d['love_movies'].add("黑客帝國")
d['dislike_movies'].update({'前任3', '電影xxxx'})
print(d)
輸出如下：
defaultdict(<class 'int'>, {'views': 1, 'transfer': 1})
defaultdict(<class 'list'>, {'allow_users': ['westos'], 'deny_users': ['user1', 'user2']})
defaultdict(<class 'set'>, {'love_movies': {'黑客帝國'}, 'dislike_movies': {'前任3', '電影xxxx'}})
練習：
defaultDict來做一個練習，把list(隨機生成50個1-100之間的隨機數)中大於66的元素和小於66的元素
from collections import defaultdict
import random
d = defaultdict(list)
num = []
for count in range(50):
num.append(random.randint(1,100))
for i in num:
if i > 66:
d['大於66的元素'].append(i)
else:
d['小於66的元素'].append(i)
print(d)
可變數據類型: 可以增刪改。可變數據類型，允許變量的值發生變化，即如果對變量進行append、+=等這種操作後，只是改變了變量的值，而不會新建一個對象，變量引用的對象的地址也不會變化，不過對於相同的值的不同對象，在內存中則會存在不同的對象，即每個對象都有自己的地址，相當於內存中對於同值的對象保存了多份，這裡不存在引用計數，是實實在在的對象。
不可變數據類型: 不可以增刪改。python中的不可變數據類型，不允許變量的值發生變化，如果改變了變量的值，相當於是新建了一個對象，而對於相同的值的對象，在內存中則只有一個對象，內部會有一個引用計數來記錄有多少個變量引用這個對象。
序列：
