当前位置： 首页 > news >正文

Python—数据容器

news 2025/7/10 15:54:04

一、数据容器入门

Python中的数据容器：

        一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如：字符串、数字、布尔等。

数据容器总共分为5种：

        列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

二、数据容器：list（列表）

1、列表的定义

基本语法：

# 字面量
[元素1, 元素2, 元素3, ......]
# 定义变量
变量名称 = [元素1, 元素2, 元素3, ......]
# 定义空列表
变量名称 = []
变量名称 = list()

        列表的每一个数据，称之为元素

                以[ ]作为标识

                列表内每一个元素之间用,逗号隔开 

# list演示
first_list=["RAY","爱学Python",666,True]
print(first_list)
print(type(first_list))

注：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

        嵌套列表的定义

# list演示
first_list=[0,["RAY","爱学Python",666,True]]
print(first_list)
print(type(first_list))

 

2、列表的下标（索引） 

可以通过下标索引取出特定位置的数据

# 列表 下标索引
name_list=["Java","Python","C"]
print(name_list[0])# 结果：Java
print(name_list[1])# 结果：Python
print(name_list[2])# 结果：C

或者，可以反向索引

name_list=["Java","Python","C"]
print(name_list[-1])# 结果：C
print(name_list[-2])# 结果：Python
print(name_list[-3])# 结果：Java

嵌套列表的下标 

        例：取出列表1中的0元素。列表[1][0]

3、列表的常用操作

  • 查询某元素的下标

        功能：查找指定元素在列表的下标，如果找不到，报错ValueError

        语法：列表.index（元素）

        index时列表对象（变量）内置的方法（函数）

myList=["RAY","爱学Python",666,True]
# 查找某元素在列表中的下标索引
index=myList.index("爱学Python")
print(f"爱学Python在列表中的下标索引值是：{index}")
# 如果被查找的元素不存在列表中，会报错
index=myList.index("hello")
print(f"hello在列表中的下标索引值是：{index}")
  •  列表的修改功能（方法）

        语法：列表[下标] = 值

        可以使用语法直接对指定下标（正向、反向）的值进行重新赋值

# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 正向下标
myList[0]="程序员"
print(myList)
# 反向下标
myList[-2]=888
print(myList)

  • 插入元素：

        语法：列表insert（下标，元素），在指定的下标位置，插入新的元素

# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 插入元素
myList.insert(1,"程序员")
print(myList)

  • 追加元素 

        语法：列表append(元素)，将指定元素，追加到列表的尾部

# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 追加元素
myList.append("!")
print(myList)

  • 追加元素方式2

        语法：列表.extend（其他数据容器），将其他数据容器的内容取出，依次追加到列表尾部

# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 追加元素2
myList.extend([1,2,3])
print(myList)

  • 删除元素

        语法1： del 列表[下标]

        语法2：列表.pop(下标)

myList=["RAY","爱学Python",666,True]
# 删除元素
# 语法1
del myList[3]
print(myList)
# 语法2
myList.pop(2)
print(myList)

  • 删除某元素在列表中的第一个匹配项

        语法：列表.remove(元素)

# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 删除某元素在列表中的第一个匹配项
myList.remove(666)
print(myList)

  • 清空列表

        语法：列表.clear()

# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 清空列表
myList.clear()
print(myList)

 

  • 统计某元素在列表内的数量

        语法：列表.count（元素）

# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 统计某元素在列表内的数量
count=myList.count(666)
print(count)

  • 统计列表内，共多少元素

        语法：len（列表）

# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
length=len(myList)
print(length)

三、list（列表）的遍历

  • while循环遍历列表
def list_while():'''使用while循环演示遍历列表:return: None'''mylist=["程序猿","爱","学Python"]index=0while index<len(mylist):element=mylist[index]print(f"列表的元素：{element}")index+=1
list_while()

  • for循环遍历列表
def list_for():'''使用for循环演示遍历列表:return: None'''mylist=["程序猿","爱","学Python"]for i in mylist:print(f"列表的元素：{i}")
list_for()

while循环和for循环，都是循环语句，但是细节不一样

        在循环控制上：

                while循环可以自定循环条件，并自行控制

                for循环不可以自定循环条件，只可以一个个从容器里取出数据

        在无限循环上：

                while循环可以通过条件控制做到无线循环

                for循环理论上不可以，因为被遍历的容器的容量不是无限的

        在使用场景上：

                while循环适用于任何想要循环的场景

                for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

四、数据容器：tuple（元组）

元组一旦完成，就不可以篡改，所以我们需要在程序内封装数据，但又不希望封装的数据被篡改，就使用元组

1、元组定义：

        定义元组使用小括号，且用逗号隔开各个数据，数据可以是不同的数据类型

# 定义元组字面量
(元素, 元素, 元素, ......)
# 定义元组变量
变量名称 = (元素, 元素, 元素, ......)
# 定义空元组
变量名称 = ()       # 方式1
变量名称 = tuple()  # 方式2

元组也支持嵌套 

# 定义一个嵌套元组
t1 = ((1, 2, 3), (4, 5, 6))
print(t1[0][1]) # 结果：2

注： 当定义一个元素的元组时，需要在这个数据后面添加逗号，否则不是元组类型

t1=("1",)

 2、元组的相关操作：        

方法作用
index（）查找某个数据，如果数据存在返回对应的下标，否则报错
count（）统计某个数据在当前元组出现的次数
len（元组）统计元组的元素数量
t1=(1,"1","程序猿","爱","学Python",1)
print(t1[0])
print(t1.index("爱"))
print(t1.count(1))
print(len(t1))

 

3、元组的遍历

        while循环：

t1=(1,"1","程序猿","爱","学Python",1)
index=0
while index<len(t1):print(f"元组元素有：{t1[index]}")index+=1

        for循环：

t1=(1,"1","程序猿","爱","学Python",1)
for i in t1:print(f"元组元素有：{i}")

注：元组不可以修改内容，但可以修改元组内的list内容，包括：修改元素、增加、删除、反转等

五、数据容器：str（字符串）

1、字符串定义

字符串是字符的容器，一个字符串可以存放任意数量的字符

字符串的下标：

        空格也会计入索引

name="RAY"
print(name[0]) # 结果：R
print(name[1]) # 结果：A
print(name[-1]) # 结果：Y

 字符串是一个无法修改的数据容器，所以不可以完成修改指定下标的字符、移除指定下标的字符、追加字符等。如果必须要做，只能得到一个新的字符串

2、字符串的常见操作

  • 字符串的替换

        语法：字符串.replace(字符串1，字符串2)

        功能：将字符串内的全部：字符串1，替换为字符串2

        注意：不是修改字符串本身，而是得到了一个新的字符串

name="RAY"
name_new=name.replace("AY","ay")
print(f"将字符串{name}替换后得到{name_new}")

  • 字符串的分割

        语法：字符串.split（字符串）

        功能：按照指定的分割字符串，将字符串划分为多个字符串，并存入到列表对象中

        注意：字符串本身不变，而是得到了一个列表对象

name="R A Y"
name_list=name.split(" ")
print(f"将字符串{name}分割后得到{name_list}")

  • 字符串的规整操作（去前后空格）

        语法：字符串.strip（）

name=" R A Y "
name_list=name.split()
print(f"将字符串{name}规整（去前后空格）后得到{name_list}")

  • 字符串的规整操作（去前后指定字符串）

        语法：字符串.strip（字符串）

name="12RAY21"
name_list=name.split("1")
print(f"将字符串{name}规整（去前后指定字符串）后得到{name_list}")

  • 统计字符串内某字符出现的次数【字符串.count（字符串）】
  • 统计字符串的字符个数 【len（字符串）】

六、数据容器（序列）的切片

序列：内容连续、有序，可以使用下标索引的一类数据容器

列表、元组、字符串，均可视为序列，序列支持切片

切片：从一个序列中，取出一个子序列

语法：序列[起始下标：结束下标：步长]
表示从序列中，从指定位置依次取出元素，到指定位置结束，得到一个新序列

        其实下标表示从何处开始，可以留空，留空视作从头开始

        结束下标（不含）表示何处结束，可以留空，留空表示视截取到结尾

        步长表示，依次取元素的间隔，默认步长1

                步长1表示，一个个取元素

                步长2表示，每次跳过一个元素取

                步长为负数表示，反向取（注意，其实下标和结束下标也要反向标记）

注：此操作不会影响序列本身，而是会得到一个新的序列

mylist=[0,1,2,3,4,5,6]
# 对mylist进行切片，从1开始，4结束，步长1
result1=mylist[1:4]
print(f"结果1：{result1}")
# 对mylist进行切片，从头到尾，步长1
result2=mylist[:]
print(f"结果2：{result2}")
# 对mylist进行切片，从头到尾，步长2
result3=mylist[::2]
print(f"结果3：{result3}")
# 对mylist进行切片，从头到尾，步长-1
result4=mylist[::-1]
print(f"结果4：{result4}")
# 对mylist进行切片，从3开始，1结束，步长-1
result5=mylist[3:1:-1]
print(f"结果5：{result5}")
# 对mylist进行切片，从头到尾，步长-2
result6=mylist[::-2]
print(f"结果6：{result6}")

七、数据容器：set（集合）

1、元组定义

基础语法：

# 定义集合字面量
{元素, 元素, 元素, ......}
# 定义集合变量
变量名称 = {元素, 元素, 元素, ......}
# 定义空集合
变量名称 = set()

特点：不支持元素的重复、并且内容无序（不支持下标索引）、可以修改、支持for循环

2、数组的常见操作 

  • 添加新元素

        语法：集合.add（元素）

        将指定元素，添加到集合内

        结果：集合本身被修改，添加了新元素

mySet={"Hello","World","!"}
mySet.add("RAY")
print(mySet) # 结果：{'Hello', 'RAY', 'World', '!'}
  • 移除元素

        语法：集合.remove（元素）

mySet = {"Hello", "World", "!"}
mySet.remove("!")
print(mySet)  # 结果：{'Hello', 'World'}
  •  随机取出一个元素

        语法：变量名=集合.pop()

mySet = {"Hello", "World", "!"}
res = mySet.pop()
print(res)  # 结果：!
print(mySet)  # 结果：{'Hello', 'World'}
  • 清空集合
mySet = {"Hello", "World", "!"}
mySet.clear()
print(mySet)  # 结果：set()
  • 取两个集合的差值

        语法：集合.difference(集合2)

        功能：取出集合1和集合2的差值（集合1有而集合2没有的）

        结果：得到一个辛几何，集合1和集合2没变

set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
print(set1) # 结果：{1, 2, 3}
print(set2) # 结果：{1, 5, 6}
print(set3) # 结果：{2, 3}
  •  消除两个集合的差值

        语法：集合1.difference_update(集合2)

        功能：对比集合1和集合2，在集合1内，删除和集合2相同的怨怒是

        结果：集合1被修改，集合2不变

set1={1,2,3}
set2={1,5,6}
set1.difference_update(set2)
print(set1) # 结果：{2, 3}
print(set2) # 结果：{1, 5, 6}
  • 2个集合合并为1个

        语法：集合1.union(集合2)

        功能：将集合1和集合2组合成新集合

        结果：得到新数组，集合1和集合2不变

set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)
print(set1) # 结果：{1, 2, 3}
print(set2) # 结果：{1, 5, 6}
print(set3) # 结果：{1, 2, 3, 5, 6}
  • 统计集合元素数量

        语法：len（集合）

set={1, 2, 3, 5, 6}
print(len(set)) # 结果：5
  • 集合的遍历

        集合不支持下标索引，不能使用while循环，可以使用for循环

set={1, 2, 3, 5, 6}
for i in set:print(f"集合的元素有：{i}")

八、数据容器:dict(字典、映射)

字典可以基于Key检索Value的场景实现

1、字典的定义 

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

# 定义字典字面量
{key: value, key: value, key: value, ......}
# 定义字典变量
myDict = {key: value, key: value, key: value, ......}
# 定义空字典
myDict = {}     # 定义空字典方式1
myDict = dict() # 定义空字典方式2
myDict1 = {"张三": 99, "李四": 88, "王五": 77}
# 定义空字典
myDict2 = {}  # 定义空字典方式1
myDict3 = dict()  # 定义空字典方式2
print(f"字典1内容是：{myDict1},类型是{type(myDict1)}")
print(f"字典2内容是：{myDict2},类型是{type(myDict2)}")
print(f"字典3内容是：{myDict3},类型是{type(myDict3)}")

注：不允许定义重复key的字典 ，重复添加等同于覆盖原有数据

        字典的Key和Value可以是任意类型（Key不可为字典）

        字典不可以使用下标检索，而是使用Key检索Value

2、字典的常见操作 

  • 字典数据的获取

        字典同集合一样，不可以使用下标索引

        但在字典中可以通过key值来获取对应的value

# 语法，字典[key]可以获取到对应的value
myDict = {"张三": 99, "李四": 88, "王五": 77}
print(myDict["张三"]) # 结果：99
print(myDict["李四"]) # 结果：88
print(myDict["王五"]) # 结果：77
# print(myDict["王老五"]) # 结果：报错
  • 字典的嵌套

         字典的Key和Value可以是任意类型（Key不可为字典）

        例：

                

score = {"张三": {"语文": 77, "数学": 66, "英语": 33},"李四": {"语文": 88, "数学": 86, "英语": 55},"王五": {"语文": 99, "数学": 96, "英语": 86}}
print(f"学生信息：{score}")
# 结果：学生信息：{'张三': {'语文': 77, '数学': 66, '英语': 33}, '李四': {'语文': 88, '数学': 86, '英语': 55}, '王五': {'语文': 99, '数学': 96, '英语': 86}}#在嵌套字典中获取数据
#看王五的语文
ww_chinese=score["王五"]["语文"]
print(f"王五的语文是：{ww_chinese}")
# 结果：王五的语文是：99
  •  新增元素

        语法：字典[Key] = Value

        结果：字典被修改，新增了元素

myDict = {"张三": 99, "李四": 88, "王五": 77}
myDict["老六"]=66
print(myDict) # 结果：{'张三': 99, '李四': 88, '王五': 77, '老六': 66}
  • 更新元素

        语法：字典[Key] = Value

        结果：字典被修改，元素被更新

        注意：字典Key不可以被修改，所以对已存在的Key执行更新元素，就是在更新Value值

myDict = {"张三": 99, "李四": 88, "王五": 77}
myDict["王五"]=55
print(myDict) # 结果：{'张三': 99, '李四': 88, '王五': 55}
  • 删除元素

        语法：字典.pop(Key)

        结果：获取指定Key的Value，同时字典被修改，指定Key的数据被删除

myDict = {"张三": 99, "李四": 88, "王五": 77}
val=myDict.pop("张三")
print(val)      # 结果：99
print(myDict)   # 结果：{'李四': 88, '王五': 77}
  • 清空元素

        语法：字典.clear（）

        结果：字典被修改，元素被清空

myDict = {"张三": 99, "李四": 88, "王五": 77}
myDict.clear()
print(myDict) # 结果：{}
  • 获取全部的Key

        语法：字典.keys()

        结果：获得字典中所有的Key

myDict = {"张三": 99, "李四": 88, "王五": 77}
keys=myDict.keys()
print(keys) # 结果：dict_keys(['张三', '李四', '王五'])
  • 遍历字典
myDict = {"张三": 99, "李四": 88, "王五": 77}
keys=myDict.keys()
# 遍历字典
# 方式1
print("============方式1==============")
for key in keys:print(f"字典的Key是:{key}")print(f"字典的value是:{myDict[key]}")
# 方式2
print("============方式2==============")
for key in myDict:print(f"字典的Key是:{key}")print(f"字典的value是:{myDict[key]}")

  • 统计字典内的元素数量 

        语法：len（字典）

myDict = {"张三": 99, "李四": 88, "王五": 77}
print(len(myDict))# 结果：3

练习 ：升值加薪

        有如下员工信息,请使用字典完成数据的记录。

        并通过for循环,对所有级别为1级的员工,级别上升1级,薪水增加1000元

        分别输出加薪前后的数据

姓名部门工资级别
吴老二科技部40002
张三科技部30001
李四市场部50002
王五科技部70003
老六市场部60002

# 定义字典
dict = {"吴老二": {"部门": "科技部", "工资": 4000, "级别": 2},"张三": {"部门": "科技部", "工资": 3000, "级别": 1},"李四": {"部门": "市场部", "工资": 5000, "级别": 2},"王五": {"部门": "科技部", "工资": 7000, "级别": 3},"老刘": {"部门": "市场部", "工资": 6000, "级别": 2}}
# 输出
print(f"对员工升职加薪前结果:{dict}")
# 结果:对员工升职加薪前结果:{'吴老二': {'部门': '科技部', '工资': 4000, '级别': 2}, '张三': {'部门': '科技部', '工资': 3000, '级别': 1}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '王五': {'部门': '科技部', '工资': 7000, '级别': 3}, '老刘': {'部门': '市场部', '工资': 6000, '级别': 2}}
# 遍历字典
for name in dict:if dict[name]["级别"] == 1:# 升职加薪# 获取员工信息字典employeeDict=dict[name]# 修改员工信息employeeDict["级别"]=2employeeDict["工资"]+=1000# 将信息返回dict[name]=employeeDict
# 输出结果
print(f"对员工升职加薪后结果:{dict}")
# 结果:对员工升职加薪后结果:{'吴老二': {'部门': '科技部', '工资': 4000, '级别': 2}, '张三': {'部门': '科技部', '工资': 4000, '级别': 2}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '王五': {'部门': '科技部', '工资': 7000, '级别': 3}, '老刘': {'部门': '市场部', '工资': 6000, '级别': 2}}

九、数据容器的异同

列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意仅字符任意

Key:Value

key：除字典外任意类型

Value：任意类型

下标索引支持支持支持不支持不支持
重复元素支持支持支持不支持不支持
可修改性支持不支持不支持支持支持
数据有序是是是否否
使用场景可修改、可重复的一批数据记录场景不可修改、可重复的一批数据记录场景场景一串字符串的记录场景不可重复的数据记录场景以Key检索Value的数据记录场景

 数据容器的通用操作：

  •  遍历：都支持for循环，部分支持while循环（列表、元组、字符串）
  • 统计容器的元素个数【len（容器）】
  • 统计容器的最大元素【max（容器）】
  • 统计容器的最小元素【min（容器）】
  • 通用转换：
    • 将给定容器转换为列表【list（容器）】
    • 将给定容器转换为字符串【str（容器）】
    • 将给定容器转换为元组【tuple（容器）】
    • 将给定容器转换为集合【set（容器）】
  • 将给容器进行排序【sorted（容器，[reverse=True]）】
http://www.dtcms.com/a/271614.html

相关文章：

  • 【解决方法】ollama在powershell或者cmd运行时乱码报错
  • C++11 std::move与std::move_backward深度解析
  • 7、整合前几篇插件列表
  • 单片机STM32F103：DMA的原理以及应用
  • 滚筒式茶叶杀青机设计【12张＋总装图】＋三维图＋设计说明书＋绛重
  • Hugging Face Agents Course unit1笔记
  • Pycharm 报错 Environment location directory is not empty 如何解决
  • Vue2开发：使用vuedraggable实现菜单栏拖拽
  • 什么是AI Agent同步调用工具和异步调用工具？
  • python实践思路（草拟计划+方法）
  • 力扣-240.搜索二维矩阵 II
  • 【C#】PanelControl与Panel
  • 【RidgeUI AI+系列】猜密码游戏
  • miniconda 初始化 base 环境
  • 洛谷 P2880 [USACO07JAN] Balanced Lineup G-普及/提高-
  • 图神经网络 gnn 应用到道路网络拓扑结构与交通碳排放相关性。，拓扑指标量化、时空关联模型及演化机制分析
  • NVIDIA显卡驱动安装失败的解决办法(例如7-zip data error或脚本错误)
  • 数据库技术体系及场景选型方案
  • Linux操作系统之进程间通信：管道概念
  • 双立柱式带锯床cad【1张总图】＋设计说明书＋绛重
  • 软件发布的完整流程梳理
  • RIP和静态路由结合实验：高可用及高可靠
  • Java -- 异常--以及处理
  • 图像自动化处理初探：从拖拽上传到参数设置
  • 智能Agent场景实战指南 Day 7：智能客服Agent设计与实现
  • 继承与多态：面向对象编程的两大支柱
  • 多线程（2）
  • 1、专栏介绍以及目录
  • Vue3常用指令
  • 可转债应该在什么价卖出？