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["级别"] += 1emp_dict["工资"] += 1000# 将员工的信息更新回emp_info_dictemp_info_dict[name] = emp_dictprint(emp_info_dict)

8. 数据容器对比总结

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

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

9. 数据容器的通用操作

字符串如何比较？

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

Python之数据容器相关推荐

【Python零基础快速入门系列 | 03】AI数据容器底层核心之Python列表
• 这是机器未来的第7篇文章原文首发地址:https://blog.csdn.net/RobotFutures/article/details/124957520 <Python零基础快速入门 ...
【Python零基础快速入门系列 | 07】浪漫的数据容器：成双成对之字典
这是机器未来的第11篇文章原文首发链接:https://blog.csdn.net/RobotFutures/article/details/125038890 <Python零基础快速入门系 ...
数据分析学习笔记—python数据类型与数据容器
文章目录 1.python标准数据类型 2.python数据容器概念 3.python数据容器思维导图 1.python标准数据类型 2.python数据容器概念容器类数据模型,从个人角度理解来说, ...
python数据容器专题
Python容器专题 [导读] 容器通常属于序列(如列表或元组)或映射(如字典),但也存在其他形式的容器.依据Python官方的说法,Python语言中标准内建容器包括 dict , list , s ...
python入门(六)——python数据容器
系列文章目录 python入门(一)--你好python python入门(二)--python基础语法 python入门(三)--python判断语句 python入门(四)--python循环语句 ...
Python数据容器：list + set + tuple + dict + str 简记黑马课程
# -*- coding:utf8 -*- """ # editor: hjjdreamer # create-time: 2022/11/16-23:08 # Pyth ...
【Python基础】Python数据容器（集合）
文章目录数据容器:set(集合) 集合的定义集合的常用操作-修改 (1)添加新元素 (2)移除元素 (3)从集合中随机取出元素 (4)清空集合 (5)取出两个集合的差集 (6)消除两个集合的差 ...
【Python基础】Python数据容器（字典）
文章目录数据容器:dict(字典.映射) 字典的定义字典数据的获取字典的嵌套字典的注意事项字典的常用操作 (1)新增元素 (2)更新元素 (3)删除元素 (4)清空字典 (5)获取全部key ...
【Python基础】Python数据容器（元组）
文章目录数据容器:tuple(元组) 元组的定义格式元组的相关操作元组的相关操作-注意事项元组的特点数据容器:tuple(元组) 元组的定义格式元组定义:定义元组使用小括号,且使用逗号隔开 ...
【Python基础】Python数据容器（字符串）
文章目录数据容器:str(字符串) 字符串的常用操作 (1)查找特定字符串的下标索引值 (2)字符串的替换 (3)字符串的分割 (4)字符串的规整操作(去前后空格) (5)字符串的规整操作(去前后指 ...

Python之数据容器