数据类型总结(二)(列表,元组,字典)
一.变量的赋值操作
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'
列表的拼接:
#1.用list的extend方法,L1.extend(L2),该方法将参数L2的全部元素添加到L1的尾部,例如:
L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1.extend(L2)
print(L1) #[1, 2, 3, 4, 5, 20, 30, 40]
#2.用切片(slice)操作,L1[len(L1):len(L1)] = L2和上面的方法等价,例如:
L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[len(L1):len(L1)] = L2
print(L1) #[1, 2, 3, 4, 5, 20, 30, 40]
#但切片方法用起来更灵活,可以插入到头部,或其他任意部位,例如:
加到开头:
L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[0:0] = L2
print(L1) #[20, 30, 40, 1, 2, 3, 4, 5]
#3加到中间:
L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[1:1] = L2
print(L1) #[1, 20, 30, 40, 2, 3, 4, 5]
#定义列表
# 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=l[index]
# if type(value) is list:
# #value是列表,value=[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']))))
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法
- Elasticsearch:Index alias
- 编程神器来了!写代码、搜问题,全部都在「终端」完成!是时候入手了
- Array - 238. Product of Array Except Self
- Array - 209. Minimum Size Subarray Sum
- Array - 334. Increasing Triplet Subsequence
- Array - 123. Best Time to Buy and Sell Stock III
- Array - 122. Best Time to Buy and Sell Stock II
- Array - 121. Best Time to Buy and Sell Stock
- Array - 220. Contains Duplicate III
- Array - 219. Contains Duplicate II
- Array - 217. Contains Duplicate
- Array - 299. Bulls and Cows
- Array - 189. Rotate Array
- Array - 277 Find the Celebrity
- Array - 80. Remove Duplicates from Sorted Array II