目录
二十八、元组
我们需要在程序内封装数据，又不希望封装的数据被篡改时，列表就不适合了，那我们需要用什么来封装呢？这个时候，不可修改的元组就非常的适合了。
元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于:元组一旦定义完成，就不可修改
1、元组定义：
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 定义元组字面量 (元素,元素,元素) # 定义元组变量 变量名称=(元素，元素，元素) #定义空元组 变量名称=() # 方式1 变量名称 = tuple() # 方式2
这里需要注意一个问题：元组只有一个数据，这个数据后面要添加一个逗号
# 定义一个元素的元组
t2 =('Hello',) # 注意必须带有逗号，否则不是元组类型元组也支持嵌套：
#定义一个嵌套元组
t1 =((1,2,3),(4,5,6))
print(t1[0][0]) # 结果：1这里还有一个需要注意的点，元组不可以修改，但是元组里面的列表能修改
可以修改元组内的list的内容（修改元素、增加、删除、反转等)
#尝试修改元组内容
t1 = (1,2,['ikun','geigei'])
t1[2][1] = 'best'
print(t1) # 结果：(1，2，['ikun'，‘best'])2、元组的方法
| 编号 | 方法 | 作用 |
| 1 | index（） | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count（） | 统计某个数据在当前元组出现的次数 |
| 3 | len（元组） | 统计元组内的元素个数 |
#根据下标（索引）取出数据
t1=(1,2,'he1lo')
print(t1[2]) # 结果：‘hello’
# 根据index（），查找特定元素的第一个匹配项
tl = (1,2,"hello",3,4,'hello')
print(tl.index('hello')) # 结果：2
# 统计某个数据在元组内出现的次数
t2 = (1,2,'hello',3,4,"hello")
print(t2.count("hello")) # 结果：2
# 统计元组内的元素个数
t3 = (1, 2, 3)
print(len(t3)) # 结果33、元组总结
列表有如下特点：
可以容纳多个数据
可以容纳不同类型的数据 （混装）
数据是有序存储的（下标索引）
允许重复数据存在
不可以修改（增加或删除元素等）
支持for循环
多数特性和list一致，不同点在于不可修改的特性。
二十九、字符串
1、字符串解析
尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一员。
字符串是字符的容器，一个字符串可以存放任意数量的字符。
如，字符串："ikun"
和其他容器一样，字符串也可以通过下标进行访问
从前向后，下标从0开始
从后向前，下标从-1开始
#通过下标获取特定位置字符
name ="ikun"
print(name[0]) # 结果 i
print(name[-1]) # 结果 n同元组一样，字符串是一个：无法修改的数据容器。
所以：修改指定下标的字符，移除特定下标的字符，追加字符等，均无法完成
2、常见操作：
①、查找特定字符串的下标索引值
语法：字符串.index（字符串）
str = "ikun and geigei"
print(str.index("and")) # 结果5②、字符串的替换
语法：字符串.replace（字符串1，字符串2）
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改了字符串，而是得到了一个新的字符串
str = "ikun and geigei"
re_str = str.replace("and", "和")
print(re_str) # 结果为ikun 和 geigei③、字符串的分割
语法：字符串.split（分隔符字符串）
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
str = "ikun and geigei"
str_list = str.split(" ")
print(str_list) # 结果为['ikun', 'and', 'geigei']④、字符串的规整操作
语法：字符串.strip（字符串）
说明：当括号里不存在东西时为去前后空格，当括号里为指定字符串的时候则去前后指定字符串.
注意：传入的是“12”，其实就是：“1”和“2”都会移除，是按照单个字符
str = " 12ikun and geigei21 "
strip_str = str.strip()
print(strip_str) # 结果为12ikun and geigei21
strip_str2 = strip_str.strip("12")
print(strip_str2) # 结果为ikun and geigei⑤、统计字符串内某个字符串出现的次数
语法：字符串.count（字符串）
str = "ikun and geigei"
count = str.count("i")
print(count) # 结果为3
⑥、统计字符串的字符个数
语法：len（字符串）
str = "ikun and geigei"
num = len(str)
print(num) # 结果为15
⑦、遍历
同列表、元组一样，字符串也支持while循环和for循环进行遍历
⑧、小结
| 编号 | 操作 | 说明 |
| 1 | 字符串[下表] | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index(字符串) | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1,字符串2) | 将字符串内的全部字符串1，替换为字符串2不会修改原字符串，而是得到一个新的 |
| 4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表 |
| 5 | 字符串.strip() 字符串.stri(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len(字符串） | 统计字符串的字符个数 |
3、字符串总结
作为数据容器，字符串有如下特点：
只可以存储字符串
长度任意（取决于内存大小）
支持下标索引
允许重复字符串存在
不可以修改（增加或删除元素等）
支持for循环
三十、序列的切片
1、序列定义：
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
2、切片：
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法:序列[起始下标：结束下标：步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)
注意：切片操作不会影响到序列本身，而是会得到一个新的序列
# 对List进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4] # 步长默认是1，所以可以省略不写
print(f"结果1:{result1}") # 结果1:[1, 2, 3]
# 对tupLe进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:] # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2:{result2}") # 结果2:(0, 1, 2, 3, 4, 5, 6)
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}") # 结果3：0246
#对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1] # 等同于将序列反转了
print(f"结果4:{result4}") # 结果4:76543210
#对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}") # 结果5：[3, 2]
#对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6:{result6}") # 结果6:(6, 4, 2, 0)
三十一、集合
1、定义：
集合是不允许重复的（去重），无序的（不支持下标索引）
2、基本语法：
| #定义集合字面量 {元素，元素，......，元素} #定义集合变量 变量名称 = {元素，元素，......，元素} #定义空集合 变量名称 = set() |
注意：集合和列表、元组、字符串等定义基本相同，不同的是：
列表使用：[] 元组使用：() 字符串使用："" 集合使用：{}
3、常用操作
①、下标索引访问：
因为集合是无序的，所以集合不支持：下标索引访问
②、添加新元素
语法：集合.add（元素）。将指定元素，添加到集合内
结果：集合本身被修改，添加了新元素
my_set = {"ikun", "and", "geigei"}
my_set.add("lizhi")
print(my_set) # 结果{'lizhi', 'geigei', 'and', 'ikun'}③、移除元素
语法：集合.remove（元素），将指定元素，从集合内移除
结果：集合本身被修改，移除了元素
my_set = {"ikun", "and", "geigei"}
my_set.remove("and")
print(my_set) # 结果{'ikun', 'geigei'}④、随机取出元素
语法：集合.pop（），功能，从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
my_set = {"ikun", "and", "geigei"}
element = my_set.pop()
print(element) # 结果ikun
print(my_set) # 结果{'and', 'geigei'}⑤、清空集合
语法：集合.clear（），将集合内所有元素清空
结果：集合本身被清空
my_set = {"ikun", "and", "geigei"}
my_set.clear()
print(my_set) # 结果set()⑥、取出2个集合的差集
语法：集合1.difference（集合2），功能：取出集合1和集合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} 不变⑦、消除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} ⑧、2个集合合并
语法：集合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}，新集合
print(set1) # 结果：{1，2，3}，set1不变
print(set2) # 结果：{1，5，6}，set2不变⑨、统计元素数量
语法：len（集合）
功能：统计集合元素数量
结果：得到集合内元素的数量
#统计集合元素数量len（）
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(num) # 结果：5⑩、遍历
集合不支持下标索引，不能用while循环但是可以用for循环
⑪ 、小结
| 编号 | 操作 | 说明 |
| 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（集合） | 得到一个整数，记录了集合的元素数量 |
4、集合总结
经过上述对集合的学习，可以总结出集合有如下特点：
可以容纳多个数据
可以容纳不同类型的数据居（混装）
数据是无序存储的（不支持下标索引）
不允许重复数据存在
可以修改文（增加或删除元素等）
支持for循环，不支持while循环
三十二、字典
1、定义：
字典的定义，同样使用{}，不过存储的元素是一个个的：键值对。
2、基本语法：
| #定义字典字面量 {key: value, key: value,......，key: value} #定义字典变量 my_dict = {key: value, key: value,......，key: value} #定义空字典 my_dict = {} # 空字典定义方式1 my_dict = dict() # 空字典定义方式2 |
字典同集合一样，不可以使用下标索引
但是字典可以通过key值来取得对应的Value
#语法，字典[Key]可以取到对应的value
stu_score ={"ikun":99, "geigei":88}
print(stu_score["ikun"]) # 结果99
print(stu_score["geigei"]) # 结果88注意：不能重复定义相同的Key，重复添加等同于覆盖原有数据
字典的Key和Value可以是任意数据类型(Key不可为字典）
那么，就表明，字典是可以嵌套的
#语法，字典[Key]可以取到对应的value
stu_score ={"ikun":{"语文":99, "数学":66}, "geigei":{"语文":88,"数学":77}}
print(stu_score["ikun"]["语文"]) # 结果99
print(stu_score["geigei"]["数学"]) # 结果773、常用操作
①新增元素
语法：字典[Key] = Value，结果：字典被修改，新增了元素
stu_score ={"ikun":99, "geigei":88}
# 新增，lizhi的分数
stu_score["lizhi"]=77
print(stu_score) # 结果：{'ikun': 99, 'geigei': 88, 'lizhi': 77}②、更新元素
语法：字典[Key] = Value，结果：字典被修改，新增了元素
注意：字典Key不可以重复，所以对已存在的key执行上述操作，就是更新Value值
stu_score ={"ikun":99, "geigei":88}
# 修改元素
stu_score["ikun"]=25
print(stu_score) # 结果：{'ikun': 25, 'geigei': 88}③、删除元素
语法：字典.pop（Key），结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
stu_score ={"ikun":99, "geigei":88}
# 删除对应元素
value = stu_score.pop("ikun")
print(value) # 结果：99
print(stu_score) # 结果：{'geigei': 88}④、清空字典
语法：字典.clear（），结果：字典被修改，元素被清空
stu_score ={"ikun":99, "geigei":88}
# 清空字典
stu_score.clear()
print(stu_score) # 结果：{}⑤获取全部的Key
语法：字典.keys（），结果：得到字典中的全部Key
stu_score ={"ikun":99, "geigei":88}
# 获取字典的全部Key，可用于for循环遍历字典
keys = stu_score.keys()
print(keys) # 结果：dict_keys(['ikun', 'geigei'])⑥统计字典元素数量
语法：len（字典），结果： 得到字典内元素的数量
stu_score ={"ikun":99, "geigei":88}
# 计算字典内的元素数量
num = len(stu_score)
print(num) # 结果：2⑦小结
| 编号 | 操作 | 说明 |
| 1 | 字典[Key] | 获取指定Key对应的Value值 |
| 2 | 字典[Key] = Value | 添加或更新键值对 |
| 3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | 字典.clear() | 清空字典 |
| 5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len(字典) | 计算字典内的元素数量 |
4、总结
经过上述对字典的学习，可以总结出字典有如下特点：
可以容纳多个数据
可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value，Key不可重复夏（重复会覆盖）
不支持下标索引
可以修改文（增加或删除更新元素等）
支持for循环，不支持while循环
三十三、数据容器总结
1、简单分类
数据容器可以从以下视角进行简单的分类：
是否支持下标索引
支持：列表、元组、字符串－序列类型
不支持：集合、字典－非序列类型
是否支持重复元素：
支持：列表、元组、字符串－序列类型
不支持：集合、字典－非序列类型
是否可以修改
支持：列表、集合、字典
不支持：元组、字符串
2、使用场景
基于各类数据容器的特点，它们的应用场景如下:
列表：一批数据，可修改、可重复的存储场景
元组：一批数据，不可修改、可重复的存储场景
字符串：一串字符串的存储场景
集合：一批数据，去重存储场景
字典：一批数据，可用Key检索Value的存储场景
3、数据容器总结
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：Value Key：除字典外任意类型 Value：任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
4、容器的通用操作
①、遍历
5类数据容器都支持for循环遍历
列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引)
尽管遍历的形式各有不同，但是，它们都支持遍历操作。
②、len（容器）
统计容器的元素个数
my_list = [1, 2, 3]
my_tuple =(1,2,3, 4, 5)
my_str = "ikun"
print(len(my_list)) # 结果3
print(len(my_tuple)) # 结果5
print(len(my_str)) # 结果4③、max（容器）
统计容器的最大元素
my_list = [1, 2, 3]
my_tuple =(1,2,3, 4, 5)
my_str = "ikun"
print(max(my_list)) # 结果3
print(max(my_str)) # 结果u
print(max(my_tuple)) # 结果5
④、min（容器）
统计容器的最小元素
my_list = [1, 2, 3]
my_tuple =(1,2,3, 4, 5)
my_str = "ikun"
print(min(my_list)) # 结果1
print(min(my_str)) # 结果i
print(min(my_tuple)) # 结果1
⑤、通用转换功能
list（容器）：将给定容器转换为列表
str（容器）：将给定容器转为字符串
tuple（容器）：将给定容器转为元组
set（容器）：将给定容器转换为集合
⑥、通用排序功能
sorted（容器，[reverse = True]）
将给定容器进行排序
⑦、小结
| 功能 | 描述 |
| 通用for循环 | 遍历容器（字典是遍历key） |
| max() | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| sorted(序列,[revers=True]) | 排序，reverse=True表示降序 得到一个排好序的列表 |
1425
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
