Python05_数据容器

Star_KeyW

已于 2024-02-06 11:30:50 修改

阅读量127

点赞数 1

分类专栏： Python学习文章标签： python windows 开发语言 pycharm

于 2023-11-02 11:35:21 首次发布

本文链接：https://blog.csdn.net/qq_48185833/article/details/134175586

版权

Python学习专栏收录该内容

13 篇文章 1 订阅

订阅专栏

声明

文章是基于：

哔哩哔哩上的《黑马程序员python教程，8天python从入门到精通，学python看这套就够了》视频教程所做的学习笔记，仅为学习使用！！如有侵权，联系删除

一、数据容器入门

思考一个问题：如果我想要在程序中，记录5名学生的信息，如姓名。应该如何操作？
数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素。
每一个元素，可以是任意类型的数据，如：字符串、数字、布尔等。
有序：在存储的过程中，每一项元素都有固定的位置，方便查找和修改。
数据容器根据特点的不同，如：
- 是否支持重复元素
- 是否可以修改
- 是否有序，等
分为5类：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

二、数据容器：list(列表)

（一）定义

 # 字面量
 [元素1, 元素2, 元素3]

# 定义变量
变量名称 = [元素1, 元素2, 元素3]

 # 定义空列表
 变量名称 = []
 变量名称 = list()

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

 # 定义一个列表 list
 my_list = ["itheima", "itcast", "python"]
 print(my_list)
 print(type(my_list))

 my_list = ["itheima", 666 True]
 print(my_list)
 print(type(my_list))

嵌套列表：列表内的元素是列表
列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
允许数据重复存在

（二）下标索引

如何从列表中取出特定位置的数据？

索引：在数据结构中用来定位和寻找数据的检索方式。列表中的元素都是有序的，因此可以通过索引的方式直接访问到列表中的某一个位置的元素。

 # 通过下标索引取出对应位置的数据
 my_list = ["Tom", "Lily", "Rose"]
 # 列表[下标索引]，从前向后从0开始，每次+1  从后向前从-1开始，每次-1
 print(my_list[0])
 print(my_list[1])
 print(my_list[2])
 # 错误示范：通过下标索引取数据，一定不要超出范围，会报错 最大下标 = 个数 - 1
 print(my_list[3])

 # 通过下标索引取出数据（倒序取出）
 print(my_list[-1])
 print(my_list[-2])
 print(my_list[-3])

嵌套列表的下标

 # 取出嵌套列表的元素
 my_list = [[1, 2, 3], [4, 5, 6]]
 print(my_list[1][1])

（三）常用操作

列表也提供了一系列功能：

插入元素
删除元素
清空列表
修改元素
统计元素个数

等等功能，这些功能我们都称之为：列表的方法

在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：
- 方法所在的student叫做class类对象，通过类对象.把方法.出来即可
- list内部提供了一一系列可供我们使用的函数

1、列表的查询功能（方法）

查找元素的下标
- 功能：查找指定元素在列表的正向下标，如果找不到，报错ValueError
- 语法：列表.index(要查找的元素)
  - index就是列表对象（变量）内置的方法（函数）
- - ```
   my_list = ["itheima", "itcast", "python"]
   index = my_list.index("itheima")
```

2、列表的修改功能

取到对应的下标索引，利用=进行重新赋值即可
语法：列表[下标] = 值
直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

3、列表的插入功能

列表.insert( 下标, 元素 )
- 插入用于将指定对象插入列表的指定位置，这个位置原来的元素会向后移动1位。
- 下标：要在哪一个下标中插入新的元素
- 元素：插入指定的元素

4、列表的追加元素功能

列表.append(元素)
- 指定元素，追加到列表的尾部
- 参数只有一个，就是待插入的元素，只能加到现存列表的末尾
列表.extend(其它数据容器)
- 将其它数据容器的内容取出，依次追加到列表尾部
- 需要注意的是：extend方法会对原始的列表直接进行修改操作，所以若想返回拼接后的结果，返回原始列表即可。

5、列表的删除操作

del 列表[下标]
列表.pop(下标)
- 本质上是将列表中的指定元素取出并返回，可以变量接受得到，取出后原列表中就等同于删除
- 可以用一个变量接收取出的值
- ```
 mylist = ["itcast", "itheima", "python"]
 element = mylist.pop(2)
 print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
```

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

列表.remove(元素)
从前向后逐个访问遍历，找到符合条件的元素进行删除

 # 删除某元素在列表中的第一个匹配项
 mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
 mylist.remove("itheima")

清空列表内容
- 列表.clear()

6、统计功能

统计某元素在列表内的数量
- 列表.count(元素)
统计列表内有多少元素
- len(列表名)
- 可以得到一个int数字，表示列表内的元素数量

7、常用功能练习

有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄
定义这个列表，并用变量接收
- ```
mylist = [21, 25, 21, 23, 22, 20]
```
追加一个数字31，到列表的尾部
- ```
mylist.append(31)
```
追加一个新列表[29, 33, 30]，到列表的尾部
- ```
mylist.extend([29, 33, 30])
```
取出第一个元素（应是：21）
- ```
num1 = mylist[0]
```
取出最后一个元素（应是：30）
- ```
num2 = mylist[-1]
```
查找元素31，在列表中的下标位置
- ```
index = mylist.index(31)
```

三、list（列表）的遍历

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代

（一）while循环

使用列表[下标]的方式取出
循环条件为 下标值 < 列表的元素数量

 my_list = ["传智教育", "黑马", "Python"]
 """
     循环控制变量通过下标索引来控制，默认0
     每一次循环都将下标索引变量 + 1
     循环条件：下标索引变量 < 列表的元素数量
 """
 
 # 定义一个变量用来标记列表的下标
 index = 0  # 初始值为0
 while index < len(my_list):
     # 通过index变量取出对应下标的元素
     # 定义变量接收
     element = my_list[index]
     print(f"列表元素：{element}")
     
     # 至关重要 将循环变量index每一次都+1
     index += 1

（二）for循环

 my_list = [1, 2, 3, 4, 5]
 # for 临时变量 in 数据容器 ：
 for element in my_list:
     print(f"列表的元素有:{element}")

（三）对比

在循环控制上
- while循环可以自定循环条件，并自行控制
- for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上
- while循环可以通过条件控制做到无限循环
- for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上
- while循环适用于任何想要循环的场景
- for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

四、数据容器：tuple(元组)

元组一旦定义完成，就不可修改
当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了
只读的list

（一）定义

使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

 t1 = (1, "Hello", True)
 t2 = ()
 t3 = tuple()
 t4 = ("Hello", )

嵌套元组：元组内的元素是一个元组

（二）常用操作

 # 根据下标（索引）取出数据
 t1 = (1, 2, 'hello')
 print(t1[2]) # 结果：hello

1、元组的运算

元组间可以使用+、+=、*号进行运算，运算后会生成一个新的元组。
使用“+”号连接两个元组，就变成了一个新的元组，它包含了两个元组中的所有元素。

2、元组的删除

del语句删除整个元组。元组从内存中被剔除。
```
tuple_1 = (1, 2, 3, 4)
del tuple_1
```

3、元组.index(元素)

 # 根据index()，查找特定元素的第一个匹配项，返回下标
 t1 = (1, 2, 'hello', 3, 4, 'hello')
 print(t1.index('hello')) # 结果2

4、元组.count(元素)

 # 统计某个数据在元组出现的次数
 t1 = (1, 2, 'hello', 3, 4, 'hello')
 print(t1.count('hello')) # 结果：2

5、len(元组)

 # 统计元组内的元素个数
 t1 = (1, 2, 3, 4)
 print(len(t1)) # 结果：4

6、注意事项

不可以修改元组的内容，否则会直接报错
可以修改元组内嵌套的list里的内容（修改元素、增加、删除、反转等）
不可以替换list为其它list或其它类型

（三）元组的遍历

1、while循环

 my_tuple = (1, 2, 3, 4, 5)
 index = 0
 while index < len(my_tuple):
     print(my_tuple[index])
     # 至关重要
     index += 1

2、for循环

 my_tuple = (1, 2, 3, 4, 5)
 for i in my_tuple:
     print(i)

（四）元组的特点

可以容纳多个数据
可以容纳不同类型的数据（混装）
允许重复数据存在
不可以修改（增加或删除元素等）
支持for循环

五、数据容器：str(字符串)

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

（一）下标索引

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

从前向后，下标从0开始
从后向前，下标从-1开始
同元组一样，字符串是一个：无法修改的数据容器。以下均无法完成：
- 修改指定下标字符
- 移除指定下标字符
- 追加字符
如果必须要做，只能得到新的字符串

（二）常用操作

1、查找特定字符串的下标索引值

字符串.index(字符串)

 my_str = "itcast and itheima"
 print(my_str.index("and")) # 结果7，返回值=特定字符串中的首字符的位置

2、字符串的替换

字符串.replace(字符串1，字符串2）
将字符串内的全部字符串1，替换为字符串2
不是修改字符串本身，而是得到了一个新字符串，会得到一个返回值

 name = "itheima itcast"
 new_name = name.replace("it", "传智")
 
 print(new_name) # 结果：传智heima 传智cast
 print(name)# 结果：itheima itcast

字符串name本身并没有发生变化，而是得到了一个新字符串对象

3、字符串的分割

字符串.split(分隔符字符串）
按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
字符串本身不变，而是得到了一个列表对象

 name = "传智播客 传智教育 黑马程序员 博学谷" 
 name_list = name.split(" ")
 
 print(name_list) # 结果：['传智播客', '传智教育', '黑马程序员', '博学谷']
 print(type(name_list)) # 结果：<class 'list'>

字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中

4、字符串的规整操作（去前后空格）

字符串.strip()
不传入参数，去除首尾空格

 my_str = "  itheima and itcast  "
 print(my_str.strip()) # 结果："itheima and itcast"

5、字符串的规整操作（去前后指定字符串）

字符串.strip(字符串)
传入参数，去除指定字符串

 my_str = "12itheima and itcast21"
 print(my_str.strip("12")) # 结果："itheima and itcast"

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

6、统计字符串中某字符串的出现次数

字符串.count(字符串)

 my_str = "itheima and itcast"
 print(my_str.count("it")) # 结果：2

7、统计字符串长度

len(字符串)
```
 my_str = "1234 abcd !@#$ 黑马程序员"
 print(len(my_str)) # 结果：20
```
- 数字（1、2、3...）
- 字母（abcd、ABCD等）
- 符号（空格、!、@、#、$等）
- 中文
均算作1个字符

（三）遍历

1、while循环

 my_str = "黑马程序员"
 index = 0
 while index < len(my_str):
     print(my_str[index])
     index += 1

2、for循环

 my_str = "黑马程序员"
 for i in my_str:
     print(i)

（四）字符串特点

只可以存储字符串（类型单一，只能是字符串类型）
长度任意（取决于内存大小）
支持下标索引
允许重复字符串存在
不可以修改（增加或删除元素等）
支持for循环

（五）练习案例

 # 定义一个字符串
 str = "itheima itcast boxuegu"
 
 # 统计字符串内有多少个"it"字符
 num = str.count("it")
 
 # 将字符串内的空格全部替换为字符："|"
 new_str = str.replace(" ", "|")
 
 # 按照"|"进行字符串分割，得到列表
 str_list = str.split("|")

六、数据容器（序列）的切片

（一）序列

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

（二）切片

切片：从一个序列中，提取出一个子序列，获取某几个元素
序列[ 起始下标 : 结束下标 : 步长 ]
- 从指定位置开始，依次取出元素，到指定位置结束，不会影响序列本身，得到一个新序列
- 起始下标表示从何处开始，可以留空，留空视作从头开始
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 起始下标和结束下标都不填写时，表示获取列表中的所有元素。即[ : ]
- 步长表示，依次取元素的间隔
  - 步长1表示，一个个取元素
  - 步长2表示，每次跳过1个元素取
  - 步长N表示，每次跳过N-1个元素取
  - 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
  - 不写默认步长为1

 my_list = [1, 2, 3, 4, 5]
 new_list = my_list[1 : 4] # 下标1开始，下标4（不含）结束，步长默认为1
 print(new_list) # 结果：[2, 3, 4]

 my_list = [1, 2, 3, 4, 5]
 new_list = mylist[::2] # 从头开始，到最后结束，步长2
 print(new_list) # 结果：[1, 3, 5]

 my_str = "12345"
 new_str = my_str[:4:2] # 从头开始，到下标4（不含）结束，步长2
 print(new_str) # 结果："13"

 my_str = "12345"
 new_str = my_str[::-1] # 从头（最后）开始，到尾结束，步长-1（倒序）
 print(new_str) # 结果："54321"

 my_list = [1, 2, 3, 4, 5]
 new_list = my_list[3:1:-1] # 从下标3开始，到下标1（不含）结束，步长-1（倒序） 
 print(new_list) # 结果：[4, 3]

小总结
- a[m : n]：索引下标m到n-1的元素
- a[m : ]：索引下标m到最后一个元素
- a[ : m]：索引第一个到m-1个元素
- a[ : -1]：索引第一个到最后一个元素-1的元素

（三）练习

 str = "万过薪月，员序程马黑来，nohtyP学"
 
 # 倒序字符串，切片取出
 result = str[::-1][9:14]
 
 # 切片取出，倒序字符串
 result = str[5:10][::-1]
 
 # split分割","，replace替换"来"为空，倒序字符串
 str.split("，")[1].replace("来", "")[::-1]

七、数据容器：set(集合)

（一）定义

去重且无序
不支持下标索引访问
因为要对元素做去重处理，所以无法保证顺序和创建的时候一致
允许修改

（二）常用操作

1、添加新元素

集合.add(元素)
将指定元素，添加到集合内，添加到末尾 -->> 集合本身被修改，添加了新元素

 my_set = {"Hello", "World"}
 my_set.add("itheima")
 print(my_set) # 结果：{'Hello', 'itheima', 'World'}

2、移除指定的元素

集合.remove(元素)
将指定元素，从集合内移除 -->> 集合本身被修改，移除了元素

 set = {"Hello", "World", "itheima"}
 set.remove("itheima")
 print(set) # 结果：{'Hello', 'World'}

3、从集合中随机取出一个元素

集合.pop()
从集合中随机取出一个元素 -->> 会得到一个元素的返回结果，同时集合本身被修改，元素被移除

 set = {"Hello", "World", "itheima"}
 element = set.pop()
 print(element) # 'Hello'
 print(set) # 结果：{'World', 'itheima'}

4、清空集合

集合.clear()
清空集合

 set = {"Hello", "World", "itheima"}
 set.clear()
 print(set) # 结果：set()  空集合

5、取出2个集合的差集

集合1.difference(集合2)
取出集合1和集合2的差集（集合1有而集合2没有的）

 set1 = {1, 2, 3}
 set2 = {1, 5, 6}
 set3 = set1.difference(set2)

 print(set3) # 结果：{2, 3} 得到新的集合
 print(set1) # 结果：原有集合{1, 2, 3} 不变
 print(set2) # 结果：原有集合{1, 5, 6} 不变

6、消除2个集合的差集

集合1.difference_update(集合2)
对比集合1和集合2，在集合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}

7、两个集合合并

集合1.union(集合2)
将集合1和集合2组合成新集合
得到新集合，集合1和集合2不变
去除重复元素

 set1 = {1, 2, 3}
 set2 = {1, 5, 6}
 set3 = set1.union(set2)
 print(set3) # 结果：{1, 2, 3, 5, 6} 若x.union(y)，则x内的元素排在前，y元素在后，且去除重复元素
 print(set1) # 结果：{1, 2, 3} 原有集合set1不变
 print(set2) # 结果：{1, 5, 6} 原有集合set2不变

8、集合长度/元素数量

len(集合)
统计集合内有多少元素
得到一个整数结果

 set1 = {1, 2, 3}
 print(len(set1)) # 结果3
 
 set2 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
 print(len(set2)) # 结果5 去除重复元素

（三）遍历

1、for循环

 set = {1, 2, 3}
 for i in set:
     print(i)

集合不支持下标索引，所以也就不支持使用while循环

（四）总结

（五）特点

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

（六）课后练习

my_list = ["黑马程序员", "传智播客", "黑马程序员", "传智播客", "itheima", "itcast", "itheima", "itcast", "best"]
 
 # 定义一个空集合
 my_set = set()
 # 通过for循环遍历列表
 for element in my_list:
     # 在for循环中将列表的元素添加至集合
     my_set.add(element)
     
 print(f"打印转换后的集合对象{my_set}")

八、数据容器：dict(字典、映射)

（一）定义

可以使用字典，实现用key取出Value的操作
无序的可变数据类型
同样使用{ }，不过存储的元素是一个个的：键值对，一个键值对称为“一个元素”
- 每一个键值对包含Key和Value（用冒号：分隔）
- 键值对之间使用逗号分隔
- Key和Value可以是任意类型的数据（key不可为字典）
- Key不可重复、唯一的，每一个键也只能对应一个值

 # 语法，字典[key]可以取到对应的value
 stu_score = {"王力宏":99, "周杰伦":11, "林俊杰":77}
 print(stu_score["王力宏"]) # 结果99
 print(stu_score["周杰伦"]) # 结果11
 print(stu_score["林俊杰"]) # 结果77

字典的嵌套

 # 记录学生各科的考试信息
 stu_score = {
     "王力宏":{"语文":77, "数学":66},
     "周杰伦":{"语文":88, "数学":86},
     "林俊杰":{"语文":99, "数学":96},
 }
 
 print(stu_score["王力宏"]) # 结果：{'语文':77, '数学':66}
 print(stu_score["王力宏"]["语文"]) # 结果：77
 print(stu_score["周杰伦"]["数学"]) # 结果：86

（二）常用操作

1、查找元素

通过索引的方式，用[ ]，在其中填入键

planet_dic = {"name": "B612", "friend": "rose"}
Info = planet_dic["friend"]

2、新增元素

字典[Key] = Value
字典被修改 or 新增了元素
必须是键和值一一对应的添加

 stu_score = {
     "王力宏":77,
     "周杰伦":88,
     "林俊杰":99
 }
 
 # 若给的key不存在，则就是新增，新增小明的考试成绩
 stu_score["小明"] = 66

3、更新元素

字典[Key] = Value
字典被修改，元素被更新
字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

 stu_score = {
     "王力宏":77,
     "周杰伦":88,
     "林俊杰":99
 }
 
 # 更新：王力宏的考试成绩
 stu_score["王力宏"] = 66

4、删除元素

字典.pop(Key)
获得指定Key的Value，从字典中取出对应的value
同时字典被修改，指定Key的数据被删除
既可以得到被删除的值，也可以删除值

 stu_score = {
     "王力宏":77,
     "周杰伦":88,
     "林俊杰":99
 }
 
 value = stu_score.pop("王力宏") # 通过变量接收
 print(value) # 结果：77  取到value
 print(stu_score) # 结果：{"周杰伦":88,"林俊杰":99}

del 字典
可以删除键值对，也可以删除整个字典

planet_dict = {"name": "B612", "firend": "reose", "size": "small"}
# 删除键值对
del planet_dict["size"]

planet_dict = {"name": "B612", "firend": "reose", "size": "small"}
# 删除整个字典
del planet_dict

5、清空字典

字典.clear()
字典被修改，元素被清空

 stu_score = {
     "王力宏":77,
     "周杰伦":88,
     "林俊杰":99
 }
 
 stu_score.clear()
 print(stu_score) # 结果：：{}

6、获得全部的key

字典.keys()
得到字典中的全部Key

 stu_score = {
     "王力宏":77,
     "周杰伦":88,
     "林俊杰":99
 }
 
 keys = stu_score.keys()
 print(keys) # 结果：dict_keys({'王力宏', '周杰伦', '林俊杰'})

7、计算字典内的全部元素（键值对）的数量

len(字典)
得到一个整数，表示字典内元素（键值对）的数量

 stu_score = {
     "王力宏":77,
     "周杰伦":88,
     "林俊杰":99
 }
 
 print(len(stu_score)) # 结果：3

（三）遍历

1、for循环

for key in 字典.keys(

 stu_score = {
     "王力宏":77,
     "周杰伦":88,
     "林俊杰":99
 }
 
 # 方式1：通过获取到全部的key来完成遍历
 keys = stu_score.keys()
 for key in keys:
     # 取出下标对应的值
     print(f"学生：{key}，分数：{stu_score[key]}")

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

 # 方式2：直接对字典进行for循环，每一次循环都是直接得到key
 for key in stu_score:
     print(f"字典的key是：{key}")
     print(f"字典的value是：{stu_score[key]}")

字典不支持下标索引，所以同样不可以用while循环遍历

（四）总结

（五）特点

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

（六）练习

 employer = {
     "王力宏":{"部门":"科技部", 
               "工资":3000, 
               "级别":1},
     "周杰伦":{"部门":"市场部", 
               "工资":5000, 
               "级别":2},
     "林俊杰":{"部门":"市场部", 
               "工资":7000, 
               "级别":3},
     "张学友":{"部门":"科技部", 
               "工资":4000, 
                "级别":1},
     "刘德华":{"部门":"市场部", 
               "工资":6000, 
               "级别":2}
 }
 
# 方法一：直接取出数据操作
print(f"全体员工当前信息如下{employer}")
for one in employer:
     if employer[one]["级别"] == 1:
         employer[one]["级别"] += 1
         employer[one]["工资"] += 1000
 
# 方法二：因为是嵌套字典，外层key对应的value值依旧是一个字典，所以可以将内层的value字典取出进
# 行修改，再赋值给外层
for name in employer:
    if employer[name]["级别"] == 1:
        # 升职加薪操作
        # 获取到员工的信息字典
        employee_info_dict = employer[name]
        # 修改员工的信息
        employee_info_dict["级别"] = 2
        employee_info_dict["工资"] += 10000
        # 将员工的信息更新回employer
        employer[name] = employee_info_dict
         
print(f"更新操作后的员工信息如下{employer}")

九、类数据容器的总结

列表：一批数据，可修改、重复的存储场景
元组：一批数据，不可修改，可重复的存储场景
字符串：一串字符串
集合：一批数据，去重存储场景
字典：一批数据，可用Key检索Value的存储场景

十、数据容器的通用操作

（一）遍历

5类数据容器都支持for循环遍历
列表、元组、字符串支持while循环
集合、字典不支持（无法下标索引）

（二）统计功能

（三）转换功能

list(容器)
- 将给定容器转换为列表
- 字符串 ---> 列表：会将字符串的每一个元素取出，作为列表的每一个单独元素
- 字典 ---> 列表：会将字典的Key取出，抛弃Value，作为列表的每一个元素
str(容器)
- 将给定容器转换为字符串
- 会给列表和元组的外面套上双引号“”
- 字典会保留Key 和 Value
tuple(容器)
- 将给定容器转换为元组
- 字符串 ---> 元组：会将字符串的每一个元素取出，作为元组的每一个单独元素
- 字典 ---> 元组：会将字典的Key取出，抛弃Value，作为元组的每一个元素
set(容器)
- 将给定容器转换为集合
- 注意集合会去重
- 字符串 ---> 集合：会将字符串的每一个元素取出，作为集合的每一个单独元素
- 字典 ---> 集合：会将字典的Key取出，抛弃Value，作为集合的每一个元素