数据容器
数据容器:一种可以存储多个元素的数据类型,容纳的每一份数据称之为1个元素,每一个元素,可以是任意类型的数据,如布尔、字符串、数字
五类数据容器:
1.列表(list) []
2.元组(tuple) ()
3.字符串(str) “”
4.集合(set) {}
5.字典(dict) {key:value}
列表(list)
“列表可以存储多个数据,且可以为不同的数据类型,支持嵌套”
列表定义的基本语法:
#字面量
[元素1,元素2,元素3…]
#定义变量
变量名称=[元素1,元素2,元素3…]
#定义空列表
变量名称=[] 变量名称=list()
print("----------列表(list)--------")
#使用[]定义列表
list=[['hello',2,True],['hi',33]] #嵌套列表
print(list,type(list))
#列表的下标索引
"""
列表中的每一个元素,都有其位置下标索引.
正向索引:从前往后的方向,从0开始,依次递增
反向索引:从后往前的方向,从-1开始,依次递减
"""
print("--------列表的下标索引----------")
list=[['hello',2,True],['hi',33]] #嵌套列表
print(list)
#正向索引
print("第一个列表的第二个元素",list[0][1]) #2 第一个列表的第二个元素
#反向索引
print("倒数第一个列表的倒数第二个元素",list[-1][-2]) #hi 倒数第一个列表的倒数第二个元素
#列表的功能
"""
列表的功能(列表的方法):
1.查询元素 list.index(元素)
2.修改元素 list[下标]=元素
3.插入元素 list.insert(下标,元素)
4.追加元素
-单个元素:list.append(元素)
-多个元素:list.extend(容器)
5.删除元素
-del list[下标]
-list.pop(下标) 可得到删除的元素内容
-list.remove(元素) 删除某元素在列表中的第一个匹配项
6.清空列表 list.clear()
7.统计元素数量
-统计列表中某元素的数量 list.count(元素)
-统计列表中的元素数量 len(list)
"""
"""
方法和函数的功能一样,有传入参数,有返回值,只是方法的使用格式不同
函数的使用:num=add(1,2)
方法的使用:student=Student()
num=student.add(1,2)
"""
#列表查询
print("-----------列表查询-----------")
#查询某元素在列表中的下标索引
list=['张三','李四','王五']
index = list.index("张三") #查询张三的下标索引
print(f"张三在列表中的下标索引值:{index}")
#查询元素不存在,会出现报错
#index = list.index(1)
#print(index)
#修改元素
print("------------修改元素----------")
list[1] = "小李四" #修改下标索引为1的元素李四为小李四
print(f"列表被修改后:{list}")
#插入元素
print("------------插入元素------------")
list.insert(2,"周日") #在下标索引为2的位置上插入周日
print(f"列表插入元素后:{list}")
#追加元素
print("------------追加元素------------")
#在列表尾部追加单个元素
list.append("五柳")
print(f"在列表尾部追加元素后:{list}")
#在列表尾部追加多个元素
list.extend([1,2,"张三"])
print(f"在列表尾部追加多个元素:{list}")
#删除元素
print("---------删除元素---------")
#del list[]
del list[6] #删除列表下标为6的元素2
print(f"删除列表下标为6的元素2后,列表内容:{list}")
#list.pop()
element=list.pop(5) #定义下标索引为5的元素
print(f"通过pop()取出元素后,列表内容:{list},被取出的元素为{element}")
#remove(元素)
list.remove("五柳") #删除五柳在列表中的第一个匹配项
print(f"删除五柳在列表中的第一个匹配项后,列表内容:{list}")
#统计元素数量
print("----------统计元素数量----------")
#统计列表中某元素的数量
count=list.count("张三")
print(f"列表中张三的数量为:{count}")
#统计列表中元素的数量
count = len(list)
print(f"列表中元素的数量:{count}")
#清空列表
print("----------清空列表---------")
list.clear()
print(f"列表内清空后,结果是:{list}")
#列表的遍历(迭代)
"""
while循环与for循环的比较:
1.循环控制上:
-while:可以自定循环条件,并自行控制
-for:不可以自定循环条件,只可以一个个从容器内取出数据
2.无限循环上:
-while:可以通过条件控制做到无限循环
-for:不可以,被遍历的容器容量不是无限的
3.使用场景上:
-while:适用于任何想要循环的场景
-for:适用于遍历数据容器的场景或简单的固定次数循环场景
"""
"""
1.while循环遍历列表
index = 0
while index<len(列表):
元素=列表[index]
对元素进行处理
index += 1
2.for循环遍历列表
for 临时变量 in 数据容器:
对临时变量进行处理
"""
#while循环遍历列表
print("---------------while循环遍历列表--------------")
def list_while_func():
list=["张三","李四","王五"]
#定义变量用来标记列表的下标
index=0 #初始值为0
while index<len(list):
#通过index变量取出对应下标的元素
element=list[index]
print(f"列表中的元素:{element}")
#循环变量,每次循环都+1
index+=1
#调用
list_while_func()
#for循环遍历列表
print("----------for循环遍历列表----------")
def list_for_func():
list = ["张三", "李四", "王五"]
for element in list:
print(f"列表中的元素:{element}")
list_for_func()
运行结果:
元组tuple()
“元组:可以封装多个、不同类型的元素。元组一旦定义完成,就不可修改”
元组定义的基本语法:
#定义元组字面量
(元素1,元素2,元素3…)
#定义元组变量
变量名称=(元素1,元素2,元素3…)
#定义空元组
变量名称=() 变量名称=tuple()
元组的操作:
1.查找元素 index()
2.统计元素出现的次数 count()
3.统计元组个数 len(元组)
print("------------元组tuple()----------")
#定义单个元素的元组,要加逗号
tuple=("张三",)
print(f"tuple类型是{type(tuple)},tuple的内容是{tuple}")
#元组的嵌套
tuple1=(("张三","李四","王五"),(1,2,3))
print(f"元组的内容为:{tuple1}")
#查找index()
print("-----------查找-----------")
tuple2=(("张三","李四","王五",1,2,3))
index = tuple2.index("张三")
print(f"在元组中,张三的下标为:{index}")
#统计元素出现的次数 count()
print("--------统计元素出现的次数-------")
count=tuple2.count("张三")
print(f"在元组中,张三出现的次数为:{count}")
#统计元组个数 len(元组)
num=len(tuple2)
print(f"元组内的元素有{num}个")
#元组的遍历:while
print("--------元组遍历:while-------")
index = 0
while index<len(tuple2):
print(f"元组的元素有{tuple2[index]}")
index +=1
#元组的遍历:for
print("----------元组遍历:for----------")
for element in tuple2:
print(f"元组的元素有{element}")
#修改元组内容 取出元组内容变换成列表
print("-------修改元组内容-------")
tuple3=(1,2,[3,4])
print(f"元组内容为:{tuple3}")
tuple3[2][0]=5
print(f"修改后的元组内容为:{tuple3}")
运行结果
字符串str
“字符串:字符的容器,可以存放任意数量的字符。无法修改的数据容器”
字符串的操作:
1.查找:index()
2.替换 replace()
3.分割 split()
4.规整操作
-strip()去除首尾空格
-strip(字符串)去除指定字符串
5.统计次数 count()
6.统计长度 len()
print("-------字符串---------")
str="I am studying Chinese"
print(str)
#通过下标牵引取值
print("-----------通过下标牵引取值---------")
value1=str[2]
value2=str[-9]
print(f"从字符串{str}取下标为2的元素值为{value1},下标为-9的元素为{value2}")
#查询
print("-----------查找index()----------")
value=str.index("am")
print(f"在字符串{str}中查找am,其起始下标为{value}")
#替换
print("--------替换replace()-------")
new_str=str.replace("a","A")
print(f"将字符串{str}进行替换,得到:{new_str}")
#分割
print("--------分割split()--------")
new_str1=str.split(" ")
print(f"将字符串{str}进行分割后,得到{new_str1},类型为{type(new_str1)}")
#规整
print("-------规整strip()-------")
str1=" A B C DEFG "
new_str2 = str1.strip()#去除首尾空格
print(f"字符串{str1}去除首尾空格后:{new_str2}")
str2="12A B C DEFG21"
new_str3 = str2.strip("12")
print(f"字符串{str2}去除12后:{new_str3}")
#统计字符串出现的次数
print("-------统计字符串出现的次数count()---------")
count=str2.count("1")
print(f"字符串{str}中1出现的次数为:{count}")
#统计长度
print("---------统计长度len()-----------")
len=len(str2)
print(f"字符串{str2}的长度为:{len}")
运行结果:
序列
“序列:内容连续、有序、可使用下标索引的一类数据容器”
“列表、元组、字符串,均可以视为序列”
“切片:从一个序列中,取出一个子序列”
“语法:序列[起始下标:结束下标:步长]步长为负数,反向取”
print("----------序列切片---------")
#对list进行切片
list=[1,2,3,4,5,6,7,8]
list1=list[0:4:2]
list2=list[:]
print(f"从0开始到4结束,步长为2:{list1}")
print(f"从头开始到最后结束,步长为1:{list2}")
#对tuple进行切片
tuple=(1,2,3,4,5,7,8)
tuple1=tuple[-1:-5:-1]
tuple2=tuple[3:7:2]
print(f"从-1开始到-5结束,步长为-1:{tuple1}")
print(f"从3开始到7结束,步长为2:{tuple2}")
#对str进行切片
str="achieve and achiece"
str1=str[1:10:4]
str2=str[-3:-15:-3]
print(f"从1开始到10结束,步长为4:{str1}")
print(f"从-3开始到-15结束,步长为-3:{str2}")
运行结果
集合
基本语法:
#定义集合字面量
{元素,元素,,,,元素}
#定义集合变量
变量名称={元素,元素,,,,元素}
#定义空变量
变量名称=set()
集合的操作:
1.添加 add()
2.移除 remove()
3.随机取元素 pop()
4.清空元素 clear()
5.取出集合的差集 集合1.difference(集合2) 集合1有而集合2没有的元素
6.消除差集 集合1.difference_update(集合2) 在集合1内删除与集合2相同的元素
7.合并 集合1.union(集合2)
8.统计集合元素数量 len()
print("--------集合--------")
"集合特点:无序且不重复,不支持下标索引"
set1={"张三","李四","王五","张三","小炸","吴在"}
set_empty=set() #定义空集合
print(f"set1的内容:{set1},类型是{type(set1)}")
print(f"set_empty的内容:{set_empty},类型是{type(set_empty)}")
print("---------添加新元素add()--------")
set1.add("张总")
set1.add("张三") #重复不显示
print(f"添加后的元素结果为:{set1}")
print("-----------移除remove()-----------")
set1.remove("张三")
print(f"移除后的元素结果为:{set1}")
print("---------随机取元素pop()-----------")
element=set1.pop()
print(f"随机取出的元素为:{element},剩余元素为:{set1}")
print("----------清空clear()---------")
set1.clear()
print(f"清空后的结果为:{set1}")
print("---------取出集合的差集 集合1.difference(集合2)----------")
set2={1,2,3,5,7}
set3={2,3,4,5,6}
set4=set2.difference(set3) #set2有而set3没有
print(f"取出差集的集合为{set4}",f"\nset2为{set2}",f"\nset3为{set3}")
print("-------消除差集 集合1.difference_update(集合2)-------")
set4=set2.difference_update(set3) #set2内删除与set3重复的
print(f"set2为{set2}",f"\nset3为{set3}")
print("--------合并 集合1.union(集合2)------------")
set2={1,2,3,5,7}
set3={2,3,4,5,6}
set5=set2.union(set3) #合并
print(f"合并后的集合为:{set5}",f"\nset2为{set2}",f"\nset3为{set3}")
#print("----------统计集合元素数量 len()-----------")
#set5={"张飒","李四"}
#len=len(set5) #int不被调用
#print(f"集合内的元素个数为{len}个")
print("----------集合的遍历-----------")
set6={1,3,4,6}
for element in set6:
print(f"集合的元素有{element}")
运行结果
字典
字典存储的元素是一个一个的键值对
#定义字典字面量
{key:value,key:value,…,key:value}
#定义字典变量
my_dict={key:value,key:value,…,key:value}
#定义空字典
my_dict={} my_dict=dict()
字典的常用操作:
1.新增 字典[key]=value
2.更新 字典[key]=value
3.删除 字典.pop(key)
4.清空 字典.clear(key)
5.获取全部key 字典.keys()
6.统计字典元素数量 len(字典)
print("-------------字典-------------")
#定义字典
my_dict={"张三":11,"李四":12,"王五":13}
#定义空字典
my_dict1={}
my_dict2=dict()
print(f"my_dict的内容是:{my_dict},类型是:{type(my_dict)}")
print(f"my_dict1的内容是:{my_dict1},类型是:{type(my_dict1)}")
print(f"my_dict2的内容是:{my_dict2},类型是:{type(my_dict2)}")
#定义重复key字典
my_dict3={"张三":11,"张三":12,"王五":13}
print(f"重复字典的内容为:{my_dict3}")
#基于key获取value
print("-----------基于key获取value---------")
my_dict={"张三":11,"李四":12,"王五":13}
num=my_dict["张三"]
print(f"张三的号码为:{num}")
#字典的嵌套
print("-----------字典的嵌套------------")
score_dict={
#key1 :{key:value,key:value}
"张三":{
"语文":89,
"数学":86,
"英语":99
},
#key2 :{key:value,key:value}
"李四":{
"语文":78,
"数学":88,
"英语":79
},
#key3 :{key:value,key:value}
"王五":{
"语文":82,
"数学":90,
"英语":79
}
}
print(f"考试情况如下所示:{score_dict}")
#从嵌套字典中获取数据
math_score=score_dict["张三"]["数学"] #获取张三数学成绩
print(f"张三的数学分数是:{math_score}")
english_score=score_dict["李四"]["英语"] #获取李四英语成绩
print(f"李四的英语分数是:{english_score}")
#字典的常用操作
print("-----------新增 字典[key]=value---------")
my_dict={"张三":11,"李四":12,"王五":13}
my_dict["周六"]=14 #key之前不存在
print(f"新增后的结果是:{my_dict}")
print("-------------更新 字典[key]=value-------------")
my_dict["周六"]=16 #key存在,修改value值
print(f"修改后的结果为:{my_dict}")
print("----------删除 字典.pop(key)------------")
value=my_dict.pop("周六")
print(f"被删除的字典值是:{value},删除后的结果为:{my_dict}")
print("------------清空 字典.clear(key)------------")
my_dict.clear()
print(f"清空后的结果是:{my_dict}")
print("---------获取全部key 字典.keys()----------")
my_dict={"张三":11,"李四":12,"王五":13}
keys=my_dict.keys()
print(f"获取所有的元素为:{keys}")
#遍历字典
print("----------通过获取全部的key来遍历--------")
#通过获取全部的key来遍历
for key in keys:
print(f"字典的key是:{key}")
print(f"字典的value是:{my_dict[key]}")
print("-------直接对字典进行for循环---------")
#直接对字典进行for循环
for key in my_dict:
print(f"字典的key是:{key}")
print(f"字典的value是:{my_dict[key]}")
#print("----------统计字典元素数量-------")
#num=len(my_dict)
#print(f"字典的元素数量为:{num}个")
运行结果
五种数据容器的分类
1.是否支持下标索引
-支持:列表、元组、字符串
-不支持:集合、字典
2.是否支持重复元素
-支持:列表、元组、字符串
-不支持:集合、字典
3.是否可以修改
-支持:列表、集合、字典
-不支持:元组、字符串
4.是否数据有序
-支持:列表、元组、字符串
-不支持:集合、字典
五种数据容器的应用场景
1.列表:一批数据、可修改、可重复的存储场景
2.元组:一批数据、不可修改、可重复的存储场景
3.字符串:一串字符串的存储场景
4.集合:一批数据、去重存储场景
5.字典:一批数据,可用key检索value的存储场景
五种数据容器的通用操作
1.遍历上
-都支持for循环遍历
-列表、元组、字符串支持while循环,集合、字典不支持(无法下标索引)
2.最大元素 max()
3.最小元素 min()
4.元素个数 len()
5.转换为列表 list()
6.转换为元组 tuple()
7.转换为字符串 str()
8.转换为集合 set()
9.排序 sorted()
10.反向排序 sorted(,reverse=True)
容器的数据排序
print("-------数据排序sorted-----------")
my_list=[2,4,5,1,3]
my_tuple=(2,4,5,1,3)
my_str="sdbdkf"
my_set={2,4,5,1,3}
my_dict={"key2":1,"key4":2,"key5":3,"key1":4,"key3":5}
#正向排序
print(f"列表的排序结果为:{sorted(my_list)}")
print(f"元组的排序结果为:{sorted(my_tuple)}")
print(f"字符串的排序结果为:{sorted(my_str)}")
print(f"集合的排序结果为:{sorted(my_set)}")
print(f"字典的排序结果为:{sorted(my_dict)}")
#反向排序
print(f"列表的反向排序结果为:{sorted(my_list,reverse=True)}") #reverse表示反转
print(f"元组的反向排序结果为:{sorted(my_tuple,reverse=True)}")
print(f"字符串的反向排序结果为:{sorted(my_str,reverse=True)}")
print(f"集合的反向排序结果为:{sorted(my_set,reverse=True)}")
print(f"字典的反向排序结果为:{sorted(my_dict,reverse=True)}")
运行结果