Python—数据容器

一、数据容器入门

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