今日內容:

1.元組

2.字典

3.集合

4.數據類型總結.

一 元組

什麽是元組:元組就是一個不可變的數列

1 用途:用於存放多個值,當存放的多個值只有讀的需求沒有改的需求最合適,

2 定義方式:在()用逗號分隔開的多個任意類型的值.

t=(‘aaa‘,‘bbb‘,123,,(1,2,3),[‘a‘,‘b‘])#tuple=(....)

res=tuple(‘hello‘)

res=tuple({‘x‘:1,‘y‘:2)

print(res)#=>(‘x‘,‘y‘)

3 常用操作+內置方法

優先掌握的操作:

1 索引取值(正向取+反向取):只能取:

t=(‘a‘,‘b‘,1)

t[0]=111

print(111,‘b‘,1)

2 切片(顧頭不顧尾,步長)

t=(‘h‘,‘e‘,‘1‘,‘1‘,‘o‘)

res=t[1:3]

print=(res)#=>(‘e‘,‘1‘ )

3 長度

t=(‘h‘,‘e‘,‘l‘,‘l‘,‘o‘)

print(len(t))#=>5

4 成員運算in和not in

t=(‘h‘,‘e‘,‘l‘,‘l‘,‘o‘)

print(‘h‘ in t)

5、循環

t=(‘h‘,‘e‘,‘l‘,‘l‘,‘o‘)
for item in t:
print(item)

　　該類型總結
存多個值

有序

不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）
t=(1,‘a‘,[‘x‘,‘y‘,‘z‘])
print(id(t[2]))

print(id(t))
t[2][0]=‘X‘
print(t)
print(id(t))

print(id(t[2]))

list1=[‘a‘,‘b‘,‘c‘]
print(id(list1[0]))
print(id(list1[1]))
print(id(list1[2]))

print(‘=‘*50)
list1[1]=‘B‘
print(id(list1[0]))
print(id(list1[1]))
print(id(list1[2]))

掌握的方法
t=(‘a‘,‘b‘,‘a‘)
print(t.index(‘a‘))
t.index(‘xxx‘)
print(t.count(‘a‘))

二 字典

　　基本使用
1、用途: 用來存方多個(不同種類的)值

2、定義方式: 在{}內用逗號分隔開多個key:value的元素,其中value可以是任意數據類型,而key的功能通常是用來
描述value的,所以key通常是字符串類型,但其實key必須是不可變的類型(int\float\str\tuple)
d={0:‘x‘,1.3:‘y‘,‘k1‘:‘z‘,(1,2,3):‘aaa‘} # d=dict(....)
print(d[(1, 2, 3)])
d1={[1,2,3]:‘aaaaa‘}

d=dict([(‘k1‘,1),(‘k2‘,2),(‘k3‘,3)])
print(d)

l=[(‘k1‘,1),(‘k2‘,2),(‘k3‘,3)]
d={}
for t in l: #t=(‘k1‘,1)
k,v=t
print(k,v)
d[k]=v
print(d)

d=dict(l)
print(d)

d=dict(x=1,y=2,z=3)
print(d)

3、常用操作+內置的方法
優先掌握的操作：
1、按key存取值：可存可取
d={‘x‘:1}
print(d[‘x‘])
print(id(d))
d[‘x‘]=1111
print(d)
print(id(d))
d[‘y‘]=2222
print(d)

2、長度len
d={‘x‘:1,‘y‘:2,‘z‘:3}
print(len(d))

3、成員運算in和not in
d={‘x‘:1,‘y‘:2,‘z‘:3}
print(1 in d)
print(‘x ‘ in d)

4、刪除
d={‘x‘:1,‘y‘:2,‘z‘:3}
del d[‘y‘]
print(d)

res=d.pop(‘y‘)
print(d)
print(res)

res=d.popitem()
print(res)

5、鍵keys()，值values()，鍵值對items()
d={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘,‘hobbies‘:[1,2,3]}
print(d.keys())
print(list(d.keys()))

print(d.values())
print(list(d.values()))
print(d.items())
print(list(d.items()))

6、循環

for k in d.keys():
print(k)
for k in d:
print(k)

for v in d.values():
print(v)

for k,v in d.items(): #k,v=(‘name‘, ‘egon‘)
print(k,v)

　　該類型總結
1 存多個值

2 無序

3 可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash

需要掌握的操作
get方法
d={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘,‘hobbies‘:[1,2,3]}
v=d.get(‘namexxxxxxx‘)
print(v)

v1=d[‘namexxxxxxxxxxx‘]
print(v1)

update方法
d={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘,‘hobbies‘:[1,2,3]}
d.update({‘x‘:1,‘name‘:"EGON"})
print(d)# fromkeys:需求是快速新造出一個字典,value的初始值全都為None,而key是來自於一個列表

keys=[‘name‘,‘age‘,‘sex‘]
d={}
for k in keys:
d[k]=None

d={}.fromkeys(keys,None)
print(d)

setdefault
d={"x":1,"y":2}

按照默認的操作形式
d[‘x‘]=1111 # key存在則修改
d[‘z‘]=1111 #key不存在則新增

按照setdefault的形式
d={"x":1,"y":2}
res=d.setdefault(‘x‘,11111) # 在key存在的情況下不修改值,會返回原值
print(d)
print(res)

res=d.setdefault(‘z‘,11111) # 在key不存在的情況下會新增值,會返回新增的值
print(d)
print(res)

練習
s=‘hello alex alex say hello sb sb‘

d={‘hello‘:2,‘alex‘:2,‘say‘:1,‘sb‘:2}

d={}
words=s.split()
print(words) #words=[‘hello‘, ‘alex‘, ‘alex‘, ‘say‘, ‘hello‘, ‘sb‘, ‘sb‘]
for word in words: #word= ‘alex‘
d[word]=words.count(word) #d[‘alex‘]=words.count(‘alex‘)
d.setdefault(word,words.count(word))
d={‘hello‘:2,‘alex‘:2}

print(d)

# pythons=[‘egon‘,‘張鐵蛋‘,‘李銅蛋‘,‘趙銀彈‘,‘王金蛋‘,‘艾裏克斯‘]
# linuxs=[‘歐德博愛‘,‘李銅蛋‘,‘艾裏克斯‘,‘lsb‘,‘ysb‘,‘wsb‘]
# l=[]
#
# for stu in pythons:
# if stu in linuxs:
# l.append(stu)
# print(l)

‘‘‘
1. 什麽是集合
在{}內用逗號分隔開多個值,集合的特點:
1. 每個值必須是不可變類型
2. 集合無序
3. 集合內元素不能重復

2. 為何要用集合
1. 用於做關系運算
2. 去重

3. 如何用集合

‘‘‘
s={1,1.3,‘aa‘,[1,2,]}
s={1,1.3,‘aa‘}
print(s)

s={1,1,1,1,1,1,1,2} #s=set(....)

print(type(s))

print(s)

d={‘x‘:1,‘x‘:2,‘x‘:3}

print(d)

res=set(‘hello‘)
res=set([1,2,[‘a‘,‘b‘]])
print(res)

集合的第一大用途: 關系運算
pythons={‘egon‘,‘張鐵蛋‘,‘李銅蛋‘,‘趙銀彈‘,‘王金蛋‘,‘艾裏克斯‘}
linuxs={‘歐德博愛‘,‘李銅蛋‘,‘艾裏克斯‘,‘lsb‘,‘ysb‘,‘wsb‘}

1 求同時報名兩門課程的學生姓名:交集
print(pythons & linuxs)
print(pythons.intersection(linuxs))

pythons=pythons & linuxs
print(pythons) #{‘李銅蛋‘, ‘艾裏克斯‘}
pythons.intersection_update(linuxs) #pythons=pythons.intersection(linuxs)
print(pythons) #{‘艾裏克斯‘, ‘李銅蛋‘}

2 求報名老男孩學校課程的所有學生姓名:並集
print(pythons | linuxs)
print(pythons.union(linuxs))

3 求只報名python課程的學生姓名: 差集
print(pythons - linuxs)
print(pythons.difference(linuxs))
print(linuxs - pythons) #求只報名linux課程的學生姓名
print(linuxs.difference(pythons))

4 求沒有同時報名兩門課程的學生姓名: 對稱差集
print((pythons - linuxs) | (linuxs - pythons))
# print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

5 父子集:指的是一種包含與被包含的關系
s1={1,2,3}
s2={1,2}
print(s1 >= s2)
print(s1.issuperset(s2))
print(s2.issubset(s1))

情況一:
print(s1 > s2) #>號代表s1是包含s2的,稱之為s1為s2的父集
print(s2 < s1)

情況二:
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) #s1如果等於s2,也可以稱為s1是s2的父集合

綜上:
s1 >= s2 就可以稱為s1是s2的父集

s3={1,2,3}
s4={3,2,1}
print(s3 == s4)

s5={1,2,3}
s6={1,2,3}
print(s5 >= s6)
print(s6 >= s5)

集合的第二大用途:去重
集合去重的局限性:
1. 會打亂原值的順序
2. 只能針對不可變的值去重

stus=[‘egon‘,‘lxx‘,‘lxx‘,‘alex‘,‘alex‘,‘yxx‘]
new_l=list(set(stus))
print(new_l)

old_l=[1,[1,2],[1,2]]
set(old_l)

l=[
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:20,‘sex‘:‘female‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)

需要掌握的操作:

s1={1,2,3}
s1.update({3,4,5})
print(s1)
print(s1.pop())
print(s1)

s1.remove(2)
print(s1)

s1={1,2,3}
print(id(s1))
s1.add(4)
print(s1)
print(id(s1))

s1={1,2,3}
s1.discard(4)
s1.remove(4)

print(s1)

s1={1,2,3}

s2={4,5}

print(s1.isdisjoint(s2))

總結
存多個值
無序
set可變

作業一

1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，將所有大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中

即： {‘k1‘: 大於66的所有值, ‘k2‘: 小於66的所有值}

list1=[11,22,33,44,55,66,77,88,99,90]
dic={}
list2=[]
list3=[]
for i in list1:
    if i>66:
        list2.append(i)
    else:
        list3.append(i)
dic[‘k1‘]=list2
dic[‘k2‘]=list3
print(dic)

2 統計s=‘hello alex alex say hello sb sb‘中每個單詞的個數

s=‘hello alex alex say hello sb sb‘
dic={}
res={}
for word in s.split():
    dic.setdefault(word,s.count(word))
print(dic)
練習二:

　一.關系運算
　　有如下兩個集合，pythons是報名python課程的學員名字集合，linuxs是報名linux課程的學員名字集合
　　pythons={‘alex‘,‘egon‘,‘yuanhao‘,‘wupeiqi‘,‘gangdan‘,‘biubiu‘}
　　linuxs={‘wupeiqi‘,‘oldboy‘,‘gangdan‘}
　　1. 求出即報名python又報名linux課程的學員名字集合

print(pythons & linuxs)
 　2. 求出所有報名的學生名字集合

print(pythons|linuxs)

 　3. 求出只報名python課程的學員名

print(pythons-linuxs)

 　4. 求出沒有同時這兩門課程的學員名字集合

print(pythons^linuxs)

‘二.去重

　　 1. 有列表l=[‘a‘,‘b‘,1,‘a‘,‘a‘]，列表元素均為可hash類型，去重，得到新列表,且新列表無需保持列
表原來的順序

l=[‘a‘,‘b‘,1,‘a‘,‘a‘]
l_new=set(l)
print(l_new)

　　 2.在上題的基礎上，保存列表原來的順序

for i in l:

　　if i in l_new:

　　　　print(i)

　　 3.去除文件中重復的行，肯定要保持文件內容的順序不變
l=[‘a‘,‘b‘,1,‘a‘,‘a‘]
l1=[]
for i in l:
if i not in l1:
l1.append(i)
print(l1)
　　 4.有如下列表，列表元素為不可hash類型，去重，得到新列表，且新列表一定要保持列表原來的順序

l=[
    {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
    {‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘},
    {‘name‘:‘egon‘,‘age‘:20,‘sex‘:‘female‘},
    {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
    {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
]
l_new=[]
for i in l:
    if i not in l_new:
        l_new.append(i)
print(l_new)

第五天 數據類型(下)