一.元祖类型 (tuple)
1.什么是元祖?
用途:用于存放多个值,当存放的多个值只有读的需求没有改变的需求时,用元祖最合适.
定义方式:在()内用逗号分隔开的多个任意类型的值
t=(1,3,1,'aaa',(1,2,3),['a','b']) #= tuple
res=tuple('hello')
res=tuple({'x':1,'y':2})
print(res)
2.常用的操作内置方法.
优先掌握的操作:
1.按索引的方式取值,(正向取,反向取都可以,但是只能去不能存.)
t=('a','b',1)
t[0]=111
2.切片(顾头不顾尾,步长)
t=('h','e','l','l','o')
res=t[1:3]
print(res)
print(t)
3.长度
t=('h','e','l','l','o')
print(len(t))
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)
该类型总结.
可以存多个值,是有序的, 是不可变类型.(但是元祖里面有列表的情况下,可以改变列表.)
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]))
需要掌握的方法
t=('a','b','a')
print(t.index('a'))
t.index('xxx')
print(t.count('a'))
可以运算一下有几个a
元祖符号
name=input('>>:').strip()
print(('my name is %s'%name).center(50,'*'))
center 代表可以在一行代码里补充入多少个字符,数字是整个长度有多少
二.字典类型 (dict)
用途:用来存多个(不同种类的值)
1.定义方式:在{}内用逗号分隔开多个Key:value的元素,其中value可以是任意的数据类型,而Key的功能通常是用来描述value的,
所以Key通常是字符串类型,但其实Key必须是不可变的类型(intfloatstr uple)
d={0:'x',1.3:'y','K1':'z',(1,2,3):'aaa'} #d=dict(...)
print(d[(1,2,3)])
d1
{[1,2,3]:'aaaa'}
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)
2.常用的操作+内置的方法
优先掌握的操作:
1.按Key存取值,可存可取
d={'x':1}
print(d['x'])
print(id(d))
d['x']=1111
print(d)
print(id(d))
d['y']=2222
print(d)
3.长度
d={'x':1,'y':2,'z':3}
print(len(d)) (可以查看字典的长度)
4.成员运算in和not in
d={'x':1,'y':2,'z':3}
print(1 in d) True
print('x ' in d) True
5.删除
d={'x':1,'y':2,'z':3}
del d['y']
print(d) (del直接删除)
d={'x':1,'y':2,'z':3}
res=d.pop('y')
print(d)
print(res) (pop可以在后面按索引删除)
6.键Keys(),值value(),键值一起是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()))
7.循环的使用
d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
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)
该类型的总结:
存在多个值, 是无序的 可变的.
需要掌握的操作.
get的方法
d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
v=d.get('namexxxxxxx')
print(v)
输出结果为: none
get可以随意的取值,还不会报错.
update的方法
d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
d.update({'x':1,'name':"EGON"})
print(d)
update更新的意思,如果没有想要更新的item就可以直接加进去,如果有了.就更新.
fromkeys:需求是快速的新造出一个字典,value的初始值为None.而Key是来自于一个列表
keys=['name','age','sex']
d={}.fromkeys(keys,None)
print(d)
setdefault 在Key存在的情况下不会修改值,会返回原值 在Key不存在的情况下会新增值,会返回新增的值.
d={"x":1,"y":2}
res=d.setdefault('x',11111)
print(d)
print(res)
d={"x":1,"y":2}
res=d.setdefault('z',11111)
print(d)
print(res)
三.集合类型 (set)
1.什么是集合
在{}内用逗号分隔开多个值,集合的特点:
1.每个值必须是不可变类型.
2.集合是无序的.
3.集合内元素不能重复
2.为何要用集合:
1.用作关系运算.
2.去重
3.如何去用集合
集合的第一大用途,关系运算!
pythons={'egon','张铁蛋','李铜蛋','赵银弹','王金蛋','艾里克斯'}
linuxs={'欧德博爱','李铜蛋','艾里克斯','lsb','ysb','wsb'}
1 求同时报名两门课程的学生姓名:交集
print(pythons & linuxs) (简单的逻辑运算符号)
print(pythons.intersection(linuxs)) (属于内置的方法不建议用)
2.求报名老男孩学校课程的所有学生姓名:并集
print(pythons | linuxs) (同上)
print(pythons.union(linuxs))
3 求只报名python课程的学生姓名: 差集
print(pythons - linuxs) (把一起上了两门课程的同学排除)
print(pythons.difference(linuxs))
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) (一样的结果,互为父集.互为子集)
2.集合的第二大用途:去重
集合去重的局限性:
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)
(不可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'},
]
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)
pop在集合里不能索引删除,
s1.remove(2)
print(s1)
remove可以在集合里随便删除,后面加上想删除的字符.
s1={1,2,3}
print(id(s1))
s1.add(4)
print(s1)
print(id(s1))
add可以随便的添加字符,但是有了同样字符的话就不添加,没有影响.
s1={1,2,3}
s1.discard(4)
print(s1)
discard可以随意的删除字符,没有这个字符也没影响.
s1={1,2,3}
s2={4,5}
print(s1.isdisjoint(s2))
isdisjoinnt:判断两个两个集合是否完全不相交.
总结:
集合存在多个值,是无序的.属于可变类型.