Python之数据容器_python数据容器

1. 数据容器入门

数据容器就是一种可以存储多个元素的Python数据类型。

Python中的数据容器：

• list（容器）
• tuple（元组）
• str（字符串）
• set（集合）
• dict（字典）

它们各有特点，但都满足可容纳多个元素的特性。

2. 列表（list）

2.1 列表的定义语法

列表的定义语法：

[元素，元素，元素，...]

元素：数据容器内的每一份数据，都称之为元素。

元素的数据类型无限制，甚至元素可以是列表，这样就定义了嵌套列表。

2.2 列表的下标索引

列表的每个元素的编号称之为下标索引：

• 从前向后的方向，编号从0开始递增。
• 从后向前的方向，编号从-1开始递减。

通过下标索引取出对应位置的元素：

• 列表[下标]

下标索引的注意事项：

• 注意下标索引的取值范围，超出范围无法取出元素，并且会报错。

# 定义一个列表
my_list = ['zhangsan','lisi','ydh']
# ['zhangsan', 'lisi', 'ydh']
print(my_list)
# <class 'list'>
print(type(my_list))
 
my_list = ['zhangsan',666,True]
print(my_list)
print(type(my_list))
 
# 定义一个嵌套的列表
my_list = [[1,2,3],[4,5,6]]
# 取出嵌套列表中的元素
# 5
print(my_list[1][1])
 
# 通过索引取数据
my_list = ['tom','rose','jack']
# 从前向后
# tom
print(my_list[0])
# rose
print(my_list[1])
# 从后向前
# jack
print(my_list[-1])
# rose
print(my_list[-2])
 
# list index out of range
# print(my_list[3])

2.3 列表的常见方法及特点

列表的常见方法：

 列表的特点：

• 可以容纳多个数据。
• 可以容纳不同类型的数据。
• 数据是有序存储的。（有序）
• 允许重复数据存在。（可重复）
• 可以修改。（可以增加或删除元素）
• 支持while循环和for循环。

my_list = ['ydh','yidaihao','python']
 
# 1.index方法
index = my_list.index('yidaihao')
print(index)
 
# index = my_list.index('hello')
# # 'hello' is not in list
# print(index)
 
# 2.修改
my_list[0] = 'zhangsan'
print(my_list)
 
# 3.insert方法
my_list.insert(1,'lisi')
# ['zhangsan', 'lisi', 'yidaihao', 'python']
print(my_list)
 
# 4.append方法
my_list.append('best')
# ['zhangsan', 'lisi', 'yidaihao', 'python', 'best']
print(my_list)
 
# 5.extend方法
my_list2 = [1,2,3]
# ['zhangsan', 'lisi', 'yidaihao', 'python', 'best', 1, 2, 3]
my_list.extend(my_list2)
print(my_list)
 
# 6.del
my_list = ['ydh','yidaihao','python']
del my_list[2]
print(my_list)
 
# 7.pop方法
my_list = ['ydh','yidaihao','python']
element = my_list.pop(1)
# yidaihao
print(element)
# ['ydh', 'python']
print(my_list)
 
# 8.remove方法
my_list = ['ydh','yidaihao','ydh','python']
my_list.remove('ydh')
# ['yidaihao', 'ydh', 'python']
print(my_list)
 
# 9.clear方法
my_list.clear()
print(my_list)
 
# 9.count方法
my_list = ['ydh','yidaihao','ydh','python']
count = my_list.count('ydh')
print(count)
 
# 10.len方法
num = len(my_list)
print(num)

2.4 列表的循环遍历

将容器内的元素依次取出并处理，称之为遍历。使用while循环或者for循环遍历。

list = ['张三丰','黄药师','郭靖','林冲']
# while循环
# i表示列表的下标
i = 0
while i < len(list):
    name = list[i]
    print('列表的元素：%s' %(name))
    i += 1
 
# for循环
# name表示列表的元素
for name in list:
    print(f'列表的元素：{name}')

for循环遍历与while循环遍历的比较：

• for循环更简单，while循环更灵活。
• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景。

3. 元组（tuple）

元组的定义方式：

(元素,元素,元素,...)

元组的操作方法：

元组的注意事项：

不可修改内容（可以修改内部list的内部元素）

元组的特点：

• 可以容纳多个数据。
• 可以容纳不同类型的数据。
• 数据是有序存储的。（有序）
• 允许重复数据存在。（可重复）
• 不可以修改。（不可以增加或删除元素）
• 支持while循环和for循环。

# 定义元组
t1 = (1,"hello",True)
t2 = ()
t3 = tuple()
# <class 'tuple'> (1, 'hello', True)
print(type(t1),t1)
# <class 'tuple'> ()
print(type(t2),t2)
# <class 'tuple'> ()
print(type(t3),t3)
 
# 定义单个元素的元组(要加上逗号)
t4 = ("hello",)
# <class 'tuple'> ('hello',)
print(type(t4),t4)
t5 = ("hello")
# <class 'str'> hello
print(type(t5),t5)
 
# 元组的嵌套
t6 = ((1,2,3),(4,5,6))
# 下标索引取出内容
num = t6[1][2]
# 6
print(num)
 
# # 修改元组内容
# # TypeError: 'tuple' object does not support item assignment
# t1[1] = "world"
 
# 可以修改内部list的内部元素
t7 = (1,2,["ydh","hhh"])
t7[2][1] = "aaa"
# (1, 2, ['ydh', 'aaa'])
print(t7)

4. 字符串（str）

字符串也是数据容器。字符串可以看做是字符的容器，支持下标索引等特性。

字符串的操作方法：

字符串的特点：

• 只可以存储字符串。
• 长度任意。（取决于内存大小）
• 支持下标索引。
• 允许重复字符串存在。
• 不可以修改。（不可以增加或删除元素）
• 支持while循环和for循环。

my_str = "itheima and itcast"
# 1.下标索引取值
value = my_str[2]
# h
print(value)
value2 = my_str[-2]
# s
print(value2)
 
# # TypeError: 'str' object does not support item assignment
# my_str[2] = "H"
 
# 2.index方法
value = my_str.index("and")
print(value)
 
# 3.replace方法
new_my_str = my_str.replace("it", "程序")
print(new_my_str)
 
# 4.split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
# ['hello', 'python', 'itheima', 'itcast']
print(new_my_str)
 
# 5.strip方法
my_str = "  itheima and itcast  "
# 不传参
new_my_str = my_str.strip()
# itheima and itcast
print(new_my_str)
 
my_str = "12itheima and itcast21"
# 传参
new_my_str = my_str.strip("12")
# itheima and itcast
print(new_my_str)
 
# 6.count方法
my_str = "itheima and itcast"
count = my_str.count("it")
print(count)
 
# 7.len方法
num = len(my_str)
print(num)

5. 序列和切片

5.1 序列

序列：内容连续、有序、支持下标索引的一类数据容器。列表、元组、字符串都可视为序列。

5.2 切片

• 序列[起始:结束:步长]
• 起始可以省略，省略从头开始。
• 结束可以省略，省略到尾结束。
• 步长可以省略，省略步长为1（可以为负数，表示倒序执行）。

# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
# 步长为1可以省略
result1 = my_list[1:4]
# [1, 2, 3]
print(result1)
 
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
# 起始从头开始和结束到尾结束可以省略，步长为1可以省略
result2 = my_tuple[:]
# (0, 1, 2, 3, 4, 5, 6)
print(result2)
 
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "0123456"
result3 = my_str[::2]
# 0246
print(result3)
 
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "0123456"
result4 = my_str[::-1]
# 6543210   相当于字符串逆序
print(result4)
 
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1]
# [3, 2]
print(result5)
 
 
# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
# (6, 4, 2, 0)
print(result6)

5.3 案例

my_str = "万过薪月，员序程马黑来，nohtyP学"
# 先倒序，后切片
result1 = my_str[::-1][9:14]
print(result1)
 
# 先切片，后倒序
result2 = my_str[5:10][::-1]
print(result2)
 
# 先分隔，再替换，最后倒序
result3 = my_str.split("，")[1].replace("来", "")[::-1]
print(result3)

6. 集合（set）

集合的定义方式：

{元素,元素,元素,...}

集合的常用操作：

# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
my_set_empty = set()
# <class 'set'> {'itheima', '传智教育', '黑马程序员'}    不重复，无序
print(type(my_set),my_set)
# <class 'set'> set()
print(type(my_set_empty),my_set_empty)
 
 
# 添加新元素
my_set.add("Python")
my_set.add("黑马程序员")
# {'传智教育', 'Python', 'itheima', '黑马程序员'}
print(my_set)
 
# 移除元素
my_set.remove("传智教育")
# {'itheima', 'Python', '黑马程序员'}
print(my_set)
 
# 随机取出一个元素
my_set = {"传智教育", "黑马程序员", "itheima"}
element = my_set.pop()
# 黑马程序员
print(element)
 
# 清空集合, clear
my_set.clear()
# set()
print(my_set)
 
# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
# set1-set2={2, 3}
print(f"set1-set2={set3}")
 
 
# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
# {2, 3},{1, 5, 6}
print(f"{set1},{set2}")
 
# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
# {1, 2, 3, 5, 6}
print(set3)
 
# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
# 注意：虽然定义集合时存在重复元素，但是在打印集合或者显示集合中元素个数时会进行去重处理
# 5
print(num)
 
# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(element)

遍历集合元素：

• 支持for循环遍历。
• 不可以使用while循环遍历，因为不支持下标索引。

集合的特点：

• 可以容纳多个数据。
• 可以容纳不同类型的数据（混装） 。
• 数据是无序存储的（不支持下标索引）。
• 不允许重复数据存在。
• 可以修改（增加或删除元素等）。
• 只支持for循环。

7.字典（dict）

7.1 字典的定义

字典可以提供基于Key检索Value的场景实现，就像查字典一样。

字典的定义语法：

{key:value,key:value,...,key:value}

# 定义字典
my_dict = {"张三":99,"李四":88,"王五":77}
# 内容：{'张三': 99, '李四': 88, '王五': 77},类型：<class 'dict'>
print(f"内容：{my_dict},类型：{type(my_dict)}")
 
 
# 定义空字典
my_dict_empty = {}
my_dict_empty2 = dict()
# 内容：{},类型：<class 'dict'>
print(f"内容：{my_dict_empty},类型：{type(my_dict_empty)}")
# 内容：{},类型：<class 'dict'>
print(f"内容：{my_dict_empty2},类型：{type(my_dict_empty2)}")
 
# 定义重复Key的字典
my_dict = {"张三":99,"张三":88,"王五":77}
# {'张三': 88, '王五': 77}  字典中出现重复数据时，新数据会覆盖旧数据
print(my_dict)
 
# 从字典中基于Key获取Value
my_dict = {"张三":99,"李四":88,"王五":77}
score = my_dict["李四"]
# 88
print(score)
 
# 定义嵌套字典
stu_score_dict = {
    "张三":{
        "语文": 84,
        "数学": 89,
        "英语": 96
    },"李四":{
        "语文": 78,
        "数学": 63,
        "英语": 85
    },"王五":{
        "语文": 86,
        "数学": 88,
        "英语": 100
    }
}
 
# 从嵌套字典中获取数据
# 李四的语文分数
score = stu_score_dict["李四"]["语文"]
# 78
print(score)

注意

• 键值对的Key和Value可以是任意类型（Key不可为字典）。
• 字典内Key不允许重复，重复添加等同于覆盖原有数据。
• 字典不可用下标索引，而是通过Key检索Value。

7.2 字典的操作

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["王力鸿"] = 66
# {'周杰轮': 99, '林俊节': 88, '张学油': 77, '王力鸿': 66}
print(my_dict)
 
# 更新元素
my_dict["周杰轮"] = 60
# {'周杰轮': 60, '林俊节': 88, '张学油': 77, '王力鸿': 66}
print(my_dict)
 
# 删除元素
score = my_dict.pop("周杰轮")
# {'林俊节': 88, '张学油': 77, '王力鸿': 66},60
print(f"{my_dict},{score}")
 
# 清空元素, clear
my_dict.clear()
# {}
print(my_dict)
 
# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
# dict_keys(['周杰轮', '林俊节', '张学油'])  并非直接的列表
print(keys)
# ['周杰轮', '林俊节', '张学油'] 调用list函数转换为列表形式
print(list(keys))
 
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(my_dict[key])
 
# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(my_dict[key])
 
# 统计字典内的元素数量, len()函数
num = len(my_dict)
# 3
print(num)

注意

• 新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（因为Key不可重复）。

字典的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是KeyValue键值对
• 可以通过Key获取到Value，Key不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加或删除更新元素等）
• 支持for循环，不支持while循环。

7.3 字典的案例

有如下员工信息，请使用字典完成数据的记录。 并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元。

emp_info_dict = {
    "王力鸿":{
        "部门":"科技部",
        "工资":3000,
        "级别":1
    },"周杰轮":{
        "部门":"市场部",
        "工资":5000,
        "级别":2
    },"林俊节":{
        "部门":"市场部",
        "工资":7000,
        "级别":3
    },"张学油":{
        "部门":"科技部",
        "工资":4000,
        "级别":1
    },"刘德滑":{
        "部门":"市场部",
        "工资":6000,
        "级别":2
    }
}
 
# for循环遍历字典
for name in emp_info_dict:
    if emp_info_dict[name]["级别"] == 1:
        # 升值加薪操作
        # 获取级别为1的员工的信息（是个字典）
        emp_dict = emp_info_dict[name]
        # 修改员工的信息
        emp_dict["级别"] += 1
        emp_dict["工资"] += 1000
        # 将员工的信息更新回emp_info_dict
        emp_info_dict[name] = emp_dict
 
print(emp_info_dict)

8. 数据容器对比总结

数据容器可以从以下视角进行简单的分类：

• 是否支持下标索引（数据是否有序）：
  • 支持（是）：列表、元组、字符串——序列类型
  • 不支持（否）：集合、字典——非序列类型
• 是否支持重复元素：
  • 支持：列表、元组、字符串——序列类型
  • 不支持：集合、字典——非序列类型
• 是否可以修改：
  • 支持：列表、集合、字典
  • 不支持：元组、字符串

9. 数据容器的通用操作

字符串如何比较？

从头到尾，一位位进行比较（比较的是字符所对应的ASCII码值），其中一位大，后面就无需比较了。