python数据容器有哪些 python存放数据的容器

1. Python数据容器

• 1.1 列表（list）

• 1.1.0 相关函数与方法总览
• 1.1.1 列表的定义与下标访问
• 1.1.2 列表的查找、修改、插入、追加
• 1.1.3 列表的删除、弹出、清空
• 1.1.4 列表元素数量的统计
• 1.1.5 列表的遍历（while与for）

• 1.2 元组（tuple）

• 1.2.0 相关函数总览
• 1.2.1 元组的定义与下标访问
• 1.2.2 元组的查找、统计
• 1.2.3 元组的遍历（while与for）

• 1.3 字符串（str）

• 1.3.1 字符串的定义与查找
• 1.3.2 字符串的替换（得到新字符串）
• 1.3.3 字符串的划分
• 1.3.4 字符串的规范化
• 1.3.5 字符串的统计
• 1.3.6 字符串的遍历（while与for）

• 1.4 序列

• 1.4.1 序列的定义
• 1.4.2 序列的切片

• 1.5 集合（set）

• 1.5.0 相关方法总览
• 1.5.1 集合的定义
• 1.5.2 集合的插入、删除、弹出、清空
• 1.5.3 集合的差集与并集
• 1.5.4 集合的长度与遍历

• 1.6 字典（dict）

• 1.6.1 字典的定义与按key访问value
• 1.6.2 字典的嵌套定义与访问
• 1.6.3 字典的插入、更新、删除、清空
• 1.6.4 获取全部的key并进行遍历
• 1.6.5 统计字典的长度（元素数量）

• 1.7 五类数据容器比较

Python中的数据容器有：列表list、元组tuple、字符串str、集合set、字典dict

1.1 列表（list）

1.1.0 相关函数与方法总览

Python包含以下函数:

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

Python包含以下方法:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop(index) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort(key=None, reverse=False) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy() 复制列表

1.1.1 列表的定义与下标访问

用[ ]定义，逗号隔开，有序，支持增删改查，数据类型可不同，允许重复，支持嵌套。

list1 = ["this", "is", 1, "list", True, 'a']
print(list1)
print(type(list1))

list2 = [[1, 2, 3], [4, 5, 6]]
print(list2)

print(list1[0], list1[2], list1[-2])
print(list2[1])
print(list2[1][2], list2[-1][-3])

1.1.2 列表的查找、修改、插入、追加

list1 = ["this", "is", 1, "list", True, 'a']

# 查询，有则返回下标，无则报错
num = list1.index("list")
print(f"\"list\"在list1中的下标为：{num}")

# 修改
list1[1] = "修改"
print(f"修改后的list1为：{list1}")

# 插入与追加
list1.insert(1, "YesYesYes")
print(f"插入元素后的list1为：{list1}")
list1.append("追加")
print(f"追加元素后的list1为：{list1}")
list2 = [1, 2]
list1.extend(list2)
print(f"追加一个list后的list1为：{list1}")

1.1.3 列表的删除、弹出、清空

list1 = ["this", "is", 1, "list", True, 'a']

# 删除
del list1[4]
print(f"删除元素后的list1为：{list1}")
# 弹出
element = list1.pop(1)
print(f"弹出元素后的list1为：{list1}，而且弹出的元素是{element}")
# 删除指定元素，只删除第一个遇到的
list1.remove("list")
print(f"删除\"list\"元素后的list1为：{list1}")
# 清空
list1.clear()
print(f"list1已被清空：{list1}")

1.1.4 列表元素数量的统计

list1 = ["list", "this", "is", 1, "list", True, 'a', "list"]

# 统计指定元素数量
count = list1.count("list")
print(f"list1中\"list\"元素的个数为{count}")

# 统计全部元素数量
count2 = len(list1)
print(f"list1中所有元素的个数为{count2}")

1.1.5 列表的遍历（while与for）

for更简单，while更灵活

1. while循环遍历列表

def list_while(list):
	index = 0
	while index < len(list):
		element = list[index]
		print(element, end=",")
		index += 1

if __name__ == '__main__':
	list1 = ["this", "is", "a", "list"]
	list_while(list1)

1. for循环遍历列表

def list_for(list):
	for element in list:
		print(element, end=",")

if __name__ == '__main__':
	list1 = ["this", "is", "a", "list"]
	list_for(list1)

结果均为：

1.2 元组（tuple）

1.2.0 相关函数总览

Python元组包含了以下内置函数

序号	方法及描述
1	len(tuple) 计算元组元素个数。
2	max(tuple) 返回元组中元素最大值。
3	min(tuple) 返回元组中元素最小值。
4	tuple(iterable) 将可迭代系列转换为元组。

1.2.1 元组的定义与下标访问

元组定义完成后不可修改，但是如果元组某元素为列表，该列表内元素可以修改

# 定义元组
tup1 = ("this", "tuple", 1, False)
tup2 = ()
tup3 = tuple()
print(f"tup1的类型是：{type(tup1)}，内容是{tup1}")
print(f"tup2的类型是：{type(tup2)}，内容是{tup2}")
print(f"tup3的类型是：{type(tup3)}，内容是{tup3}")

# 定义单元素元组
tup4 = ("aa", )
print(f"tup4的类型是：{type(tup4)}，内容是{tup4}")

# 元组的嵌套
tup5 = ("bb", ("a", "b", "c"))
print(f"tup5的类型是：{type(tup5)}，内容是{tup5}")

# 通过下标访问元组内元素
element = tup5[1][2]
print(f"从嵌套元组中取出一个数据为：{element}")

1.2.2 元组的查找、统计

tup1 = ("this", "tuple", 1, False, "tuple", 2, "tuple")

# index 查找
index = tup1.index("tuple")
print(f"元组中\"tuple\"元素的下标为：{index}")

# count 统计元素数量
num = tup1.count("tuple")
print(f"元组中\"tuple\"元素的个数为：{num}")

# len 元组长度
le = len(tup1)
print(f"元组的长度为：{le}")

1.2.3 元组的遍历（while与for）

1. while

def tuple_while(tup):
	index = 0
	while index < len(tup):
		element = tup[index]
		print(element, end=",")
		index += 1

if __name__ == '__main__':
	tup1 = ("this", "tuple", 1, False, 2)
	tuple_while(tup1)

1. for

def tuple_for(tup):
	for element in tup:
		print(element, end=",")

if __name__ == '__main__':
	tup1 = ("this", "tuple", 1, False, 2)
	tuple_for(tup1)

结果均为：

1.3 字符串（str）

1.3.1 字符串的定义与查找

字符串不可修改，只能重新创建新的字符串

str1 = "this is a string"

# 通过下标访问
value1 = str1[1]
value2 = str1[-1]
print(value1, value2)

# index方法
value3 = str1.index("str")
print(f"字符串中\"str\"第一次出现的下标为：{value3}")

1.3.2 字符串的替换（得到新字符串）

str1 = "this is a string"

# replace方法（不是修改，而是得到了新的字符串）
str1_new = str1.replace("is","啊哈")
print(f"字符串中\"is\"替换为\"啊哈\"：{str1_new}")

1.3.3 字符串的划分

# split方法（划分，并存入列表中）
str2 = "this is a string"
str2_list = str2.split(" ")
print(f"字符串进行划分：{str2_list}，类型为：{type(str2_list)}")

1.3.4 字符串的规范化

# strip方法（规范化字符串，去除空格与指定字符串）
str3 = " a string "
str3_new = str3.strip()		# 去除首尾空格
print(f"str3被strip后，新的字符串为：{str3_new}")
str4 = "12a string21"
str4_new = str3.strip("12")
print(f"str4被strip(\"st\")后，新的字符串为：{str4_new}")

1.3.5 字符串的统计

str5 = " a string, str"

# 统计字符串中某字符串的出现次数
count = str5.count("str")
print(f"str5中\"str\"出现的次数为{count}")

# 统计字符串长度
le = len(str5)
print(f"str5的长度为{le}")

1.3.6 字符串的遍历（while与for）

str1 = "这是一个字符串"
index = 0
while index < len(str1):
	print(str1[index])
	index += 1

str1 = "这是一个字符串"
for element in str1:
	print(element)

1.4 序列

1.4.1 序列的定义

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

列表、元组、字符串均为序列

1.4.2 序列的切片

myList = ["this", "is", 1, "list", True, "aa"]
# 对列表list切片，正步长
result1 = myList[1:5]
print(result1)
# 对列表list切片，负步长
result4 = myList[5:1:-1]
print(result4)

myTuple = ("this", "is", 1, "tuple", "bbb", 5)
# 对元组tuple切片，正步长
result2 = myTuple[1:5]
print(result2)
# 对元组tuple切片，负步长
result5 = myTuple[5:1:-1]
print(result5)

myStr = "abcdefghijklmn"
# 对字符串str切片，正步长
result3 = myStr[::2]
print(result3)
# 对字符串str切片，负步长
result6 = myStr[::-1]
print(result6)

1.5 集合（set）

1.5.0 相关方法总览

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
pop()	随机移除元素
remove()	移除指定元素
union()	返回两个集合的并集
update()	给集合添加元素

1.5.1 集合的定义

集合没有重复元素（自动去重），且集合内元素无序

# 集合的定义
set1 = {"这是", "一个", "集合", "set", "set", 1, "set"}
set2 = set()
print(f"set1的内容是：{set1}，类型是：{type(set1)}")
print(f"set2的内容是：{set2}，类型是：{type(set2)}")

1.5.2 集合的插入、删除、弹出、清空

set1 = {"这是", "一个", "集合", "set", 1}
# 添加新元素
set1.add("new element")
print(f"添加元素后set1的内容是：{set1}")

# 删除元素
set1.remove("这是")
print(f"删除元素后set1的内容是：{set1}")

# 随机取出一个元素
ele = set1.pop()
print(f"弹出后set1的内容是：{set1}")
print(f"弹出的内容是：{ele}")

# 清空
set1.clear()
print(f"set1被清空了：{set1}")

1.5.3 集合的差集与并集

set1 = {1, 2, 3}
set2 = {1, 5, 6}
# 集合的差集
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)

# 消除差集
set1.difference_update(set2)
print(set1)
print(set2)

set1 = {1, 2, 3}
set2 = {1, 5, 6}
# 并集
set3 = set1.union(set2)
print(set3)

1.5.4 集合的长度与遍历

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
# 集合的长度
num1 = len(set1)
num2 = len(set2)
print(num1, num2)

由于集合内元素无序，不能用下标访问，故无法用while循环遍历集合，只能用for循环

set1 = {1, 2, 3, 4, 5}
# 集合的遍历
for element in set1:
	print(element)

1.6 字典（dict）

1.6.1 字典的定义与按key访问value

字典的key也不可以重复

dict1 = {"Tom": 80, "Mike": 95, "Bob": 85}
dict2 = {}
dict3 = dict()

print(dict1, type(dict1))
print(dict2, type(dict2))
print(dict3, type(dict3))

dict1 = {"Tom": 80, "Mike": 95, "Bob": 85}
score = dict1["Mike"]
print(f"Mike's score is {score}")

1.6.2 字典的嵌套定义与访问

dict1 = {
	"Tom": {
		"Python": 80, "C++": 85, "Java": 100
	}, "Mike": {
		"Python": 92, "C++": 83, "Java": 93
	}, "Bob": {
		"Python": 93, "C++": 89, "Java": 85
	}
}

num1 = dict1["Mike"]["Java"]
print(f"All students' scores: {dict1}")
print(f"Mike's Java score is: {num1}")

1.6.3 字典的插入、更新、删除、清空

dict1 = {"Tom": 80, "Mike": 95, "Bob": 85}

dict1["Bill"] = 72
print(f"插入新的元素后，字典为{dict1}")

dict1["Tom"] = 90
print(f"修改已有元素后，字典为{dict1}")

ele = dict1.pop("Bill")
print(f"Bill被移除，他的分数是{ele}")
print(f"移除元素后，字典为{dict1}")

dict1.clear()
print(f"字典被清空，字典为{dict1}")

1.6.4 获取全部的key并进行遍历

1. 通过获取全部的key来进行for遍历

dict1 = {"Tom": 80, "Mike": 95, "Bob": 85}

keys = dict1.keys()
print(keys)

for key in keys:
	print(f"key:{key}, value:{dict1[key]}")

2. 直接对字典进行for循环，每一次循环都是直接得到key

dict1 = {"Tom": 80, "Mike": 95, "Bob": 85}

for key in dict1:
	print(f"key:{key}, value:{dict1[key]}")

1.6.5 统计字典的长度（元素数量）

dict1 = {"Tom": 80, "Mike": 95, "Bob": 85}

print(len(dict1))

1.7 五类数据容器比较

1. 是否支持下标索引（有序）、重复元素

• 支持：列表、元组、字符串
• 不支持：集合、字典

2. 是否可以修改

• 支持：列表、集合、字典
• 不支持：元组、字符串