【Python基础】数据存储容器实战操作详解


#定义列表
item_list = [56, 90, 88, 65, 90, "A", "Hello", True]
print(type(item_list))

# 获取列表元素
print(item_list[0])
print(item_list[-1])

# 修改元素
item_list[1]=99
print(item_list)

# 删除列表元素
del item_list[1]
print(item_list)

print("----------------")

# 遍历列表
for item in item_list:
    print(item)

2.2.4 列表切片

切片是指对操作的数据截取其中一部分的操作。列表、字符串、元组都支持切片操作。基本语法如下：

序列数据[开始索引:结束索引:步长]

不包含结束索引位置对应的元素(开始索引未指定默认为0
- 结束索引未指定默认为列表长度(直到列表末尾);步长未指定默认为1)
索引采用正向、反向索引都可以
步长是选取间隔，默认步长为1

比如要对下面这个列表的数据做切片：

如果对上面的这个列表数据进行切片的话，可以得到：

s[O:5:1]切片后的结果为["A"，"C"，"E"，"B"，"D"]
S[O:5:2]切片后的结果为 ["A"，"E"，"D"]

下面是一个基本的列表切片案例代码

SS=["A","C","H","K","L","B","D","X","C","U"]

print(SS[0:4:1])
print(SS[:4:])
print(SS[:4])

print(SS[0:5:2])

print(SS[0:-3:1])

运行后效果如下：

2.2.5 列表中的常用方法使用

列表的常用方法就是指列表这种数据类型内置的常见功能(添加元素、删除元素、排序等)。列表中有下面常见的方法：

如下是list 操作的常用方法

print("=============list 常用方法===========")

s = [56, 90, 88, 65, 90, 100, 209, 72, 145]
print(s)

#append():在列表尾部追加元素
s.append(188)
print(s)

#insert():在指定索引之前，插入元素
s.insert(2,80)
print(s)

#remove():移除列表中第一个匹配到的元素
s.remove(90)
print(s)

#pop():删除列表中指定索引位置的元素并返回(如果未指定，默认删除最后一个)
e = s.pop(1)
print(s)

e = s.pop()
print(s)

# sort 排序
s.sort()
print(s)

# 反转列表
s.reverse()
print(s)

2.2.6 列表常用操作案例

下面再通过几个案例的学习加深对列表的理解和掌握

案例一：

将用户输入的10个数字存储到一个列表中，并将列表中的数字进行排序，输出其中的最小值、最大值和平均值。

案例代码如下：


num_list= []

for i in range(1,10):
    num = int(input("请输入一个有效的数字："))
    num_list.append(num)

print("数字列表：",num_list)

# 列表排序
num_list.sort()
print(num_list)

#输出其中的最小值、最大值和平均值
print("最小值：",num_list[0])
print("最小值：",num_list[-1])
print("平均值：",sum(num_list)/len(num_list))

运行结果如下：

案例二：

合并两个列表中的元素，并对合并的结果进行去重处理(去除列表中的重复元素)。

完整代码如下：

#案例2:合并两个列表中的元素，并对合并的结果进行去重处理(去除列表中的重复元素)
num_list1 = [19, 23, 54, 64, 875, 20, 109, 232, 123, 54]
num_list2 = [55, 80, 72, 35, 60, 123, 54, 29, 91]

# 合并列表
for num in num_list2:
    num_list1.append(num)

print("合并后的列表：",num_list1)

# 简化写法，列表解包形式
#new_list = [*num_list1, *num_list2]

#去除重复元素
num_list3 = []

for num in num_list1:
    if num not in num_list3:
        num_list3.append(num)

print("去重后的列表：",num_list3)

运行结果如下：

2.3 字符串

2.3.1 字符串容器定义

字符串是字符的容器，一个字符串中可以存放任意数量的字符。如:"Python"，'Python'，"""Python""，其特点为：

不可变性(无法修改)、有序性、可迭代性
字符串中的每一个字符元素都有其对应的下标(索引)，通过元素对应的索引，就可以获取到对应的元素。

如下，将一个字符串拆开来看，从容器的角度来理解

注意：

从前向后(正向索引)，下标从o开始;从后向前(反向索引)，下标从-1开始

2.3.2 字符串切片

字符串切片语法：

s[start:end:step]

核心特点：

start:开始索引，不指定默认为0(第一个元素的索引)
end:结束索引，不指定默认为-1(最后一个元素的索引)
step:步长，不指定默认为1(-1表示从后向前)

与前面list 的切片操作基本类似，下面看一个完整的示例代码


s = "Hello-Python"

print(s[4])#正向索引
print(s[-1])#反向索引

# 遍历元素
for i in s:
    print(i)

# 切片操作
print(s[0:5:1])
print(s[:5:1])
print(s[:5:])
print(s[:5])

# 反向截取
print(s[-1:-6:-1])

2.3.3 字符串常用方法

字符串有下面常用的方法

下面是一个字符串常用方法操作的完整案例代码

s = "Hello-Python-Hello-Python"

#find()查找指定字符串第一次出现的索引位置
index = s.find("-")
print(index)

#count()统计子字符串在指定字符串中出现的次数
C = s.count("o")
print(C)

#upper()转为大写
su = s.upper()
print(su)

#lower()转为小写
sl = s.lower()
print(sl)

#split()将字符串按照指定字符串切割- 列表
slist = s.split("-")
print(slist)

#strip()去除字符串两端的空格
Ss = s.strip()
print(Ss)

#replace()将字符串中的指定子串替换为新的内容
Sr = s.replace("-","+")
print(Sr)

#startswith()/endswith()判断字符串是否是以指定的字符串开头/结尾，返回布尔值
print(s.startswith("Hello"))
print(s.endswith("Python"))

2.4 元组

2.4.1 为什么需要元组

在上面我们学习了list列表这个容器，为什么还需要元组呢？我们知道列表的数据可重复，有序且可修改，如果要要记录一些信息，而这些信息，不能被修改，只能查询呢？

列表就不适合了
此时就可以考虑使用元组，元组与列表最大的不同点在于：元组一旦定义完成，不可修改

2.4.2 元组基本介绍

元组是不可变的序列，类似于列表，但创建后不能修改。其特点如下：

可以存储不同类型的元素
元素可以重复、有序、不可以修改(支持索引访问、切片)

其定义的数据结构如下：

元组中的常用方法：

count(): 统计某元素在元组中出现的次数
index(): 查找某个元素在元组中的索引位置(第一次出现的位置)

2.4.3 元组基本使用

元组中大部分操作和列表很像，下面是一个对于元组操作的完整案例代码

#元组基本操作- tuple--->元素可以重复，有序，不可修改

t1 = (80, 95, 78, 50, 76, 80, 85, 20)
print(t1)
print(type(t1))

#索引访问
print(t1[0])
print(t1[-1])

#切片
print(t1[0:5:1])

#count()统计元素的个数
print(t1.count(80))

#index()获取元素的索引(第一个元素的位置)
print(t1.index(80))

#定义单元素的元组
t2 = (100,)
print(t2)

2.4.4 元组的组包与解包

组包(Packing)：将多个值合并到一个容器(元组、列表)中。

解包(Unpacking)：将容器(元组、列表)解开成独立的元素，分别赋值给多个变量。

下面这张图完整呈现了元组的组包与解包过程：

说明：

在元组解包时，*表示收集剩余的所有元素，允许我们处理不确定数量的元素(生成列表，以便于可以进行进一步的处理)

下面是一个完整的示例代码：

t1 = (5, 7, 9, 10, 2, 23, 12)
t2 = 5, 7, 9, 10, 2, 23, 12

print(t1)
print(t2)

# 解包操作1
a,b,c,d,e,f,g = t1
print(a,b,c,d,e,f,g)

# 解包操作2
first,second,*other,last = t1
print(first,second)
print(other)
print(last)

2.4.5 元组案例使用

接下来再通过几个案例加深对元祖的理解和掌握

需求一：

完整案例代码如下：

# 定义基本信息
students = (
    ("S001","王林",85,92,78),
    ("S002","李慕婉",92,88,95),
    ("S003","十三",78,85,82),
    ("S004","曾牛",88,79,91),
    ("S005","周轶",95,96,89),
    ("S006","王卓",76,82,77),
    ("S007","红蝶",89,91,94),
    ("S008","徐立国",75,69,82),
    ("S009","许木",86,89,98),
    ("S010","遁天",66,59,72)
)

#方式一：计算每个学生的总分、各科平均分，然后一并输出出来
print("学号\t\t姓名\t\t语文\t\t数学\t\t英语\t\t总分\t\t平均分")
for s in students: # ("S001", "王林", 85, 92, 78)
    total = s[2] + s[3] + s[4]
    avg = total / 3
    print(f"{s[0]} \t {s[1]} \t {s[2]} \t {s[3]} \t {s[4]} \t {total} \t {avg:.1f}")

#方式二:元组解包
for id,name,chinese,math,english in students:
    total = chinese + math + english
    avg = total / 3
    print(f"{id} \t {name} \t {chinese} \t {math} \t {english} \t {total} \t {avg:.1f}")


#2.统计各科成绩的最低分、最高分、平均分，并输出。
#2.1获取到各科的成绩列表
chinese_scores = [s[2] for s in students]
math_scores = [s[3] for s in students]
english_scores = [s[4] for s in students]

#2.2统计各科成绩的最低分、最高分、平均分，并输出。
print(f"语文最低分: {min(chinese_scores)}, 最高分: {max(chinese_scores)}, 平均分: {sum(chinese_scores)/len(chinese_scores)}")
print(f"数学最低分: {min(math_scores)}, 最高分: {max(math_scores)}, 平均分: {sum(math_scores)/len(math_scores)}")
print(f"英语最低分: {min(english_scores)}, 最高分: {max(english_scores)}, 平均分: {sum(english_scores)/len(english_scores)}")

#3.查找成绩优秀(平均分大于90)的学生，并输出。
print("优秀学生(平均分>90)名单如下:")
for s in students:
    total = s[2] + s[3] + s[4]
    avg = total / 3
    if avg > 90:  # 优秀学生
        print(f"学号:{s[0]},姓名:{s[1]},平均分:{avg:.1f}")

运行效果如下：

2.5 Set

2.5.1 为什么需要Set

比如在这个业务场景下，需要定义一个变量，来批量存储用户的手机号(唯一的)？

选择列表list、元组tuple可以存吗?
- 不可以，因为这两种类型是可以存储重复元素的
此时就可以使用集合set来存储，set会自动去重，存储不重复的元素

2.5.2 Set 定义

集合(set)是一种无序的、不可重复、可修改的数据容器。其有下面2种定义方式：

注意：

空集合的定义不可以使用{}，{}表示的是空字典;由于集合是无序的，因此是不支持下标索引访问的。

2.5.3 Set 基本示例

在下面的示例中，通过输出可以看到，set 会自动去重


s1 = {1,2,3,4,5,6,3,2,1}

print(s1)
print(type(s1))

2.5.4 Set 常用方法

Set 中有下面的常用方法

下面是针对这些常用方法的完整代码示例


# s1 = {1,2,3,4,5,6,3,2,1}
#
# print(s1)
# print(type(s1))

#add():添加元素到集合

s1 = {100,200,300,400,500,600,700,800}
print(s1)

s1.add(1200)
print(s1)

#remove():移除集合中的指定元素(指定元素不存在将报错)
s1.remove(200)
print(s1)

#pop():随机删除集合中的元素并返回
e = s1.pop()
print(e)
print(s1)

#clear():清空集合
s1.clear()
print(s1)

s2 = {"A","B","C","D","E","X","Y"}
s3 = {"C", "E", "Y", "Z"}

#difference():求两个集合的差集(存在于第一个集合，但不存在于第二个集合)
print(s2.difference(s3))

#union():求两个集合的并集
print(s2.union(s3))
print(s2.union(s3))

#intersection():求两个集合的交集
print(s2.intersection(s3))
print(s2.intersection(s3))

2.6 字典

2.6.1 为什么需要字典？

比如在下面的案例中，需要存储班级学员高考成绩，其中包含王林(670)，韩立(556)，李慕婉(582)，紫灵(435)，许立国(608)，该如何存储呢？如果使用list来存储，就会非常繁琐。而使用字典这种键值对类型的集合存储，就优雅而简洁。

2.6.2 什么是字典？

使用键值对(key:value)来存储数据，每一个键都对应一个值，通过键(key)可以快速找到对应的值(value)。

字典的特点是，键值对(key:value)存储、键(key)不能重复、可修改。

如下是字典的定义与存储结构

注意：

字典(dict)中的value可以是任何类型的数据，而key不能为可变类型(如:不能为列表list、集合set、字典dict)

2.6.3 字典基本案例

下面是Dict的基础示例

# 字典--
# key不能重复(如果重复，后面的值，会覆盖前面的值)、key必须得是不可变类型(str，int，float，tuple)

dict1 ={"王林":670,"李慕婉":608,"徐立国":580,"韩立":688}
print(dict1)
print(type(dict1))

#key必须得是不可变类型(str，int，float，tuple)，不能是list、set、dict
dict2 = {0:670, 1.5:608, (1,2):580, ('A','B'):688}
print(dict2)

#访问
print(dict1["李慕婉"])#获取
dict1["李慕婉"] = 688 #修改
print(dict1)

2.6.4 字典中的注意事项

value可以是任意类型，而key必须是不可变类型(不能为list、set、dict)
字典内的key不允许重复，如果重复定义，后面的覆盖前面的
字典是没有索引下标的，不能根据索引获取值，只可以根据key获取value

2.6.5 字典中的常用方法

字典中有如下常用方法

下面是一个完整的操作字典中的各种方法的案例

dict1 = {"王林":670,"李慕婉":608,"许立国":580,"韩立":688}
print(dict1)

# 添加 - key不存在就是添加
dict1["涛哥"]=550
print(dict1)

# 修改-key存在就是修改
dict1["涛哥"]=620
print(dict1)

#查询
print(dict1["涛哥"])# 根据key获取value
print(dict1.get("涛哥")) # 根据key获取value

print(dict1.keys())# 获取所有的key
print(dict1.values()) # 获取所有的value
print(dict1.items())# 获取所有的键值对 key:value

#删除
score = dict1.pop("许立国")
print(score)
print(dict1)

# 遍历1
for key, value in dict1.items():
    print(f"{key}: {value}")

print("=================")
# 遍历2
for key in dict1.keys():
    print(f"{key}: {dict1[key]}")