（一） 数据容器入门
1. 数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素。每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
2.. 种类：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）
（二） 数据容器：list（列表）
1. 定义
（1） 基本语法：
# 字面量
[元素1 ，元素2 ，元素3，……]
# 定义变量
变量名称 = [元素1 ，元素2 ，元素3，……]
# 定义空列表
变量名称 = []
变量名称 = list（）
（2） 元素：列表中的每个数据
列表可以一次存储多个数据，且可以为不同类型，支持嵌套
2. 列表的下标索引
（1） 类型：正向：从前向后，从0开始，依次递增
反向：从后向前，从-1开始，依次递减
（2） 使用：
列表[下标]
下标超出范围，则无法取出元素，并且会报错
3. 列表的常用操作（方法）
* 函数：封装的代码单元，可提供特定功能。
如将函数定义为class（类）的成员，则称函数为方法。
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | index | 列表.index（元素） | 查找指定元素在列表中的下标，找不到则报错ValueError |
| 2 | len | len（列表） | 统计容器中有多少元素 |
| 3 | count | 列表.count（元素） | 统计此元素在列表中出现的次数 |
| 4 | del | del 列表[下标] | 删除列表指定的下标元素 |
| 5 | pop | 列表.pop[下标] | 删除列表指定的下标元素 |
| 6 | remove | 列表.remove（元素） | 从前向后，删除此元素的第一个匹配项 |
| 7 | append | 列表.append（元素） | 向列表中追加一个元素 |
| 8 | extend | 列表.extend（容器） | 将数据容器中的内容依次取出，追加到列表尾部 |
| 9 | insert | 列表.insert（下标，元素） | 在指定下标处，插入指定的元素 |
| 10 | clear | 列表.clear（） | 清空列表 |
| 11. | sort | list.sort() | 对列表中的元素进行排序。 |
| 12. | reverse | list.reverse() | 倒排列表中的元素。 |
4. 列表的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改.
age = [21, 25, 21, 23, 22, 20]
age.append(31)
print(age)
age.extend([29, 33, 30])
print(age)
x = age[0]
y = age[-1]
print(x, y)
a = age.index(31)
print(a)
练习2：
#
a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count('x'))#统计此元素在列表中出现的次数
#
a.insert(2, -1)#在指定下标处，插入指定的元素
a.append(333)#向列表中追加一个元素
print(a)
#
a.index(333)#返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
print(a.index(333))
#
a.remove(333)#从前向后，删除此元素的第一个匹配项
print(a)
#
a.reverse() #倒排列表中的元素。
print(a)
#
a.sort()#对列表中的元素进行排序。
print(a)
（三） list（列表）的遍历
遍历：将容器内的元素依次取出，并处理
1. 使用while遍历
可以指定循环条件，自行控制
可以通过条件控制做到无限循环
适用于任何想要循环的场景
2. 使用for遍历
不可以指定循环条件，只可以一个个从容器内取出数据
理论上不可以无限循环，因为被遍历的容器容量不是无限的
适用于遍历数据容器的场景或简单的固定次数循环场景
练习：
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l1 = list()
l2 = list()
i = 0
# 取出偶数
while i < len(L):
if L[i] % 2 == 0:
l1 . append(L[i])
i = i + 1
else:
i = i + 1
print(f"通过while循环，从列表：{L}，中取出偶数，组成新列表{l1}")
for j in L:
if j % 2 == 0:
l2 . append(j)
print(f"通过for循环，从列表：{L}，中取出偶数，组成新列表{l2}")（四） 数据容器：tuple（元组）
* 元组一旦定义，不可进行修改
1. 元组的定义
（1） 基本语法：
# 字面量
（元素1 ，元素2 ，元素3，……）
# 定义变量
变量名称 =（元素1 ，元素2 ，元素3，……）
# 定义空列表
变量名称 = （）
变量名称 =tuple（）
元组即使只含有一个数据，这个数据后也要添加，也可进行嵌套
2. 元组的操作（方法）
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | index | index（） | 查找指定数据在元组中的下标，找不到则报错 |
| 2 | len | len（元组） | 统计元组内有多少元素 |
| 3 | count | count（） | 统计某个数据在元组中出现的次数 |
！ 不可修改元组内容，否则直接报错
！ 可修改元组内list的内容
！ 不可以替换元组内list为其他list或其他类型
3. 元组的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
- 可进行循环
- 不可修改
练习：
T = ('周杰伦', 11, ['football', 'music'])
a = T.index(11)
n = T[0]
print(a,n)
del T[2][0]
T[2].append('coding')
print(T)
（五） 数据容器：str（字符串）
1. 字符串
字符的容器，一个字符串可以存放任意数量的字符。
2. 字符串的下标（索引）
从前向后，下标从0开始
从后向前，下标从-1开始
！ 字符串是一个无法修改的数据容器
！ 如果要修改，则会得到一个新的字符串，旧的字符串是无法修改的
3. 字符串的常用操作
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 | |
| 2 | index | 字符串.index（字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | replace | 字符串.replace（字符串1，字符串2） | 将字符串内的全部字符串1，替换为字符串2 ！不会改变原字符串，而是得到一个新的字符串 |
| 4 | split | 字符串.split（字符串） | 按照给定字符串，对字符串进行分割 ！不会改变原字符串，而是得到一个新的列表 |
| 5 | strip | 字符串.strip（） 字符串.strip（字符串） | 移除首尾的空格和换行符或指定字符串 |
| 6 | count | 字符串.count（字符串） | 统计字符串内某字符串的出现次数 |
| 7 | len | len（字符串） | 统计字符串的字符个数 |
4. 字符串的特点
- 只可以存储字符串
- 长度任意
- 支持下标索引
- 允许重复的字符串出现
- 不可以修改
- 支持循环
练习：
S = "itheima itcast boxuegu"
n = S.count("it")
print(f"字符串{S}中有{n}个it字符")
S1 = S.replace(" ", "|")
print(f"字符串{S}，被替换空格后，结果{S1}")
L = S1.split("|")
print(f"字符串{S}，按照“|”分割后，得到{L}")
（七） 数据容器：set（集合）
1. 集合的基本语法
# 定义集合字面量
（元素，元素，……，元素）
# 定义集合变量
变量名称 = {元素，元素，……，元素}
# 定义空集合
变量名称 = set（）
！ 去重且无序，无法保证顺序与创建的时候一致
！ 不支持：下标索引访问，因此不支持while循环
补充：
定义：
列表[] 可修改、支持重复元素且有序
元组（） 不可修改、支持重复元素且有序
字符串“” 不可修改、支持重复元素且有序
集合{} 可修改、不支持重复元素、无序
2. 集合的常用功能
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | add | 集合.add（元素） | 集合内添加一个元素 |
| 2 | remove | 集合.remove（元素） | 移除集合内指定的元素 |
| 3 | pop | 集合.pop（） | 从集合中随机取出一个元素 |
| 4 | clear | 集合.clear（） | 将集合清空 |
| 5 | difference | 集合1.difference（集合2） | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 |
| 6 | update | 集合1.difference_update（集合2） | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | union | 集合1.union（集合2） | 得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变 |
| 8 | len | len（集合） | 得到一个整数，记录了集合的元素数量 |
3. 集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标存储）
- 不允许重复数据存在
- 可以修改
- 支持for循环，不支持while循环
练习：
my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
S = set()
for i in my_list:
S.add(i)
print(f"有列表：{my_list}")
print(f"存入集合后结果：{S}")
（八） 数据容器：dict（字典、映射）
1. 字典的基本语法
# 定义字典字面量
{key：value，key：value，……，key：value}
# 定义字面变量
my_dict = {key：value，key：value，……，key：value}
# 定义空字典
my_dict = {}
my_dict = dict{}
！ 每个元素均为键值对，key和value可以为任意类型数据（key不可为字典）
！ key不可重复，重复会对原有数据覆盖
！ 不可以使用下标索引，但可通过key值取得对应的value，不可使用while循环
！ 字典可嵌套
2. 字典的常用操作
| 编号 | 关键字 | 使用方法 | 作用 |
| 1 | 字典[Key] | 获取指定Key对应的Value值 | |
| 2 | 字典[Key] = Value | 添加或更新键值对 | |
| 3 | pop | 字典.pop（Key） | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | clear | 字典.clear（） | 清空字典 |
| 5 | keys | 字典.keys（） | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len | len（字典） | 计算字典内的元素数量 |
3. 字典的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 不支持下标索引
- 可以修改
- 支持for循环，不支持while循环
练习：
D = {
"王力鸿":{"部门":"科技部","工资":3000,"级别":1},
"周婕纶":{"部门":"市场部","工资":5000,"级别":2},
"凌俊杰":{"部门":"市场部","工资":7000,"级别":3},
"张雪有":{"部门":"科技部","工资":4000,"级别":1},
"牛德华":{"部门":"市场部","工资":6000,"级别":2}
}
keys = D.keys()
print(D)
for key in keys:
if D[key]["级别"] == 1:
D[key]["工资"] = D[key]["工资"] + 1000
print(D)
扩展：数据容器的对比总结
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：除字典外任意类型 Value：任意类型 |
| 下标索引 | ✓ | ✓ | ✓ | × | × |
| 重复元素 | ✓ | ✓ | ✓ | × | × |
| 可修改性 | ✓ | × | × | ✓ | ✓ |
| 数据有序 | ✓ | ✓ | × | × | × |
| 使用场景 | 可修改、可重复的一批数据的记录 | 不可修改、可重复的一批数据的记录 | 一串字符的记录 | 不可重复的数据记录 | 以Key检索Value的数据记录 |
（九） 数据容器的通用操作
| 序号 | 功能 | 描述 |
| 1 | for循环 | 遍历容器（字典是遍历key） |
| 2 | max（） | 容器内最大元素 |
| 3 | min（） | 容器内最小元素 |
| 4 | len（） | 容器内元素个数 |
| 5 | list（） | 转换为列表 |
| 6 | tuple（） | 转换为元组 |
| 7 | str（） | 转换为字符串 |
| 8 | set（） | 转换为集合 |
| 9 | sorted（序列，[reverse = True]） | 排序，得到一个排好序的列表 reverse = True表示“降序” |
（十）综合案例
练习题1：
# 幸运数字6：
# 1. 输入任意数字，如数字8，生成nums列表，元素值为1-8，
# 2. 从中选取幸运数字（能被6整除）移动到新列表lucky
# 3. 打印nums和lucky
n = int(input("请输入您所想的数字："))
i = 1
j = 0
nums = list()
lucky = list()
print(n)
while i <= n:
nums.append(i)
i = i + 1
print(f"nums列表为：{nums}")
for j in nums:
if j % 6 == 0:
lucky.append(j)
j = j + 1
print(f"lucky列表为：{lucky}")结果1：
结果2：
练习题2：
# 列表嵌套：
# 3个教室[[],[],[]]
# 8名讲师['A','B','C','D','E','F','G','H']
# 随机分配
import random
classroom = [[],[],[]]
teacher = ['A','B','C','D','E','F','G','H']
j = random.randint(0,2)
for i in teacher:
classroom[j].append(i)
j = random.randint(0,2)
print(f"分配后为：{classroom}")
