一、元組

1、元組的概念

• 元組 tuple，是一個不可變序列
• 一般情況下如果不希望資料改變的時候就用元組，其餘情況都用列表

my_tuple = (1,2,3,4,5)
print(my_tuple,type(my_tuple))    # (1, 2, 3, 4, 5) <class 'tuple'>
my_tuple[3] = 8    # TypeError: 'tuple' object does not support item assignment

• 當元組中只有一個元素時，元素後面應該要加一個逗號，這樣才能成為元組。

a_tuple = (1)
print(a_tuple,type(a_tuple))    # 1 <class 'int'>

a_tuple = (1,)
print(a_tuple,type(a_tuple))    # (1,) <class 'tuple'>

2、元組的解包

• 元組的解包指將元組當中的每一個元素都賦值給一個變數。
• 在對一個元祖解包的時候，變數的數量要和元組中元素的數量保持一致。
• 如果變數的數量和元素的數量不一致，也可以在變數前面加上一個 星號*。這樣會獲取元組中剩餘的元素，並以列表的形式返回。
• 任何可迭代物件都支援解包，可迭代物件包括元組、列表、字典、集合、字串、生成器等。

my_tuple = 1,2,3,4,5
print(my_tuple, type(my_tuple))    # (1, 2, 3, 4, 5) <class 'tuple'>

a,b,*c = my_tuple
print('a =',a)    # a = 1
print('b =',b)    # b = 2
print('c =',c)    # c = [3, 4, 5]

a,*b,c = my_tuple
print('a =',a)    # a = 1
print('b =',b)    # b = [2, 3, 4]
print('c =',c)    # c = 5

*a,b,c = my_tuple
print('a =',a)    # a = [1, 2, 3]
print('b =',b)    # b = 4
print('c =',c)    # c = 5

*a,*b,c = my_tuple    # SyntaxError: two starred expressions in assignment
print('a =',a)
print('b =',b)
print('c =',c)

a,b,*c = 'hello python'
print('a =',a)    # a = h
print('b =',b)    # b = e
print('c =',c)    # c = ['l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n']

a,b,*c = [1,2,3,4,5,6]
print('a =',a)    # a = 1
print('b =',b)    # b = 2
print('c =',c)    # c = [3, 4, 5, 6]

二、字典

1、字典的概念

• 字典 dict，對映（mapping）型別的資料結構。
• 字典的作用其實和列表類似，是用來儲存物件的容器。
• 列表儲存資料的效能非常好，但是查詢資料的效能很差。而字典正好相反。
• 在字典當中每一個元素都有唯一的一個名字，通過這個名字可以快速查詢到指定的元素。
• 這個唯一的名字我們一般稱之為鍵 key，通過 key 我們可以查詢到 value 值。
• 所以字典我們也稱之為 鍵值對(key-value)。
• 每個字典當中可以有多個鍵值對，每一個鍵值對我們可以稱之為一項（item）。
• 字典中的鍵是不能重複的，如果重複後面的會替換前面的。

2、語法

• 語法: {key:value,key:value…}

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
# 需要根據鍵來獲取值
print(d['name'],d['age'],d['sex'])    # 鋼鐵俠 38 男

3、字典的使用

3.1 建立字典

• 使用dict()函式來建立字典

d = dict(name='鋼鐵俠',age=35,sex='男')
print(d,type(d))    # {'name': '鋼鐵俠', 'age': 35, 'sex': '男'} <class 'dict'>

• dict()函式也可以將一個包含有雙值子序列轉換為字典
  • 雙值序列：序列中有2個值。例如 [1,2]、(‘b’,‘a’)、‘ab’
  • 子序列：如果序列中的元素也是序列，那麼我們就稱這個元素為子序列。例如 [(1,2),(3,4)]

d = dict([('name','鋼鐵俠'),('age',35)])
print(d,type(d))    # {'name': '鋼鐵俠', 'age': 35} <class 'dict'>

3.2 len()

• len() 獲取字典中鍵值對的個數

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
print(len(d))    # 3

3.3 in、not in

• in 檢查字典中是否包含指定的鍵，返回True / False
• not in 檢查字典中是否不包含指定的鍵

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
print('name' not in d)    # False

3.4 獲取字典中的值

3.4.1 根據鍵獲取字典中的值

• 語法：d[key]

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
print(d['age'])    # 38

3.4.2 用get方法獲取字典中的值

• 語法：字典名.get(key,[default])
• 如果字典當中沒有這個Key值，會返回一個None；
• 也可以指定一個預設值來作為第二個引數，這樣獲取不到Key值的時候就返回預設值。

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
print(d.get('age'))    # 38
print(d.get('job'))    # None
print(d.get('birthday','這個key值不存在'))    # 這個key值不存在

3.5 修改字典

3.5.1 d[key] = value

• 修改字典中的key-value

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
d['name'] = '葫蘆娃'
print(d)    # {'name': '葫蘆娃', 'age': 38, 'sex': '男'}

• 向字典中新增key-value

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
d['phone'] = '12345678'
print(d)    # {'name': '鋼鐵俠', 'age': 38, 'sex': '男', 'phone': '12345678'}

3.5.2 setdefault(key,[default])

• 向字典中新增 key-value
• 如果這個key已經存在於字典當中，則返回key值，不會對字典有任何的影響；
• 如果Key不存在，則向字典中新增這個key，並設定value。

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
result = d.setdefault('name','葫蘆娃')
print(result)    # 鋼鐵俠
print(d)    # {'name': '鋼鐵俠', 'age': 38, 'sex': '男'}

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
result = d.setdefault('hello','葫蘆娃')
print(result)    # 葫蘆娃
print(d)    # {'name': '鋼鐵俠', 'age': 38, 'sex': '男', 'hello': '葫蘆娃'}

3.5.3 update( )

• 將其他字典當中的key-value新增到當前字典當中

d1 = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6}
d1.update(d2)
print(d1)    # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
print(d2)    # {'d': 4, 'e': 5, 'f': 6}

3.6 刪除

3.6.1 del

• 刪除字典中的一對key-value

d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
del d1['a']
del d1['b']
print(d1)    # {'c': 3, 'd': 4, 'e': 5, 'f': 6}

3.6.2 popitem( )

• 隨機刪除一個鍵值對，一般都會刪除最後一個
• 它會將刪除之後的鍵值對作為返回值返回。返回的是一個元組， 元組中有2個元素：第一個元素是刪除的key，第二個元素是刪除的value。

d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
result = d1.popitem()
print(result)    # ('f', 6)
print(d1)    # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

3.6.3 pop(key,[default])

• 根據key來刪除 key-value

d1 = {'c': 3, 'd': 4, 'e': 5}
result = d1.pop('b','這個key值不存在')
print(result)    # 這個key值不存在
print(d1)    # {'c': 3, 'd': 4, 'e': 5}
result = d1.pop('c')
print(result)    # 3
print(d1)    # {'d': 4, 'e': 5}

3.6.4 clear( )

• 清空字典

d1 = {'c': 3, 'd': 4, 'e': 5}
d1.clear()
print(d1)    # {}

3.7 copy( )

• copy( )用於對字典進行一個淺複製。
• 淺複製只會複製字典的本身，如果字典中還有字典，是不會被複制的。
• 複製以後的物件，和原物件是獨立的。修改一個不會影響另一個。

d = {'a':{'name':'黑貓警長','age':18},'b':2,'c':3}
d1 = d
print('d =',d,id(d))  # d = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 2, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 2, 'c': 3} 3039239036648

d1['b'] = 20
print('d =',d,id(d))  # d = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 20, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 20, 'c': 3} 3039239036648

d1['a']['name'] = '皮卡丘'
print('d =',d,id(d))  # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648

d = {'a':{'name':'黑貓警長','age':18},'b':2,'c':3}
d2 = d.copy()
print('d =',d,id(d))  # d = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 2, 'c': 3} 2039041347728

d2['b'] = 20
print('d =',d,id(d))  # d = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '黑貓警長', 'age': 18}, 'b': 20, 'c': 3} 2039041347728

d2['a']['name'] = '皮卡丘'
print('d =',d,id(d))  # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 2039041347728
# 修改d2中‘a’對應的字典，d中的字典也變了，說明字典{'name': '皮卡丘', 'age': 18}沒有被複制。

4、遍歷字典

4.1 keys( )

• 該方法返回的是一個序列，儲存的是字典中所有的鍵。

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
print(d.keys())    # dict_keys(['name', 'age', 'sex'])
list_keys = []
for k in d.keys():
    list_keys.append(k)
print(list_keys)    # ['name', 'age', 'sex']

4.2 values( )

• 該方法返回的是一個序列，儲存的是字典中所有的值。

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
print(d.values())    # dict_values(['鋼鐵俠', 38, '男'])
list_values = []
for k in d.values():
    list_values.append(k)
print(list_values)    # ['鋼鐵俠', 38, '男']

4.3 items( )

• 該方法返回的是一個序列，儲存的是字典中所有的項。
• 這個序列當中包含有雙值子序列，雙值就是字典中的key-value。

d = {'name':'鋼鐵俠','age':38,'sex':'男'}
print(d.items())
for k,v in d.items():
    print(k,'=',v)
# 執行結果：
# dict_items([('name', '鋼鐵俠'), ('age', 38), ('sex', '男')])
# name = 鋼鐵俠
# age = 38
# sex = 男

三、集合

1、集合的概念

集合 set 和列表非常相似，但也有不同點：

• 1 集合中只能儲存不可變物件
• 2 集合中儲存的物件是無序的
• 3 集合中不能出現重複的元素

# 集合中只能儲存不可變物件
s = {[1,2,3],[4,5,6]}    # TypeError: unhashable type: 'list'
print(s,type(s))

# 集合中儲存的物件是無序的
s = {'a','b',1,2,3}
print(s[0])    # TypeError: 'set' object does not support indexing

# 集合中不能出現重複的元素
s = {2,3,1,4,2,2,3,1}
print(s,type(s))    # {1, 2, 3, 4} <class 'set'>

s = {}
print(s,type(s))    # {} <class 'dict'>

s = {1,2,3}
print(s,type(s))    # {1, 2, 3} <class 'set'>

# set() 可以將序列和字典轉換為集合
s = set()
print(s,type(s))    # set() <class 'set'>

s = set([4,2,1,5,3,1,2,3,5,5])
print(s,type(s))    # {1, 2, 3, 4, 5} <class 'set'>

s = set('hello')
print(s,type(s))    # {'h', 'o', 'e', 'l'} <class 'set'>

# 使用set()函式將字典轉換為集合的時候，只會包含字典中的鍵
s = set({'a':1,'b':2,'c':3})
print(s,type(s))    # {'a', 'c', 'b'} <class 'set'>

s = {'a','b',1,2,3}
print(s,type(s))    # {1, 2, 3, 'b', 'a'} <class 'set'>
a = list(s)
print(a,type(a))    # [1, 2, 3, 'b', 'a'] <class 'list'>

2、集合的使用

2.1 in 和 not in

s = {'a','b',1,2,3}
print('a' in s)    # True
print('a' not in s)    # False

2.2 len( )

• 獲取集合的長度（即集合內元素的個數）

s = {'a','b',1,2,3}
print(len(s))     # 5

2.3 add( )

• 向集合中新增元素

s = {'a','b',1,2,3}
s.add(4)
print(s)    # {1, 2, 3, 4, 'a', 'b'}

2.4 update( )

• 將一個集合中的元素新增到另一個集合中

s = {'a','b',1,2,3}
s2 = set('hello')
s.update(s2)
print(s)    # {'b', 2, 3, 1, 'h', 'o', 'e', 'l', 'a'}
print(s2)    # {'l', 'h', 'o', 'e'}

2.5 pop( )

• 刪除集合中的一個元素

s = {'a','b',1,2,3}
r = s.pop()
print(s)    # {1, 2, 3, 'a'}
print(r)    # b

2.6 remove( )

• 刪除集合中指定的元素

s = {'a','b',1,2,3}
s.remove('a')
print(s)    # {1, 2, 3, 'b'}

2.7 clear( )

• 清空集合中的元素

s = {'a','b',1,2,3}
s.clear()
print(s)    # set()

3、集合的運算

3.1 交集運算 &

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 & s2
print(r)    # {3, 4, 5}

3.2 並集運算 |

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 | s2
print(r)    # {1, 2, 3, 4, 5, 6, 7}

3.3 差集運算 -

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r1 = s1 - s2
print(r1)    # {1, 2}
r2 = s2 - s1
print(r2)    # {6, 7}

3.4 異或集運算 ^

• 集合裡面不相交的部分

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 ^ s2
print(r)    # {1, 2, 6, 7}

3.5 比較運算

• 返回的是布林型別
• <= 檢查一個集合是否是另一個集合的子集
• < 檢查一個集合是否是另一個集合的真子集
• >= 檢查一個集合是否是另一個集合的超集
• > 檢查一個集合是否是另一個集合的真超集

a = {1,2,3}
b = {1,2,3,4,5}
c = {1,2,3}
r1 = a <= b
print(r1)    # True
r2 = a < b
print(r2)    # True
r3 = a < c
print(r3)    # False