数据容器（python学习第五弹）

数据容器

数据容器：一种可以存储多个元素的数据类型，容纳的每一份数据称之为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)}")

运行结果