字典类型
一：基本使用
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)