Python技术手册 · 数据容器

文豪野橘Sam

已于 2022-11-26 12:49:36 修改

阅读量614

点赞数

分类专栏： Python技术手册文章标签： python 开发语言 pycharm

于 2022-11-21 10:55:27 首次发布

本文链接：https://blog.csdn.net/qq_52173406/article/details/127775968

版权

Python技术手册专栏收录该内容

3 篇文章 0 订阅

订阅专栏

写在最后

数据容器前瞻

数据容器的解释：在Python中一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，可以是任意的数据类型（字符串/数字/布尔等）

数据容器的作用以及意义：一个容器（变量）可容纳多份数据，用于批量存储或使用多份数据

数据容器的简介及操作方法

数据容器：列表（list）

概念解释：列表可以封装多个、不同类型的元素在内，且列表即使定义完成也可以修改

适用环境：满足需要在程序内封装数据，且可以随意修改数据

列表定义：列表使用中括号（英式），且使用逗号隔开各个数据元素，数据可以是不同的数据类型

#语法：数据容器_列表
list=["数据容器_列表" , -1.0  ,  1<0]#定义列表
#使用for循环遍历列表
num = None
for num in range(0,len(list)):
    print(f"list[{num}]，其输出为{list[num]}，数据容器类型为：{type(list)}，其输出数据类型为{type(list[num])}")

列表操作方法：

使用方式	作用
列表.append（元素）	向列表中追加一个元素
列表.extend（容器）	将数据容器中的内容依次取出，追加到列表尾部
列表.insert（下标，元素）	在指定下标处，插入指定的元素
列表.pop（下标）	取出列表内指定下标的对应元素
列表.remove（元素）	从前向后删除此元素第一个匹配项
列表.clear（）	清空列表
列表.count（元素）	统计此元素在列表中出现的次数
列表.index（元素）	查找指定元素在列表的下标否则报错：valueerror
del列表[下标]	删除列表指定下标元素
len（列表）	统计列表元素

数据容器：元组（tuple）

概念解释：元组可以封装多个、不同类型的元素在内，但元组一但定义完成就不可修改

适用环境：满足需要在程序内封装数据，但数据不可被篡改

元组定义：定义列表使用小括号（英式），且使用逗号隔开各个数据元素，数据可以是不同的数据类型

注意事项：元组只有一个数据时，这个数据后面需要添加逗号，否则其语法不为元组类型

#语法：数据容器_元组
tuple=("数据容器_元组" , -1.0  ,  1<0)#定义元组
#使用for循环遍历元组
num = None
for num in range(0,len(tuple)):
    print(f"tuple[{num}]，其输出为{tuple[num]}，数据容器类型为：{type(tuple)}，其输出数据类型为{type(tuple[num])}")

元组操作方法：

使用方法	作用
元组.index（元素）	查找指定元素在元组的下标否则报错：valueerror
元组.count（元素）	统计某个元素在元组中出现的次数
len（元组）	统计元组内的元素个数

数据容器：字符串（str）

概念解释：字符串可以封装多个、不同类型的元素在内，但字符串一但定义完成就不可修改

适用环境：满足需要在程序内封装数据，但数据不可被篡改

字符串定义：定义字符串使用双引号（英式），且使用逗号隔开各个数据元素，数据可以是不同的数据类型

注意事项：字符串中双引号引起的内容定义中一个字符即为一个元素（包括空格）

#语法：数据容器_字符串
str="my name is fortune you can call me 7"#定义字符串
#使用for循环遍历字符串
num = None
for num in range(0,len(str)):
    print(f"str[{num}]，其输出为{str[num]}，数据容器类型为：{type(str)}，其输出数据类型为{type(str[num])}")

字符串操作方法：

使用方法	作用
字符串.index（字符串）	查找给定字符的第一个匹配项的下标
字符串.replace（字符串1，字符串2）	用字符串2替换掉字符串1内的全部字符得到一个新字符串，原字符串不变
字符串.split（字符串）	按照给定字符串，对字符串进行分割得到一个新列表，不会修改原字符串
字符串.strip（字符串）	移除收尾空格和换行符或指定字符串
字符串.count（字符串）	统计字符串内某字符出现的次数
len（字符串）	统计字符串的长度

数据容器：集合（set）

概念解释：集合可以封装多个、不同类型的元素在内，且集合即使定义完成也可以修改

适用环境：满足在程序内封装数据时需要自动去重

集合定义：定义集合使用大括号（英式），且使用逗号隔开各个数据元素，数据可以是不同的数据类型

注意事项：集合内不允许重复元素（并非在定义时不可以定义重复元素，而是集合会自动实现去重的功能，不允许重复元素的定义表现在输出运行中）且集合内元素无序（即不支持下标索引）

#语法：数据容器_集合
set={"数据容器_集合" ,"数据容器_集合" , -1.0  ,-1.0  ,1<0,  1<0}#定义集合
#输出集合内容
print(f"数据容器内容：{set}，数据容器长度：{len(set)}，数据容器类型：{type(set)}")
#其输出内容顺序随机无序，且会自动执行去重操作，数据容器长度为去重操作后的长度

使用方法	作用
集合.add（元素）	集合内添加一个元素
集合.remove（元素）	移除集合内的指定元素
集合.pop（）	从集合中随机取出一个元素
集合.clear（）	清空集合
集合1.difference（集合2）	得到一个新集合，内含两个集合的差集原有的两个集合内容不变
集合1.difference_update（集合2）	在集合1中，删除集合2中存在的元素集合1被修改，集合2不变
集合1.union（集合2）	得到一个新集合，内含两个集合的全部元素原有的两个集合内容不变
len（集合）	统计集合的长度

数据容器：字典（dict）

概念解释：字典可以封装多个、不同类型的元素在内，且字典即使定义完成也可以修改

适用环境：字典可以提供基于Key检索Value的场景实现（即一个萝卜一个坑）

字典定义：定义字典使用大括号（英式），符合 ‘key = value’（键对值）的格式且使用逗号隔开各个数据元素，数据可以是不同的数据类型

注意事项：字典内不允许重复元素（重复添加等同于覆盖原有信息）且字典内元素无序（即不支持下标索引）

#语法：数据容器_字典
dict={"name": "数据容器_集合","name": "数据容器_集合_1","num": -1.0,"num_1":-1.0,"result": 1<0,"result_1": 1<0}#定义字典
#输出字典内容
print(f"数据容器内容：{dict}，数据容器长度：{len(dict)}，数据容器类型：{type(dict)}")
#其输出内容顺序随机无序，且会自动执行去重操作，数据容器长度为去重操作后的长度
#去重的重点在于‘键对值’中的‘键’
#‘值可以相同’但‘键不可以相同’
#如果‘键’相同，后定义的‘键’所对应内容将会覆盖之前相同‘键’定义的内容

使用方法	作用
字典[key]	获取指定key对应的value值
字典[key]＝value	添加或更新‘键对值’
字典.pop（key）	取出并key的value并删除字典内次key的键值对
字典.clear（）	清空字典
字典.keys（）	获取字典的全部key，可用于for循环遍历字典
len（字典）	统计字典的长度

数据容器的下标及其索引

解释：数据容器中的每一个元素都有其对应位置的下标索引，从前往后的方向，从0开始依次递增，从后往前，从-1开始依次递减

作用：可以通过已知的下标索引调用其对应位置的元素

下标索引 · 列表元组字符串 · 以列表为例

数据容器_下标索引_正向

#语法: 数据容器_列表 下标索引_正向
list=["数据容器_列表" , 1 ,   1>0]
#         下标[0]   下标[1] 下标[2]
print(f"{list[0]},输出数据类型为：{type(list[0])}") #输出数据类型为 字符串
print(f"{list[1]},输出数据类型为：{type(list[1])}") #输出数据类型为 整形
print(f"{list[2]},输出数据类型为：{type(list[2])}") #输出数据类型为 布尔

数据容器_下标索引_反向

#语法: 数据容器_列表 下标索引_反向
list=["数据容器_列表" , -1.0  ,  1<0]
#         下标[-3]  下标[-2] 下标[-1]
print(f"{list[-1]},输出数据类型为：{type(list[-1])}") #输出类型为 字符串
print(f"{list[-2]},输出数据类型为：{type(list[-2])}") #输出类型为 浮点型
print(f"{list[-3]},输出数据类型为：{type(list[-3])}") #输出类型为 布尔

数据容器_嵌套数据容器的下标索引

#语法：数据容器_嵌套列表的下标索引
list=[[ "嵌套列表" ,    0     ,  0==0 ] , [ "下标索引" ,    0.0   ,  0!=0 ]]
#       下标[0][0] 下标[0][1] 下标[0][2]     下标[1][0] 下标[1][1] 下标[1][2] 

#使用嵌套循环用于输出list全部内容

i=None; j=None;

for i in range(0,2):
    for j in range(0,3):
        print(f"{list[i][j]},输出数据类型为：{type(list[i][j])}")
        j+=1
    i+=1
    print("\t")

数据容器的遍历

for循环 · 列表元组字符串 · 以列表为例

#语法：数据容器_列表
list=["数据容器_列表" , -1.0  ,  1<0]#定义列表

#使用for循环遍历列表
num = None
for num in range(0,len(list)):
    print(f"list[{num}]，其输出为{list[num]}，数据容器类型为：{type(list)}，其输出数据类型为{type(list[num])}")

#使用for循环遍历数据容器 可以通过len()函数获取数据容器长度避免出现下标越界（会报错）的情况
#使用for循环遍历数据容器 只可遍历列表 元组 字符串三种元素有序的数据容器
#使用for循环遍历 元组与字符串其原理与代码段格式相同

while循环 · 列表元组字符串 · 以列表为例

#语法：数据容器_列表
list=["数据容器_列表" , -1.0  ,  1<0]#定义列表

#使用while循环遍历列表
num = 0
while num < len(list):
    print(f"list[{num}]，其输出为{list[num]}，数据容器类型为：{type(list)}，其输出数据类型为{type(list[num])}")
    num += 1

#使用while循环遍历数据容器 可以通过len()函数获取数据容器长度避免出现下标越界（会报错）的情况
#使用while循环遍历数据容器 只可遍历列表 元组 字符串三种元素有序的数据容器
#使用while循环遍历 元组与字符串其原理与代码段格式相同

数据容器的切片

解释：从一个序列中，取出一个子序列（均为有序序列，即仅支持列表元组字符串进行操作）

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

起始下标表示从何处开始可以留空但留空即视为从头开始

结束下标表示从何处结束可以留空但留空即视为截取到尾

步长表示依次取元素的间隔

重点：序列的切片操作并非修改原序列，而是通过切片操作产生一个新的序列

#语法：数据容器_切片
str="my/name/is/fortune/you/can/call/me/7"#定义字符串
#数据容器切片及输出
str_cut = str[1:4]
print(f" 字符串str内容：{str} \n 字符串str切片后str_cut内容：{str_cut} \n 字符串str切片后内容：{str}")
#输出如下（\n为换行操作符）：
# 字符串str内容：my/name/is/fortune/you/can/call/me/7
# 字符串str切片后str_cut内容：y/n #下标1:y 下标2:/ 下标3:n
# 字符串str切片后内容：my/name/is/fortune/you/can/call/me/7

数据容器的通用操作

数据容器的统计功能：

#语法：数据容器_通用操作_以字符串为例
str="11011912012138"#定义字符串

#统计功能：
num = len(str)      #len函数 用于统计数据容器长度
max_num = max(str)  #max函数 用于比较并选出数据容器中的最大值
min_num = min(str)  #min函数 用于比较并选出数据容器中的最小值
print(f"str长度：{num} str中最大值：{max_num} str中最小值：{min_num}")
#输出结果
#str长度：14 str中最大值：9 str中最小值：0

数据容器的转换功能：

注意事项（转换功能）：其中有序数据容器转无序数据容器时输出可能会打乱原数据容器内容顺序

#语法：数据容器_通用操作_以字符串为例
str_text = "11011912012138" #定义字符串

#转换功能：
mylist = list(str_text)
mytuple = tuple(str_text)
mystr = str(str_text)
myset = set(str_text)
print(f"字符串转列表： {mylist} \n字符串转元组： {mytuple} \n字符串转字符串： {mystr} \n字符串转集合： {myset}")
#输出结果：
#字符串转列表： ['1', '1', '0', '1', '1', '9', '1', '2', '0', '1', '2', '1', '3', '8'] 
#字符串转元组： ('1', '1', '0', '1', '1', '9', '1', '2', '0', '1', '2', '1', '3', '8') 
#字符串转字符串： 11011912012138 
#字符串转集合： {'9', '8', '3', '1', '2', '0'}

数据容器的排序功能：

注意事项（排序功能）：排序的结果输出均为列表对象且字典排序排的是‘键’而非‘值’

#语法：数据容器_通用操作
str_text = "312"#定义字符串
dict_text = {"key3":1,"key1":2,"key2":3}#定义字典

#排序功能_正序
mystr = sorted(str_text)#字符串排序
mydict = sorted(dict_text)#字典排序
print(f" 经过正序排序后的字符串：{mystr} \n 经过正序排序后的字典：{mydict}")

print("\t")

#排序功能_倒序
mystr = sorted(str_text,reverse=True)#字符串排序
mydict = sorted(dict_text,reverse=True)#字典排序
print(f" 经过倒序排序后的字符串：{mystr} \n 经过倒序排序后的字典：{mydict}")
#输出结果：
# 经过正序排序后的字符串：['1', '2', '3']
# 经过正序排序后的字典：['key1', 'key2', 'key3']

# 经过倒序排序后的字符串：['3', '2', '1']
# 经过倒序排序后的字典：['key3', 'key2', 'key1']

数据容器的对比总结

是否支持下标索引：是否支持元素重复：是否支持修改：

是：列表元组字符串是：列表元组字符串是：列表集合字典

否：集合字典否：集合字典否：元组字符串

**各类数据容器特点对比**
数据容器	列表	元组	字符串	集合	字典
元素数量	任意	任意	任意	任意	任意
元素类型	任意	任意	仅字符	任意	键对值 key = value
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	有序	有序	有序	无序	无序
使用场景	存储一批可修改、可重复记录的数据	存储一批不可修改、可重复的数据	存储一串字符串	存储一批不可以重复的数据	存储一批根据key去检索value的数据