07元組、字典和集合

要熟練掌握元組、字典和集合的不同功能的方法

1.元組簡介

• 元組是不可變序列，通過（）可以創建，或者不用（）而直接用‘，’將各個元素分隔開也可以

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

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

tup=(1,2,3,4,5)
print(tup.index(1)) # 0  返回了1的索引值

print(tup[1]) # 2  注意這裏依然是[]來調用，tup[1]是索引爲1的元組的值
print(tup) # (1,2,3,4,5)  注意這裏tup是一個變量對象
tup[1]=9  # 不可變序列給序列重新賦值是不允許的  TypeError: 'tuple' object does not support item assignment
tup=9	# 這是給變量對象重新賦值，是允許的

''' 
將元組的元素賦值給變量的過程就叫做解包
——賦值時變量個數與元組內的元素個數必須保持一致
——如果元組元素在解包時不逐個分解，可通過*c的方式可以將多個元素放入列表中
——字符串和列表同樣適用這些解包的方法
'''
tup=10,20,30,40
a,b,c=tup  #  ValueError: too many values to unpack (expected 3)
a,b,c,d,e=tup   #   ValueError: not enough values to unpack (expected 5, got 4)
a,b,c,d=tup  #	變量個數與元組內的元素個數必須保持一致
'''變量個數與元組內的元素個數必須不一致時採用以下方法'''
a,b,*c=tup          #   a=tup[0],b=tup[1],*c表示剩下的都給了列表c，c=[tup[2],tup[3]]
a,*b,c=tup          #   a=tup[0],c=tup[3],*b表示剩下的都給了列表b，b=[tup[1],tup[2]]
*a,b,c=tup          #   b=tup[2],c=tup[3],*a表示剩下的都給了列表a，a=[tup[0],tup[1]]
# 以下打印結果是省略版
print('a =',a)      #   a = 10      a = 10      a = [10, 20]
print('b =',b)      #   b = 20      b = [20, 30]        b = 30
print('c =',c)      #   c = [30, 40]        c = 40      c = 40

''' 遍歷、索引、切片、解包等方式在列表、字符串、元組中都是可以通用的，這些操作本質上都沒有對原來序列進行變更 '''
# 字符串的解包
a,b,*c='python'
print('a =',a)      #   a = p
print('b =',b)      #   b = y
print('c =',c)      #   c = ['t', 'h', 'o', 'n']

# 列表的解包
a,b,*c=[1,2,3,4,5,6,7,7]
# a,*b,*c=[1,2,3,4,5,6,7,7]    # 不能出現多個*  SyntaxError: two starred expressions in assignment
print('a =',a)      #   a = 1
print('b =',b)      #   b = 2
print('c =',c)      #   c = [3, 4, 5, 6, 7, 7]

2.字典簡介

2.1字典的基本介紹

• 字典屬於一種新的數據結構，被稱之爲映射（mapping）
• 字典的作用和列表類似，都是用來存儲對象的一種容器
• 列表對數據的存儲比較在好，但數據的查詢檢索則相對差一些，而字典正好與之相反
• 字典中的每一個元素都有一個唯一的名字，通過這個名字可以快速查找到指定元素
• 唯一的名字被稱之爲Key，通過key來查詢的值稱之爲Value，鍵值對（Key—Value）一項成爲Item

'''
創建字典{}
語法：{key:value，key:value,....}
創建字典dict()
語法：dict(key=value，key=value,....)
字典的value可以是任意的對象
字典的key是不可變的對象，如int、str、bool、tuple...
'''
d={}
print(d,type(d))  # {} <class 'dict'>

d={'name':'李雷','age':12,'sex':'男'}   # {'name': '李雷', 'age': 12, 'sex': '男'} <class 'dict'>
d=dict(name='李雷',age=12,sex='男')   # {'name': '李雷', 'age': 12, 'sex': '男'} <class 'dict'>
print(d,type(d))    

''' 字典的鍵是不能重複的，如果重複，後面的值會替換前面的值 '''
d={'name':'李雷','age':12,'sex':'男','name':'韓梅梅'}
print(d,type(d))    # {'name': '韓梅梅', 'age': 12, 'sex': '男'} <class 'dict'>

# 另一種書寫格式
header={
    'name':'李雷',
    'age':12,
    'sex':'男'
}

# 根據鍵key來獲取值value
print(d['name'],d['age'],d['sex']) 	# 韓梅梅 12 男

2.2字典的使用

# 創建字典

# # 使用dict()函數
# d=dict(name='李雷',age='15',sex='男')  # {'name': '李雷', 'age': '15', 'sex': '男'} <class 'dict'>
# print(d,type(d))

'''
dict（）函數通過雙值子序列創建字典
雙值序列：序列中有兩個元素[1,2]，(m,n)，'ab'
子序列：如果序列中的元素也是個序列，我們稱之爲子序列[(1,2),(3,4)]
'''

d=dict([('name','李雷'),('age','15')])    # {'name': '李雷', 'age': '15', 'sex': '男'} <class 'dict'>
print(d,type(d))

''' len（）獲取字典中鍵值對的個數 '''
print(len(d))   # 2

''' in/not in：檢查字典中是否 包含/不包含 指定的鍵 '''
print('name' in d)  # True
print('sex' not in d)  # True

''' 
通過鍵值來獲取字典中的對應Value值
d[key]
get(key[,default])當字典中不存在前面的key時，返回default的內容
'''
print(d['name'])   # 李雷
# print(d['sex'])     # KeyError: 'sex'當鍵值爲其他錯誤值時這種方式取值會直接拋出異常
# get(key[,default]) 該方法根據字典中key值獲取相應value值
# default爲第二個參數，當key值不存在時指定返回值
print(d.get('sex'))    # None 同過get方法獲取時，當鍵值錯誤會返回一個none，這樣就不會影響程序的運行啦
print(d.get('sex','字典中不存在sex這個key'))    # 字典中不存在sex這個key

''' 
修改字典：
=
setdefault()
update()
'''
# 通過賦值直接修改key——value
d['name']='超人'  # {'name': '超人', 'age': '15'}
# 通過賦值直接添加新的key——value
d['sex']='男'    # {'name': '超人', 'age': '15', 'sex': '男'}
# 通過setdefault方法添加新的key——value，如果key已經存在則不會對原值修改，而是返回原值
r=d.setdefault('name','死亡之神')   # 超人
# 通過update方法向一個字典中添加另一個字典（key-value）
# 如果key已經存在則對原值修改
# 如果value已經存在，並不影響修改key-value
d1={'a':1,'b':2,'c':3}
d2={'d':7,'e':8,'f':9}
# d1.update(d2)   #{'a': 1, 'b': 2, 'c': 3, 'd': 7, 'e': 8, 'f': 9}
d3={'b':7,'c':8,'f':9}
# d1.update(d3)   #{'a': 1, 'b': 7, 'c': 8, 'f': 9}
d4={'d':1,'e':2,'f':9}
# d1.update(d4)   #{'a': 1, 'b': 2, 'c': 3, 'd': 1, 'e': 2, 'f': 9}

'''
刪除
del通過鍵值刪除
popitem方法隨機刪除一個key-value，一般是最後一個
popitem方法有返回值，以元組形式返回刪除的key-value
pop根據一個key刪除一個key-value，有返回值（刪除的value）
pop(key[,default])當字典中不存在前面的key時，返回default的內容
'''
# del
# del d1['a']     # {'b': 2, 'c': 3}
# popitem
# r=d1.popitem()    # ('c', 3)
# pop
# r=d1.pop('b')   # 2
# r=d1.pop('f','字典中沒有這個鍵值對')    #字典中沒有這個鍵值對
# r=d1.pop('b','字典中沒有這個鍵值對')    # 2
print(r)

2.3 copy（）、淺複製

d1={'a':1,'b':2,'c':3}
'''
d2=d1,這種情況不屬於複製，而是變量賦值，對d2的修改直接修改d1
'''
d2=d1  # {'a': 1, 'b': 2, 'c': 3}
d2['a']=8
print('d2 =',d2)    # d2 = {'a': 8, 'b': 2, 'c': 3}
print('d1 =',d1)    # d1 = {'a': 8, 'b': 2, 'c': 3}

d1={'a':1,'b':2,'c':3}
'''
d2=d1.copy(),複製，對d2的修改不影響d1
'''
d2=d1.copy()
d2['a']=8
print('d2 =',d2)    # d2 = {'a': 8, 'b': 2, 'c': 3}
print('d1 =',d1)    # d1 = {'a': 1, 'b': 2, 'c': 3}

'''
淺複製，針對多層結構的字典而言，對內層的字典不屬於複製，新字典內層的修改也會對源字典內層修改
'''
d={'a':{'name':'李雷','age':15},'b':2,'c':3}
d3=d.copy()
d3['a']['sex']='男'
print('d3 =',d3)    # d3 = {'a': {'name': '李雷', 'age': 15, 'sex': '男'}, 'b': 2, 'c': 3}
print('d =',d)      # d = {'a': {'name': '李雷', 'age': 15, 'sex': '男'}, 'b': 2, 'c': 3}

3.遍歷字典

'''
遍歷方式
keys()返回字典所有的key值
values()返回字典所有的value值
items()返回所有的key-value值
'''
d={'name': '李雷', 'age': 12, 'sex': '男'}

# keys()
print(d.keys())   # dict_keys(['name', 'age', 'sex'])
for k in d.keys():
    print('k =', k)
    # 結果是：
    # k = name
    # k = age
    # k = sex
# values()
print(d.values())   # dict_values(['李雷', 12, '男'])
for v in d.values():
    print('v =', v)
    # 結果是:
    # v = 李雷
    # v = 12
    # v = 男
# items
print(d.items())    # dict_items([('name', '李雷'), ('age', 12), ('sex', '男')])
for t in d.items():
    print('t =', t)
    # 結果是:
    # t = ('name', '李雷')
    # t = ('age', 12)
    # t = ('sex', '男')
'''
關於items還可以換一種方法
這樣看起來就很不錯
'''
for k,v in d.items():
    print(k, '=', v)
    # 結果是：
    # name = 李雷
    # age = 12
    # sex = 男

4.集合set

4.1集合簡介

• 類似列表，但各方面和列表略有不同
• 集合中存儲的元素沒有固定順序，所以也沒法被直接訪問
• 集合中的元素也不可以由重複的，必須是唯一的，重複的會被刪掉
• 集合中的元素是不可變的？？？

'''
集合
無序而唯一
{x,y,z...}創建集合
set（[...]）將序列和字典轉換成集合
'''
# 同樣是{}，但是集合與列表不同
n={}
print(n,type(n))    # {} <class 'dict'>
s={1,2,3}
print(s,type(s))    # {1, 2, 3} <class 'set'>
b={'a':1,'b':2,'c':3}
print(b,type(b))    # {'a': 1, 'b': 2, 'c': 3} <class 'dict'>

# set()
'''
set將列表轉換爲集合
'''
s=set(['python'])
print(s,type(s))    # {'python'} <class 'set'>
'''
set將字典轉換爲集合時，取其key值，舍掉value值
'''
s=set({'a':1,'b':2,'c':3})
print(s,type(s))    # {'a', 'b', 'c'} <class 'set'>

# 集合的無序與排重性
s1={1,1,3,5,6,8,'a','k','e'}
print('s1 =',s1)    # s1 = {1, 3, 5, 6, 'k', 8, 'e', 'a'}

#集合轉化爲list
s2={'教皇','比比東','大師'}
print(s2,type(s2))  # {'比比東', '大師', '教皇'} <class 'set'>
L1=list(s2)
# d1=dict(s2)
print(L1,type(L1))  # ['大師', '比比東', '教皇'] <class 'list'>

# 不能直接訪問集合
# print(s2[1])    # TypeError: 'set' object does not support indexing
print(list(s2)[1])  # 比比東

• len（）、add（）、update（）、pop（）、remove（）、clear（）

s={'唐三','小舞','沐白','竹清'}
# in 、not in
print('a' in s) # False
print('a' not in s) # True
# len(),add(),update(),pop(),remove(),clear()
# len()獲取集合中元素個數
print(len(s)) # 4
# add()向集合中隨機位置添加元素
s.add('榮榮')
print(s)    # {'唐三', '小舞', '沐白', '榮榮', '竹清'}
# update() 將一個集合中的元素添加到另一個集合當中
s1={1,2,3,4}
s.update(s1)
print(s)    # {1, 2, '小舞', 3, 4, '竹清', '沐白', '唐三', '榮榮'}
# pop() 隨機刪除一個元素,會返回刪除的元素
a=s1.pop()
print(a)    # 1
print(s1)   # {2, 3, 4}
# remove() 刪除集合中的指定元素
b=s1.remove(3)
print(b)    # None 說明沒有返回值
print(s1)   # {2, 4}
# clear（）清空集合
s1.clear()
print(s1)   # set()

4.2集合運算

• 交集運算 &
• 並集運算 |
• 差集運算 -
• 亦或集 ^
• 檢查一個集合是否是另一個集合的子集 <=
• 檢查一個集合是否是另一個集合的真子集 <
• 檢查一個集合是否是另一個集合的超集 >=
• 檢查一個集合是否是另一個集合的真超集 >

'''
交集運算 &
並集運算 |
差集運算 -
亦或集  ^
檢查一個集合是否是另一個集合的子集   <=
檢查一個集合是否是另一個集合的真子集  <
檢查一個集合是否是另一個集合的超集  >=
檢查一個集合是否是另一個集合的真超集  >
'''
s1={1,2,3,4,5}
s2={3,4,5,6,7}
t={1, 2, 3, 4, 5, 6, 7}
# 交集運算 &
s=s1&s2
print(s)    # {3, 4, 5}
# 並集運算 |
s=s1|s2
print(s)    # {1, 2, 3, 4, 5, 6, 7}
# 差集運算 -
'''
值得注意的是差集求的是第一個集合中存在而第二個集合中不存在的
不是兩個集合中不同的元素
'''
a=s1-s2
b=s2-s1
print('s1-s2=',a)   # s1-s2= {1, 2}
print('s2-s1=',b)   # s2-s1= {6, 7}
# 亦或集  ^
'''
值得注意的是兩個集合的異或集求的是兩個集合中不同的元素
'''
c=s1^s2
d=s2^s1
print('s1^s2=',c)   # s1-s2= {1, 2}
print('s2^s1=',d)
# 檢查一個集合是否是另一個集合的子集   <=
print(1)if s1<=s else print(0) #1
print(1)if t<=s else print(0) #1
# 檢查一個集合是否是另一個集合的真子集  <
print(1)if s1<s else print(0) # 1
# 檢查一個集合是否是另一個集合的超集  >=
print(1)if s>=s1 else print(0) # 1
print(1)if t>=s else print(0) #1
# 檢查一個集合是否是另一個集合的真超集  >
print(1)if s>s1 else print(0) # 1