python数据容器

认识数据容器

• 数据容器：一种可以存储多个元素的python数据类型

• python数据容器

  • list：列表

  • tuple：元组

  • str：字符串

  • set：集合

  • dict：字典

列表

列表定义

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

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

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

• 语法

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

• 代码示例

# 定义列表
l1 = ["元素1", "元素2", "元素3"]
print(l1)
print(type(l1))# 定义嵌套
l2 = [[1, 2, 3], [4, 5]]print(l2)
print(type(l2))l3 = [1, 2, True, 2.34, [1234]]print(l3)
print(type(l3))

list下标索引

• 从前向后：从0开始每次加1；从后往前：从-1开始，每次减1

• 注意：通过下标取数据，一定不能超出范围

• 代码示例

print(l2[0])
print(l2[0][1])
print(l2[-1][1])

列表的常用操作

方法

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

def add(x, y):return x+yclass Student:def add(x, y):return x+y

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

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

  • 方法的使用：

  stu=Student()
  stu.add(1,2)
  

列表的查询功能

• 查找某个元素的下标

• 功能：查找指定元素在列表的下摆哦，如果找不到，报错ErrorValue

• 语法：列表.index(元素)

• 代码示例

mylist = [1, 2, 3]
# 查找元素在列表内的下标索引
print(f'2在列表中的下标索引是{mylist.index(2)}')
# ValueError: 4 is not in list
# print(f'2在列表中的下标索引是{mylist.index(4)}')

列表的修改功能

• 修改特定位置的元素值

• 语法：列表[下标]=值

• 代码示例

# 修改列表中的值
print(f'当前列表元素{mylist}')
print(f'修改0位置的元素为9')
mylist[0] = 9
print(f'当前列表元素{mylist}')
print(f'修改-2位置的元素为7')
mylist[-2] = 7
print(f'当前列表元素{mylist}')

插入元素

• 语法：列表.insert(下标,元素)

• 代码示例：

print(f'当前列表元素{mylist}')
mylist.insert(1, 12)
print(f'当前列表元素{mylist}')

追加元素

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

• 代码示例

mylist.append(mylist, 'hello')
mylist.append(mylist, 'h', 4, 18)

删除元素

• 语法

# 语法1
del 列表[下标]
# 语法2
列表.pop(下标)

• 代码示例

del mylist[1]
mylist.pop(1)

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

• 语法：列表.remove(元素)

• 代码示例

mylist.remove('h')

清空列表

• 语法：列表.clear()

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

• 语法：列表.count(元素)

统计列表中元素个数

• 语法：列表.len()

总结

列表遍历

• 代码示例

# while遍历
def list_while_func(l):index = 0while index < len(l):print(l[index], end=' ')index += 1# for遍历
def list_for_func(l):for i in l:print(l[i], end=' ')mylist = [1, 2, 3, 'a', True, "dsadas"]list_while_func(mylist)
list_for_func(mylist)

元组

为什么需要元组

• 列表是可以修改的，如果想要传递的信息不被修改，列表就不合适了

• 元组和列表最大的区别：元组一旦完成定义就不可修改

定义元组

• 元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同数据类型

• 语法

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

• 注意：元组只有一个数据时，这个数据后面要添加逗号，否则不是元组类型

• 代码示例

# 基本定义
t1 = (1, 2, 3, 'a', True)
# 单数据定义：元组只有一个数据时，这个数据后面要添加逗号
t2 = (1,)
# 嵌套定义
t3 = ((1, 2, 3), (4, 5))
print(t3)

下标索引取出内容

• 同列表操作

• 代码示例

# 下标取元组内容
print(t3[1])
print(t3[1][1])

元组相关操作

• index：查找某个数据，如果数据存在返回对应的下标，否则报错

• count：统计某个数据在当前元组出现的次数

• len(元组)：统计元组内的元素个数

print(t1.index(3))
print(t1.count(3))
print(len(t1))

元组的遍历

• 代码示例

for i in t3:print(i, end=' ')
print()index = 0
while (index < len(t1)):print(t1[index], end=' ')index += 1
print()

字符串

特点

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

• 字符串是一个无法修改的容器

• 只可以存储字符串

• 支持下标索引

• 允许重复字符串存在

• for和while循环都支持

字符串的下标

• 从前向后：下标从0开始

• 从后向前：下标从-1开始

• 代码示例

name = "zhangsan"
print(name[1])
print(name[-4])

字符串的常用操作

查找子串

• 语法：字符串.index(字符串)

• 代码示例

my_str = "we are happy"
print(my_str.index("are"))
# ValueError: substring not found
# print(my_str.index("are1"))

字符串替换

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

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

• 注意：替换

• 代码示例

# replace字符串替换
new_str = my_str.replac

字符串分割

• 语法：字符串.split(分割字符串)

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

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

• 代码示例

# 字符串分割
split_str = my_str.split(' ')
print(f'分割后原字符串{my_str}')
print(f'分割后新字符串{split_str}')

字符串规整

• 语法：

字符串.strip()
字符串.strip(字符串)

• 代码示例

# 去掉字符串首尾空格
blank_str = "  we  ert dsf rew "
print(f'原始字符串:{blank_str}')
new_blank_str = blank_str.strip()
print(f'规整后字符串:{new_blank_str}')blank_str1 = "@@@we  ert dsf rew@@@"
print(f'原始字符串:{blank_str1}')
new_blank_str1 = blank_str1.strip('@')
print(f'规整后字符串:{new_blank_str1}')

统计字符串出现次数

• 语法：字符串.count(指定字符串)

• 代码示例

# 统计字符串中某字符串出现次数
print(f'@字符串出现次数:{blank_str1.count("@")}')

统计字符串长度

• 语法：len(字符串)

• 代码示例

# 统计字符串长度
print(f'字符串长度：{len(my_str)}')

总结

数据容器(序列)的切片

序列

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

• 列表、元组、字符串均可视为序列

切片

• 定义：从一个序列中取出另一个切片

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

  • 起始下标表示从何处开始，可以为空，表示从头开始

  • 结束下标表示从何处结束，可以为空，表示到尾结束

  • 步长：表示依次取元素的间隔，可正可负

• 代码示例

# 对序列进行切片操作
# 正向操作
# 取列表中2到5位置，步长为1
l = [1, 2, 3, 4, 5, 6, 7]
s1 = l[2:5:1]
print(s1)# 取元组中所有元素
t = (1, 2, 3, 4, 5, 6, 7)
s1 = t[:]
print(s1)# 字符串反转
str = "dhjskkkk"
s1 = str[::-1]
print(s1)# 反向操作：从3开始到1结束，步长为-1
s1 = l[3:1:-1]
print(s1)# 从头开始到尾结束步长为-2
s1 = t[::-2]
print(s1)

集合

特点

• 可以容纳多个元素，且类型可以不同

• 数据是无序存储，不支持下标操作

• 不允许重复数据存在

• 可以修改

• 支持for循环

基本语法

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

集合常用功能

• 代码示例

# *_*coding:utf-8 *_*
# 定义集合
my_set = {1, 2, 1, 1, True, 4.321, "dsadas"}
# 元素不能重复,会自动去重
# 内容是乱序的
print(f'包含重复元素的set结果{my_set}')
print(type(my_set))my_set1 = set()
my_set2 = {}
print(f'空集合内容{my_set1}')
print(f'空集合内容{my_set2}')# 常用操作
# 添加新元素
my_set1.add(1)
my_set1.add(2)
my_set1.add(5)
my_set1.add(6)
my_set1.add(7)
my_set1.add(1)
my_set1.add(3)
print(f'add添加元素后结果是{my_set1}')# 移除元素
# remove移除置顶元素
my_set1.remove(2)
print(f'remove移除元素后结果是{my_set1}')# pop随机移除
my_set1.pop()
print(f'pop移除元素后结果是{my_set1}')# clear清空集合
my_set1.clear()
print(f'clear清空集合元素后结果是{my_set1}')set1 = {1, 2, 3, 5, 6}
set2 = {4, 5, 6, 7, 8, 9}# 差集
diff_set = set1.difference(set2)
print(f'difference求两个集合的差集{diff_set}')
union_set = set1.union(set2)
print(f'difference求两个集合的并集{union_set}')
inter_set = set1.intersection(set2)
print(f'difference求两个集合的交集{inter_set}')# 集合遍历
for i in set2:print(i, end=' ')
print()

字典

特点

• 可以容纳多个数据

• 可以容纳不同类型数据

• 每一个元素是key:val格式

• 可以通过key获取value值，key不能重复否则会被覆盖

• 不支持下标索引

• 支持for循环，不支持while循环

• 可以修改

字典定义

• 字典的定义同样使用{}，不过存储的元素是一个个的键值对

• 语法：

# 字典定义
dict1 = {"name": "zsx", "age": 18, "score": 80.5}
dict2 = {}
dict3 = dict()
print(f'内容：{dict1}, 类型：{type(dict1)}')
print(f'内容：{dict2}, 类型：{type(dict2)}')
print(f'内容：{dict3}, 类型：{type(dict3)}')
# key值不允许重复，重复的key值会被覆盖
dict2 = {"age": 14, "age": 13}
print(f'内容：{dict2}, 类型：{type(dict2)}')

获取字典数据

• 字典同集合一样，不可以使用下标索引

• 字典需要通过key值来获取相应的value值

print(f'获取key值为age的value值:{dict2["age"]}')
# KeyError: 'age1',key值不存在时会报错
# print(f'获取key值为age的value值:{dict2["age1"]}')

字典的嵌套

• 字典的key和value可以是任意数据类型，key不可为字典

# 字典的嵌套
nested_dict = {"zs": {"age": 18, "sex": "male"}, "xh": {"age": 20, "sex": "female"}}
print(f'内容：{nested_dict}, 类型：{type(nested_dict)}')
print(f'获取嵌套的内层元素value值{nested_dict["zs"]["age"]}')

字典的常用操作

• 代码示例

# *_*coding:utf-8 *_*# 新增/更新元素
# 语法：字典[key]=value，key不存在为新增元素,key存在为更新元素
# 新增
my_dict = dict()
print(f'原始字典内容{my_dict}')
my_dict["key"] = "val"
my_dict["key1"] = "val1"
my_dict["key2"] = "val2"
print(f'新增元素后字典内容：{my_dict}')# 更新元素
my_dict["key"] = "new_val"
print(f'更新key元素后字典内容：{my_dict}')# 删除元素
my_dict.pop("key2")
print(f'删除key2元素后字典内容：{my_dict}')# 获取全部key
all_keys = my_dict.keys()
print(f'获取全部key内容：{all_keys}')
all_vals = my_dict.values()
print(f'获取全部val内容：{all_vals}')# 遍历字典
# 方式一：通过遍历所有key来取值
for key in all_keys:print(f'key：{key}, val：{my_dict[key]}')# 方式二直接使用for循环取值
for key in my_dict:print(f'key---{key}, val----{my_dict[key]}')# 统计字典内元素数量
print(f'字典内的元素数量为:{len(my_dict)}')# 清空元素
my_dict.clear()
print(f'清空元素后字典内容：{my_dict}')

数据容器总结

分类

• 是否支持下标索引

  • 支持：列表、元组、字符串–序列类型

  • 不支持：集合、字典–非序列类型

• 是否支持重复元素

  • 支持：列表、元组、字符串

  • 不支持：集合、字典

• 是否可以修改

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

  • 不支持：元组、字符串

特点对比

通用操作

• 都支持for循环遍历；列表、元组、字符串支持while，集合、字典不支持

• len：统计元素个数

• max：统计容器最大元素

• min：统计容器最小元素

容器的通用转换类型

• list(容器)：将给定容器转化为列表

• str(容器)：将给定容器转化为字符串

• tuple(容器)：将给定容器转化为元组

• set(容器)：将给定容器转化为集合

• 代码示例

# *_*coding:utf-8 *_*src_list = [1, 2, 3, 4, 5]
src_tuple = (1, 2, 3, 4, 5)
src_set = {1, 2, 3, 4, 5}
src_str = "12345"# 转列表
print(f'列表转列表{list(src_list)}, 类型：{type(list(src_list))}')
print(f'元组转列表{list(src_tuple)}, 类型：{type(list(src_tuple))}')
print(f'集合转列表{list(src_set)}, 类型：{type(list(src_set))}')
print(f'字符串转列表{list(src_str)}, 类型：{type(list(src_str))}')# 转元组
print(f'列表转元组{tuple(src_list)}, 类型：{type(tuple(src_list))}')
print(f'元组转元组{tuple(src_tuple)}, 类型：{type(tuple(src_tuple))}')
print(f'集合转元组{tuple(src_set)}, 类型：{type(tuple(src_set))}')
print(f'字符串转元组{tuple(src_str)}, 类型：{type(tuple(src_str))}')# 转字符串
print(f'列表转字符串{str(src_list)}, 类型：{type(str(src_list))}')
print(f'元组转字符串{str(src_tuple)}, 类型：{type(str(src_tuple))}')
print(f'集合转字符串{str(src_set)}, 类型：{type(str(src_set))}')
print(f'字符串转字符串{str(src_str)}, 类型：{type(str(src_str))}')# 转集合
print(f'列表转集合{set(src_list)}, 类型：{type(set(src_list))}')
print(f'元组转集合{set(src_tuple)}, 类型：{type(set(src_tuple))}')
print(f'集合转集合{set(src_set)}, 类型：{type(set(src_set))}')
print(f'字符串转集合{set(src_str)}, 类型：{type(set(src_str))}')

通用排序功能

• 代码示例

src_list = [1, 4, 5, 2, 3]
src_tuple = (1, 3, 4, 2, 5)
src_set = {1, 4, 2, 3, 5}
src_str = "13425"print(f'正序排序：{sorted(src_list)},逆序排序：{sorted(src_list, reverse=True)}')
print(f'正序排序：{sorted(src_tuple)},逆序排序：{sorted(src_tuple, reverse=True)}')
print(f'正序排序：{sorted(src_set)},逆序排序：{sorted(src_set, reverse=True)}')
print(f'正序排序：{sorted(src_str)},逆序排序：{sorted(src_str, reverse=True)}')

字符串比较

• 从头到尾，一位一位比较，其中一位大，后续就无须比较了

• 通过ASCII码确定对应的字符值大小