字典，元組，集合類型
字典類型
一：基本使用
1 用途：用來存多個值，但每一個值都有一個key與之對應，key對值有描述性的功能
當存儲多個值表示的不同的狀態時，
2 定義方式:{}內用逗號分隔開多個元素，每一個元素都是key：value的形式
value可以是任意數據類型，但是key必須為不可變類型，key通常應該是字符串類型，
d={‘x‘:1,‘y‘:2} #d=dict({‘x‘:1,‘y‘:2})
d=dict(a=1,b=2,c=3)
print(d)
dic={1:‘a‘,0:‘b‘,1.1:‘c‘,(1,2,3):‘d‘}
print(dic[1])
print(dic[0])
print(dic[1.1])
print(dic[(1,2,3)])
dic={[1,2,3]:‘a‘}
dic={{‘x‘:1}:‘a‘}
3 常用操作+內置的方法
優先掌握的操作：
1、按key存取值：可存可取
d={‘x‘:1,‘y‘:2}
d[‘x‘]=100
print(d)
d[‘z‘]=3
print(d)
l=[‘a‘,‘b‘]
l[2]=‘c‘
2、長度len
d={‘x‘:1,‘y‘:2}
print(len(d))
3、成員運算in和not in
d={‘x‘:1,‘y‘:2}
print(‘x‘ in d)
4、刪除
d={‘x‘:1,‘y‘:2}
del d[‘x‘]
print(d)
res=d.pop(‘y‘)
print(d)
print(res)
res=d.popitem()
print(d)
print(res)
d={‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
for k in d:
print(k)
l=[1,2,3]
del l[1]
print(l)
5、鍵keys()，值values()，鍵值對items()
msg_dic={
‘apple‘:10,
‘tesla‘:100000,
‘mac‘:3000,
‘lenovo‘:30000,
‘chicken‘:10,
}
names=[]
for k in msg_dic:
names.append(k)
print(names)
values=[]
for k in msg_dic:
values.append(msg_dic[k])
print(values)
keys=msg_dic.keys()
print(keys)
for k in keys:
print(k)=
l=list(keys)
print(l)
vals=msg_dic.values()
print(vals)
print(list(vals))
print(msg_dic.items())
print(list(msg_dic.items()))
6、循環
msg_dic={
‘apple‘:10,
‘tesla‘:100000,
‘mac‘:3000,
‘lenovo‘:30000,
‘chicken‘:10,
}
只取key
for k in msg_dic:
print(k,msg_dic[k])
for k in msg_dic.keys():
print(k,msg_dic[k])
只取value
for v in msg_dic.values():
print(v)
取key和value
for k,v in msg_dic.items(): #k,v=(‘apple‘, 10)
print(k,v)
需要掌握的內置方法（****）
d={‘x‘:1,‘y‘:2,‘z‘:3}
v=d.get(‘xxxx‘)
print(v)
print(d[‘xxxxxxx‘])
d={‘x‘:1,‘y‘:2,‘z‘:3}
d1={‘a‘:1,‘x‘:1111111}
d.update(d1)
print(d)
l=[‘name‘,‘age‘,‘sex‘]
d={}
for k in l:
d[k]=None
d=dict.fromkeys(l,None)
print(d)
info.setdefault
info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}
如果字典中有setdefault指定的key，那麽不改該key對應的值，返回原的value
res=info.setdefault(‘name‘,‘EGON_NB‘)
print(info)
print(res)
如果字典中沒有setdefault指定的key，那麽增加一個key:value,返回新的value
info.setdefault(‘height‘,1.80)
print(info)
info={‘age‘:18,‘sex‘:‘male‘}
v=info.setdefault(‘name‘,‘浩哥‘)
print(v)
s=‘hello alex alex say hello sb sb‘
l=s.split()
print(l)
d={}
for word in l: #word= ‘hello‘
if word not in d:
d[word]=1 #{‘hello‘:2, ‘alex‘:2,‘say‘:1}
else:
d[word]+=1
print(d)
s=‘hello alex alex say hello sb sb‘
l=s.split()
print(l)
d={}
d={‘hello‘:2,‘alex‘:2}
for word in l: #word=‘alex‘
d[word]=l.count(word) #d[‘alex‘]=2
d.setdefault(word,l.count(word))
print(d)
#二：該類型總結
1 存一個值or存多個值
可以存多個值，值都可以是任意類型，而key必須是不可變類型，通常應該是不可變類型中字符串類型
2 有序or無序
無序
3 可變or不可變
d={‘x‘:1,‘y‘:2}
print(id(d))
d[‘x‘]=1111
print(id(d))
d=123
元組類型
一：基本使用
1 用途：元組是不可變的列表，能存多個值，但多個值只有取的需求，而沒有改的需求，那麽用元合最合理
2 定義方式:在()內用逗號分割開，可以存放任意類型的值
names=(‘alex‘,‘egon‘,‘wxx‘) #names=tuple((‘alex‘,‘egon‘,‘wxx‘))
print(type(names))
強調: 當元組內只有一個元素時，務必記住加一個逗號
x=(‘egon‘,)
print(type(x))
3 常用操作+內置的方法
1、按索引取值(正向取+反向取)：只能取
names=(‘alex‘,‘egon‘,‘wxx‘)
names[0]=‘sb‘
2、切片(顧頭不顧尾，步長)
names=(‘alex‘,‘egon‘,‘wxx‘,‘lxx‘,‘cxxx‘)
print(names[1:3]
)
3、長度
names=(‘alex‘,‘egon‘,‘wxx‘,‘lxx‘,‘cxxx‘)
print(len(names))
4、成員運算in和not in
names=(‘alex‘,‘egon‘,‘wxx‘,‘lxx‘,‘cxxx‘)
print(‘alex‘ in names)
5、循環
names=(‘alex‘,‘egon‘,‘wxx‘,‘lxx‘,‘cxxx‘)
for item in names:
print(item)
二：該類型總結
1 存一個值or存多個值
可以存多個值，值都可以是任意數據類型
2 有序or無序
有序
3 可變or不可變
不可變
names=(‘alex‘,‘egon‘,‘wxx‘,‘lxx‘,‘cxxx‘,‘lxx‘)
del names[0]
names[0]=‘sb‘
print(names.count(‘lxx‘))
print(names.index(‘wxx‘,0,3))
names=(‘alex‘,‘egon‘,‘wxx‘,‘lxx‘,‘cxxx‘,‘lxx‘)
names=1
l=[1,243,3]
l=3333
l=[‘a‘,‘b‘,‘c‘]
print(id(l[0]))
l[0]=‘A‘
print(id(l[0]))
names=(‘a‘,‘b‘,‘c‘)
列表可變的底層原理：
指的是索引所對應的值的內存地址是可以改變的
元組不可變的底層原理：
指的是索引所對應的值的內存地址是不可以改變的
或者反過來說，只要索引對應值的內存地址沒有改變，那麽元組始終是沒有改變的
t1=([‘a‘,‘b‘,‘c‘],‘wc‘,‘office‘)
print(id(t1[0]))
print(id(t1[1]))
print(id(t1[2]))
t1[0][0]=‘AAAA‘
print(t1)
print(id(t1[0]))
集合類型
一：基本使用
1 用途: 關系運算、去重
2 定義方式:{}內用逗號分隔開多個元素，每一個元素都必須是不可變（即可hash）類型
強調：
2.1 集合內元素都必須是不可變（即可hash）類型
2.2 集合內的元素無序
2.3 集合內的元素不能重復
s={1,2,‘a‘} #s=set({1,2,‘a‘})
print(type(s))
s={1.1,1,‘aa‘,(1,2,3),{‘a‘:1}}
s={1,‘a‘,‘hello‘,(1,2,3),4}
for item in s:
print(item)
s={1,1,1,1,1,1,1,1,1,‘a‘,‘b‘,‘a‘}
s={(1,2,3),(1,2,3),‘a‘,‘b‘,‘a‘}
print(s)
s=set(‘hello‘)
print(s)
單純的用集合去重，需要註意的問題是
1、去重的目標所包含的值必須都為不可變類型
2、去重的結果會打亂原來的順序
names=[‘asb‘,‘asb‘,‘asb‘,‘wsb‘,‘wsb‘,‘egon_nb‘,[1,2,3]]
s=set(names)
names=list(s)
print(names)
3 常用操作+內置的方法
優先掌握的操作：
1、長度len
pythoners={‘王大炮‘,‘李二丫‘,‘陳獨秀‘,‘艾裏克斯‘,‘wxx‘,‘歐德博愛‘}
print(len(pythoners))
2、成員運算in和not in
print(‘李二丫‘ in pythoners)
pythoners={‘王大炮‘,‘李二丫‘,‘陳獨秀‘,‘艾裏克斯‘,‘wxx‘,‘歐德博愛‘}
linuxers={‘陳獨秀‘,‘wxx‘,‘egon‘,‘張全蛋‘}
3、|並集
print(pythoners | linuxers)
print(pythoners.union(linuxers))
4、&交集
print(pythoners & linuxers)
print(pythoners.intersection(linuxers))
print(linuxers & pythoners)
5、-差集
print(pythoners - linuxers)
print(pythoners.difference(linuxers))
print(linuxers - pythoners)
print(linuxers.difference(pythoners))
6、^對稱差集
print(pythoners ^ linuxers)
print(pythoners.symmetric_difference(linuxers))
print(linuxers ^ pythoners)
7、==
s1={1,2,3}
s2={1,2,3}
print(s1 == s2)
8、父集(包含關系)：>,>=
s1={1,2,3,4,5}
s2={1,2,3}
print(s1 > s2) # s1包含s2
print(s1.issuperset(s2))
print(s2.issubset(s1))
s3={1,2,10}
print(s1 > s3)
s1={1,2,3,4,5}
s2={1,2,3,4,5}
print(s1 >= s2)
9、子集(被包含的關系)：<,<=
1={1,2,3,4,5}
s1.add(6)
print(s1)
s1.update({4,7,8,9})
print(s1)
res=s1.pop()
print(res)
res=s1.remove(4)
print(res)
print(s1)
s1={1,2,3,4,5}
s2={2,3,7,8}
s1=s1 - s2
print(s1)
s1.difference_update(s2) # s1=s1 - s2
print(s1)
s1={1,2,3,4,5}
s1.pop()
s1.remove(7)
s1.discard(7) # 即便要刪除的元素不存在也不會報錯
s1={1,2,3,4,5}
s2={5,6,7,8}
print(s1.isdisjoint(s2))
二：該類型總結
1 存一個值or存多個值
可以存多個值，值都必須為不可變類型
2 有序or無序
無序
3 可變or不可變
set集合是可變類型
s={1,2,3}
print(id(s))
s.add(4)
print(s)
print(id(s))
=====================集合的去重==========================
單純的用集合去重，需要註意的問題是
1、去重的目標所包含的值必須都為不可變類型
2、去重的結果會打亂原來的順序
names=[‘asb‘,‘asb‘,‘asb‘,‘wsb‘,‘wsb‘,‘egon_nb‘,[1,2,3]]
s=set(names)
names=list(s)
print(names)
stu_info=[
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘},
{‘name‘:‘oldboy‘,‘age‘:84,‘sex‘:‘female‘},
]
new_info=[]
for info in stu_info:
if info not in new_info:
new_info.append(info)
print(new_info)
字典，元組，集合類型