目录
前言:
本篇文章主要讲解Python数据容器的基础,适合刚开始学习python的朋友,也可作为一篇对数据容器相关知识的复习,建议读者依据目录,结合自身需求进行学习。新手小白案例练习部分一定要自己动手敲一遍再看答案!
数据容器简介:
在Python中,数据容器是用于存储和组织数据的结构,主要分为:列表(list),元组(tuple),字符串(string) ,集合(set),字典(dict)。
下面对各个数据容器逐一介绍。
一、list(列表)
列表特点:
1、列表存储的元素类型不受限制,甚至可以是列表类型
2、列表有序存储(有下标索引)
3、允许重复数据存在
4、可以修改
列表定义:
使用[ ],如下定义方式。
1、定义有元素的列表
[元素1,元素2,元素3,-------]
变量名称= [元素1,元素2,元素3,-------]
2、定义空列表
变量名称=[]
变量名称=list()
代码演示:
my_list=[123,"你好",[1,2,3]]
print(my_list)
print(type(my_list))
运行结果:
列表的下标索引:
和C语言的数组下标索引相同,列表下标索引从0开始(从左向右),在Python中,有反向索引,即从最后一个元素-1开始(从右向左),如下代码取列表中的元素。(注意:索引不要超出范围)
my_list=[123,"你好",[1,2,3]]
print(my_list)
print(type(my_list))
print(my_list[-1]) # 输出结果为[1,2,3]
print(my_list[2][0]) # 输出结果为1
列表的常用方法:
首先简单介绍一个概念,方法,在Python中,如果将函数定义为class类的成员,那么函数会称之为方法。
代码具体演示列表的常用方法:
my_list=[123,"你好",[1,2,3]]
# 查找指定元素在列表中的索引
index=my_list.index("你好")
print(index) # 输出结果为1
# 修改特定下标元素
my_list[0]=456
print(my_list) # 输出结果为[456, '你好', [1, 2, 3]]
# 在指定索引处插入
my_list.insert(1,"hello")
print(my_list) # 输出结果为 [456, 'hello', '你好', [1, 2, 3]]
#单个元素尾部追加
my_list.append('666')
print(my_list) # 输出结果为[456, 'hello', '你好', [1, 2, 3], '666']
# 多个元素追加,将另一个列表全部内容追加到该列表尾部
my_list1=[1,2,3]
my_list2=[4,5,6]
my_list1.extend(my_list2)
print(my_list1) # 输出结果为[1, 2, 3, 4, 5, 6]
# 删除
# 1、直接将列表中该元素删除
my_list=[123,"你好",[1,2,3],"你好"]
del my_list[0] # 注意写法
print(my_list) # 输出结果为['你好', [1, 2, 3]]
# 2、将该元素从列表中取出(返回该元素值)并将其从列表中删除
my_list=[123,"你好",[1,2,3],"你好"]
element =my_list.pop(0)
print(element) # 输出结果为123
print(my_list) # 输出结果为['你好', [1, 2, 3],'你好']
# 3、找到第一个符合删除信息的元素删除
my_list=[123,"你好",[1,2,3],"你好"]
my_list.remove("你好")
print(my_list) # 输出结果为[123, [1, 2, 3], '你好']
# 清空列表
my_list.clear()
# 统计列表中某个元素的数量
my_list=[123,"你好",[1,2,3],"你好"]
count= my_list.count("你好")
print(count) # 输出结果为2
# 统计列表中所有元素的数量(列表长度)
my_list=[123,"你好",[1,2,3],"你好"]
count=len(my_list)
print(count) # 输出结果为4
列表案例练习:
定义一个学生年龄列表students_age=[21,25,21,23,22,20,],对其进行以下操作。
代码:
students_age=[21,25,21,23,22,20,]
#追加单个元素
students_age.append(31)
print(students_age)
#追加列表
new_studens_age=[29,33,30]
students_age.extend(new_studens_age)
print(students_age)
# 取第一个元素
print(students_age[0])
# 取最后一个元素
print(students_age[-1])
# 查找元素31的索引下标
index=students_age.index(31)
print(index)
运行结果:
列表的遍历:
1、while循环遍历
my_list3=[1,2,4,2,4,5]
i=0
while i<len(my_list3):
element = my_list3[i]
print(element)
i+=1
2、for循环遍历
my_list3=[1,2,4,2,4,5]
for x in my_list3:
print(x)
列表遍历练习
通过while循环和for循环取出列表中的偶数并存入另一个列表
while 循环代码:
datas=[1,2,3,4,5,6,7,8,9,10]
new_datas=[]
i=0
while i<len(datas):
if datas[i]%2==0:
new_datas.append(datas[i])
i+=1
print(f"通过while循环,从列表{datas}中取出偶数,组成新列表:{new_datas}")
for循环代码:
datas=[1,2,3,4,5,6,7,8,9,10]
new_datas=[]
for x in datas:
if x%2==0:
new_datas.append(x)
print(f"通过for循环,从列表{datas}中取出偶数,组成新列表:{new_datas}")
运行结果:
二、tuple(元组)
元组特点:
1、不可修改(修改会直接报错)
其他特点和列表特点相同
元组定义:
使用(),如下定义方式。
1、定义有元素的元组
(元素1,元素2,元素3,-------)
变量名称= (元素1,元素2,元素3,-------)
2、定义空元组
变量名称=()
变量名称=tuple()
注意:定义单个元素时,需要在后面加上逗号,否则会被视为字符串,如下代码:
t1=("hello")
print(type(t1))
t2=("hello",)
print(type(t2))
运行结果:
元组同样和列表具有相同的下标索引,由于元组元素不可修改,故其操作相对列表较少,基本的查找,计数等方法和列表相同,这里不再过多演示。
元组嵌套列表:
元组中嵌套列表可以对列表中内容进行修改,如下代码。
t3=("hello",["itcast","world"])
t3[1][0]="你好"
print(t3) # 输出结果为('hello', ['你好', 'world'])
元组案例练习:
定义一个元组,内容为:('张三',23,['basketball','muisic']),通过元组对其进行操作,如下代码:
person=('张三',23,['basketball','muisic'])
# 查询年龄下标
index=person.index(23)
print(index)
# 查询人名
name=person[0]
print(name)
# 删除篮球爱好
del person[2][0]
print(person)
# 增加爱好coding到爱好list中
person[2].insert(0, 'coding')
# 注意不要写成person.insert[2][0],会报错显示元组没有该操作方法,理解为我们要先取出列表再进行操作。
print(person)
运行结果:
三、string(字符串)
字符串特点:
1、可存放任意数量的字符
2、支持下标索引访问
字符串常用方法:
代码具体演示字符串的常用方法:
同样字符串可以进行查询遍历等操作,和前面一样不再做演示
下面展示一些其他方法
# 修改字符串指定的所有内容,注意replace方法是返回一个新的字符串
str1="hello world my name is sandy"
str2=str1.replace("world","school")
print(f"{str1} 被修改后,字符串为 {str2}")
# 输出结果为 hello world my name is sandy 被修改后,字符串为 hello school my name is sandy
# 切分字符串,同样不会对原字符串进行修改
str1="hello world my name is sandy"
list1=str1.split(" ") # 按照空格切分
print(f"{str1} 被切分后,得到列表{list1}") # 切分后得到的是列表
# 输出结果为 hello world my name is sandy 被切分后,得到 ['hello', 'world', 'my', 'name', 'is', 'sandy']
# 字符串规整操作
str=" hello sandy "
str1=str.strip()# 默认去除首尾空格
print(str1) # 输出结果为 hello sandy
str="12hello world21"
str2=str.strip("12")# 注意这里将12换为单个字符,只要满足12中的一个就被删除
print(str2) # 输出结果为 hello world
字符串案例练习:
对字符串"itheima itcast boxuegu"进行如下操作。
str="itheima itcast boxuegu"
# 统计it个数
num=str.count("it")
print(num)
# 将空格替换为"|"
str1=str.replace(" ","|")
print(str1)
# 按照|对字符串分割得到列表
list1=str1.split("|")
print(list1)
运行结果:
四、序列:
序列简介:
在 Python 中,序列不是指一个单独的数据容器,而是指一类内容连续,有序(可使用下标索引)的一类数据容器的统称。常见的 Python 序列类型即前文介绍到的列表(List)、元组(Tuple)和字符串(String)。
序列切片操作:
切片,即从一个序列中,取出一个子序列。
语法:序列[起始下标:结束下标:步长],注意为冒号,下标包左不包右,步长为N,即每跳过N-1个取,省略起始下标和结束下标,默认全部取完
序列切片案例练习:
使用学过的任何方式,用字符串"万过薪月,烂敲盘键,员序程个一是我" 得到“程序员”字符串。
燃烧吧大脑!
str="万过薪月,烂敲盘键,员序程个一是我"
# 法一:从后向前直接取
str1=str[-5:-8:-1]
print(str1)
# 法二: 先对字符串整体反转再切片取出
str2=str[::-1]
str3=str2[4:7]
str4=str[::-1][4:7] # 或者前面两行代码合并为一行代码
print(str3)
print(str4)
# 法三: 先切片取出再对字符串反转
str5=str[10:13:][::-1]
print(str5)
# 法四: 先按照逗号分割成列表再从列表中取出来再反转
str="万过薪月,烂敲盘键,员序程个一是我"
str6=str.split(",")[2].replace("我是一个","")[::-1]
print(str6)
五、set(集合):
集合特点:
1、不支持元素重复
2、内部无序(不支持下标访问)
集合常用方法:
代码具体演示集合的常用方法:
my_set={1,2,2,2,3,4,5,6,3}
print(my_set)
# 添加元素
my_set.add(1) # 无法添加已经存在的元素
print(my_set) # 输出结果{1,2,3,4,5,6}
my_set.add(7) # 可以添加不存在的元素
print(my_set) # 输出结果{1,2,3,4,5,6,7}
# 随机取出一个元素
element=my_set.pop()
print(element) # 输出结果1
# 求两个集合的差集
set1={1,2,3}
set2={2,3,4}
set3=set1.difference(set2)
print(set3) # 输出结果{1}
# 消除差集
set1={1,2,3}
set2={2,3,4}
set1.difference_update(set2)
print(set1) # 输出结果{1}
# 合并
set1={1,2,3}
set2={2,3,4}
set4=set1.union(set2)
print(set4) # 输出结果{1, 2, 3, 4}
# 集合遍历不支持while循环,但支持for循环
set1={1,2,3}
for element in set1:
print(element) # 输出结果 1 2 3(竖向)
六、dict(字典):
字典特点:
1、可以通过key取出value,但没有下标索引。
2、值不可重复。
3、字典的key和value 可以是任意数据类型(但key不能为字典,字典可以嵌套)。
字典定义:
字典定义和集合一样使用{},不过字典里面储存的是一个个的键值对,如下语法:
1、定义有元素的字典
{key:value,key:value,key:value,key:value}
变量名称 = {key:value,key:value,key:value,key:value}
2、定义空字典
变量名称 = {}
变量名称 = dict()
代码演示:
# 定义重复元素的字典
my_dict1={"张三":99,"张三":88,"王五":87,"赵四":77,}
print(my_dict1) # 输出结果遵循覆盖原则{'张三': 88, '王五': 87, '赵四': 77}
# 定义空字典
my_dict2={}
my_dict3=dict()
字典嵌套演示:
# 定义
students_scores={
"张三":{
"语文":88, # 别忘了逗号
"数学":92,
"英语":76
},"李四":{
"语文":83,
"数学":96,
"英语":90
},"王五":{
"语文":88,
"数学":96,
"英语":77
}
}
print(students_scores)
# 输出结果(一行)
# {'张三': {'语文': 88, '数学': 92, '英语': 76},
# '李四': {'语文': 83, '数学': 96, '英语': 90},
# '王五': {'语文': 88, '数学': 96, '英语': 77}}
# 获取信息
num=students_scores["张三"]["语文"]
print(num) # 输出结果88
字典的常用方法:
代码具体演示字典的常用方法:
# 定义字典
my_dict1={"张三":88,"王五":87,"赵四":77}
# 字典内容获取
score=my_dict1["张三"]
print(score) # 输出结果88
# 更新元素
my_dict1['王五']=97
print(my_dict1) # 输出结果为{'张三': 88, '王五': 97, '赵四': 77}
# 添加元素
my_dict1['周八']=88
print(my_dict1) # 输出结果为{'张三': 88, '王五': 97, '赵四': 77, '周八': 88}
# 删除元素
score=my_dict1.pop('赵四')
print(my_dict1) # 输出结果为{'张三': 88, '王五': 97, '周八': 88}
# 清空元素
my_dict1.clear()
print(my_dict1) # 输出结果为{}
# 获取全部的key
my_dict1={"张三":88,"王五":87,"赵四":77}
keys=my_dict1.keys()
print(keys) # 输出结果为dict_keys(['张三', '王五', '赵四'])
# 遍历字典
my_dict1={"张三":88,"王五":87,"赵四":77}
for key in keys:
print(f"{key}:{my_dict1[key]} ",end='') # 输出结果为张三:88 王五:87 赵四:77
# 统计字典元素数量:
my_dict1 = {"张三": 88, "王五": 87, "赵四": 77}
num= len(my_dict1)
print(num) # 输出结果为3
补充对应嵌套字典的遍历:
students_scores = {
"张三": {
"语文": 88,
"数学": 92,
"英语": 76
},
"李四": {
"语文": 83,
"数学": 96,
"英语": 90
},
"王五": {
"语文": 88,
"数学": 96,
"英语": 77
}
}
# 内容获取
zhangsan_scores = students_scores["张三"]
print("张三的成绩:", zhangsan_scores) # 输出张三的成绩字典
# 更新
students_scores["张三"]["语文"] = 90
print("更新后张三的语文成绩:", students_scores["张三"]["语文"]) # 输出更新后的成绩
# 增添
students_scores["赵六"] = {
"语文": 85,
"数学": 90,
"英语": 88
}
print("增添赵六后的字典:", students_scores) # 输出增添后的字典
# 删除
del students_scores["李四"]
print("删除李四后的字典:", students_scores) # 输出删除后的字典
# 清空
students_scores.clear()
print("清空后的字典:", students_scores) # 输出清空后的空字典
# 遍历
for student, scores in students_scores.items():
for subject, score in scores.items():
print(f"{student}在{subject}的分数是{score}")
字典操作案例练习:
代码演示:
info_dict={
'王力鸿':{
'部门':'科技部',
'工资':3000,
'级别':1
},
'周杰轮':{
'部门':'市场部',
'工资':5000,
'级别':2
},
'林俊节':{
'部门':'市场部',
'工资':7000,
'级别':3
},
'张学油':{
'部门':'科技部',
'工资':4000,
'级别':1
},
'刘德滑':{
'部门':'市场部',
'工资':6000,
'级别':2
}
}
# print("全体员工当前信息如下:",info_dict)
# 让格式更美观的输出
print("全体员工当前信息如下:")
for name in info_dict:
print(name + ": " + str(info_dict[name]))
for name in info_dict: # 依次取到内层字典
if info_dict[name]['级别']==1:
employee_info_dict=info_dict[name] # 获取内层字典信息
employee_info_dict['级别']=2
employee_info_dict['工资']+=1000
info_dict[name]=employee_info_dict # 将员工信息更新回字典
# print("全体员工级别为1的员工完成升值加薪操作,操作后:",info_dict)
# 让格式更美观的输出
print("全体员工级别为1的员工完成升值加薪操作,操作后:")
for name in info_dict:
print(name,":"+str(info_dict[name]))
运行结果:
类数据容器总结:
各个数据容器的使用场景:
列表:一批数据可修改,可重复的存储场景。
元组:一批数据不可修改,可重复的存储场景。
字符串:一串字符串的存储场景。
集合:一批数据去重存储的场景。
字典:通过key检索value的存储场景。
数据容器的相互转化操作:
各容器转列表:
my_list=["你好",12,1,3]
my_tuple=(1,2,3,4,5)
my_str='12345'
my_set={1,2,3,4,5}
my_dict={'1':'张三','2':'李四',"3":'王五'}
print(list(my_tuple))
print(list(my_str))
print(list(my_set))
print(list(my_dict)) # 保存key
各容器转元组:
my_list=["你好",12,1,3]
my_tuple=(1,2,3,4,5)
my_str='12345'
my_set={1,2,3,4,5}
my_dict={'1':'张三','2':'李四',"3":'王五'}
print(tuple(my_list))
print(tuple(my_str))
print(tuple(my_set))
print(tuple(my_dict)) # 保存key
各容器转字符串:
my_list=["你好",12,1,3]
my_tuple=(1,2,3,4,5)
my_str='12345'
my_set={1,2,3,4,5}
my_dict={'1':'张三','2':'李四',"3":'王五'}
# 自动去除""
print(str(my_list))
print(str(my_tuple))
print(str(my_set))
print(str(my_dict)) # key和value都被保存
各容器转集合:
my_list=["你好",12,1,3]
my_tuple=(1,2,3,4,5)
my_str='12345'
my_set={1,2,3,4,5}
my_dict={'1':'张三','2':'李四',"3":'王五'}
# 转换后无序
print(set(my_list))
print(set(my_tuple))
print(set(my_str))
print(set(my_dict)) # 保存key
各容器排序操作:
# 全部排序后转换为列表
# 若要反向排序,后加reverse=True即可
my_list=[4,5,1,3]
my_tuple=(1,2,3,4,5)
my_str='12345'
my_set={1,2,3,4,5}
my_dict={'1':'张三','2':'李四',"3":'王五'}
print(sorted(my_list))
print(sorted(my_tuple))
print(sorted(my_str))
print(sorted(my_set))
print(sorted(my_dict))
博主水平有限,文中难免存在错误和不足之处。欢迎各位读者在评论区留言指正,您的每一条宝贵意见都将成为我不断进步和完善的动力源泉。同时,如果您觉得这篇文章对您有所帮助,您的投币将是对我创作的最大鼓励和支持,这将激励我为大家带来更多优质、有价值的内容。再次感谢您的阅读和支持,期待与您在Python的海洋中共同成长!