1.1 元组
思考：列表是可以修改的。如果想要传递的信息不被篡改，列表就不合适了。
元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改。
所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组非常合适。
定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 定义元组字面量
（元素，元素，......，元素）
# 定义元组变量
变量名称 = （元素，元素，......，元素）
# 定义空元组
变量名称 = （）
变量名称 = tuple（）元组的相关操作
| 编号 | 方法 | 作用 |
| 1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |
"""
演示tuple元组的定义和操作
"""
from itertools import count
# 定义元组
t1 = (1,'Hello',True)
# 定义空元组
t2 = ()
t3 = tuple()
print(f"{t1}的类型是：{type(t1)}")
print(f"{t2}的类型是：{type(t2)}")
print(f"{t3}的类型是：{type(t3)}")
# 定义单个元素的元组
# 注意，元组只有一个数据时，这个数据后面要添加逗号
t4 = (1,)
# 元组的嵌套
t5 = (1,(2,),3)
print(f"{t5}的类型是：{type(t5)}")
# 下标索引去取出内容
print(f"{t5[1][0]}的类型是：{type(t5)}")
# 元组的操作，index查找方法
index_tuple = t5.index(1)
print(f"t5的t5[1][0]位元素是：{t5[1][0]}")
print(f"t5的元素1在第{t5.index(1)}位")
# 元组的操作，count统计方法
count_tuple = t5.count((2,))
print(f"t5里面，2这个元素一共有{t5.count((2,))}个")
# 元组的操作，len函数统计元组元素数量
print(f"t5里面一共有{len(t5)}个元素")
# 元组的遍历：while
def tuple_while_func():
# 声明一个index
tuple_index = 0
while tuple_index < len(t5):
# 依次打印里面的元素
print(f"{(t5[tuple_index])}")
tuple_index += 1
# 调用while循环方法
tuple_while_func()
# 元组的遍历：for
def tuple_for_func():
# for循环
for element in t5:
print(element)
# 调用for循环方法
tuple_for_func()注意事项：
· 不可以修改元组的内容，否则会直接报错；
· 但是可以修改元组内的list内容（修改元素、增加、删除、反转等）
元组的特点：
· 可以容纳多个数据
· 可以容纳不同类型的数据（混装）
· 数据是有序存储的（下标索引）
· 允许重复数据存在
· 不可以修改（增加或删除元素等）
· 支持for循环
1.2 字符串
字符串是字符的容器，一个字符串可以存放任意数量的字符。
字符串的下标（索引）
和其它容器如：列表、元组一样，字符串也可以通过下标进行访问
· 从前向后，下标从0开始
· 从后向前，下标从-1开始
同元组一样，字符串是一个：无法修改的数据容器
所以：
× 修改指定下标的字符 （如：字符串[0] = "a"）
× 移除特定下表的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
× 追加字符等 （如：字符串.append()）
均无法完成。如果必须要做，只能得到一个新的字符串。
"""
演示以数据容器的角色，学习字符串的相关操作
"""
str_str = "asd fggb vxcba sdf"
# 通过下标索引取值
element = str_str[2]
print(element)
# index方法
index = str_str.index('v')
print(index)
# replace方法(是修改成了一个新的字符串)
str_replace = str_str.replace('a','A')
print(str_replace)
# split方法(截取，从哪里截取)（截取之后获得字符串）
str_split = str_str.split(' ')
print(str_split)
# strip方法（去除前后指定字符串）
str_strip = str_str.strip('sdf')
print(str_strip)
# 统计字符串中某字符串的出现次数
str_count = str_str.count('f')
print(str_count)
# 统计字符串的长度
print(len(str_str))| 编号 | 操作 | 说明 |
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index（字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1，字符串2） | 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的字符串 |
| 4 | 字符串.split（字符串） | 按照给定字符串，对字符串进行分隔 不会修改字符串，而是得到一个新的列表 |
| 5 | 字符串.strip() 字符串,strip(字符串) | 移除首尾的空格和换行符或指定字符 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len（字符串） | 统计字符串的字符个数 |
2. 序列
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列。
序列的常用操作 - 切片
切片：从一个序列中，取出一个子序列。
语法：序列[起始下标：结束下标：步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
· 起始下标表示从何处开始，可以留空，留空视作从头开始。
· 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾。
· 步长表示，依次取元素的间隔
· 步长1表示，一个个取元素
· 步长2表示，每次跳过1个元素取
· 步长n表示，每次跳过n-1个元素取
· 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
注意：此操作不会影响序列本身，而是会得到一个新的序列。
"""
演示Python中的序列和切片
"""
# 对list进行切片，从1开始，到4结束，步长1
list_cut_1 = [1,5,6,8,9,4,2,3,7]
print(list_cut_1[1:4:1])
# 对tuple进行切片，从头开始，到最后结束，步长1
tuple_cut = (13,"asdf",["asdf",])
print(tuple_cut[::1])
# 对str进行切片，从头开始，到最后结束，步长2
str_cut_1 = "asdf dfgh hgjk "
print(str_cut_1[::2])
# 对str进行切片，从头开始，到最后结束，步长-1
str_cut_2 = "qwer werrty thhy"
print(str_cut_2[::-1])
# 对列表进行切片，从3开始，到1结束，步长-1
print(list_cut_1[3:1:-1])
# 对元组进行切片，从头开始，到尾结束，步长-2
print(tuple_cut[::-2])3.1 集合
基本语法：
# 定义集合字面量
{元素,元素,......,元素}
# 定义结婚变量
变量名称 = {元素,元素,......,元素}
# 定义空集合
变量名称 = set{}和列表、元组、字符串等定义基本相同：
· 列表使用[]
· 元组使用（）
· 字符串使用”“
· 集合使用{}
集合的常用操作 - 修改
首先，因为集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。
· 添加新元素
语法：集合.add(元素)。将指定元素，添加到集合内
结果：集合本身被修改，添加了新元素
· 移除元素
语法：集合.remove(元素)，将指定元素从集合内移除
结果：集合本身被修改，移除了元素
· 从集合中随机取出元素
语法：集合.pop()，从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
· 取两个集合的差集
语法：集合1.difference(集合2)，取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变
· 消除两个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
结果：集合1被修改，集合2不变。
· 两个集合合并
语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变
| 编号 | 操作 | 说明 |
| 1 | 集合.add(元素) | 集合内添加一个元素 |
| 2 | 集合.remove(元素) | 移除集合内指定的元素 |
| 3 | 集合.pop() | 从集合中随机取出一个元素 |
| 4 | 集合.clear() | 将集合清空 |
| 5 | 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 |
| 6 | 集合1.difference_updata(集合2) | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变 |
| 8 | len(集合) | 得到一个整数，记录了集合的元素数量 |
总结：
· 可以容纳多个数据
· 可以容纳不同类型的数据（混装）
· 数据是无序存储的（不支持下标索引）
· 不允许重复数据存在
· 可以修改（增加或删除元素等）
· 支持for循环
"""
有如下列表：
my_list = ['程序员','青岛','威海','烟台','itcast','itbest','iter']
请：
· 定义一个空集合
· 通过for循环遍历列表
· 在for循环中将列表的元素添加至集合
· 最终得到元素去重后的集合对象，并打印输出
"""
my_list = ['程序员','程序员','程序员','青岛','威海','烟台','烟台','烟台','烟台','itcast','itbest','iter']
# 定义空集合
null_set = set()
# 通过循环将列表的元素加入到集合中
for element in my_list:
# 集合会自动去重
null_set.add(element)
# 打印结果
print(null_set)4.1 字典
定义：同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
# 定义字典字面量
{key: value, key:value,......,key:value}
# 定义字典变量
my_dict = {key: value, key:value,......,key:value}
# 定义空字典
my_dict = {} # 空字典定义方式1
my_dict = dict() # 空字典定义方式2注意：
· 键值对的Key和Value可以是任意类型（key不可为字典）
· 字典内Key不允许重复，重复添加等同于覆盖原有数据
· 字典不可以用下标索引，而是通过Key检索Value
"""
演示字典dict的常用操作
"""
# 定义字典
students_score = my_dict_1 = {"张三": {"语文": 77, "数学": 66, "英语": 99},
"李四": {"语文": 99, "数学": 86, "英语": 39},
"王二": {"语文": 97, "数学": 65, "英语": 100}}
# 新增元素
students_score['刘五'] = {"语文": 100, "数学": 100, "英语": 99}
print(students_score)
# 更新元素 注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
students_score['张三'] = {"语文": 10, "数学": 1, "英语": 99}
print(students_score)
# 删除元素
students_score.pop('张三')
print(students_score)
# 清空元素
# students_score.clear()
# print(students_score)
# 获取全部的Key
all_keys = students_score.keys()
print(all_keys)
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in all_keys:
print(f"字典的key是：{key},对应的value是：{my_dict_1[key]}")
# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key_1 in all_keys:
print(key_1)
# 统计字典内的元素数量
num = len(students_score)
print(num)
| 编号 | 操作 | 说明 |
| 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循环
"""
字典dict的实战
"""
stuff_dict = {"王力宏": {"部门": "科技部", "工资": 3000, "级别": 1},
"周杰伦": {"部门": "市场部", "工资": 5000, "级别": 2},
"林俊杰": {"部门": "市场部", "工资": 7000, "级别": 3},
"张学友": {"部门": "科技部", "工资": 4000, "级别": 1},
"刘德华": {"部门": "市场部", "工资": 6000, "级别": 2}}
# 通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元
for stuff in stuff_dict:
# 如果员工的级别为1级
if stuff_dict[stuff]["级别"] == 1:
# 级别 + 1
stuff_dict[stuff]["级别"] += 1
# 工资 + 1000
stuff_dict[stuff]["工资"] += 1000
print(stuff_dict)5.1 数据容器对比总结
数据容器可以从以下视角进行简单的分类：
· 是否支持下标索引
· 支持：列表、元组、字符串 - 序列类型
· 不支持：集合、字典 - 非序列类型
· 是否支持重复元素
· 支持：列表、元组、字符串 - 序列类型
· 不支持：集合、字典 - 非序列类型
· 是否可以修改
· 支持：列表、集合、字典
· 不支持：元组、字符串
| 列表 | 元组 | 字符串 | 集合 | 字典 | |
| 支持元素数量 | 多个 | 多个 | 多个 | 多个 | 多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：Value Key：除字典外任意类型 Value：任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
5.2 数据容器的通用操作 - 遍历
· 5类数据容器都支持for循环遍历
· 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
· 方法：len(容器) 可以用来统计容器的元素个数
· 方法：max(容器) 可以用来统计容器的最大元素
· 方法：min(容器) 可以用来统计容器的最小元素
容器通用转换功能
· list(容器) 将给定容器转换为列表
· str(容器) 将给定容器转换为字符串
· tuple(容器) 将给定容器转换为元组
· set(容器) 将给定容器转换为集合
容器通用排序功能
· sorted(容器,[reverse=True]) 将给定容器进行排序
"""
演示数据容器的通用功能
"""
my_list = [14, 42, 63, 47, 5]
my_tuple = (12, 24, 13, 4, 25)
my_str = "asdfasdf"
my_set = {91, 2, 13, 45, 45}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5, }
# len元素个数
print(len(my_list))
print(len(my_tuple))
print(len(my_str))
print(len(my_set))
print(len(my_dict))
# max最大元素
print(max(my_list))
print(max(my_tuple))
print(max(my_str))
print(max(my_set))
print(max(my_dict))
# min最小元素
print(min(my_list))
print(min(my_tuple))
print(min(my_str))
print(min(my_set))
print(min(my_dict))
# 类型转换：容器转列表
print(list(my_list))
print(list(my_tuple))
print(list(my_str))
print(list(my_set))
print(list(my_dict))
# 类型转换：容器转元组
print(tuple(my_list))
print(tuple(my_tuple))
print(tuple(my_str))
print(tuple(my_set))
print(tuple(my_dict))
# 类型转换：容器转字符串
print(str(my_list))
print(str(my_tuple))
print(str(my_str))
print(str(my_set))
print(str(my_dict))
# 类型转换：容器转集合
print(set(my_list))
print(set(my_tuple))
print(set(my_str))
print(set(my_set))
print(set(my_dict))
# 进行容器排序
print(sorted(my_list))
print(sorted(my_tuple))
print(sorted(my_str))
print(sorted(my_set))
print(sorted(my_dict))
# 进行容器反向排序
print(sorted(my_list,reverse=True))
print(sorted(my_tuple,reverse=True))
print(sorted(my_str,reverse=True))
print(sorted(my_set,reverse=True))
print(sorted(my_dict,reverse=True))| 功能 | 描述 |
| 通用for循环 | 遍历容器(字典是遍历key) |
| max() | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转为列表 |
| str() | 转为字符串 |
| tuple() | 转为元组 |
| set() | 转为集合 |
| sorted(序列,[reverse=True]) | 排序，reverse=True表示降序 |
6.1 字符串的大小比较
在程序中，字符串所用的所有字符串都有其对应的ASCII码表值
每一个字符都能对应上一个数字的码值
字符串进行比较就是基于数字的码值大小进行比较的。
字符串比较
字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
