Python数据容器的前言
Python的数据容器例如：set、dic、tuple等等都是Python语言特有的。
对于我来说是全新的东西，所以我将用案例来帮助咱们理解Python各个数据容器的特点
目录
一. 数据容器
- 数据容器出现的意义是什么？
思考一个问题：如果我们想要再程序中，记录5名学生我的信息，如姓名。该怎么做？
依照以前的知识我们只能像左边的语句去写
但是我们运用数据容器后简单的一行代码即可以解决
- 总结下：Python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
- 数据容器根据特点的不同，有的特点：
- 是否支持重复元素
- 是否可以修改
- 是否有序，等
- 数据容器的分类：
- 列表（List） 、元组（Tuple）、字符串（Str）、集合（Set）、字典（Dic）
二.List列表
基本语法
- 以[ ]作为标识
- 列表内每一个元素，用逗号隔开
python
#字面量
[元素1，元素2，元素3，元素4，......]
#定义变量
变量名称 = [元素1，元素2，元素3，元素4，......]
#定义空列表
变量名称=[]
变量名称list（） 下标索引
- 列表中的每一个元素，都有其位置下标索引，我们只需要按照下标索引，即可取得对应位置的元素。
- 从前向后方向，从0开始依次递减
- 从后向前方向，从-1开始依次递减
- 下标索引的注意事项：
- 注意下标索引的取值范围，超出范围无法取出元素，并且会报错
- 列表元素的类型
- 元素的数据类型没有任何限制，甚至元素也可以是列表，这也就是嵌套列表
常用操作（方法）
- 前言：什么叫做方法？函数与方法有什么区别
-
在python里，如果函数定义为class（类）的成员，那么函数会称之为：方法
-
方法和函数的功能一样，有传入参数，有返回值，只是方法的使用格式不同
-
python
#函数：
def add(x,y):
return x+y
#方法
class Student:
def add(x,y):
return x+y
#函数的使用
num = add(1,2)
#方法的使用
student=Student
num = student.add(1,2)index查找某元素的下标
- 功能：查找指定元素在列表的下标，如果找不到，报错ValueError
- 语法：列表.index(元素)
修改特定位置（索引）的元素值
- 语法：列表[下标]=值
python
#正向下标
my_list = [1,2,3]
my_list[0] = 5
print(my_list) #结果：[5,2,3]insert插入元素
- 功能：在指定下标，插入指定元素 。
- 语法：列表.insert(下标，元素)
- 说明：参数中下标，是插入后元素的下标
python
my_list = [1,2,3]
my_list.insert(1,"junsheng")
print(my_list) #结果：[1,"junsheng",3,4]append追加元素
- 功能：将指定元素，追加在列表的尾部
- 语法：列表.append(元素)
python
my_list = [1,2,3]
my_list.append(4)
print(my_list) #结果：[1,2,3,4]extend追加元素方式2
- 功能：将其他数据容器取出，依次追加到列表尾部
- 语法：列表.extend(其他数据容器)
python
my_list = [1,2,3]
my_list.append([4,5,6])
print(my_list) #结果：[1,2,3,4,5,6]删除元素
- 第一种方法：
- 语法1：del 列表[下标]
- 第二种方法：
- 语法2：列表.pop(下标)
- 注意：这两种方法在使用上有一定的区别的，关键字删除是进行删除，使用方法删除我们可以把删除的值返回回去
python
my_list = [1,2,3]
#方式1
del my_list[0]
print(my_list) #结果：[2,3]
#方式2
my_list.pop(0)
print(my_list) #结果：[3]remove删除某元素
- 功能：删除某元素在列表中第一个匹配项，也就是指定元素删除
- 语法：列表.remove(元素)
python
my_list = [1,2,3,2,3]
my_list.remove(2)
print(my_list) #结果：[1,3,2,3]clear清空列表
- 语法：列表.clear()
python
my_list = [1,2,3]
my_list.clear()
print(my_list) #结果：[]count统计元素
- 功能：统计某元素在列表内的数量
- 语法：列表.count(元素)
python
my_list = [1,1,1,2,3]
print(my_list.count(1)) #结果：3len计算总数
- 功能：统计列表内，有多少元素
- 语法：len（列表）
- 返回值：可以得到一个int数字，表示列表内的元素数量
python
my_list = [1,1,1,2,3]
print(my_list.len(my_list)) #结果：5总结
- 列表的特点：
- 可以容纳多个元素（2**63-1，9223372036854775807个）
- 可以容纳不同类型的元素（混装）
- 数据是有序存储的（带下标序号）
- 允许重复数据存在
- 可以修改（增加或删除元素等）
| 列表.append(元素) | 将指定元素，追加在列表的尾部 |
|---|---|
| 列表.extend(其他数据容器) | 将数据容器的内容依次取出，追加到列表的尾部 |
| 列表.insert(下标，元素) | 在指定下标，插入指定元素 |
| del 列表[下标] | 删除列表指定下标元素 |
| 列表.pop(下标) | 删除列表指定下标元素 |
| 列表.remove(元素) | 从前向，删除此元素第一个匹配项 |
| 列表.clear() | 清空列表 |
| 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 列表.index(元素) | 查找指定元素在列表的下标，找不到报错ValueError |
| len（列表） | 统计容器内有多少元素 |
三、元组
- 元组出现的意义？
- 列表是可以修改的。如果想要传递的信息，不被篡改，列表就不合适了。
- 元组同列表一样，都是可以封装多个、不同类型的元素在内。最大的不同
元组一旦完成，就不可以修改
基本语法
- 元组的定义：定义元组使用
小括号、且使用逗号隔开各个数据，数据可以是不同类型 元组只有一个数据，这个数据后面要添加逗号- 注意：不可修改元组的内容
但是可以修改嵌套元组中元组的内容
python
#定义元组字面量
(元素,元素,元素,...,元素)
#定义元组变量
变量名称 =(元素,元素,...,元素)
#定义空元组
变量名称 =() #方式1
变量名称 =tuple()#方式2
#定义1个元素的元组
t2=('Hello',) #注意，必要带有逗号，否则不是元组类型
#尝试修改元组内容
t1 =(1,2,['shuaige','meinv'])
t1[2][1] ='best'
print(t1) #结果（1，2，['shuaige'，'best']）下标索引
- 下标索引取tuple的元素，跟列表一样，我们取元素都是用[ ]
常用操作
| 元组.index(元素) | 查找指定元素在列表的下标，找不到报错ValueError |
|---|---|
| 列表.count(元素) | 统计此元素在列表中出现的次数 |
| len(元组) | 统计容器内有多少元素 |
总结
- 元组的特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 数据是有序存储
- 允许重复数据存在
不可修改（增加或者删除元素等）
多数特征与list一致，不同点在于不可修改的特性
四、字符串
- 同元组一样，字符串是一个无法修改的容器
常用操作
replace字符串的替换
- 功能：将字符串内的全部：字符串1，替换成字符串2
- 语法：字符串.replace(字符串1，字符串2)
- 注意：
不是修改字符串本身，而是得到了一个新字符串(需要一个变量接收)
python
my_str="it is best"
new_my_str=my_str.replace("it","程序")
print(f"将字符串{my_str},进行替换后得到：{new_my_str}")
# output：将字符串it is best,进行替换后得到：程序 is bestsplit字符串分隔
- 功能：按照
指定的分隔符分隔字符串，将字符串划分为多个字符串，并存入列表对象 - 语法：字符串.split(分隔符)
- 注意：字符串本身不变，而是得到一个
列表对象
python
my_str="hello Python"
new_my_str=my_str.split(" ")
print(f"将字符串{my_str},进行分隔后得到：{new_my_str},类型是：{type(new_my_str)}")
# output：将字符串it is best,进行分隔后得到：['hello','Python'],类型是：<class 'list'>strip规整操作
- 功能：去除字符串所有的某个指定内容，默认是空格
- 语法：字符串.strip()；字符串.strip(指定字符串)
- 注意：指定的字符串是多个字符构成的时候，是把指定字符串
按照单个字符然后判断的
python
my_str="12hello Python21"
new_my_str=my_str.strip("12")
print(f"将字符串{my_str},进行分隔后得到：{new_my_str},类型是：{type(new_my_str)}")
# output：将字符串12hello Python21,进行分隔后得到：hello Python
#注意规整是把指定字符串拆分单个字符总结
| 字符串[下标] | 根据 |
|---|---|
| 字符串.index(字符串) | 根据下标索引取出特定位置字符 |
| 字符串.replace(字符串1，字符串2) | 查找给定字符的第一个匹配项的下标 |
| 字符串.split(字符串) | 将字符串内的全部字符串1，替换为字符串2；结果是列表 |
| 字符串.strip() | 移除首位的空格和换行符 |
| 字符串.strip(字符串) | 移除指定字符串 |
| 字符串.count(字符串) | 统计字符串内某字符串出现次数 |
| len(字符串) | 统计字符串的字符个数 |
五、序列
- 序列是指：内容连续、有界，可使用下标索引的一类数据容器
- 列表、元组、字符串均可以是为序列
基本操作
切片
-
功能：根据下标取出值
-
语法：序列[起始坐标：结束下标：步长]
- 起始坐标表示从何开始，可以留空，留空视作从头开始
- 结束下标（取不到下标元素）表示从何处结束,可以留空，留空十位截取到结尾
- 步长表示，依次取元素的间隔
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，方向取（起始和结束下标也要反向标记）
-
注意：List Tuple Str都是序列，都可以使用下标索引，因为Tuple和str的存在，所以我们的序列的切片操作也是不会影响序列本事，而是生成新序列
六、集合
-
集合存在的意义
- 列表可修改、支持重复元素且有序
- 元组、字符串不可修改、支持重复元素且有序
-
这些存在局限：它们都支持重复元素，如果场景需要去重，那么集合的产生就是去重
基本语法
python
#定义集合字面量
{元素，元素，元素，....元素}
#定义集合变量
集合名称 ={元素，元素，元素，....元素}
#定义空集合
变量名称 = set()set()空集合；set（）不仅表示构造函数，表示空集合
- 和列表、元组、字符串等定义基本相同
- 列表：[ ]
- 元组：()
- 字符串：""
- 集合：{}
- 注意：集合中顺序是没办法保证的，不允许重复的，无序的不能下标索引
基本操作
add添加新元素
- 功能：将指定元素，添加到集合内，集合本身被修改，添加了新元素
- 语法：集合.add(元素)
- 结果：集合本身被修改，添加新元素
pop随机取出元素
- 功能：从集合中随机取出一个元素会得到一个元素的结果。同样集合本身被修改，元素被移除
- 语法：集合.pop()
- 结果：集合被修改
python
my_set ={"Hello","world","shuaige"}
element =my_set.pop()#集合本身被修改了
print(my_set) #{'world','shuaige'}
print(element) #output:'Hello'remove移除元素
- 功能：集合本身被修改，移除了元素，将指定元素，从集合内移除
- 语法：集合.remove(元素)
- 结果：集合被修改
clear清空集合
- 功能：清空集合
- 语法：集合.clear()
- 结果：集合被清空
difference取出两个集合的差集
- 功能：取出集合1和集合2的差集（集合1有而集合2没有的），得到一个新集合
集合1和集合2不变 - 语法：集合1.difference（集合2）
- 结果：集合1和集合2不变，得到一个新集合
python
set1 ={1,2,3}
set2 ={1,5,6}
set3 =set1.difference(set2)
print(set1) #output {1,2,3}
print(set2) #output {1,5,6}
print(set3) #output {2,3}difference_updata消除两个集合的差集
- 功能：对比集合1和集合2，将difference的数据给集合1
- 语法：集合1.difference_updata(集合2)
- 结果：集合1被修改，集合2不变
python
set1 ={1,2,3}
set2 ={1,5,6}
set3 =set1.difference_updata(set2)
print(set1) #output {2,3}
print(set2) #output {1,5,6}两个集合合并
- 功能：将集合1和集合2组合成新集合
- 语法：集合1.union(集合2)
- 结果：得到新集合，集合1和集合2不变
python
set1 ={1,2,3}
set2 ={1,5,6}
set3 =set1.union(set2)
print(set1) #output {1,2,3}
print(set2) #output {1,5,6}
print(set3) #output{1,2,3,5,6}总结
| 集合.add(元素) | 将指定元素，添加到集合内 |
|---|---|
| 集合.pop() | 从集合中随机取出一个元素 |
| 集合.remove(元素) | 将指定元素，从集合内移除 |
| 集合.clear() | 清空集合 |
| 集合1.difference（集合2） | 取出集合1和集合2的差集（集合1有而集合2没有的） |
| 集合1.difference_updata(集合2) | 对比集合1和集合2，将difference的数据给集合1 |
| 集合1.union(集合2) | 将集合1和集合2组合成新集合 |
- 集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据（混装）
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改
- 只能for循环
七、字典
基本语法
- 字典的定义，同样使用{}，不过存储的元素是一个个的：键值对
- 字典和集合一样，不可以用下标索引,
但是字典可以通过key值来取得对应的Value
python
#定义字典字面量
{Key:Value,Key:Value,...}
#定义字典变量
字典名称={Key:Value,Key:Value,...}
#定义空字典
字典名称={}
字典名称=dic()
#找Value值
Stu_core=["早克拉":99，"那杰买提":88]
print(Stu_core["早克拉"]) # output 99- 注意：
如果Key写重复了，后面的Key会覆盖前面的Key
python
Stu_core=["早克拉":99，"早克拉"：100"那杰买提":88]
print(Stu_core["早克拉"]) # output 100字典里面的Key和Value可以是任意数据类型（Key不可为字典）