目录
6.1 数据容器入门
学习数据容器，就是为了批量存储或批量使用多份数据
Python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如：
- 是否支持重复元素
- 是否可以修改
- 是否有序，等
分为5类，分别是：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
它们各有特点，但都满足可容纳多个元素的特性。
6.2 数据容器：list(列表)
6.2.1 列表的定义
列表内的每一个数据，称之为元素
- 以 [ ] 作为标识
- 列表内每一个元素之间用, 逗号隔开
注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
- 1. 列表的定义语法 [元素1, 元素2, 元素3, ......]
- 2. 什么是元素？ 数据容器内的每一份数据，都称之为元素
- 3. 元素的类型有限制吗？ 元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表
6.2.2 列表的下标索引
如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素。
列表的下标（索引） - 反向
或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3......）
如图，从后向前，下标索引为：-1、-2、-3，依次递减。
嵌套列表的下标（索引）
如果列表是嵌套的列表，同样支持下标索引
6.2.3 列表的常用操作
列表除了可以：
- 定义
- 使用下标索引获取值
以外，列表也提供了一系列功能：
- 插入元素
- 删除元素
- 清空列表
- 修改元素
- 统计元素个数
等等功能，这些功能我们都称之为：列表的方法
列表的查询功能（方法）
查找某元素的下标(index)
- 功能：查找指定元素在列表的下标，如果找不到，报错ValueError
- 语法：列表.index(元素)
index就是列表对象（变量）内置的方法（函数）
my_list = ["Vue", "java", "python"]
print(my_list.index("python"))
2
Process finished with exit code 0
统计某元素在列表内的数量(count)
语法：列表.count(元素)
my_list = [1, 1, 1, 2, 3]
print(my_list.count(1)) # 3统计列表内，有多少元素(len)
语法：len(列表)
可以得到一个int数字，表示列表内的元素数量
my_list = [1, 2, 3, 4, 5, 6]
print(len(my_list)) # 6列表的修改功能（方法）
修改特定位置（索引）的元素值： (index)
- 语法：列表[下标] = 值
- 可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）
# 正向下标
my_list = [1, 2, 3]
my_list[0] = 5
print(my_list) # [5, 2, 3]
# 反向下标
my_list = [1, 2, 3]
my_list[-2] = 5
print(my_list) # [1, 5, 3]插入元素(insert)
语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素
my_list = [1, 2, 3]
my_list.insert(1, "Python")
print(my_list) # [1, 'Python', 2, 3]追加元素1(append)
语法：列表.append(元素)，将指定元素，追加到列表的尾部
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # [1, 2, 3, 4]
my_list = [1, 2, 3]
my_list.append([4, 5, 6])
print(my_list) # [1, 2, 3, [4, 5, 6]]追加元素2(extend)
语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list) # [1, 2, 3, 4, 5, 6]删除元素(del和pop)
- 语法1： del 列表[下标]
- 语法2：列表.pop(下标)
my_list = [1, 2, 3, 4, 5, 6]
# 方式1
del my_list[0]
print(my_list) # [2, 3, 4, 5, 6]
# 方式2
my_list.pop(0)
print(my_list) #[3, 4, 5, 6]删除某元素在列表中的第一个匹配项(remove)
语法：列表.remove(元素)
my_list = [1, 2, 3, 2, 3]
my_list.remove(2)
print(my_list) # [1, 3, 2, 3]清空列表内容(clear)
语法：列表.clear()
my_list = [1, 2, 3]
my_list.clear()
print(my_list) # []列表的方法 - 总览
| 编号 | 使用方式 | 作用 |
| 1 | 列表.append(元素) | 向列表中追加一个元素 |
| 2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
| 3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
| 4 | del 列表[下标] | 删除列表指定下标元素 |
| 5 | 列表.pop(下标) | 删除列表指定下标元素 |
| 6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 7 | 列表.clear() | 清空列表 |
| 8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 9 | 列表.index(元素) | 查找指定元素在列表的下标 找不到报错ValueError |
| 10 | len(列表) | 统计容器内有多少元素 |
6.2.4 列表的特点
- 可以容纳多个元素（上限为2**63-1、9223372036854775807个）
- 可以容纳不同类型的元素（混装）
- 数据是有序存储的（有下标序号）
- 允许重复数据存在
- 可以修改（增加或删除元素等）
6.2.5 list（列表）的遍历
列表的遍历 - while循环
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。
如何遍历列表的元素呢？
- 可以使用前面学过的while循环
如何在循环中取出列表的元素呢？
- 使用列表[下标]的方式取出
循环条件如何控制？
- 定义一个变量表示下标，从0开始 循环条件为 下标值 < 列表的元素数量
列表的遍历 - for循环
除了while循环外，Python中还有另外一种循环形式：for循环。
对比while，for循环更加适合对列表等数据容器进行遍历。
语法：
表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，我们可以对临时变量（元素）进行处理。
# 遍历列表
my_list = [1, 2, 3, 4, 5, 6]
for i in my_list:
print(i)1
2
3
4
5
6
每一次循环将列表中的元素取出，赋值到变量i，供操作
while循环和for循环的对比
while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
- while循环可以自定循环条件，并自行控制
- for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上：
- while循环可以通过条件控制做到无限循环
- for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上：
- while循环适用于任何想要循环的场景
- for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
总结：
- for循环更简单，while更灵活
- for用于从容器内依次取出元素并处理，while用以任何需要循环的场景
6.3 数据容器：tuple(元组)
6.3.1 元组的定义
为什么需要元组
元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改
所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了
元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
6.3.2 元组的相关操作
| 编号 | 方法 | 作用 |
| 1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |
元组由于不可修改的特性，所以其操作方法非常少。
# 根据下标（索引）取出数据
t1 = (1, 2, 'hello')
print(t1[2]) # hello
# 根据index()，查找特定元素的第一个匹配项
t2 = (1, 2, 'hello', 3, 4, 'hello')
print(t2.index('hello')) # 2
# 统计某个数据在元组内出现的次数
print(t2.count('hello')) # 2
# 统计元组中元素的个数
t3 = (1, 2, 3)
print(len(t3)) # 3
元组的相关操作 - 注意事项
- 不可以修改元组的内容，否则会直接报错
- 可以修改元组内的list的内容（修改元素、增加、删除、反转等）
- 不可以替换list为其它list或其它类型
6.3.3 元组的遍历
同列表一样，元组也可以被遍历。
可以使用while循环和for循环遍历它
# 元组的遍历
t4 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
# while循环
index = 0
while index < len(t4):
print(t4[index])
index += 1
# for循环
for i in t4:
print(i)6.3.4 元组的特点
经过上述对元组的学习，可以总结出列表有如下特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是有序存储的（下标索引）
- 允许重复数据存在
- 不可以修改（增加或删除元素等）
- 支持for循环
多数特性和list一致，不同点在于不可修改的特性。
6.4 数据容器：str(字符串)
字符串是字符的容器，一个字符串可以存放任意数量的字符。
6.4.1 字符串的下标（索引）
和其它容器如：列表、元组一样，字符串也可以通过下标进行访问
- 从前向后，下标从0开始
- 从后向前，下标从-1开始
同元组一样，字符串是一个：无法修改的数据容器。
所以：
- 修改指定下标的字符 （如：字符串[0] = “a”）
- 移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
- 追加字符等 （如：字符串.append()）
均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改
6.4.2 字符串的常用操作
查找特定字符串的下标索引值（index）
语法：字符串.index(字符串)
# 查
my_str = "Python and Java"
print(my_str.index("and")) # 7字符串的替换（replace）
语法：字符串.replace(字符串1，字符串2）
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串哦
# 替换
my_str = "Python and Java"
new_str = my_str.replace("Ja", "C++")
print(new_str) # Python and C++va
print(my_str) # Python and Java可以看到，字符串name本身并没有发生变化
而是得到了一个新字符串对象
字符串的分割（split）
语法：字符串.split(分隔符字符串）
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
# 分割
name = "张三 李四 王五 Python Java Vue"
name_list = name.split(" ")
print(name) # 张三 李四 王五 Python Java Vue
print(name_list) # ['张三', '李四', '王五', 'Python', 'Java', 'Vue']可以看到，字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中。
字符串的规整操作（去前后空格）（strip）
语法：字符串.strip()
# 规整操作
name = " 张三 李四 王五 Python Java Vue "
print(name.strip()) # "张三 李四 王五 Python Java Vue" 字符串的规整操作（去前后指定字符串）（strip）
语法：字符串.strip(字符串)
print(name.strip("ue")) # " 张三 李四 王五 Python Java V"统计字符串中某字符串的出现次数（count）
语法：字符串.count(字符串)
print(name.count("a")) # 2统计字符串的长度（len）
语法：len(字符串)
print(len(name)) #28
- 数字（1、2、3...）
- 字母（abcd、ABCD等）
- 符号（空格、!、@、#、$等）
- 中文
均算作1个字符
字符串常用操作汇总
| 编号 | 操作 | 说明 |
|---|---|---|
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index(字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的 |
| 4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表 |
| 5 | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len(字符串) | 统计字符串的字符个数 |
字符串的遍历
同列表、元组一样，字符串也支持while循环和for循环进行遍历
str1 = "Python and Java"
# while循环
index = 0
while index < len(str1):
print(str1[index])
index += 1
# for循环
for i in str1:
print(i)字符串的特点
- 只可以存储字符串
- 长度任意（取决于内存大小）
- 支持下标索引
- 允许重复字符串存在
- 不可以修改（增加或删除元素等）
- 支持for循环
基本和列表、元组相同
不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。
不同于列表，相同于元组的在于：字符串不可修改
6.5 数据容器（序列）的切片
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
如图，序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
- 起始下标表示从何处开始，可以留空，留空视作从头开始
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示，依次取元素的间隔
- 步长1表示，一个个取元素
- 步长2表示，每次跳过1个元素取
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4] # 下标1开始，下标4（不含）结束，步长1
print(new_list) # 结果：[2, 3, 4]
my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:] # 从头开始，到最后结束，步长1
print(new_tuple) # 结果：(1, 2, 3, 4, 5)
my_list = [1, 2, 3, 4, 5]
new_list = my_list[::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]
my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] # 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple) # 结果：(5, 3)
可以看到，这个操作对列表、元组、字符串是通用的
同时非常灵活，根据需求，起始位置，结束位置，步长（正反序）都是可以自行控制的
6.6 数据容器：set(集合)
为什么使用集合：
通过特性来分析：
- 列表可修改、支持重复元素且有序
- 元组、字符串不可修改、支持重复元素且有序
局限就在于：
- 它们都支持重复元素。
- 如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。
- 而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序
和列表、元组、字符串等定义基本相同：
- 列表使用：[]
- 元组使用：()
- 字符串使用：""
- 集合使用：{}
修改
首先，因为集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。
- 添加新元素
- 语法：集合.add(元素)。将指定元素，添加到集合内
- 结果：集合本身被修改，添加了新元素
- 移除元素
- 语法：集合.remove(元素)，将指定元素，从集合内移除
- 结果：集合本身被修改，移除了元素
- 从集合中随机取出元素
- 语法：集合.pop()，
- 功能，从集合中随机取出一个元素
- 结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
- 清空集合
- 语法：集合.clear()，
- 功能，清空集合
- 结果：集合本身被清空
- 取出2个集合的差集
- 语法：集合1.difference(集合2)，
- 功能：取出集合1和集合2的差集（集合1有而集合2没有的）
- 结果：得到一个新集合，集合1和集合2不变
- 消除2个集合的差集
- 语法：集合1.difference_update(集合2)
- 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
- 结果：集合1被修改，集合2不变
- 2个集合合并
- 语法：集合1.union(集合2)
- 功能：将集合1和集合2组合成新集合
- 结果：得到新集合，集合1和集合2不变
集合长度
- 查看集合的元素数量
- 语法：len(集合)
- 功能：统计集合内有多少元素
- 结果：得到一个整数结果
for循环遍历
集合同样支持使用for循环遍历
要注意：集合不支持下标索引，所以也就不支持使用while循环。
| 编号 | 操作 | 说明 |
| 1 | 集合.add(元素) | 集合内添加一个元素 |
| 2 | 集合.remove(元素) | 移除集合内指定的元素 |
| 3 | 集合.pop() | 从集合中随机取出一个元素 |
| 4 | 集合.clear() | 将集合清空 |
| 5 | 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 |
| 6 | 集合1.difference_update(集合2) | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变 |
| 8 | len(集合) | 得到一个整数，记录了集合的元素数量 |
集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改（增加或删除元素等）
- 支持for循环
6.7 数据容器：dict(字典、映射)
字典的定义
字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
- 使用{}存储原始，每一个元素是一个键值对
- 每一个键值对包含Key和Value（用冒号分隔）
- 键值对之间使用逗号分隔
- Key和Value可以是任意类型的数据（key不可为字典）
- Key不可重复，重复会对原有数据覆盖
字典同集合一样，不可以使用下标索引 但是字典可以通过Key值来取得对应的Value
字典的嵌套
字典的Key和Value可以是任意数据类型（Key不可为字典）
那么，就表明，字典是可以嵌套的
字典的常用操作
- 新增元素
- 语法：字典[Key] = Value，
- 结果：字典被修改，新增了元素
- 更新元素
- 语法：字典[Key] = Value，
- 结果：字典被修改，元素被更新
- 注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
- 删除元素
- 语法：字典.pop(Key)，
- 结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
- 清空字典
- 语法：字典.clear()，
- 结果：字典被修改，元素被清空
- 获取全部的key
- 语法：字典.keys()，
- 结果：得到字典中的全部Key
- 遍历字典
- 语法：for key in 字典.keys()
注意：字典不支持下标索引，所以同样不可以用while循环遍历
- 计算字典内的全部元素（键值对）数量
- 语法：len(字典)
- 结果：得到一个整数，表示字典内元素（键值对）的数量
| 编号 | 操作 | 说明 |
| 1 | 字典[Key] | 获取指定Key对应的Value值 |
| 2 | 字典[Key] = Value | 添加或更新键值对 |
| 3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | 字典.clear() | 清空字典 |
| 5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len(字典) | 计算字典内的元素数量 |
字典的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 每一份数据是KeyValue键值对
- 可以通过Key获取到Value，Key不可重复（重复会覆盖）
- 不支持下标索引
- 可以修改（增加或删除更新元素等）
- 支持for循环，不支持while循环
6.8 数据容器对比总结
数据容器可以从以下视角进行简单的分类：
- 是否支持下标索引
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
- 是否支持重复元素：
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
- 是否可以修改
- 支持：列表、集合、字典
- 不支持：元组、字符串
6.9 数据容器的通用操作
遍历
数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。
首先，在遍历上：
- 5类数据容器都支持for循环遍历
- 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
尽管遍历的形式各有不同，但是，它们都支持遍历操作。
通用统计功能
除了遍历这个共性外，数据容器可以通用非常多的功能方法除了遍历这个共性外，数据容器可以通用非常多的功能方法
通用转换功能
除了下标索引这个共性外，还可以通用类型转换
通用排序功能
通用功能总览
6.10 字符串大小比较
- 1. 字符串如何比较
- 从头到尾，一位位进行比较，其中一位大，后面就无需比较了。
- 2. 单个字符之间如何确定大小？
- 通过ASCII码表，确定字符对应的码值数字来确定大小
898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
