Python数据容器

Python数据容器

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

数据容器根据特点不同，如：是否支持重复元素，是否可以修改，是否有序等分为五类，分别是：列表list、元组tuple、字符串str、集合set、字典dict。

列表

基本语法

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

列表内的每一个数据称之为元素，以[]作为标识，列表内每一个元素之间用，隔开。

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

下标索引

# 语法：列表[下标索引]
这种操作即可取出对应位置的元素
从前向后取，编号从0开始递增
从后向前取，编号从-1开始逐渐递减

下标索引不可以超出列表的长度，超出会导致程序报错

#取出嵌套列表的元素
my_list = [[1,2,3,],[4,5,6]]
my_list[1][2] # 即取出第二个列表的第三个元素，即6

常用操作方法和特点

在python中，如果将函数定义为class的成员，那么函数会称之为：方法

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同

函数的使用：num = add(1,2)

方法的使用：Student = Student() num = student.add(1,2)

列表的查询

查找某元素的下标

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

语法：列表.index(元素)

列表的修改

修改特定位置（索引）的元素值

语法：列表[下标] = 值

可以使用该方法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

my_list = [1,2,3]
my_list[0] = 5
# 即将0号索引位置的1换成了5

插入元素

语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

my_list = [1,2,3]
my_list.insert(1,"ceshi")
print(my_list) # 结果：[1,"ceshi",2,3]

追加元素

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

my_list = [1,2,3]
my_list.append(4)
print(my_list) #结果：[1,2,3,4]

# 追加容器
my_list.append([4,5,6])
print(my_list) # 结果： [1,2,3,[4,5,6]]

追加元素方式2

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

# 批量追加
my_list.extend([4,5,6])
print(my_list) # 结果： [1,2,3,4,5,6]

删除元素

语法1：del 列表[下标]

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

my_list = [1,2,3]

#方式1
del my_list[0]
print(my_list)#结果：[2,3]
#方式2
my_list.pop(0)
print(my_list)# 结果[3]

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

语法：列表.remove(元素)

my_list = [1,2,3,2,3]
my_list.remove(2)
print(my_list)# 结果：[1,3,2,3]

清空列表内容

语法：列表.clear()

my_list = [1,2,3]
my_list.clear()
print(my_list) # 结果：[]

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

语法：列表.count(元素)

my_list= [1,1,1,2,3]
print(my_list.count(1)) # 结果：3

统计列表内，有多少元素

语法：len(列表)

可以打得到一个int数字，表示列表的元素数量

my_list = [1,2,3,4,5]
print(len(my_list)) # 5

列表的循环遍历

while循环遍历

index = 0
while index < len(列表):
    元素 = 列表[index]
    对元素进行处理
    index += 1

for循环遍历

for 临时变量 in 数据容器:
    对临时变量进行处理

两种循环遍历的区别

在循环控制上：

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

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

在无限循环上：

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

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

使用场景：

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

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

元组

​ 元组与列表一样，都是可以封装多个、不同类型的元素在内，最大的不同点，元组一旦定义完成，就不可以修改。

​ 适用于需要在程序内封装数据，但又不希望封装的数据被篡改。

定义语法

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

# 定义单个元素,若只有一个元素需要在后面加，否则不认为是元组类型
t1 = ("hello",)
# 通过索引取出方式与列表相同  
# index查找方法
t1.index(元素)
# count统计元素出现次数
t1.count(元素)
# len统计元组元素数量
len(t1)
# 循环遍历与列表相同

字符串

可以通过下标索引取值，正向反向均可

字符串是一个不可修改的数据容器

index查找要寻找的字符串在字符串中的起始下标

字符串的替换

"""
	字符串的替换
	语法：字符串.replace(字符串1，字符串2)
	功能：将字符串中的全部字符串1，替换为字符串2
	注意：不是修改字符出本身，而是得到了一个新的字符串
"""

字符串的分割

语法：字符串.split(分隔符字符串)

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

注意：字符串本身不变，而是得到了一个由分割开的字符串组成的列表对象

字符串的规整操作

去前后空格

语法：字符串.strip()

去前后指定字符串

字符串.strip(字符串)

例如字符串.strip(“12”)

传入的是“12”其实就是“1”和“2”都会移除，按照单个字符

count方法与len方法依旧适用，遍历与列表相同

字符串特点：只可以存储字符串，长度任意（取决于内存大小），支持下标索引，允许重复字符串存在，不可以修改，支持for循环

拓展

字符串大小比较

ASCII码比较，每一个字符都能对应一个数字的码值，字符串比较就是基于数字码值大小进行比较。

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大

数据容器的切片

序列是指：内容连续、有序，可使用下标索引的一类数据容器。列表，元组，字符串均可视为序列。

切片是指从一个序列中，取出一个子序列。

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

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

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

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

步长表示，依次取元素的间隔，1表示一个一个取，2表示跳过1个取，n表示跳过n-1个取，步长为负数表示，反向取（起始下标和结束下标也要反向标记）

步长为-1相当于反转序列

set集合

基本语法

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

集合中不允许重复，顺序也无法保证

因为集合是无序的，所以集合不支持：下标索引访问，是允许修改的

常用操作

添加操作

my_set.add("python")

移除操作

my_set.remove("hello")

随机取出一个元素

my_set.pop() #随机从集合中取出一个元素，取出后集合中没有该元素

清空集合

my_set.clear() #集合本身被清空

取两个集合的差集

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.deifference(set2)
print(set3) # 结果，{2，3} 得到新集合
print(set1) # 结果，{1，2，3}不变
print(set2) # 结果，{1，5，6}不变

消除差集

对比集合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}

集合合并

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3) # 结果，{1,2,3,5,6} 得到新集合
print(set1) # 结果，{1，2，3}不变
print(set2) # 结果，{1，5，6}不变

统计集合中元素数量

len(set1) #集合长度

集合遍历

集合不支持while循环，因为不支持下标索引

for element in set1:
    print(f"集合中的元素:{element}")

字典dict

字典是通过key找到对应的value,存储的是键值对

基本语法

# 定义字典字面量
{key:value,key:value,......,key:value}
# 定义字典变量
my_dict = {key:value,key:value,......,key:value}
# 定义空字典
my_dict = {} # 空字典定义方式1
my_dict = dict() # 空字典定义方式2

key是不可以重复的，存入相同的话，新的会覆盖掉老的

my_dict[key]# 取出key对应的value

嵌套字典

stu_score_dict = {
    "w":{
        "语文":77,
        "英语":88,
        "数学":99
    }, "x":{
        "语文":76,
        "英语":86,
        "数学":96
    },"y":{
        "语文":75,
        "英语":85,
        "数学":95
    }
}
# 取x的语文成绩	
stu_score_dict["x"]["语文"]

常用操作

新增元素

stu_score[key] = value # 设置一个新的key和value即可新增一个元素

更新元素

stu_score[key] = value # 对一个已存在的key操作即为更新元素

删除元素

stu_score.pop(key)# 获得指定key的value，同时字典被修改，指定key的数据被删除

清空字典

stu_score.clear()# 清空字典

获取全部的key

keys = stu_score.keys()# 获取全部的key

遍历字典

# 通过获取全部的key完成遍历
for key in keys:
    print(f"字典的value{stu_score[key]}")
    
# 直接对字典进行for循环
for key in stu_score:
    print(f"字典的value{stu_score[key]}")

因为字典不支持下标索引，所以不支持while循环

统计字典元素数量

num = len(stu_score)

对比总结

数据容器简单的分类：

是否支持下标索引：

​ 支持：列表、元组、字符串-序列类型-序列类型

​ 不支持：集合、字典-非序列类型

是否支持重复元素：

​ 支持：列表、元组、字符串-序列类型

​ 不支持：集合、字典-非序列类型

是否可以修改：

​ 支持：列表、集合、字典

​ 不支持：元组、字符串

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	key:value key：除字典外任意类型 value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符串的记录场景	不可重复的数据记录场景	以key检索value的数据记录场景

通用操作

**在遍历上：**5类数据容器都支持for循环遍历

列表、元组、字符串支持while循环，集合、字典不支持（无下标索引）

**通用统计功能：**len(容器)统计容器长度， max(容器)最大元素， min(容器)最小元素

通用的类型转换

​ list(容器)将给定的他容器转换为列表

​ str(容器)将给定容器转换为字符串

​ tuple(容器)将给定容器转换为元组

​ set(容器)将给定容器转换为集合

因为没有键值对的特性，所以都无法转换成字典

通用排序

sorted(容器，reverse=True)将给定容器进行排序，排序结果类型是列表，不加reverse参数是正向排序，加参数后是反向排序。
以上内容均为个人学习使用整理，仅供参考