Python基础七 元组、字典、集合
文章目录
- 1.元组
-
- 1.1 元组的简介
- 1.2 元组的创建
- 1.3 元组常用方法
- 1.4 元组不可以使用的方法
- 1.5 特殊方法
- 1.6 元组解包（拆包）
- 1.7练习题
- 2.字典
-
- 2.1概念
- 2.2字典创建
- 2.3 字典的增删改查
- 2.4字典的常用方法
- 2.5 字典生成式
- 2.6 字典的案例演示
- 3. 集合(set)
-
- 3.1 集合简介
- 3.2 集合创建
- 3.3 集合的遍历
- 3.4 集合常用操作方法
- 3.5 集合的运算
- 3.6 类型转换
- 3.7 set集合综合案例
- 4. 大作业
1.元组
1.1 元组的简介
- 元组的概念
元组（Tuple）是一组有序的、不可变的数据集合（不可改的List）
在定义的时候，主要元组用的是小括号（），是可以通过下标进行访问的，也可以通过切片进行访问
# 元组的创建和访问
tuple01 = (1,2,3,4,5,6)
print(tuple01[0]) # 通过下标访问第一个元素:1
print(tuple01[1:5]) # 通过切片访问第二个到第五个元素 (2, 3, 4, 5)
1.2 元组的创建
(1) 常规元组的创建
一开始就得全部声明，因为后面是不可以更改的
#常规元组创建的方法
tuple01 = (11,22,33,44,55) # 元组的创建
tuple02 = () # 空元组也是可以创建的
(2) 单个元组的创建
如果创建单元素的元组不能直接写成tupel03 = (11)，因为这种创建方式默认创建的整型，那么怎么创建单元素的元组呢？
我们需要在单个元素后面添加一个逗号，这样就能够创建单个元素的元组了：
# 创建单元素元组
my_tuple = (11,) # 单元素元组一定要加逗号
(3) 元组的拼接
元组虽然不可以修改，但是支持多个元组的拼接；
# 元组的拼接
tuple01 = (11,22,33,44,55)
tuple02 = (1,3,5,7)
tuple03 = tuple01 + tuple02
print(tuple03)
#(11, 22, 33, 44, 55, 1, 3, 5, 7)
1.3 元组常用方法
(1) 元组中可以用的常用方法
- 整体赋值操作
# 元组使用整体赋值运算符
tuple01 = (11,22,33,44)
tuple02 = tuple01
- 拼接操作
# 元组的拼接
tuple01 = (11,22,33,44,55)
tuple02 = (1,3,5,7)
tuple03 = tuple01 + tuple02
print(tuple03)
#(11, 22, 33, 44, 55, 1, 3, 5, 7)
- 打印指定遍数
tuple01 = (11,22)
print(tuple01 * 3)
#(11, 22, 11, 22, 11, 22)
- 求元组的长度
# 元组使用求长度运算符
tuple01 = (11,22,33)
print(len(tuple01)) # 3
- 是否包含
# 元组使用是否包含运算符
tuple01 = (11,22,33)
print("是否包含11:",11 in tuple01)
#是否包含11: True
- 求最值、求和
# 元组的计算
tuple01 = (11,22,33,44,9,6,5)
print(max(tuple01))
print(min(tuple01))
print(sum(tuple01))
- 查找（元组不可以用find()函数查找）
# 元组的查找
tuple01 = (-11,11,13,44,999,66,2)
print(tuple01.index(11))# 返回值是索引的位置：1
#如果元组里有相同的元素，返回值是最前面元素的索引值。
tuple01 = (-11,11,13,11,999,66,2)
print(tuple01.index(11))# 返回值：1
- 统计元素的次数
#统计出现的次数
tuple01 = (-11,11,13,44,999,66,11)
print(tuple01.count(11)) # 2
#元组tuple01中11出现在的次数为：2
1.4 元组不可以使用的方法
元组不可以直接使用列表中的添加、插入、删除方法，但是注意：虽然元组里直接的元素没法改，但是元组里嵌套了list的话，还是可以非常方便的增加、删除、修改list元素的。
# 修改元组中嵌套的列表元素
tuple01 = (11,22,33,44,[44,55,66])
tuple01[4].append(77)
tuple01[4].remove(55)
tuple01[4].extend([88,99])
print(tuple01)
1.5 特殊方法
- 元组的删除
元组里的单个元素是无法删除的，但是可以用del方法，把整个元组删除
# 元组的删除
tuple01 = (11,22,33)
del tuple01
- 元组的排序
用于排序的sort()方法，和反转排序的reverse()方法，改变了元素的存储位置所以不可用于元组的排序，但是临时排序sorted()方法就可以，因为它并没有改变元素的原始存储位置，只是用于排序输出
tuple01 = (-11,1,13,44,999,66,2)
print(sorted(tuple01))
#[-11, 1, 2, 13, 44, 66, 999]升序排列
1.6 元组解包（拆包）
- 元组拆包指将元组当中的每一个元素都赋值给一个变量，元组元素的数量与变量的数量相同。
my_tuple = (1, 2, 3, 4, 5, 6)
#元组的拆包
a,b,c,d,e,f = my_tuple
print(a) #可以单独取值
print(b) #可以单独取值
print(a,b,c,d,e,f) # 也可以这样一起取值
#
1
2
1 2 3 4 5 6
- 在对一个元组拆包的时候，变量的数量和元组中元素的数量要把持一致
# 错误示例
my_tuple = (1, 2, 3, 4, 5,6) #元组里6个元素
a,b,c,d,e = my_tuple #变量的数量（5个） 和 元组中元素的数量不一样。
print(a)
print(a,b,c,d,e)
#不管是打印一个值，还是打印多个都会报错
#报错：ValueError: too many values to unpack (expected 6)(需要打开的值太多，预期6个），这个报错很明显，我们可以看到拆包的变量只有5个，而元组内的元素数量有6个，5个变量接收6个值，变量不够呀，所以会报错。
# 正确示例
my_tuple = (1,2,3,4,5,6)
a,b,c,d,e,f = my_tuple #变量的数量 和 元组中元素的数量一样。
print(a)
print(a,b,c,d,e)
- 如果变量和元素不一致，就可以在变量前面加上一个* ，这样会获取元组中剩余的元素，以列表的形式返回;如果打印的时候给变量前加一个*，返回值就不会列表形式；
tuple1 = (1,2,3,4,5)
a,*b = tuple1
print(a,b) #返回值是列表形式
print(a,*b) # 返回值非列表形式
# 打印结果:
1 [2, 3, 4, 5]
1 2 3 4 5
##
list1 = [1, 2, 3, 4,5]
a, *b, c = list1
print(a, b, c) # 1 [2, 3, 4] 5
1.7练习题
案例1：
输入一个数字，转换成中文数字，比如：1234567890转换成壹贰叁肆伍陆柒捌玖零
# 定义汉字数字元组
tuple_chinese = ('零','壹','贰','叁','肆','伍','陆','柒','捌','玖')
# 定义阿拉伯数字元组
tuple_num = (0,1,2,3,4,5,6,7,8,9)
# 读取输入的数值字符串
num_input = input("请输入数字：")
for i in range(len(num_input)):
if num_input[i] == '.':
print("点",end="")
else:
# 把读取到的数值字符串每一个数逐一转为整型
num_single = int(num_input[i])
print(tuple_chinese[num_single],end="")
案例2：
根据花色和数字生成一副扑克牌
# 案例：根据花色和数字生成一副扑克牌
poker_type = ("♣","♦","♠","♥")
poker_number = ("3","4","5","6","7","8","9","10","J","Q","K","A","2")
count = 0
for i in poker_number:
for j in poker_type:
print(j+i,end="\t")
count+=1
print()
print("扑克有%d张"%count)
2.字典
2.1概念
- 字典是一组无序的且不重复的(key-value)数据集合，它是一种特殊的set集合；
字典中元素由key和value组成，比如：{‘name’：“张三”}，
冒号前面称为key，冒号后面称为value
2.2字典创建
# 字典在创建的时候直接初始化
student_result = {"张三": 342,"李四": 334,"王五": 443}
print(student_result["张三"])
# 创建一个空的字典，后期一个个添加
student_result = {}
student_result["张三"] = 344
student_result["李四"] = 321
student_result["王五"] = 345
print(student_result)
2.3 字典的增删改查
(1) 删除
删除字典的元素有三种方法
- 方法一：pop()方法
参数传入key，pop(key)可以删除指定键值对
# 使用pop(key)
student_result = {"张三": 342,"李四": 334,"王五": 443}
print(student_result)
student_result.pop("张三") # 删除“张三”
print(student_result)
如果传入的key不存在，程序会报keyvalue异常
- 方法二:popitem()方法
不需要参数即可删除字典中最后一个元素
# 使用popitem() 删除字典的最后一个
student_result = {"张三": 342,"李四": 334,"王五": 443}
print(student_result)
student_result.popitem()
print(student_result)
- 方法三：clear方法
使用clear方法删除整个字典
student_result = {"张三": 342,"李四": 334,"王五": 443}
print(student_result)
student_result.clear()
print(student_result)
（2）字典元素的遍历和访问
- 字典元素的访问
这里我们先假设有一个字典，key为学生学号，value为成绩
dict01 = {95001:56,95002:89,95003:77,95004:87}
可以通过dict01[95001]来访问该学号的，但是如果key不存在怎么办呢？有两个解决办法，setdefault()和get()方法
print(dict01.setdefault(95004,"None")) # 如果key存在正常查找，如果不存在返回定义的"None"
print(dict01.get(95001,"None")) # 避免获取每个key不存在出现异常，所设置的初始值
我们前面关于字典元素的删除也可以通过这种方式来避免异常的发生
print(dict01.pop(95001,"None")) # 如果key存在则返回对应的值，否则返回None
- 字典元素的遍历
1.标准遍历方式
dict01 = {95001:56,95002:89,95003:77,95004:87}
for i in dict01:
print(i,":",dict01[i])
2.使用items遍历
dict01 = {95001:56,95002:89,95003:77,95004:87}
print(dict01.items()) # 使用items遍历
print(list(dict01.items())) # 结果转化为list
print(list(dict01.items())[0]) # 访问list第一个元素，这里是(95001,56)
# 遍历
list01 = list(dict01.items())
for i in list01:
print(list(i)[0],list(i)[1])
3.使用keys遍历
keys_list = list(dict01.keys())
for i in keys_list:
print(i,":",dict01[i])
4.使用keys和values遍历
keys_list = list(dict01.keys()) # 把字典转化为keys
values_list = list(dict01.values()) # 把字典转化为values
for i in range(len(keys_list)):
print(keys_list[i],":",values_list[i])
2.4字典的常用方法
- 合并与多次打印输出
字典和set的存储模式使一样的，乘号和加号是不能用的。
两个字典的合并不能用加号，而是用update进行合并；
字典的多次打印输出不能像列表那样直接使用乘号
dic01 = {95001:88,95002:99,95003:67}
dic02 = {95004:89,95005:87,95006:99}
# print(dic01 + dic02) # 加号合并输出不支持
# print(dic01 * 3) # 乘号多次输出不支持
dic01.update(dic02)
print(dic01)
- 复制操作
可以直接使用赋值符号将dic01赋给dic03，如果dic01里某个元素发生了改变，dic03也会发生改变。如果不想让dic03元素跟着发生改变则可以使用浅复制方法，把存储的每一个值索引复制一份，改变字典元素的一个元素而另外一个复制的字典值不变。
dic03 = dic01.copy() - 其它常用操作
- 获取字典的长度
使用len()方法获取字典的长度
dic01 = {95001:88,95002:99,95003:67}
print(len(dic01))
- 判断字典是否包含
使用关键词in判断key是否包含
dic01 = {95001:88,95002:99,95003:67}
print(95001 in dic01)
- 排序
按照key进行排序
dic01 = {95001:88,95002:99,95003:67}
print(sorted(dic01))
打印出来的结果为只有key的列表
- 计算
max、min、sum都是针对key的
dic01 = {95001:88,95002:99,95003:67}
print(max(dic01)) # 打印最大的索引
print(min(dic01)) # 打印最小的索引
print(sum(dic01)) # 打印索引的和
- 用列表作为索引创建新的字典
如果我们已经有了某个列表，我们可以根据列表创建字典的键，比如已知学号列表student_no，可以创建一个新的由学号列表为键的成绩字典student_result。
student_no = [95001,95002,95003,95004] # 学号列表
student_result = {}.fromkeys(student_no) # 从学号列表获取keys
student_result[95001] = 97 # 对字典中的元素进行直接赋值
print(student_result)
2.5 字典生成式
字典生成式
dic={'1':2,'2':3}
print({k:v for k,v in dic.items()})#k是字典的键，v是字典的值
#输出结果为：{'1':2,'2':3}
#进阶版：
print({k:v*2 for k,v in dic.items()})#给V乘以2，意思是给字典的值乘以2
#输入结果为：{'1':4,'2':6}
#我们看结果字典的值都变为，乘以2以后的结果
2.6 字典的案例演示
案例：
有10个学生，姓名自行添加。有三门考试：语文、数学、英语，随机为这10名学生生成分数【50-100】需求：打印一张总分倒序的成绩表：
# 有10个学生，姓名自行添加。有三门考试：语文、数学、英语，随机为这10名学生生成 分数【50-100】需求：打印一张总分倒序成绩表
import random
# 初始化学生基本信息
dict_student_info = {95001:"赵一",95002:"钱二",95003:"孙三",95004:"李四",95005:"周五",
95006:"吴六",95007:"郑七",95008:"王八",95009:"冯九",95010:"陈十"}
# 生成成绩
student_result = []
for i in range(len(dict_student_info)):
temp_result = []
for j in range(3):
temp_result.append(random.randint(50,100))
student_result.append(temp_result)
# 组合存储结构
total_student_result = {}
# total_student_result = {}.fromkeys(list(dict_student_info.keys()))
# print(total_student_result)
# 生成总分的list
total_result = []
for i in student_result:
total_result.append(sum(i))
# print(total_result)
# 把总分倒序排列
total_result.sort(reverse = True)
# print(total_result)
# 获得学生的学号
student_sno = list(dict_student_info.keys())
# 遍历
index = 0
for i in student_sno:
temp_total = {}
temp_total["姓名"] = dict_student_info[i]
temp_total["明细"] = student_result[index]
temp_total["排名"] = total_result.index(sum((student_result)[index])) + 1
temp_total["总分"] = sum((student_result)[index])
total_student_result[i] = temp_total
index += 1
# for i in student_sno:
# print(i,":",total_student_result[i])
# 打印成绩
print("\n################成绩表################")
print("=====================================")
print("名次 学号 姓名 语文 数学 英语 总分 均分")
for i in range(len(total_student_result)):
for j in total_student_result:
if total_student_result[j]["排名"] == (i+1):
print(i+1,end="\t")
print(j,end=" ")
print(total_student_result[j]["姓名"],end=" ")
print(total_student_result[j]["明细"][0],end=" ")
print(total_student_result[j]["明细"][1],end=" ")
print(total_student_result[j]["明细"][2],end=" ")
print(total_student_result[j]["总分"],end=" ")
print("%.2f" % ((total_student_result[j]["总分"])/3))
break
else:
continue
print("=====================================")
输出结果：
################成绩表################
=====================================
名次 学号 姓名 语文 数学 英语 总分 均分
1 95003 孙三 100 94 65 259 86.33
2 95006 吴六 53 80 97 230 76.67
3 95001 赵一 68 69 90 227 75.67
4 95007 郑七 63 82 74 219 73.00
5 95004 李四 56 72 85 213 71.00
7 95010 陈十 63 60 83 206 68.67
8 95009 冯九 90 56 56 202 67.33
9 95002 钱二 66 56 76 198 66.00
10 95008 王八 58 60 73 191 63.67
=====================================
3. 集合(set)
3.1 集合简介
- set集合是一组无序的且不能重复的集合，打印set集合时会自动消除重复的元素项；
- set集合用大括号表示；
- set集合存储的时候就是无序的，它不支持通过索引的方式进行访问；
- set集合在初始化时的顺序与打印出来时的顺序是不一样的；
set01 = {11,22,33,44,55}
3.2 集合创建
（1）使用{}来创建集合:my_set = {11,22,33}
（2）创建空的set集合，然后往里加入值
创建空set不能想当然的使用set{}，这样创建的是一个空字典，创建空set集合应该使用方法set()
# 创建空set
set02 = set()
set02.add("Tom")
set02.add("Bob")
set02.add("Jerry")
print(set02)
3.3 集合的遍历
使用for循环遍历集合
# 集合本身是无序的，所以遍历出来的结果也是无序的。
N_set = {11,33,22,66,88,Jerry,Tom}
for i in N_set:
print(i)
3.4 集合常用操作方法
（1）集合的长度：len()
set1 = {11,33,'刘亦菲', '周慧敏', '范冰冰',12,89}
s = len(set1)
print(s)# 7
（2）添加元素:add()和update()
# 使用add()方法添加元素
set01 = {11,33,'刘亦菲', '周慧敏'}
set01.add('李子柒')
print(set01)
#{33, 11, '周慧敏', '刘亦菲', '李子柒'}
# update() 将一个集合中的元素添加到另一个集合中
s = {'周慧敏', '刘亦菲', '李子柒'}
s1 = {2, 3, 4, (1, 2)}
s.update(s1) # 将s1添加到s集合里
print(s)
（3）删除元素：pop()，remove()
- pop() 随机删除
pop函数的参数不能指定某一个要删除元素的具体的值。
s = {'周慧敏', '刘亦菲', '李子柒','范冰冰',12,89}
s.pop()
print(s)
#{'李子柒', 12, '刘亦菲', '范冰冰', '周慧敏'}
- remove()删除,
#remove指定删除元素
s = {'周慧敏', '刘亦菲', '李子柒','范冰冰',12,89}
s.remove(12)
print(s)
- discard
discard删除原先不存在的值，集合不发生变化而且也不会报错
但是如果用remove方法，要删除的值如果不存在，那么程序便会报KeyError错；
# discard方法删除元素
set01 = {11,3,-15,99,69,(1,5)}
print("删除99前",set01)
set01.discard(99)
print("删除99后",set01)
set01.discard(119)
print("删除一个不存在的119",set01)
结果:
删除99前 {3, 99, 69, 11, -15, (1, 5)}
删除99后 {3, 69, 11, -15, (1, 5)}
删除一个不存在的119 {3, 69, 11, -15, (1, 5)}
（4） 排序和反转
直接的排序是不支持的，sort()、reverse()
但是支持临时排序
# set支持临时排序
set01 = {11,2,-1,222,23}
print(sorted(set01))
（5） 判断是否包含元素
set01 = {11,22,33}
print("是否包含22：",22 in set01)
（6） 最值，求和（max,min,sum）
set03 = {11,2,222,12,1,456,-2}
print(min(set03)) # 打印集合中的最小值
print(max(set03)) # 打印集合中的最大值
print(sum(set03)) # 打印集合中的数值元素的和
（7） 赋值预算
set01 = {11,22,33}
set02 = set01
（8） 不可以使用加法运算和乘法运算符
列表可以使用加法运算符将两个列表拼接在一起，set集合不可以使用；
列表可以使用乘法运算符将指定列表打印指定次数，set集合不可以使用；
3.5 集合的运算
交集、并集、差集、对等差集、是否子集、是否父集，两种表示方法任选一个即可
# 逻辑运算
set01 = {11,22,33,44,55}
set02 = {44,55,66,77,88}
# 交集
print(set01 & set02)
print(set01.intersection(set02))
# 并集
print(set01 | set02)
print(set01.union(set02))
# 差集
print(set01 - set02)
print(set01.difference(set02))
# 对等差集
print(set01 ^ set02)
print(set01.symmetric_difference(set02))
print((set01-set02) | (set02-set01))
# 判断是否是子集
set01 = {11,22,33}
set02 = {11,22}
print(set01.issubset(set02))
print(set01 <= set02)
print(set01.issuperset(set02))
print(set01 >= set02)
3.6 类型转换
set集合可以转化为list列表、tuple元组、str字符串，可以直接通过类型转换来实现：
# 类型转化
set01 = {11,2,2,3,0,1,2}
list01 = list(set01) # 转换为列表
tuple01 = tuple(set01) # 转换为元组
str01 = str(set01) # 转换为字符串
3.7 set集合综合案例
案例01： 生成0-10之间5个不相等的数
# 生成0-10之间5个不相等的数
import random
set01 = set()
while len(set01) < 5:
set01.add(random.randint(1,10))
print(set01)
案例02：十个学生，姓名自行添加，有三门考试：语文、数学、英语，随机为这10名学生
生成分数【50-100】，要求每一门科目中所有学生分数不能重复
需求：
【1】统计出每门分数前三名和后三名
【2】统计出总分的前三名和后三名
【3】在【50-100】的数字中，哪些数字没有在三门的分数中出现过
import random
# 定义一个生成学科成绩的函数
def get_result(result:set):
while True:
temp = random.randint(50,100)
if temp not in result:
result.add(temp)
break
else:
continue
return result
student_name = ["赵一","钱二","孙三","李四","周五","吴六","郑七","王八","冯九","陈十"]
subject_list = ["语文","数学","英语"]
student_result = []
chinese_result = set() # 存储语文的分数
math_result = set() # 存储数学的分数
english_result = set() # 存储英语的分数
# 开始生成分数
for i in range(len(student_name)):
chinese_result = get_result(chinese_result)
math_result = get_result(math_result)
english_result = get_result(english_result)
# 把三个set集合转为list
chinese_result = list(chinese_result)
math_result = list(math_result)
english_result = list(english_result)
# 生成成绩明细
for i in range(10):
temp_list = []
temp_list.append(chinese_result[i])
temp_list.append(math_result[i])
temp_list.append(english_result[i])
student_result.append(temp_list)
# 需求1：统计每门科目的前三名和后三名【包括姓名和具体的分数】
chinese_one = max(chinese_result)
print("语文第一名：姓名：%s 分数：%d"%(student_name[chinese_result.index(chinese_one)],chinese_one))
chinese_two = sorted(chinese_result)[8]
print("语文第二名：姓名：%s 分数：%d"%(student_name[chinese_result.index(chinese_two)],chinese_two))
chinese_three = sorted(chinese_result)[7]
print("语文第三名：姓名：%s 分数：%d"%(student_name[chinese_result.index(chinese_three)],chinese_three))
chinese_last_one = sorted(chinese_result)[0]
print("语文倒数第一名：姓名：%s 分数：%d"%(student_name[chinese_result.index(chinese_last_one)],chinese_last_one))
chinese_last_two = sorted(chinese_result)[1]
print("语文倒数第二名：姓名：%s 分数：%d"%(student_name[chinese_result.index(chinese_last_two)],chinese_last_two))
chinese_last_three = sorted(chinese_result)[2]
print("语文倒数第三名：姓名：%s 分数：%d"%(student_name[chinese_result.index(chinese_last_three)],chinese_last_three))
# 【2】统计出总分的前三名和后三名
student_total_result = []
for i in student_result:
student_total_result.append(sum(i))
total_one = sorted(student_total_result)[9]
print("总分第一名是%s 分数%d"%(student_name[student_total_result.index(total_one)],total_one))
total_two = sorted(student_total_result)[8]
print("总分第二名是%s 分数%d"%(student_name[student_total_result.index(total_two)],total_two))
total_three = sorted(student_total_result)[7]
print("总分第三名是%s 分数%d"%(student_name[student_total_result.index(total_three)],total_three))
# 【3】在【50-100】的数字中，哪些数字没有在三门的分数中出现过
all_num = set()
for i in range(50,101):
all_num.add(i)
had_num = (set(chinese_result) | set(math_result) | set(english_result) )
print("未出现的数字有:",all_num - had_num)
print(len(all_num - had_num))
输出结果：
语文第一名：姓名：赵一 分数：98
语文第二名：姓名：王八 分数：90
语文第三名：姓名：周五 分数：86
语文倒数第一名：姓名：吴六 分数：54
语文倒数第二名：姓名：郑七 分数：56
语文倒数第三名：姓名：冯九 分数：60
总分第一名是赵一 分数292
总分第二名是周五 分数248
总分第三名是李四 分数236
未出现的数字有: {50, 52, 53, 55, 58, 62, 63, 64, 66, 67, 69, 72, 73, 75, 76, 77, 78, 81, 88, 89, 91, 92, 93, 94, 97, 99, 100}
27