首页 > 代码库 > 数据类型总结（二）（列表，元组，字典）
数据类型总结（二）（列表，元组，字典）
一.变量的赋值操作
x=1 a=10 b=10 # #链式赋值 a=b=c=d=e=f=10 print(a,b,c,d,e,f) #多元赋值 #方式一 x=1 y=2 z=x #z=1 x=y #x=2 y=z #y=1 print(x,y) #方式二：python特有 x,y=y,x print(x,y) #增量赋值 x=10 x+=1 #x=x+1 print(x) #解压序列类型 s=‘hello‘ a=s[0] b=s[1] c=s[2] d=s[3] e=s[4] print(a,b,c,d,e) a,b,c,d,e=s print(a,b,c,d,e) a,_,_,_,e=‘alexs‘ print(a,e) print(_) a,*_,e=‘alexs‘ print(a,e) m,n,*_=‘alexs‘ print(m,n) *_,m,n=‘alexs‘ print(m,n)
二.列表
定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特性：
1.可存放多个值
2.可修改指定索引位置对应的值，可变
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
用途（存多个值，可以修改）：爱好，装备，女朋友们
hobby=[‘play‘,‘eat‘,‘sleep‘]
方法：
hobby.append
hobby.remove
操作：
查看：
>>> girls=[‘alex‘,‘wsb‘,[‘egon‘,‘ysb‘]]
>>> girls[2]
[‘egon‘, ‘ysb‘]
>>> girls[2][0]
增加
girls.append(元素)
删除
girls.remove(元素)
del girls[元素的索引]
修改
girls[0]=‘alexSB‘
#定义列表 # l=[1,‘a‘,[3,4]] #l=list([1,‘a‘,[3,4]]) #取值 # print(l[0]) # print(l[2][0]) # # l=[1,2,[[‘a‘,‘b‘],‘c‘]] # print(l[2][0][1]) #循环 l=[1,2,3,[4,5]] # count=0 # while count < len(l): # print(l[count]) # count+=1 # for count in range(len(l)): # print(l[count]) # l=[1,2,3,[4,5]] # for count in range(len(l)): # if type(l[count]) is list: # #pass # for i in range(len(l[count])): # print(l[count][i]) # else: # print(l[count]) # l=[1,2,3,[4,5]] # l_size=len(l) # for index in range(l_size): # value=http://www.mamicode.com/l[index] # if type(value) is list: # #value是列表,value=http://www.mamicode.com/[4,5] # for i in range(len(value)): # print(value[i]) # else: # #value不是列表，直接打印 # print(value) # # print(‘没有修改之前的列表：‘,id(l),type(l),l) # #id不动，type也不动，value被修改了，则称为可变类型 #可变指的是：在id和type不动的前提下，值可变 # print(l[0]) # print(l[2][1]) # l[0]=11111111111111111 # print(l) # print(‘修改之后的列表：‘,id(l),type(l),l) #列表常用操作 # 索引 # 切片 # l=[‘ab‘,1,2,‘hello‘] # print(l[1:3]) #切片操作是读操作，并不会修改原来的数据 # print(l) # 追加 # l=[‘ab‘,1,2,‘hello‘] # print(l) # l.append(‘alex‘) # l.append(‘alex1‘) # l.append(‘alex2‘) # l.append(‘alex3‘) # print(l) # 插入 # l.insert(0,‘first‘) # print(l) # l.insert(2,‘abc‘) # print(l) # 删除 # l=[‘a‘,‘b‘,‘c‘,‘hello‘] # print(l) # l.pop(1) # print(l) # l.pop() # l.pop() # l.pop(0) # l.pop(0) # print(‘刚刚删除的元素是‘,l.pop(0)) # # print(l) #队列：先进先出 l=[] #append与pop(0) #入队列 # l.append(‘people1‘) # l.append(‘people2‘) # l.append(‘people3‘) # print(l) #出队列 # print(l.pop(0)) # print(l.pop(0)) # print(l.pop(0)) #insert(0,item) #入队 l.insert(0,‘people1‘) l.insert(0,‘people2‘) l.insert(0,‘people3‘) # print(l) #出队 # print(l.pop()) # print(l) # print(l.pop()) # print(l) # print(l.pop()) #堆栈：先进后出,或者说后进的先出 #append与 # l=[] # l.append(‘people1‘) # l.append(‘people2‘) # l.append(‘people3‘) # print(l) # print(l.pop()) # print(l.pop()) # print(l.pop()) # 长度 l=[1,2,3] # print(len(l)) # 切片 # 循环 # 包含 # s=‘alex is sb‘ # print(‘sb‘ in s) # # names=[‘alex‘,‘egon‘,‘yuanhao‘] # print(‘yuanhao‘ in names) #列表的其他操作 l=list([‘a1‘,‘a2‘,‘a3‘]) # print(l) # print(l.index(‘a2‘)) # # l.append(‘a2‘) # print(l.count(‘a2‘)) # print(l) # l.extend([1,2,3]) # l.append([1,2,3]) # print(l) # print(l) # l.remove(‘a2‘) # l=[‘a1‘,‘a2‘,‘a1‘,‘a1‘,‘a3‘] # l.remove(‘a1‘) # print(l) # l=[2,3,1] # l.sort(reverse=True) # print(l) # l=[‘a‘,‘c‘,‘alex‘] # l.reverse() # print(l)
# l=[1,2,3] #l=list([1,2,3]) # print(type(l)) #pat1===》优先掌握部分 # 索引 # # 切片 l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘] # print(l[1:5]) # print(l[1:5:2]) # print(l[2:5]) # print(l[-1]) #了解 # print(l[-1:-4]) # print(l[-4:]) # l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘] # print(l[-2:]) # 追加 # hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # hobbies.append(‘girls‘) # print(hobbies) # 删除 hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # x=hobbies.pop(1) #不是单纯的删除，是删除并且把删除的元素返回，我们可以用一个变量名去接收该返回值 # print(x) # print(hobbies) # x=hobbies.pop(0) # print(x) # # x=hobbies.pop(0) # print(x) #队列：先进先出 queue_l=[] #入队 # queue_l.append(‘first‘) # queue_l.append(‘second‘) # queue_l.append(‘third‘) # print(queue_l) #出队 # print(queue_l.pop(0)) # print(queue_l.pop(0)) # print(queue_l.pop(0)) #堆栈:先进后出，后进先出 # l=[] # #入栈 # l.append(‘first‘) # l.append(‘second‘) # l.append(‘third‘) # #出栈 # print(l) # print(l.pop()) # print(l.pop()) # print(l.pop()) #了解 # del hobbies[1] #单纯的删除 # hobbies.remove(‘eat‘) #单纯的删除，并且是指定元素去删除 # 长度 # hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # print(len(hobbies)) # 包含in # hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # print(‘sleep‘ in hobbies) # msg=‘hello world egon‘ # print(‘egon‘ in msg) ##pat2===》掌握部分 hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘,‘eat‘,‘eat‘] # hobbies.insert(1,‘walk‘) # hobbies.insert(1,[‘walk1‘,‘walk2‘,‘walk3‘]) # print(hobbies) # print(hobbies.count(‘eat‘)) # print(hobbies) # hobbies.extend([‘walk1‘,‘walk2‘,‘walk3‘]) # print(hobbies) hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘,‘eat‘,‘eat‘] # print(hobbies.index(‘eat‘)) #pat3===》了解部分 hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘,‘eat‘,‘eat‘] # hobbies.clear() # print(hobbies) # l=hobbies.copy() # print(l) # l=[1,2,3,4,5] # l.reverse() # print(l) l=[100,9,-2,11,32] l.sort(reverse=True) print(l)
三.元组
作用：存多个值，对比列表来说，元组不可变，主要是用来读
定义：与列表类型，只不过[]换成()
可以当做字典的key
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))
常用操作：
索引
切片
循环
长度
包含in
#为何要有元组，存放多个值，元组不可变，更多的是用来做查询 t=(1,[1,3],‘sss‘,(1,2)) #t=tuple((1,[1,3],‘sss‘,(1,2))) # print(type(t)) # #元组可以作为字典的key # d={(1,2,3):‘egon‘} # print(d,type(d),d[(1,2,3)]) # 索引 # # 切片 # goods=(‘iphone‘,‘lenovo‘,‘sanxing‘,‘suoyi‘) # print(goods[1:3]) # # 长度 # #in: #字符串:子字符串 #列表：元素 #元组：元素 #字典：key # goods=(‘iphone‘,‘lenovo‘,‘sanxing‘,‘suoyi‘) # print(‘iphone‘ in goods) # d={‘a‘:1,‘b‘:2,‘c‘:3} # print(‘b‘ in d) #掌握 # goods=(‘iphone‘,‘lenovo‘,‘sanxing‘,‘suoyi‘) # print(goods.index(‘iphone‘)) # print(goods.count(‘iphone‘)) #补充：元组本身是不可变的，但是内部的元素可以是可变类型 t=(1,[‘a‘,‘b‘],‘sss‘,(1,2)) #t=tuple((1,[1,3],‘sss‘,(1,2))) # t[1][0]=‘A‘ # print(t) # t[1]=‘aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa‘ #元组的元素可以是任意数据类型 t=(‘a‘,1,‘b‘,1,(3,4)) # print(id(t),type(t),t) #元组的特性是：不可变 #取值 # print(t[4][0]) #循环 t=(‘a‘,1,‘b‘,1,(3,4)) # index=0 # while index < len(t): # print(t[index]) # index+=1 # for i in range(len(t)): # print(t[i]) #tuple类型的方法 # print(t.count(1)) # print(t.index(‘b‘)) #tuple常用操作 # 索引 # 切片 # t=(‘a‘,1,‘b‘,1,(3,4)) # print(t[1:3]) # print(t) # 循环 # 长度 # print(len(t)) # 包含 # # print(‘a‘ in t) #元组的特性是：不可变,元组的元素可以是任意数据类型 # t=(1,2,[‘a‘,‘b‘]) # print(id(t),type(t),t) # t[2][0]=‘aaaaaaa‘ # print(t) # print(id(t),type(t),t) # t[2]=3 # t[2][0]=123123123123 #评论 # comments=[(‘真傻比‘,),(‘确实傻逼‘,)] # print(comments) # # comments.pop(0) # comments[0]=‘真牛逼‘ # print(comments)
四.字典
用途：存多个值，这一点与列表相同，值可以是任意数据类型
特征：每一个值都一个唯一个对应关系，即key，强调一点，key必须是
不可变类型：字符串，数字
student_info={
‘age‘:81,
‘name‘:‘alex‘,
‘sex‘:None,
‘hobbies‘:[‘zsb0‘,‘zsb1‘,‘zsb2‘,‘zsb30‘]
}
操作：
查看
>>> student_info={
... ‘age‘:81,
... ‘name‘:‘alex‘,
... ‘sex‘:None,
... ‘hobbies‘:[‘zsb0‘,‘zsb1‘,‘zsb2‘,‘zsb30‘]
... }
>>>
>>> student_info[‘age‘]
81
>>> student_info[‘hobbies‘]
[‘zsb0‘, ‘zsb1‘, ‘zsb2‘, ‘zsb30‘]
>>> student_info[‘hobbies‘][2]
‘zsb2‘
增加
student_info[‘stu_id‘]=123456
删除
del student_info[‘stu_id‘]
修改
student_info[‘name‘]=‘alexSB‘
#字典的常用方法 d={‘x‘:1,} # d.clear() # print(d) # print(d[‘x‘]) # print(d[‘y‘]) # print(d.get(‘y‘)) # print(d.get(‘y‘,‘找不到的啦‘)) # print(d.get(‘x‘,‘找不到的啦‘)) d={‘x‘:1,‘y‘:1} # print(d.items()) # for item in d.items(): #[(‘x‘, 1), (‘y‘, 1)] # print(item) # for k,v in d.items(): #[(‘x‘, 1), (‘y‘, 1)] # print(k,v) # d={‘x‘:1,‘y‘:1} # print(d.keys()) # for i in d.keys(): # print(i) # for i in d: # print(i) d={‘x‘:1,‘y‘:1} # print(d.keys(),type(d.keys())) # # res=list(d.keys()) # print(res,type(res)) d={‘x‘:1,‘y‘:12222} # print(d.values()) # print(list(d.values())) # print(list(d.values())[1]) # res=d.pop(‘y‘) # print(res) # # print(d) # d={‘x‘:1,‘y‘:12222} # print(d.pop(‘z‘,‘没有的啦‘)) # # d={‘x‘:1,‘y‘:12222} # print(d.popitem()) # print(d) # d={‘x‘:1,‘y‘:12222} # # # d.setdefault(‘z‘,3) # # print(d) # # # d[‘name‘]=‘egon‘ # # print(d) # # d={‘x‘:1,‘y‘:12222} # print(d.setdefault(‘x‘,3333333333333333333333333333)) # print(d) # d1={} # d2=dict() # print(d1,d2) # # d3=dict(x=1,y=2,z=3) # print(d3) # # # d4=dict({‘x‘:1,‘y‘:2,‘z‘:3}) # print(d4) # # # # d5=dict([(‘x‘,1),(‘y‘,2),(‘z‘,3)]) # print(d5) # # # d6={}.fromkeys([‘name‘,‘age‘],None) # print(d6) # # d7={}.fromkeys([‘name‘,‘age‘],[‘egon‘,18]) # print(d7) # # d={‘name‘:‘alex‘,‘sex‘:‘male‘} # # d1={‘name‘:‘alexsb‘,‘age‘:50} # d.update(d1) # print(d) #新增 d={} d[‘x‘]=1 print(d) # 删除 # d.pop(‘x‘) # d.popitem() # 键、值、键值对 # d.keys() # d.values() # d.items() # 循环 # 长度 # # d={‘x‘:1,‘u‘:2} # print(len(d)) # #成员运算 # d={‘x‘:1,‘u‘:2} # # print(‘x‘ in d) # print(1 in d.values())
#字典定义的基本形式：key:value # d={‘name‘:‘egon‘,‘age‘:18} #d=dict({‘name‘:‘egon‘,‘age‘:18}) # # print(id(d),type(d),d) #定义字典需要注意的问题：key必须是不可变类型，或者说是可hash类型 # print(hash(1)) # print(hash(‘xxxxxx‘)) # print(hash((1,2,3))) # print(hash({‘a‘:1})) d={1:‘id‘,‘a‘:1,‘b‘:2,‘name‘:‘egon‘,(1,2):‘aaaaaaaa‘} #字典的取值,字典是无序的 # print(d[1]) # print(d[‘name‘]) # print(d[(1,2)]) # d={‘name‘:‘alex‘,‘age‘:18} # print(d[‘name‘]) # d[‘name‘]=‘aaaaasb‘ # print(d) #循环 d={‘name‘:‘alex‘,‘age‘:18,‘sex‘:‘male‘,‘height‘:130,‘weight‘:200} # print(d.keys()) # print(d.values()) # print(type(d.keys())) # for k in d: # print(k,d[k]) # l=[1,2,3] # for i in l: # print(i) # t=(1,2,3) # for i in t: # print(i) # s=‘hello‘ # for i in s: # print(i) ‘‘‘ 一：可变不可变 可变：列表，字典 不可变：数字，字符串，元组 二：存放值的个数 一个值：数字，字符串 多个值(容器类型)：列表，元组，字典 三：取值方式 直接取值：数字 序列类型：字符串，元组，列表 映射类型：字典 ‘‘‘ #字典的嵌套使用 # d={‘a‘:1} # print(d[‘b‘]) # print(d.get(‘a‘)) # user_info=[ # {‘username‘:‘egon‘,‘password‘:‘123‘}, # {‘username‘:‘alex‘,‘password‘:‘alex3714‘}, # {‘username‘:‘yuanhao‘,‘password‘:‘sb123‘}, # ] # for item in user_info: # print(item[‘username‘],item[‘password‘]) # tag=True # while tag: # user=input(‘u>>: ‘) # pwd=input(‘p>>: ‘) # for item in user_info: # if user == item[‘username‘] and pwd ==item[‘password‘]: # print(‘login ok‘) # tag=False # break # user_info=[ # {‘username‘:‘egon‘,‘password‘:‘123‘}, # {‘username‘:‘alex‘,‘password‘:‘alex3714‘}, # {‘username‘:‘yuanhao‘,‘password‘:‘sb123‘}, # ] user_dic={ ‘egon‘:‘123‘, ‘alex‘:‘alex3714‘, ‘yuanhao‘:‘sb123‘ } # print(‘egon‘ in user_dic) while True: user=input(‘u>>: ‘) pwd=input(‘p>>: ‘) if user in user_dic: if pwd == user_dic[user]: print(‘login ok‘) break # if user == ‘egon‘ and pwd == ‘123‘: # print(‘login ok‘) # break
练习
1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。（2分）
即： {‘k1‘: 大于66的所有值, ‘k2‘: 小于66的所有值}
a={‘k1‘:[],‘k2‘:[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
if i>66:
a[‘k1‘].append(i)
else:
a[‘k2‘].append(i)
print(a)
2 统计s=‘hello alex alex say hello sb sb‘中每个单词的个数
结果如：{‘hello‘: 2, ‘alex‘: 2, ‘say‘: 1, ‘sb‘: 2}
s=‘hello alex alex say hello sb sb‘ l=s.split() dic={} for item in l: if item in dic: dic[item]+=1 else: dic[item]=1 print(dic)
s=‘hello alex alex say hello sb sb‘ dic={} words=s.split() print(words) for word in words: #word=‘alex‘ dic[word]=s.count(word) print(dic) #利用setdefault解决重复赋值 ‘‘‘ setdefault的功能 1：key存在，则不赋值，key不存在则设置默认值 2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值 d={} print(d.setdefault(‘a‘,1)) #返回1 d={‘a‘:2222} print(d.setdefault(‘a‘,1)) #返回2222 ‘‘‘ s=‘hello alex alex say hello sb sb‘ dic={} words=s.split() for word in words: #word=‘alex‘ dic.setdefault(word,s.count(word)) print(dic) #利用集合，去掉重复，减少循环次数 s=‘hello alex alex say hello sb sb‘ dic={} words=s.split() words_set=set(words) for word in words_set: dic[word]=s.count(word) print(dic)
五.集合
作用：去重，关系运算，
知识点回顾
可变类型是不可hash类型 不可变类型是可hash类型
定义集合:
集合：可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2:没有重复的元素
3：无序 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
常用方法：
in 和 not in
|合集
&交集
-差集
^对称差集
==
>，>= ，<,<= 父集，子集
练习：
一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={‘alex‘,‘egon‘,‘yuanhao‘,‘wupeiqi‘,‘gangdan‘,‘biubiu‘}
linuxs={‘wupeiqi‘,‘oldboy‘,‘gangdan‘}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 pythons={‘alex‘,‘egon‘,‘yuanhao‘,‘wupeiqi‘,‘gangdan‘,‘biubiu‘} linuxs={‘wupeiqi‘,‘oldboy‘,‘gangdan‘} # 求出即报名python又报名linux课程的学员名字集合 print(pythons & linuxs) # 求出所有报名的学生名字集合 print(pythons | linuxs) # 求出只报名python课程的学员名字 print(pythons - linuxs) # 求出没有同时这两门课程的学员名字集合 print(pythons ^ linuxs)
二.去重
1. 有列表l=[‘a‘,‘b‘,1,‘a‘,‘a‘]，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
2.在上题的基础上，保存列表原来的顺序
3.去除文件中重复的行，肯定要保持文件内容的顺序不变
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=[‘a‘,‘b‘,1,‘a‘,‘a‘] print(set(l)) #去重,并保持原来的顺序 #方法一:不用集合 l=[1,‘a‘,‘b‘,1,‘a‘] l1=[] for i in l: if i not in l1: l1.append(i) print(l1) #方法二:借助集合 l1=[] s=set() for i in l: if i not in s: s.add(i) l1.append(i) print(l1) #同上方法二,去除文件中重复的行 import os with open(‘db.txt‘,‘r‘,encoding=‘utf-8‘) as read_f, open(‘.db.txt.swap‘,‘w‘,encoding=‘utf-8‘) as write_f: s=set() for line in read_f: if line not in s: s.add(line) write_f.write(line) os.remove(‘db.txt‘) os.rename(‘.db.txt.swap‘,‘db.txt‘) #列表中元素为可变类型时,去重,并且保持原来顺序 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‘}, ] # print(set(l)) #报错:unhashable type: ‘dict‘ s=set() l1=[] for item in l: val=(item[‘name‘],item[‘age‘],item[‘sex‘]) if val not in s: s.add(val) l1.append(item) print(l1) #定义函数,既可以针对可以hash类型又可以针对不可hash类型 def func(items,key=None): s=set() for item in items: val=item if key is None else key(item) if val not in s: s.add(val) yield item print(list(func(l,key=lambda dic:(dic[‘name‘],dic[‘age‘],dic[‘sex‘]))))
数据类型总结（二）（列表，元组，字典）
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。