一、元组
什么是元组: 元组就是一个不可变的列表
======================================基本使用======================================
1、用途: 用于存放多个值,当存放的多个值只有读的需求没有改的需求时用元组最合适,这个时候使用元组比列表更节省内存空间,因为列表还要使用一部分内存来准备接接收新的值.
2、定义方式:在()内用逗号分隔开多个任意类型的值
t=(1,3.1,'aaa',(1,2,3),['a','b']) #在后台执行: t=tuple(...) 同样具有转换功能
print(type(t))
res=tuple('hello') 输出:('h', 'e', 'l', 'l', 'o')
res=tuple({'x':1,'y':2}) 输出:('x', 'y') 转换字典时只取key
print(res)3、常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
t=('a','b',1)
t[0]=111
2、切片(顾头不顾尾，步长)
t=('h','e','l','l','o')
res=t[1:3]
print(res) 输出:('e', 'l')
print(t) 输出:('h', 'e', 'l', 'l', 'o') 不会改变元组原来的值
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)
======================================该类型总结====================================
存多个值
有序不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
t=(1,'a',['x','y','z'])
print(id(t[2])) 输出:列表在元组中的id 1251157770568
print(id(t)) 输出:元组t的id 2393562071400
t[2][0]='X' 把元组中的列表中的索引值为0的'x'替换为"X"
print(t) 输出为:(1,'a',['X','y','z'])
print(id(t)) 输出:t的id 和之前输出的元组t的id一样 2393562071400 在这里元组
中的列表发生了变化但是元组的id没有变化,不能说明元组是可变类型,对
于元组来说,所含的元素还是一个int、一个float、一个list.可变是因
为列表是一个可变的数据类型
print(id(t[2])) 输出:列表的id 1251157770568
list1=['a','b','c']
print(id(list1[0])) 3177196097464
print(id(list1[1])) 3177196096064
print(id(list1[2])) 3177166902080
print(id(list1)) 3177197306184
print('='*50) ==================================================
list1[1]='B'
print(id(list1[0])) 3177196097464
print(id(list1[1])) 3177196424472
print(id(list1[2])) 3177166902080
print(id(list1)) 3177197306184
这几行代码说明列表中的值改变但是列表本身的内存地址并不会改变,因为列表是一个可变的数据类型
掌握的方法
t=('a','b','a')
print(t.index('a')) index寻找索引值找到a在元组中的索引值
t.index('xxx')
print(t.count('a')) 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) 输出:{'k1': 1, 'k2': 2, 'k3': 3}
其实上边字典的转换操作具体如下:
l=[('k1',1),('k2',2),('k3',3)]
d={} 首先创建一个空的字典d
for t in l: #t=('k1',1) 使用for循环将列表l中的元组取出来赋值给t
k,v=t 使用解压赋值将元组中的值分别赋给k和v
# print(k,v)
d[k]=v 将字典中的key赋值
print(d) 打印填充好的字典 {'k1': 1, 'k2': 2, 'k3': 3}
d=dict(l) 上边的操作可以一步实现
print(d) {'k1': 1, 'k2': 2, 'k3': 3}
d=dict(x=1,y=2,z=3)
print(d) {'x': 1, 'y': 2, 'z': 3}
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() 因为字典时无序的所以popitem取值时为随机取值
print(res)
5、键keys()，值values()，键值对items()
d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
# print(d.keys()) 取出字典d中的所有key使用一个内存地址存起来(相对于python2节省了内存空间,在python2中会吧每一个值都使用 一个内存地址存起来老母鸡) dict_keys(['name', 'age', 'sex', 'hobbies']) (相当于一个迭代器)
print(list(d.keys())) ['name', 'age', 'sex', 'hobbies'] (列表的转换功能)
# print(d.values()) 取出字典d中所有的value并使用一个内存地址存起来 dict_values(['egon', 18, 'male', [1, 2, 3]])
print(list(d.values())) ['egon', 18, 'male', [1, 2, 3]]
# print(d.items()) 取出字典中所有的键值对并使用一个内存地址存起来
dict_items([('name', 'egon'), ('age', 18), ('sex', 'male'), ('hobbies', [1, 2, 3])])
print(list(d.items())) [('name', 'egon'), ('age', 18), ('sex', 'male'), ('hobbies', [1, 2, 3])]
6、循环
for k in d.keys(): 经过.keys取出key之后可以直接使用for循环把值取出来
print(k)
for k in d: 直接将d写上去时,for循环默认取字典中的key
print(k)
for v in d.values():
print(v)
for k,v in d.items(): #k,v=('name', 'egon')
print(k,v)
======================================该类型总结====================================
存多个值
无序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash
需要掌握的操作
get方法 用于取值,当输入的key不存在时,不会报错,会给返回值:None
d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
v=d.get('namexxxxxxx')
print(v)
v1=d['namexxxxxxxxxxx']
print(v1) 直接取值时,如果输入的key不存在程序会报错,并终止运行
update方法 以更新的值为标准,如果key之前存在但是key的值和要跟新的value不一样,以新的value为准尽心更新,如果之前不存在, 将新的键值对添加进去作为一个新元素
d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
d.update({'x':1,'name':"EGON"})
print(d) {'name': 'EGON', 'age': 18, 'sex': 'male', 'hobbies': [1, 2, 3], 'x': 1}
fromkeys:需求是快速新造出一个字典,value的初始值全都为None(初始值根据具体需求设定),而key是来自于一个列表
keys=['name','age','sex']
fromkeys原理
d={}
for k in keys:
d[k]=None
print(d) {'name': None, 'age': None, 'sex': None}
d={}.fromkeys(keys,None)
print(d) {'name': None, 'age': None, 'sex': None}
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中每个单词出现的次数,并做成字典
s='hello alex alex say hello sb sb'
d={'hello':2,'alex':2,'say':1,'sb':2}
d={} 创建一个空列表
words=s.split() 将字符串以空格为切分标志且分为多个字符并赋值给words
print(words) #words=['hello', 'alex', 'alex', 'say', 'hello', 'sb', 'sb']
for word in words: #word= 'alex' 使用for循环将words中的值分别取出来放到word中
d[word]=words.count(word) #d['alex']=words.count('alex')使用count计数
d.setdefault(word,words.count(word)) 将每个单词以及对应的value添加到空字典d中
d={'hello':2,'alex':2}
print(d) 最后进行输出:{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}补充元组符号
t=(1,) 元组中只有单个值时,一定要使用()
print(t,type(t))
三、集合
pythons=['agon','张铁蛋','李铜蛋','赵银弹','王金蛋','艾里克斯']
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'}
s.add(2)
print(s) {1, 2, 'aa', 1.3}
s={1,1,1,1,1,1,1,2} #s=set(....)set同样具有转换功能
print(type(s))
print(s)
d={'x':1,'x':2,'x':3}
print(d) {'x': 3} 字典中也不能重复赋值
res=set('hello') 输出为:{'l', 'o', 'e', 'h'} 集合是无序的
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课程的学生姓名:
求差集
求差集的时候减号左右两边的位置是有区别的(A-B)表示在A中去掉AB的交集部分
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) True
s5={1,2,3}
s6={1,2,3}
print(s5 >= s6) True
print(s6 >= s5) True
集合的第二大用途:去重
集合去重的局限性:
1. 会打乱原值的顺序
2. 只能针对不可变的值去重
stus=['egon','lxx','lxx','alex','alex','yxx']
new_l=list(set(stus))
print(new_l) ['yxx', 'lxx', 'egon', 'alex'] (可见转换成集合时会自动去重,但是顺序会打乱)
old_l=[1,[1,2],[1,2]]
set(old_l) 程序会报错,只能针对不可变的类型去重,而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中
new_l.append(dic) 如果不在将其使用,append命令添加到列表new_l中
print(new_l) [{'name': 'egon', 'age': 18, 'sex': 'male'}, {'name': 'alex', 'age': 73, 'sex': 'male'}, {'name': 'egon', 'age': 20, 'sex': 'female'}]
需要掌握的操作:
s1={1,2,3}
s1.update({3,4,5}) update更新值,和字典中用法一样,不在赘述
print(s1)
print(s1.pop()) pop取值,因为集合是无序的,所以使用.pop取值时也是随机取值的
print(s1)
s1.remove(2) remove命令来删除集合中的值,当删除集合中没有的值时一样会报错
print(s1)
s1={1,2,3}
print(id(s1)) 2297489841736
s1.add(4)
print(s1) {1, 2, 3, 4}
print(id(s1)) 2297489841736 (证明集合是一个可变的数据类型)
s1={1,2,3}
s1.discard(4) .discard删除命令,如果删除的值在集合中不存在,程序不会报错,但是也不会给返回值
s1.remove(4) remove删除命令,如果删除的值在集合中不村子啊,程序会报错,并终止运行
print(s1)
s1={1,2,3} .isdisjiont判断命令.用来判断两个集合是否完全没有交集,是的话判定结果为True.否的话哦安定结果为False
s2={4,5}
print(s1.isdisjoint(s2))
总结
存多个值
无序
set可变
到今天为止,python中所有的基础数据类型就全部介绍完了,接下来会介绍字符编码,文件处理,面向编程等等