Python基础——数据容器（超详细版!）

Zik----

已于 2024-07-20 16:13:13 修改

阅读量682

点赞数 8

文章标签： python 开发语言

于 2024-07-18 10:25:21 首次发布

本文链接：https://blog.csdn.net/2301_80162458/article/details/140420590

版权

前言：

本篇文章主要讲解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
# 方式一：
for key in my_dict1:
    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))

博主水平有限，文中难免存在错误和不足之处。欢迎各位读者在评论区留言指正，您的每一条宝贵意见都将成为我不断进步和完善的动力源泉。同时，如果您觉得这篇文章对您有所帮助，您的投币将是对我创作的最大鼓励和支持，它将激励我为大家带来更多优质、有价值的内容。再次感谢您的阅读和支持，期待与您在知识的海洋中共同成长！

Zik----

关注

8
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python基础——数据容器（超详细版!）

本文讲解Python数据容器基础，涵盖列表、元组、字符串、集合、字典等多种数据容器类型。从基础的定义、特点、操作方法到实际案例练习，详细且全面。无论是刚入门的 Python 新手，还是需要复习巩固的开发者，都能通过本文有所收获。
复制链接

扫一扫