字典，元组，集合类型

Posted 2020-11-11 wanglecn

字典类型

一：基本使用
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)