一、元组
1.1、元组的定义
为什么要有元组？
如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？这时候是不是会想到上个作品所讲的列表，但是列表可以被修改，所以列表并不适合。举个例子，比如一个城市的经纬度数，他是一个固定不变的值，因为元组具有不可变性，这时候我们就可以用元组来存储他的位置。
元组的特点：有序性、不可变性、可重复性、异构性。
元组的定义：定义元组使⽤ ⼩括号，且使⽤ 逗号 隔开各个数据。
代码：
# 定义多个数据的元组
my_tuple = (1,"小宁爱Python",True,3.14)
print(my_tuple)
print(type(my_tuple))
# 定义单个数据的元组
my_tuple1 = ("小宁爱Python") #定义单个数据的时候需要在后面加上一个逗号，不然不会是元组类型
my_tuple2 = ("小宁爱Python",)
print(my_tuple1)
print(type(my_tuple1))
print(my_tuple2)
print(type(my_tuple2))运行结果：
1.2、元组的增删改查？
前面说过元组具有：有序性、不可变性、可重复性、异构性。由于元组具有不可变性质，所以元组只可以进行查的操作，在这里小宁建议大家一定要根据不同数据序列的性质进行学习和记忆，可以根据代码多尝试，这样才能够记忆深刻。
元组的运用：以下两种其实本质上都是元组。
比如下次要学的函数，函数的参数和返回值，⼀个函数可以接受任意多个参数，或者依次返回多个数据。
def func(参数1, 参数2, 参数3):
return 返回值1, 返回值2, 返回3;或者是格式化字符串，百分号输出，格式化字符串后⾯的（）。
name = "小宁爱Python"
age = 20
address = "长沙天心区"
print("我的名字是:%s，我的姓名是：%d岁，我来自%s" % (name,age,address))
查：
内置方法：
|
元组[索引]
|
根据 索引下标 查找元素
|
|
index()
|
查找某个数据，如果数据存在返回
对应的下标，否则报错，语法和列
表、字符串的index⽅法相同
|
|
count()
|
统计某个数据在当前元组出现的次
数
|
|
len()
|
统计元组中数据的个数
|
代码：
# 与元组的增删改查？
# 元组只可以进行查操作
my_tuple = (1, 3.14, "小宁爱Python","a",True,1,1,1)
index_result = my_tuple.index("小宁爱Python")
print(f"使用index查询”小宁爱Python的下标是：",{index_result})
count_result = my_tuple.count(1)
print(f"使用count查询1出现的次数：",{count_result})
len_result = len(my_tuple)
print(f"len()函数查找元组的长度为：",{len_result})运行结果：
1.3、元组的切片
在前面的作品里面，小宁已经讲过了字符串的切片和列表的切片，那么元组是否也会有切片操作呢，是否元组的切片操作的语法（名字【起始索引：结束索引：步长】）也会和前面讲过的切片相同呢？其实在Python里面的所有切片操作都有异曲同工之妙。所以更加具体的操作在这里就没有具体的展示了，大家可以看看之前的作品。
代码：
# 元组的切片
my_tuple = (1, 3.14, "小宁爱Python","a",True)
print(my_tuple[0:1])
print(my_tuple[:])
print(my_tuple[::2])
运行结果：
1.4、元组的遍历
代码：
# 元组的遍历
# while循环遍历
my_tuple = (1, 3.14, "小宁爱Python","a",True,1,1,1)
i = 0
while i < len(my_tuple):
print(f"my_tuple的第{i+1}个元素是{my_tuple[i]}")
i += 1
# for循环遍历
for x in my_tuple:
print(x,end=" ")运行结果：
二、字典
2.1、字典的定义
为什么要有字典？
⽐如我们要存储⼀个⼈的信息，姓名：小宁爱Python，年龄：20，性别：男，家庭住址：海南。在⽇常⽣活中，姓名、年龄以及性别同属于⼀个⼈的基本特征。但是如果使⽤列表对其进⾏存 储，则分散为3个元素，这显然不合逻辑。我们有没有办法，将其保存在同⼀个元素中，姓名、年龄以及 性别都作为这个元素的3个属性。
字典的特点：键key：不可以改变，不可以重复，异构。
值value：可变，异构，可重复，有序。
① 符号为 ⼤括号（花括号） => {}
② 数据为 键值对 形式出现 => {key:value}，key：键名，value：值，在同⼀个字典中，key必须是
唯 ⼀
（类似于索引下标）
③ 各个键值对之间⽤ 逗号 隔开
字典的定义：
# 字典的创建
# 定义有数据的字典
my_dict = {"name":"小宁爱Python","age":20,"sex":"男"}
print(my_dict)
print(type(my_dict))
# 定义空字典
my_dict1 = {}
print(my_dict1)
print(type(my_dict1)) 
2.2、字典的增删改查
2.2.1、增：可以通过dictionary[key] = value的方式添加新的键 - 值对。
my_dict = {"name":"小宁爱Python","age":20,"sex":"男"}
my_dict["adrrse"] = "Python俱乐部"
print(my_dict)
2.2.2、删：
内置方法：
| del dictionary[key] | 删除指定键对应的键 - 值对 |
| pop() | 删除并返回指定键对应的键 - 值对 |
| popitem() | 随机删除并返回一个键 - 值对 |
| clear() | 清空字典
|
代码：
# 删：
my_dict = {"name": "小宁爱Python", "age": 20, "sex": "男", "address":"python俱乐部"}
print(my_dict)
del my_dict["address"]
print(my_dict)
result = my_dict.pop("sex")
print(result,my_dict)
result1 = my_dict.popitem()
print(result1,my_dict)运行结果：
2.2.3、改：
基本语法：字典名【key】= new_value
代码：
# 改：
my_dict = {"name": "小宁爱Python", "age": 20, "sex": "男", "address":"python俱乐部"}
my_dict["address"] = "常德武陵区"
print(my_dict)运行结果：
2.2.4、查：
| keys() | 返回所有键的视图 |
| values() | 返回所有值的视图 |
| items() | 返回所有键 - 值对的视图 |
| get() | 获取指定键的值，如果键不存在可以返回默认值 |
代码：
# 查
my_dict = {"name": "小宁爱Python", "age": 20, "sex": "男", "address":"python俱乐部"}
keys = my_dict.keys()
print(f"使用keys来获取所有的键{keys}")
values = my_dict.values()
print(f"使用values来获取所有的值{values}")
items = my_dict.items()
print(f"使用items来获取索引的键——值对{items}")
gets = my_dict.get("name")
print(f"使用get来获取对应键的值{gets}")运行结果：
2.3、字典的切片？
字典不是我们之前学过的那种索引和值的关系，这里是键值对的关系，所以不能直接切片，如果要进行切片操作，那么就需要把值或键单独拿出来，然后转换为其他可以切片的类型，才能进行切片。
2.4、字典的遍历
代码：
# 字典的遍历
my_dict = {"name": "小宁爱Python", "age": 20, "sex": "男", "address": "python俱乐部"}
print("使用keys()遍历所有的键：")
for key in my_dict.keys():
print(key)
print("使用values()遍历所有的值：")
for value in my_dict.values():
print(value)
print("使用items()遍历所有的键值对：")
for key, value in my_dict.items():
print(key, value)运行结果：
2.5、字典的综合案例
代码：
# 案例：开个⼀个通讯录的管理系统，主要⽤于实现存储班级中同学的信息（姓名、年龄、电话）
# students = [0,1,2]
# student = {'name':'刘备', 'age':18, 'mobile': '10086'}
# 组装：
# students = [{'name':'刘备', 'age':18, 'mobile': '10086'}, {'name':'关⽻', 'a
# ge':17, 'mobile': '10000'}, {'name':'张⻜', 'age':16, 'mobile': '10010'}]
students = []
flag = True
while flag:
print("--"*20)
print("1、添加学生信息")
print("2、删除学生信息")
print("3、修改学生信息")
print("4、退出系统")
print("--"*20)
user_is = input("请输入你要实现的功能：")
if user_is == '1':
student = {} #没写元素的话创建的是字典
student_name = input("请输入学生的姓名：")
student_age= int(input("请输入学生的年龄："))
student_phone = input("请输入学生的电话：")
student["name"] = student_name
student["age"] = student_age
student["phone"] = student_phone
students.append(student)
print(f"添加后的所有学生的信息如下：{students}")
elif user_is == '2':
student_name = input("请输入你要删除学生的姓名：")
for i in students:
if i["name"] == student_name:
students.remove(i)
print("删除成功！！！")
print(f"删除后的所有学生的信息如下：{students}")
break
else:
print("您输入输学生不存在")
elif user_is == '3':
student_name = input("请输入你要修改学生信息的姓名：")
for i in students:
if i["name"] == student_name:
new_name = input("请输入该学生的新名字：")
new_age = int(input("请输入该学生新的年龄："))
new_phone = input("请输入该学生新的电话：")
i["name"] = new_name
i["age"] = new_age
i["phone"] = new_phone
print(f"修改后的学生的所有信息如下：{students}")
break
else:
print("您输入输学生不存在")
elif user_is == '4':
print("感谢你使用***教务系统！！！")
flag = False
else:
print("你输入的有误，请重新输入！！！")
运行结果：
三、集合
3.1、集合的定义
为什么要有集合？
在现实生活中，有一些数字可能要进行计算交集，差集，并集的操作，但是我们之前学过的数据数列又没有这些对应的函数操作。所有我们就要学习集合，因为集合有这一些内置方法可以直接使用。
集合的特点：无序，可变，去重（不可重复），异构、不可切片。
集合的定义：集合名 = {}
代码：
# 集合的定义
# 定义一个有数据的数组
my_set = {1,"小宁爱Python",2.34,True,1} #去重操作
print(my_set)
print(type(my_set))
my_set1 = set()
# 定义一个空集合：只能使用set（）函数来建立
print(my_set1)
print(type(my_set1))
# 直接定义为字典，因为集合和字典都是大括号，没有元素默认为字典
my_set2 = {}
print(my_set2)
print(type(my_set2))运行结果：
3.2、集合的增删改查，数学运算？
有序无序的性质：所以不能够进行下标的相关操作。
增：
内置函数：
| add() | 添加一个元素 |
| update() | 添加多个元素，参数是可迭代对象 |
代码：
# 增
my_set = {1,"小宁爱Python",2.34,True,1}
updata_set = {2,5,6,4}
list = [100,23,134]
my_set.add(3)
print(my_set)
my_set.update(updata_set)
print(my_set)
my_set.update(list)
print(my_set)运行结果：
删：
内置函数：
| remove() | 删除指定元素，如果元素不存在会报错 |
| discard() | 删除指定元素，如果元素不存在不会报错 |
| pop() | 随机删除并返回一个元素 |
| clear() | 清空集合 |
代码：
# 删
my_set = {1,"小宁爱Python",2.34,True,234,546,76,23}
my_set.remove(1)
print(my_set)
# my_set.remove(2) 会报错，因为2不存在于集合
my_set.discard(76)
print(my_set)
result = my_set.pop()
print(my_set)
print(result)
my_set.clear()
print(my_set)运行结果：
数学运算：
代码：
# 集合与集合之间的数学操作:
my1_set = {1,2,3,4,5}
my2_set = {3,4,5,6,7}
my3_set = {1,2,3}
my5_set = {5,6,7}
my4_set = {1,2,3,4,5,6,7,8}
union = my1_set.union(my2_set)#并集
print(union)
intersection = my1_set.intersection(my2_set)#交集
print(intersection)
difference = my1_set.difference(my2_set)#差集
print(difference)
symmetric_difference = my1_set.symmetric_difference(my2_set)#对称差集
print(symmetric_difference)
is_ziji =my3_set.issubset(my1_set) #判断是否为子集
print(is_ziji)
is_chaoji = my3_set.issubset(my5_set) #判断是否为超集
print(is_chaoji)
is_jiaoji = my3_set.issubset(my5_set) #判断是否有教交集
print(is_jiaoji)运行结果：
3.3、集合的切片？
集合具有无序的性质，所有不能够通过索引进行直接切片。
3.4、集合的遍历
由于集合无序，所以不能够使用下标遍历集合，我们一般使用for循环直接遍历。
代码：
# 集合的遍历
my_set = {1,"小宁爱Python",2.34,True,234,546,76,23}
for x in my_set:
print(x)
i = 0运行结果:
四、列表推导式
4.1、为什么要有列表推导式
推导式comprehensions（⼜称解析式），是Python的⼀种独有特性。推导式是可以从⼀个数据序列构建 另⼀个新的数据序列（⼀个有规律的列表或控制⼀个有规律列表）的结构体。 共有三种推导： 列表推导 式 、 集合推导式 、 字典推导式 。
案例：
创建⼀个0-9的列表。
while循环：
# 初始化计数器
i = 0
list1 = []
# 编写循环条件
while i <= 9:
list1.append(i)
# 更新计数器
i += 1
print(list1)list1 = []
# 编写for循环
for i in range(0, 10):
list1.append(i)
print(list1)
思考：我们能不能把以上代码简化为⼀⾏代码搞定这个程序呢？ 当然可以，那就是使⽤推导式。
4.2、列表推导式的运用
语法：
变量名 = [表达式 for 变量 in 列表]
定义0-9之间的列表
list1 = [i for i in range(10)]
print(list1)变量名 = [表达式 for 变量 in 列表 if 条件]
# ⽣成0-9之间的偶数（i%2 == 0）序列
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]
# 创建列表 => [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list1 = [(i, j) for i in range(1, 3) for j in range(0, 3)]
print(list1)五、数据序列的相互转换？
目前我们学过的数据序列有列表、元组、字典、集合这四种数据类型。我们想象一下整数，浮点数，字符串之间有数据类型的转换，那我们这些数据能不能相互转换数据类型呢？当然可以，但是由于字典的数据结构是键值对类型的。而其他三种的数据结构和字典的数据结构不相同，所以列表、元组、集合能够相互转换，而字典不能够直接转换，只能够对键或者值单独的转换。
代码：
# print(f"{10 not in my_tuple}")
# print(f"{1 in my_dict}")
# print(f"{1 in my_set}")
# 相互转换
my_list = [1,3.14,3,True,"abc"]
my_tuple = (1,3.14,3,3,"abc")
my_dict = {"a":1,"b":3.14,"c":True}
my_set = {"a","b","c",1,23,4}
# list转换
print("其他类型转化为list类型：————————————————————————————————————————————")
result_list = list(my_tuple)#元组--列表
print(result_list)
print(type(result_list))
result_list1 = list(my_set)#集合--列表
print(result_list1)
print(type(result_list1))
result_list2 = list(my_dict.items())#字典--列表
print(result_list2)
print(type(result_list2))
# tuple转换
print("其他类型转化为tuple类型：————————————————————————————————————————————")
result_list3 =tuple(my_list) #列表--元组
print(result_list3)
print(type(result_list3))
result_list4 = tuple(my_set) #集合--元组
print(result_list4)
print(type(result_list4))
result_list5 = tuple(my_dict.keys()) #字典--元组
print(result_list5)
print(type(result_list5))
# set转换
print("其他类型转化为set类型：————————————————————————————————————————————")
result_list6 = set(my_list) #列表--集合
print(result_list6)
print(type(result_list6))
result_list7 = set(my_tuple) #元组--集合
print(result_list7)
print(type(result_list7))
result_list8 = set(my_dict.keys()) #字典--集合
print(result_list8)
print(type(result_list8))
# dict转换:不能转换，所以注释了，感兴趣的可以自己尝试一下
# print("其他类型转化为dict类型：————————————————————————————————————————————")
# result_list9 = dict(my_list)
# print(result_list9)
# print(type(result_list9))
# result_list9 = dict(my_set)
# print(result_list9)
# print(type(result_list9))
# result_list9 = dict(my_tuple)
# print(result_list9)
# print(type(result_list9))运行结果：
五、总结
1、列表（List）：
性质：
- 有序：元素的顺序是固定的，通过索引可以访问特定位置的元素，索引从 0 开始。
- 可以包含不同类型的元素，如整数、字符串、其他列表等。
- 可变：可以修改、添加、删除列表中的元素。
内置函数：
- 增：append()（在末尾添加一个元素）、extend()（将一个可迭代对象的元素添加到列表末尾）、insert()（在指定位置插入元素）。
- 排序：sort()（对列表内元素进行排序，会改变原列表）、sorted()（返回排序后的新列表，原列表不变）
- 查：index()（返回指定元素的索引）、count()（统计指定元素出现的次数）
- 改：可以通过索引直接修改元素的值。
- 删：remove()（删除指定元素）、pop()（删除并返回指定位置的元素，默认是最后一个）、clear()（清空列表）。
- 反转：reverse()（反转列表元素的顺序）。
2、元组（Tuple）
性质：
- 有序：和列表一样，元素顺序固定，通过索引访问，索引从 0 开始
- 可以包含不同类型的元素。
- 不可变：一旦创建，元素不能被修改、添加或删除。
内置函数：
- 查：index()（返回指定元素的索引）、count()（统计指定元素出现的次数）。
- 因为元组不可变，所以没有像列表那样用于修改元素的函数
3、字典（Dictionary）
性质：
- 无序：元素没有固定的顺序
- 键是唯一的，必须是不可变类型（如字符串、数字、元组），值可以是任何类型。
- 可变：可以添加、修改、删除键 - 值对。
内置函数：
- 增：可以通过dictionary[key] = value的方式添加新的键 - 值对。
- 查：keys()（返回所有键的视图）、values()（返回所有值的视图）、items()（返回所有键 - 值对的视图），可以用于遍历字典；get()（获取指定键的值，如果键不存在可以返回默认值）。
- 改：可以通过dictionary[key] = new_value修改指定键的值。
- 删：del dictionary[key]（删除指定键对应的键 - 值对）、pop()（删除并返回指定键对应的键 - 值对）、popitem()（随机删除并返回一个键 - 值对）、clear()（清空字典）。
4、集合（Set）
性质：
- 无序：元素没有特定的顺序。
- 元素具有唯一性，即集合中不会有重复的元素。
- 可变（普通集合）：可以添加、删除元素。
内置函数：
- 增：add()（添加一个元素）、update()（添加多个元素，参数是可迭代对象）。
- 删：remove()（删除指定元素，如果元素不存在会报错）、discard()（删除指定元素，如果元素不存在不会报错）、pop()（随机删除并返回一个元素）、clear()（清空集合）。
- 集合运算：union()（并集）、intersection()（交集）、difference()（差集）、symmetric_difference()（对称差集）。
扫一扫
315
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
