目录
数据容器
反向索引
list列表
语法
案例
列表的特点
列表的下表索引
list的常用操作
list列表的遍历
while循环遍历
for循环遍历
tuple元组
前言
元组定义
元组特点
获取元组元素
元组的相关操作
元组的遍历
while循环遍历
for循环遍历
字符串
前言
获取字符串字符
字符串的常用操作
字符串的特点
数据容器的切片操作
序列
切片语法
set集合
集合语法
集合特点
集合的常用操作
集合的遍历
字典
字典定义
字典的特点
通过key获取value
字典的常用操作
遍历字典
数据容器总结
数据容器的通用操作
数据容器通用方法
比较大小
通用容器转换
容器的通用排序功能
数据容器
含义：一种可以容纳多份数据的数据类型，容纳每一份数据称之为一个元素，可以是任意类型的数据，如字符串、数字、布尔等
注意：数据容器根据特点（是否支持重复元素、是否可以修改元素、是否有序等）的不同，可以分为5类，分别是列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）等
反向索引
理解：从后向前的索引，也就是从-1开始，依次递减（-1，-2，-3，……）
#定义列表
my_list=["hello",666,True,888]
print(f"列表第一个元素{my_list[0]},列表最后一个元素{my_list[-1]}")
#列表第一个元素hello,列表最后一个元素888注意：数据容器中支持下标访问的容器都支持反向索引。
list列表
语法
#定义列表
变量名称=[元素1,元素2,元素3,……]#定义空列表
变量名称=[]
变量名称=list()案例
#定义列表
my_list=["hello",666,True,[1,"app"]]
print(f"列表内容为：{my_list}，列表类型为：{type(my_list)}")
#列表内容为：['hello', 666, True, [1, 'app']]，列表类型为：<class 'list'>列表的特点
- 整个列表用[]括起来，列表中的每个元素用逗号隔开
- 列表可以一次存储多个数据，且可以为不同数据类型，支持嵌套所有容器（上限为2**63-1）
- 数据是有序存储的（有下标序号）
- 允许重复数据存在
- 数据可以修改（增加或删除元素等）
- 支持for和while循环遍历
列表的下表索引
前言：我们可以使用列表的下标索引去取出特定位置的数据
理解：在列表中可以存储多个元素，元素是有顺序的，按照顺序从左到右第一个元素他有一个下标索引叫做0，第二个元素索引为1依次类推（从左到右逐步加一）
接收下标索引语法：接受变量=列表名[索引]
注意：使用下标索引时，一定不要超出索引的范围，不然会报错
list的常用操作
查询某元素下标：接受变量=列表.index(元素)
注意：查找指定元素在列表的下标，若找不到，就会报ValueError错误
修改列表指定下标的值：列表[下标]=新值
在指定下标插入指定元素：列表.insert(下标,元素)
追加指定元素在列表尾部：列表.append(元素)
追加一批元素在列表尾部：列表.extend(其他数据容器)
注意：将数据容器的内容依次取出，追加到列表（若是字典只追加key）
删除列表指定下标元素：del 列表[下标]
删除列表指定下标元素并返回删除元素：变量=列表.pop(下标)
删除列表中指定元素：列表.remove(具体元素)
注意：先拿到具体元素，从列表中由前到后搜索，删除匹配的第一个
清空整个列表：列表.clear()
统计某元素在列表内的数量：接受变量=列表.count(具体元素)
统计列表中全部元素数量：接受变量=len(列表)
list列表的遍历
前言：既然数据容器可以存储多个元素，那么就会有需求从容器内依次取出元素进行操作，将容器内的元素依次取出进行处理的行为，称之为遍历
while循环遍历
index=0
while index<len(列表):print(f"列表的第{index+1}个元素为：{列表[index]}")index+=1for循环遍历
index=1
for i in 列表:print(f"列表的第{index}个元素为：{i}")index+=1tuple元组
前言
- 列表是可以修改的，若想要传递的信息不被篡改，列表就不合适了
- 元组同列表一样，都是可以封装多个、不同类型的元素在内，但是元组一旦定义完成，就不可更改（但是元组内的list内容可修改）
元组定义
#定义元组变量
(元素1,元素2,……,元素n)#定义空元组
变量名=()
变量名=tuple()注意：
- 元组定义单个元素，那么一定要在后面写个逗号（"元素",）
- 元组也支持反向索引
元组特点
- 整个元组用()括起来，元组中的每个元素用逗号隔开
- 元组可以一次存储多个数据，且可以为不同数据类型，支持嵌套所有容器
- 数据是有序储存的（有下标索引）
- 允许数据重复存在
- 元素不可修改（但是列表作为元素，列表里的内容可以修改）
- 支持for循环和while循环
获取元组元素
获取元组元素：接受变量=元组名[下标]
元组的相关操作
查找某个元素的下标：接受变量=元组.index(具体元素)
统计元素在元组中出现的次数：接受变量=元组名.count(元素名)
统计元组元素数量：接受变量=len(元组名)
元组的遍历
while循环遍历
index=0
while index<len(元组):print(f"元组的第{index+1}个元素为：{元组[index]}")index+=1for循环遍历
index=1
for i in 元组:print(f"元组的第{index}个元素为：{i}")index+=1字符串
前言
- 尽管字符串看起来并不像列表、元组那样，一看就是存放许多数据类型的容器，但不可否认，字符串同样也是数据容器中的一员
- 字符串是字符的容器，一个字符串可以存放任意数量的字符
- 字符串和其他容器一样也可以通过下标进行访问（从前到后下标从0开始、从后向前下标从-1开始）
- 同元组一样，字符串是不可修改的数据容器；若必须要做，我们只能得到一个新字符串
获取字符串字符
获取字符串字符：接收变量=字符串[下标]
字符串的常用操作
查找特定字符串的下标索引值：接受变量=字符串.index(字符串)
str="i love you" n=str.index("love") print(f"love在字符串的下标索引为：{n}")#2将字符串内的字符串1全部替换为字符串2：字符串.replace(字符串1,字符串2)
注意：这里并不是修改字符串本身，而是得到一个新的字符串
字符串分割：列表对象=字符串.split(分隔符字符串)
功能：按照指定的分隔符，将字符串划分为多个字符串，并存取列表对象中（这里字符串本身不变，而是得到一个列表对象）
去除字符串前后空格以及回车符：接收变量=字符串.strip()（字符串本身不变)
去除前后指定的字符串：接受变量=字符串.strip(指定的字符串)（字符串本身不变)
str="12i love you21" str_1=str.strip("12") print(f"去除12后字符串的内容为：{str_1}") #去除12后字符串的内容为：i love you注意：这里的指定字符串指将这个指定的字符串分为子串后，再看前后固定长度的字符串是否都含有该字串，有则去掉
统计字符串中某个字符串出现的次数：接受变量=字符串.count(子串)
统计字符串的总长度：接受变量=len(字符串)
字符串的特点
- 字符串作为数据容器只能存储字符串
- 字符串长度任意（取决于内存大小）
- 支持下标索引
- 允许重复字符串存在
- 字符串内容不可修改（可以创建一个新的字符串）
- 支持for，while循环
数据容器的切片操作
序列
序列：序列是指内容连续、有序、可使用下标索引的一类数据容器
注意：
- 列表、元组、字符串都可以称为序列
- 序列支持切片操作（从一个序列中取出一个子序列）
- 切片操作并不会影响到序列本身，而是得到一个新的序列
切片语法
切片语法：新序列=序列[起始下标:结束下标:步长]
理解：表示从序列中，指定位置开始，依次取出元素，直到指定位置结束，得到一个新序列
具体解释
- 起始下标：表示从何处开始，可以留空，留空视作从头开始
- 结束下标：表示何时结束，可以留空，留空表示截取到结尾
- 步长：表示依次取元素的间隔，也可以为负数表示倒着取（默认为1）
my_list=[0,1,2,3,4,5,6]
new_list=my_list[1:5:1]
print(f"切片得到的新序列为：{new_list}")
#切片得到的新序列为：[1, 2, 3, 4]
f_list=my_list[5:1:-1]
print(f"切片得到的新序列为：{f_list}")
#切片得到的新序列为：[5, 4, 3, 2]set集合
前言：若场景需要对内容做去重处理，那么列表，元组，字符串就不方便了。而集合最主要的特点就是不支持元素的重复（自带去重功能，并且内容无序）
集合语法
#定义集合变量
变量名称={元素1,元素2,……,元素n}
#定义空集合
变量名称=set()集合特点
- 整个集合用{}括起来，集合中的每个元素用逗号隔开
- 集合可以容纳多个不同类型的数据，集合不支持嵌套
- 数据是无序的，不支持下标索引
- 不允许重复数据存在
- 可以修改元素内容
- 仅支持for循环遍历
集合的常用操作
添加新元素：集合.add(元素)
移除元素：集合.remove(元素)
从集合中随机取出一个元素：接受变量=集合.pop()
清空集合：集合.clear()
取两个集合的差集：新集合=集合1.difference(集合2)
注意：取出集合1有而集合2没有的，得到一个新集合，集合1和集合2本身没有任何改变
消除两个集合的差集：集合1.difference_update(集合2)
注意：对比集合1和集合2，在集合1内，删除和集合2相同的元素，结果集合1被修改，集合2不变
两个集合合并为1个：新集合=集合1.union(集合2)
注意：将集合1和集合2组合成新集合，结果得到新集合，集合1和集合2不变
统计集合元素数量：变量=len(集合)
集合的遍历
注意：集合不支持下标索引，所以不支持while循环
my_set={1,2,3,4,5}
for i in my_set:print(f"集合的元素为：{i}")字典
前言：通过字典，我们可以实现从key取出value的操作
字典定义
#定义字典变量
变量名={key:value,……,key:value}
#定义空字典
变量名={}
变量名=dict()注意：
- 根据字典我们可以实现从key取出value的操作
- 字典的key不允许重复，若有重复的key，则后面的key会把前面的键值对会把前面的键值对覆盖
- 字典同集合一样，不可以使用下标索引，但是字典可以通过key值来取得对应的value
- 字典的value支持嵌套，key不可嵌套
- 字典若被其他容器嵌套，那么字典只会将key作为其他容器的元素
字典的特点
- 字典的定义，同样使用{}，不过存储的元素是一个个的键值对，每个键值对用逗号隔开，一个键值对一起称为一个元素
- 可以容纳多个不同类型的数据
- 每一份数据都是由key和value键值对组成
- 可以通过key获取到value，数据是无序的，key不可重复
- 不支持下标索引
- 可以修改或增加元素
- 支持for循环不支持while循环
通过key获取value
语法：变量=字典[key]
字典的常用操作
新增/更新元素：字典[key]=value
删除并取出元素：变量=字典.pop(key)
清空字典：字典.clear()
获取全部key：列表对象=字典.keys()
统计字典的元素数量：变量=len(字典)
遍历字典
前言：因为字典没有下标，所以仅支持for循环遍历
#方式1
for key in 字典.keys():print(f"字典的key是：{key}")print(f"字典的value是：{字典[key]}")#方式2
for key in 字典:print(f"字典的key是：{key}")print(f"字典的value是：{字典[key]}")数据容器总结
数据容器的通用操作
前言：数据容器尽管各自有各自的特点，但是他们也有通用的一些操作
- 遍历上5类数据容器都支持for循环遍历，列表、元组、字符串支持while循环，集合、字典不支持（没有下标索引）
- 数据容器可以通用非常多的功能方法，如len()
数据容器通用方法
比较大小
查找容器最大元素：变量=max(容器)
查找容器最小元素：变量=min(容器)
注意：
- 字符串比较大小是根据字符串的ASCII码值比较
- 字典比较大小比较的是key值的大小
通用容器转换
将给定容器转为列表：变量=list(容器)
将给定容器转为字符串：变量=str(容器)
将给定容器转为元组：变量=tuple(容器)
将给定容器转为集合：变量=set(容器)
注意：字典可以转换为别的容器（转换成字符串，那么value就会保留，转换成其他的value就会丢失），但别的容器不可以转换为字典。
容器的通用排序功能
将给定容器进行排序：列表对象=sorted(容器,[reverse=true])
注意：
- 若想容器的排序进行反转，那么就将reverse的参数改为true
- 排序后的结果统统变为列表对象
- 字典的排序是对key值的排序
