Python—数据容器

RAY_01042025-07-10 15:45

一、数据容器入门

Python中的数据容器：

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

数据容器总共分为5种：

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

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

1、列表的定义

基本语法：

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

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

以[ ]作为标识

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

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

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

嵌套列表的定义

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

2、列表的下标（索引）

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

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

或者，可以反向索引

python 复制代码 
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时列表对象（变量）内置的方法（函数）

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

语法：列表[下标] = 值

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

python 复制代码 
# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 正向下标
myList[0]="程序员"
print(myList)
# 反向下标
myList[-2]=888
print(myList)
  • 插入元素：

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

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

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

python 复制代码 
# list列表的常用操作
myList=["RAY","爱学Python",666,True]
# 追加元素
myList.append("!")
print(myList)
  • 追加元素方式2

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

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

语法1： del 列表[下标]

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

python 复制代码 
myList=["RAY","爱学Python",666,True]
# 删除元素
# 语法1
del myList[3]
print(myList)
# 语法2
myList.pop(2)
print(myList)
  • 删除某元素在列表中的第一个匹配项

语法：列表.remove(元素)

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

语法：列表.clear()

python 复制代码 
# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 清空列表
myList.clear()
print(myList)
  • 统计某元素在列表内的数量

语法：列表.count（元素）

python 复制代码 
# list列表的常用操作
myList=["RAY","爱学Python",666,True,666]
# 统计某元素在列表内的数量
count=myList.count(666)
print(count)
  • 统计列表内，共多少元素

语法：len（列表）

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

三、list（列表）的遍历

  • while循环遍历列表
python 复制代码 
def list_while():
    '''
    使用while循环演示遍历列表
    :return: None
    '''
    mylist=["程序猿","爱","学Python"]
    index=0
    while index<len(mylist):
        element=mylist[index]
        print(f"列表的元素：{element}")
        index+=1
list_while()
  • for循环遍历列表
python 复制代码 
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

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

python 复制代码 
t1=("1",)

2、元组的相关操作：

|---------|---------------------------|
| 方法 | 作用 |
| index（） | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| count（） | 统计某个数据在当前元组出现的次数 |
| len（元组） | 统计元组的元素数量 |

python 复制代码 
t1=(1,"1","程序猿","爱","学Python",1)
print(t1[0])
print(t1.index("爱"))
print(t1.count(1))
print(len(t1))

3、元组的遍历

while循环：

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

for循环：

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

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

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

1、字符串定义

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

字符串的下标：

空格也会计入索引

python 复制代码 
name="RAY"
print(name[0]) # 结果：R
print(name[1]) # 结果：A
print(name[-1]) # 结果：Y

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

2、字符串的常见操作

  • 字符串的替换

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

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

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

python 复制代码 
name="RAY"
name_new=name.replace("AY","ay")
print(f"将字符串{name}替换后得到{name_new}")
  • 字符串的分割

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

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

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

python 复制代码 
name="R A Y"
name_list=name.split(" ")
print(f"将字符串{name}分割后得到{name_list}")
  • 字符串的规整操作（去前后空格）

语法：字符串.strip（）

python 复制代码 
name=" R A Y "
name_list=name.split()
print(f"将字符串{name}规整（去前后空格）后得到{name_list}")
  • 字符串的规整操作（去前后指定字符串）

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

python 复制代码 
name="12RAY21"
name_list=name.split("1")
print(f"将字符串{name}规整（去前后指定字符串）后得到{name_list}")
  • 统计字符串内某字符出现的次数【字符串.count（字符串）】
  • 统计字符串的字符个数 【len（字符串）】

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

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

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

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

语法：序列[起始下标：结束下标：步长]

表示从序列中，从指定位置依次取出元素，到指定位置结束，得到一个新序列

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

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

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

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

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

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

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

python 复制代码 
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（元素）

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

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

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

语法：集合.remove（元素）

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

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

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

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

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

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

python 复制代码 
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不变

python 复制代码 
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不变

python 复制代码 
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（集合）

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

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

python 复制代码 
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
python 复制代码 
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

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

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

例：

python 复制代码 
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

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

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

语法：字典[Key] = Value

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

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

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

语法：字典.pop(Key)

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

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

语法：字典.clear（）

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

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

语法：字典.keys()

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

python 复制代码 
myDict = {"张三": 99, "李四": 88, "王五": 77}
keys=myDict.keys()
print(keys) # 结果：dict_keys(['张三', '李四', '王五'])
  • 遍历字典
python 复制代码 
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（字典）

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

练习 ：升值加薪

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

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

分别输出加薪前后的数据

|-----|-----|------|----|
| 姓名 | 部门 | 工资 | 级别 |
| 吴老二 | 科技部 | 4000 | 2 |
| 张三 | 科技部 | 3000 | 1 |
| 李四 | 市场部 | 5000 | 2 |
| 王五 | 科技部 | 7000 | 3 |
| 老六 | 市场部 | 6000 | 2 |

python 复制代码 
# 定义字典
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["级别"]=2
        employeeDict["工资"]+=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]）】
相关推荐
失败又激情的man3 分钟前
python之requests库解析
开发语言·爬虫·python
打酱油的；9 分钟前
爬虫-request处理get
爬虫·python·django
专注VB编程开发20年26 分钟前
常见 HTTP 方法的成功状态码200，204,202,201
开发语言·网络协议·tcp/ip·http
有没有没有重复的名字31 分钟前
线程安全的单例模式与读者写者问题
java·开发语言·单例模式
开开心心_Every1 小时前
便捷的电脑自动关机辅助工具
开发语言·人工智能·pdf·c#·电脑·音视频·sublime text
用什么都重名2 小时前
MinerU：高效智能PDF文档解析工具完全指南
人工智能·python·pdf·mineru·makedown
霖002 小时前
C++学习笔记三
运维·开发语言·c++·笔记·学习·fpga开发
倔强青铜三3 小时前
苦练Python第4天：Python变量与数据类型入门
前端·后端·python
这我可不懂3 小时前
Python 项目快速部署到 Linux 服务器基础教程
linux·服务器·python
倔强青铜三3 小时前
苦练Python第3天：Hello, World! + input()
前端·后端·python
热门推荐
01Ubuntu环境下统计进程资源利用率02集群聊天服务器---MySQL数据库的建立03Coze扣子平台完整体验和实践（附国内和国际版对比）04KGG转MP3工具|非KGM文件|解密音频05Java学习第十五部分——MyBatis06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07深度神经网络训练过程与常见概念08基于odoo17的设计模式详解---单例模式09DeepSeek各版本说明与优缺点分析10免费领50刀！AnyRouter一键解锁Claude最强编程模型