Python随堂笔记 列表 元组 字典 集合

张时贰
134 阅读18分钟

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

🌴 2022.04.06 下午

前言

🎬本文章是 【Python语言基础】 专栏的文章，主要是上课的随堂笔记与练习
🔗Python专栏 传送门
💻提示：本文的环境配置是Python3的开发环境。目录顺序以当堂内容(教材)为准，所以并非“1、2、3”
📽本节主要内容：Python与其它语言不同，数据类型更多，有了列表、元组、集合、字典的细分，小张刚开始看的时候感觉真多啊，其实各有各的共同之处，也不是很繁琐，而且功能比其它语言更强大，相当于把一些功能封装起来了，咱们可以直接调用

4 组合数据

4.1 概述

Python中的组合数据类似于其他编程语言中的数组等，但类型更多、功能更强大。 在Python中，除字符串外，组合数据主要包括列表、元组、集合和字典等

数据类型数据示例
列表{0,2,4,8,12}
元组('Google', 'Runoob', 1997, 2000)
字典{'name': 'runoob', 'likes': 123, 'url': 'www.csdn.net'}
集合{'Taobao', 'Facebook', 'Google', 'Youtube'}

4.2 列表

4.2.1 列表创建

  • 列表(List)是写在方括号 [] 之间、用,隔开的元素集合
  • 列表中的元素可以是零个或多个,只有零个元素的列表称为空列表[]
  • 列表中的元素可以相同，也可以不相同
  • 列表中的元素可以类型相同
  • 同字符串类似，列表支持元素的双向索引

🚀 语法

使用[]运算符创建列表，列表名 ＝ [元素1,元素2,元素3,…]

list1 = []             		                 	
list2 = [1.25,21.06,0.3,4.7,58.1]        	
list3 = ["石油","汽车","建筑","IT"]         	
list4 = ['Alice',18,'Beth',19]

使用list()函数创建列表，列表名 = list(sequence)

list1 = list()                           	
list(("李白","杜甫","白居易"))     		
['李白', '杜甫', '白居易']
list("CSDN张时贰")            	
['C', 'S', 'D', 'N', '张', '时', '贰']
list(range(5))          				
[0, 1, 2, 3, 4]

4.2.2 列表访问

访问列表

🚀 访问列表及元素

carList = ["奔驰","大众","福特","宝马","奥迪","雪佛兰"] 	#汽车品牌.
print("carList:",carList)
carList: ['奔驰', '大众', '福特', '宝马', '奥迪', '雪佛兰']
print("carList[2]:",carList[2])		#carList[2]: 福特
print("carList[-1]:",carList[-1])	#carList[-1]: 雪佛兰

🚀 列表切片

与range()函数类似，[起点:终点:步长]

carList = ["奔驰","大众","福特","宝马","奥迪","雪佛兰"]
print("carList[2:5]:",carList[2:5])		#carList[2:5]: ['福特', '宝马', '奥迪']
print("carList[2:5:2]:",carList[2:5:2])		#carList[2:5:2]: ['福特', '奥迪']
print("carList[:]:",carList[:])		#carList[:]: ['奔驰', '大众', '福特', '宝马', '奥迪', '雪佛兰']
print("carList[:5]:",carList[:5])	#carList[:5]: ['奔驰', '大众', '福特', '宝马', '奥迪']
print("carList[3:]:",carList[3:])	#carList[3:]: ['宝马', '奥迪', '雪佛兰']
print("carList[2:-1]:",carList[2:-1])	#carList[2:-1]: ['福特', '宝马', '奥迪']

🚀 遍历列表

carList = ["奔驰","大众","福特","宝马","奥迪","雪佛兰"]
print("世界汽车品牌:",end = ' ')
for car in carList:
  print(car,end=' ')
#世界汽车品牌: 奔驰 大众 福特 宝马 奥迪 雪佛兰

添加列表元素

列表创建后，可以使用列表函数或切片为列表添加新的元素

list.append(newItem) 在列表末尾添加新元素 list.insert(index, newItem)在索引为index的位置插入新元素 list.extend(seq)在列表末尾添加迭代对象seq中的所有元素作为列表新元素 list[len(list):] = newList使用切片在列表list末尾添加新元素(newList中的元素)

firsttier_city_list = ["北京","上海","广州","深圳"]
print(firsttier_city_list[:])	#['北京','上海','广州','深圳']
firsttier_city_list.append("成都")
print(firsttier_city_list[:])	#['北京', '上海', '广州', '深圳', '成都']
firsttier_city_list.insert(2,"杭州")
print(firsttier_city_list[:])	#['北京', '上海', '杭州', '广州', '深圳', '成都']
firsttier_city_list.extend(["重庆","武汉"])
print(firsttier_city_list[:])	#['北京', '上海', '杭州', '广州', '深圳', '成都', '重庆', '武汉']
firsttier_city_list[8:] = ["天津","郑州"]
print(firsttier_city_list[:])	#['北京', '上海', '杭州', '广州', '深圳', '成都', '重庆', '武汉', '天津', "郑州"]

修改列表元素

list[index]=newValue对指定索引index的列表元素进行修改。 list[::] = newList对指定范围的列表元素进行修改

fruitList = ["苹果","梨子","桃子","火龙果"]
fruitList[0] = "西瓜"
print(fruitList[:])		#['西瓜', '梨子', '桃子', '火龙果']
fruitList[1:3] = ["杧果","木瓜"]
print(fruitList[:])		#['西瓜', '杧果', '木瓜', '火龙果']

删除列表元素

列表创建后，可以根据需要使用列表函数、del语句或切片删除指定元素或所有元素

  • del list[index]：删除索引为index的元素
  • list.pop()：删除列表末尾的元素
  • list.pop(index)：删除索引为index的元素
  • list.remove(item)：删除列表元素item(元素名)
  • list.clear()：删除列表中所有元素
  • list[::] = []：对指定范围的列表元素进行删除
cityList = ["珠海","威海","信阳","惠州","厦门","金华","柳州","曲靖","九江","绵阳"]
del cityList[8]                   	
print(cityList[:])	#['珠海', '威海', '信阳', '惠州', '厦门', '金华', '柳州', '曲靖', '绵阳']
cityList.pop()      #删除'绵阳'
cityList.pop(6)     #删除'柳州'
cityList.remove("厦门")            	
print(cityList[:])	#['珠海', '威海', '信阳', '惠州', '金华', '曲靖']
cityList[4:] = []                   	
print(cityList[:])	#['珠海', '威海', '信阳', '惠州']
cityList.clear()
print(cityList[:])	#[]

4.2.3 列表复制和删除

🚀 列表复制

  • list_copy = list.copy():列表浅复制
  • list_copy = list:字典复制，list改变，list_copy也改变
planetList = ["水星","金星","地球","火星","木星","土星","天王星","海王星"] 
planetList_copy1 = planetList.copy()      	#列表浅复制
planetList_copy2 = planetList            	#列表复制
planetList.pop()
print("planetList:",planetList)
print("planetList_copy1:",planetList_copy1)
print("planetList_copy2:",planetList_copy2)
'''
planetList: ['水星', '金星', '地球', '火星', '木星', '土星', '天王星']
planetList_copy1: ['水星', '金星', '地球', '火星', '木星', '土星', '天王星', '海王星']
planetList_copy2: ['水星', '金星', '地球', '火星', '木星', '土星', '天王星']
'''

🚀 列表删除

当列表不再需要使用后，可以使用del语句删除列表，其一般格式为del 列表名

capitalList = ["华盛顿","伦敦","巴黎","北京"]      	
print("部分国家首都:",capitalList)
del capitalList                      				#删除列表.
print("部分国家首都:",capitalList)
'''
部分国家首都: ['华盛顿', '伦敦', '巴黎', '北京']
  File "d:/pythonProjects/test.py", line 4, in <module>
    print("部分国家首都:", capitalList)
NameError: name 'capitalList' is not defined
'''

4.2.4 列表运算

  • +：将多个列表组合成一个新列表
  • *：将整数n和列表相乘可以得到一个将原列表元素重复n次的新列表
  • in：用于判断给定对象是否在列表中
  • not in：用于判断给定对象是否不在列表中
  • 关系运算符：规则是从两个列表的第1个元素开始比较，如果比较有结果则结束；否则继续比较两个列表后面对应位置的元素
tang_list = ["韩愈","柳宗元"]
song_list = ["欧阳修","苏轼","苏洵","苏辙","王安石","曾巩"]
tang_song_list = tang_list + song_list
print("唐宋八大家:",tang_song_list)
print("杜甫是唐宋八大家吗?","杜甫" in tang_song_list)         
print("李白出现3次的列表:",["李白"] * 3)                     
print("tang_list < tang_song_list:",tang_list < tang_song_list)   
'''
唐宋八大家: ['韩愈', '柳宗元', '欧阳修', '苏轼', '苏洵', '苏辙', '王安石', '曾巩']
杜甫是唐宋八大家吗? 
False
李白出现3次的列表: ['李白', '李白', '李白']
tang_list < tang_song_list: True
'''

4.2.5 列表统计

  • len(list)：返回列表list中的元素个数
  • max(list)：返回列表list中元素的最大值
  • min(list)：返回列表list中元素的最小值
  • sum(list)：返回列表list中所有元素的和
  • list.count(key)：返回关键字key在列表中的出现次数
ktlsl_list = [1,1,2,5,14,42,132,429,1430,4862]   	
print("列表中元素的个数:",len(ktlsl_list))
print("列表元素的最大值:",max(ktlsl_list))
print("列表元素的最小值:",min(ktlsl_list))
print("列表元素的和:",sum(ktlsl_list))
print("元素 %d 在列表中出现次数: %d."%(14,ktlsl_list.count(14)))
'''
列表中元素的个数: 10
列表元素的最大值: 4862
列表元素的最小值: 1
列表元素的和: 6918
元素14在列表中出现次数: 1.
'''

4.2.6 列表查找与排序

🚀 列表元素查找

list.index(key)函数用于查找并返回关键字在列表中第1次出现的位置

animalList = ["elephant","tiger","lion","leopard","monkey"]      
key = "tiger"
print("%s 在列表中第1次出现的位置：%d. "%(key,animalList.index(key)))    
#tiger 在列表中第1次出现的位置：1

🚀 列表元素排序

列表创建后，可以使用以下函数根据关键字对列表中的元素进行排序、倒序或临时排序

  • list.sort()：对列表list中的元素按照一定的规则排序(或者list.sort( key=None, reverse=True/False),key指定元素排序)
  • list.reverse()：对列表list中的元素按照一定的规则反向排序
  • sorted(list)：对列表list 中的元素进行临时排序，返回副本
buildingList = ["金字塔","长城","埃菲尔铁塔","比萨斜塔","雅典卫城","古罗马竞技场"]
print(buildingList[:])	#['金字塔', '长城', '埃菲尔铁塔', '比萨斜塔', '雅典卫城', '古罗马竞技场']
buildingList.sort()
print(buildingList[:])	#['古罗马竞技场', '埃菲尔铁塔', '比萨斜塔', '金字塔', '长城', '雅典卫城']
buildingList.reverse()
print(buildingList[:])	#['雅典卫城', '长城', '金字塔', '比萨斜塔', '埃菲尔铁塔', '古罗马竞技场']
print(sorted(buildingList))		#['古罗马竞技场', '埃菲尔铁塔', '比萨斜塔', '金字塔', '长城', '雅典卫城']
print(buildingList[:])	#['雅典卫城', '长城', '金字塔', '比萨斜塔', '埃菲尔铁塔', '古罗马竞技场'],sorted知识临时排序顺序并没有改变

4.3 元组

4.3.1 元组创建

元组(Tuple)是写在小括号()之间、用,隔开的元素集合

与列表不同，元组创建后，对其中的的元素不能修改

与列表相似，元组中的元素类型可以相同或不同，其中的元素可以重复或不重复，可以是简单或组合数据类型，元组的下标从0开始，支持双向索引 (1,1,2,3,5)中的元素为简单数字类型，有重复元素；(("语文",122), ( "数学",146),( "英语",138))中的元素为元组类型，元素值各不相同

使用()运算符创建元组

元组名 ＝ (元素1,元素2,元素3,…)

tuple1 = ()             				    #空元组
tuple2 = (1,8,27,64,125)                    #元素为数字
tuple3 = ("计算机科学","生物信息","电子工程")   #元素为字符串
tuple4 = ("华为",701,"中兴",606)             #元素为数字和字符串混合

使用tuple()函数创建元组

元组名 = tuple(sequence)

tuple1=tuple(["莎士比亚","托尔斯泰","但丁","雨果","歌德"])
print(tuple1[:])  	#('莎士比亚', '托尔斯泰', '但丁', '雨果', '歌德')
tuple2=tuple("理想是人生的太阳")
print(tuple2[:])	#('理', '想', '是', '人', '生', '的', '太', '阳')	
tuple3=tuple(range(1,6))       		                    	
print(tuple3[:])	#(1, 2, 3, 4, 5)

4.3.2 元组访问

🚀 访问元组及指定元素

通过tuple[index]访问指定索引为index的元组元素

cityTuple = ("维也纳","苏黎世","奥克兰","慕尼黑","温哥华","杜塞尔多夫")
print(cityTuple[:])		#('维也纳', '苏黎世', '奥克兰', '慕尼黑', '温哥华', '杜塞尔多夫')
print(cityTuple[3])		#'慕尼黑'
print(cityTuple[-2])	#'温哥华'

🚀 元组切片

cityTuple = ("维也纳","苏黎世","奥克兰","慕尼黑","温哥华","杜塞尔多夫")  
print(cityTuple[:])		#('维也纳', '苏黎世', '奥克兰', '慕尼黑', '温哥华', '杜塞尔多夫')
print(cityTuple[1:4])	#('苏黎世', '奥克兰', '慕尼黑')
print(cityTuple[1:4:2])	#('苏黎世', '慕尼黑')
print(cityTuple[:4])	#('维也纳', '苏黎世', '奥克兰', '慕尼黑')
print(cityTuple[2:])	#('奥克兰', '慕尼黑', '温哥华', '杜塞尔多夫')
print(cityTuple[2:-2])	#('奥克兰', '慕尼黑')

🚀 遍历元组

cityTuple = ("维也纳","苏黎世","奥克兰","慕尼黑","温哥华","杜塞尔多夫")
print("全球生活质量高的城市:",end = ' ')
for city in cityTuple:
  print(city,end=' ')
#全球生活质量高的城市: 维也纳 苏黎世 奥克兰 慕尼黑 温哥华 杜塞尔多夫

4.3.3 元组复制和删除

list_copy = list：复制 del 列表名：删除

bat_tuple = ("百度","阿里巴巴","腾讯")
bat_tuple_copy = bat_tuple          #复制元组
print(bat_tuple)		#('百度', '阿里巴巴', '腾讯')
print(bat_tuple_copy)	#('百度', '阿里巴巴', '腾讯')
del bat_tuple        	#删除元组                           
print(bat_tuple)		#NameError: name 'bat_tuple' is not defined

4.3.4 元组运算

wanyue_tuple = ("柳永","晏殊","欧阳修","秦观","李清照")
haofang_tuple  = ("陆游","苏轼","辛弃疾")                     	            
ci_author_tuple = wanyue_tuple + haofang_tuple                         
print("宋朝词人:",ci_author_tuple)	#宋朝词人: ('柳永', '晏殊', '欧阳修', '秦观', '李清照', '陆游', '苏轼', '辛弃疾')
print("李清照是宋朝词人吗?" ,"李清照" in ci_author_tuple)   #李清照是宋朝词人吗? True        
print("'岳飞'出现3次的元组:",("岳飞") * 3)  	#'岳飞'出现3次的元组: 岳飞岳飞岳飞   
print("wanyue_tuple < ci_author_tuple ?",wanyue_tuple < ci_author_tuple)	#wanyue_tuple < ci_author_tuple ? True

4.3.5 元组统计

  • len(list)：返回列表list中的元素个数
  • max(list)：返回列表list中元素的最大值
  • min(list)：返回列表list中元素的最小值
  • sum(list)：返回列表list中所有元素的和
  • list.count(key)：返回关键字key在列表中的出现次数
pellTuple = (0,1,2,5,12,29,70,169,408,985)      	#佩尔数列
print("元组中元素个数:",len(pellTuple))	#10
print("元组中元素最大值:",max(pellTuple))	#元组中元素最大值: 985
print("元组中元素最小值:",min(pellTuple))	#元组中元素最小值: 0
print("元组所有元素的和:",sum(pellTuple))	#元组所有元素的和: 1681
print("元素 %d 在元组中出现次: %d次."%(5,pellTuple.count(5)))	#元素5在元组中出现次数: 1
print("元组中的元素个数: %d."%(len(pellTuple)))	#元组中的元素个数: 10

4.4 字典

4.4.1 字典创建

  • 字典(Dictionary)是一种映射类型，用{}标识，是一个无序的“键(key): 值(value)”对集合
  • 键(key)必须使用不可变类型，如字符串、数字等；值可以是简单数据或组合数据等多种不同类型
  • 在同一个字典中，键(key)必须是唯一的，值可以是不唯一的
  • 与列表通过索引(Index)访问和操作元素不同，字典当中的元素是通过键来访问和操作的

🚀 使用{}运算符创建字典

字典名 ＝ {key1:value1,key2:value2,key3:value3,…}

dict1 = {}       #空字典.
dict2 = {"氮":0.78,"氧":0.21,"稀有气体":0.00939,"二氧化碳":0.00031,"其他":0.0003}

🚀 使用dict()函数创建字典

dict1 = dict ()  # 空字典
dict ( name="Mary", height=165, weight=51 )  # 以关键字创建字典
# {'name': 'Mary', 'height': 165, 'weight': 51}
dict ( zip ( [ "name", "height", "weight" ], [ "Jack", 178, 72 ] ) )  # 以映射函数创建字典
# {'name': 'Jack', 'height': 178, 'weight': 72}
dict ( [ ("name", "Linda"), ("height", 166), ("weight", 53) ] )  # 以可迭代对象创建字典
# {'name': 'Linda', 'height': 166, 'weight': 53}

4.4.2 字典访问

🚀 访问字典

通过字典名访问字典，通过“dict[key]”或“dict.get(key)”访问指定元素

LSZ_dict = {"姓名":"李时珍","出生时间":1518,"籍贯":"湖北","职业":"医生"}
print("LSZ_dict:",LSZ_dict)
print("LSZ_dict中元素个数:",len(LSZ_dict))
print("姓名:",LSZ_dict["姓名"])
print("籍贯:",LSZ_dict.get("籍贯"))
print("职业:",LSZ_dict.get("职业"))   
'''
LSZ_dict: {'姓名': '李时珍', '出生时间': 1518, '籍贯': '湖北', '职业': '医生'}
LSZ_dict中元素个数: 4
姓名: 李时珍
籍贯: 湖北
职业: 医生
'''

遍历字典中所有元素

LSZ_dict = {"姓名":"李时珍","出生时间":1518,"籍贯":"湖北","职业":"医生"}
print("字典中所有的键 / 值:",end = '')
for key,value in LSZ_dict.items():
  print(key,'/',value,end = ', ')
print()
print("字典中所有的键:",end = '')
for key in LSZ_dict.keys():
  print(key,end = ', ')
print()
print("字典中所有的值:",end = '')
for value in LSZ_dict.values():
  print(value,end = ', ')
'''
字典中所有的键 / 值:姓名 / 李时珍, 出生时间 / 1518, 籍贯 / 湖北, 职业 / 医生, 
字典中所有的键:姓名, 出生时间, 籍贯, 职业, 
字典中所有的值:李时珍, 1518, 湖北, 医生,
'''

🚀 添加字典元素

Libing_dict = {"姓名":"李冰","性别":"男","职业":"水利"}
Libing_dict["时期"] = "战国"              #如果存在就修改，不存在就添加到最后
print("Libing_dict:",Libing_dict)
#Libing_dict: {'姓名':'李冰','性别':'男','职业':'水利','时期':'战国'}

🚀 添加字典元素

dict[key] = value

dict1 = {"name":"Alice","sex":"female","age":21}
dict1["age"] = 22           #修改字典元素
print("age:",dict1["age"])	#age: 22

🚀 添加字典元素

字典创建后，可以根据需要使用字典函数或del语句删除指定元素或所有元素

del dict[key]：删除关键字为key的元素 dict.pop(key)：删除关键字为key的元素 dict.popitem()：随机删除字典中的元素 dict.clear()：删除字典中所有元素

influential_people_dict = {"牛顿":"物理学家","孔子":"儒家","亚里士多德":"哲学家","达尔文":"生物学家","欧几里得":"数学家","伽利略":"天文学家"}
del influential_people_dict ["牛顿"]
print(influential_people_dict)		#{'孔子': '儒家', '亚里士多德': '哲学家', '达尔文': '生物学家', '欧几里得': '数学家', '伽利略': '天文学家'}
influential_people_dict.pop("亚里士多德")
print(influential_people_dict)		#{'孔子': '儒家', '达尔文': '生物学家', '欧几里得': '数学家', '伽利略': '天文学家'}
influential_people_dict.popitem()
print(influential_people_dict)		#{'孔子': '儒家', '达尔文': '生物学家', '欧几里得': '数学家'}
influential_people_dict.clear()
print(influential_people_dict)		#{}

4.4.3 字典复制和删除

  • list_copy = list.copy():字典浅复制
  • list_copy = list:字典复制，list改变，list_copy也改变
  • del 列表名
chinese_figure_dict = {"张衡":"地质学家","张仲景":"医学家","祖冲之":"数学家"}
chinese_figure_dict_copy1 = chinese_figure_dict.copy() 	#字典浅复制
chinese_figure_dict_copy2 = chinese_figure_dict        	#字典复制
chinese_figure_dict["沈括"] = "科学家"
print(chinese_figure_dict)		#{'张衡': '地质学家', '张仲景': '医学家', '祖冲之': '数学家', '沈括': '科学家'}
print(chinese_figure_dict_copy1)#{'张衡': '地质学家', '张仲景': '医学家', '祖冲之': '数学家'}
print(chinese_figure_dict_copy2)#{张衡': '地质学家', '张仲景': '医学家', '祖冲之': '数学家', '沈括': '科学家'}
del chinese_figure_dict         #删除字典
print(chinese_figure_dict)		#NameError: name 'chinese_figure_dict' is not defined

4.5 集合

4.5.1 集合创建

  • 集合(Set)：在大括号{}之间、用逗号分隔、无序且不重复的元素集合
  • 不可以为集合创建索引或执行切片(slice)操作
  • 没有键(key)可用来获取集合中元素的值
  • Python中可以使用{}运算符或者 set()函数创建集合

🚀 使用{}运算符创建集合

集合名 ＝ {元素1,元素2,元素3,…}

set1 = {1,4,9,16,25}              #元素为数字
set2 = {"锂","铷","铯","钫","铍"}    #元素为字符串

集合名 ＝ set(sequence)

set1 = set()                        #空集合
set(["氮","氧","氦","氖","氩","氪"])  #列表转换为集合
set(range(1,20,3))     				#使用range()函数创建集合

4.5.2 集合访问

🚀 访问集合元素

tourismSet = {"大峡谷","大堡礁","棕榈海滩","南岛","好望角","拉斯维加斯","悉尼港"}
print("世界著名旅游景点:",tourismSet)
print("遍历'世界著名旅游景点'集合: ",end = '')
#遍历集合
for item in tourismSet:
  print(item,end = ' ')
'''
世界著名旅游景点: {'南岛', '拉斯维加斯', '悉尼港', '大堡礁', '棕榈海滩', '好望角', '大峡谷'}
遍历'世界著名旅游景点'集合: 南岛 拉斯维加斯 悉尼港 大堡礁 棕榈海滩 好望角 大峡谷
'''

🚀 添加和修改集合元素

集合创建后，可以使用集合函数在集合中添加或修改元素

  • set.add(item)：在集合中添加新元素item。
  • set.update(sequence)：在集合中添加或修改元素。
phoneSet = {"华为","苹果"}
print("手机品牌:",phoneSet)		#手机品牌: {'华为', '苹果'}
phoneSet.add("小米")                 			
print("set.add()添加元素后:",phoneSet)	#set.add()添加元素后: {'小米', '华为', '苹果'}
phoneSet.update(["华为","Oppo","Vivo"])  		
print("set.update()添加元素后:",phoneSet)	#set.update()添加元素后: {'Vivo', 'Oppo', '苹果', '小米', '华为'}
#重复会忽略

🚀 删除集合元素

  • set.remove(item)：删除指定元素item
  • set.discard(item)：删除指定元素item
  • set.pop()：随机删除集合中的元素
  • set.clear()：清空集合中的所有元素
world_tournament_set = {"世界杯排球赛","世界乒乓球锦标赛","世界篮球锦标赛","世界足球锦标赛"}      #世界球类大赛
print("世界大赛:",world_tournament_set)
world_tournament_set.remove("世界足球锦标赛")             	#删除指定集合元素
print("set.remove()删除元素后:",world_tournament_set) 
world_tournament_set.discard("世界杯排球赛")               #删除指定集合元素
print("set.discard()删除元素后:",world_tournament_set)
world_tournament_set.pop()         						#随机删除集合元素
print("set.pop()删除元素后:",world_tournament_set)
world_tournament_set.clear()        					#清空集合元素
print("set.clear()清空元素后:",world_tournament_set)
'''
世界大赛: {'世界足球锦标赛', '世界乒乓球锦标赛', '世界杯排球赛', '世界篮球锦标赛'}
set.remove()删除元素后: {'世界乒乓球锦标赛', '世界杯排球赛', '世界篮球锦标赛'}
set.discard()删除元素后: {'世界乒乓球锦标赛', '世界篮球锦标赛'}
set.pop()删除元素后: {'世界篮球锦标赛'}
set.clear()清空元素后: set()
'''

4.5.3 集合复制和删除

  • list_copy = list.copy():列表浅复制
  • list_copy = list:字典复制，list改变，list_copy也改变
  • del 列表名
world_GDP_set = {"美国","中国","日本","德国","英国"}
world_GDP_set_copy1 = world_GDP_set.copy()
world_GDP_set_copy2 = world_GDP_set
world_GDP_set.add("法国")
print("world_GDP_set:",world_GDP_set)	#world_GDP_set: {'英国', '日本', '中国', '美国', '德国', '法国'}
print("world_GDP_set_copy1:",world_GDP_set_copy1)	#world_GDP_set_copy1: {'美国', '英国', '德国', '日本', '中国'}
print("world_GDP_set_copy2:",world_GDP_set_copy2)	#world_GDP_set_copy2: {'英国', '日本', '中国', '美国', '德国', '法国'}
del world_GDP_set
print(world_GDP_set)	#NameError: name 'world_GDP_set' is not defined

4.5.4 集合运算

  • set1.union(set2) 或 set1 | set2：并集运算
  • set1.intersection(set2) 或 set1 & set2：交集运算
  • set1. difference(set2) 或 set1 - set2：差集运算
  • set1. issubset(set2) 或 set1 < set2：子集运算
  • item in set 或item not in set：成员运算
delicacySet1 = {"中国冰糖葫芦","墨西哥卷饼","英国炸鱼","美国热狗","土耳其烤肉","新加坡炒粿"}
delicacySet2 = { "新加坡炒粿","日本章鱼烧","韩国炸鸡","越南虾饼","曼谷香脆煎饼"}
print(delicacySet1 | delicacySet2)		#{'墨西哥卷饼', '韩国炸鸡', '美国热狗', '曼谷香脆煎饼', '日本章鱼烧', '中国冰糖葫芦', '英国炸鱼', '越南虾饼', '新加坡炒粿', '土耳其烤肉'}
print(delicacySet1 & delicacySet2)		#{'新加坡炒粿'}
print(delicacySet1 - delicacySet2)		#{'墨西哥卷饼', '美国热狗', '中国冰糖葫芦', '英国炸鱼', '土耳其烤肉'}
print(delicacySet1 < delicacySet2)		#False
print("墨西哥巧克力" in delicacySet1 | delicacySet2)		#False

4.5.5 集合统计

  • len(list)：返回列表list中的元素个数
  • max(list)：返回列表list中元素的最大值
  • min(list)：返回列表list中元素的最小值
  • sum(list)：返回列表list中所有元素的和
triangleSet = {1,3,6,10,15,21,28,36,45,55}      	
print("集合中的元素个数: %d ."%(len(triangleSet)))		#集合中的元素个数: 10	
print("集合中元素最大值:",max(triangleSet))				#集合中元素最大值: 55
print("集合中元素最小值:",min(triangleSet))				#集合中元素最小值: 1
print("集合所有元素的和:",sum(triangleSet))				#集合所有元素的和: 220

4.6 嵌套组合数据

list = [[1,0,0],[0,1,0],[0,0,1]]  	     #单位嵌套列表
print("list:",list)		#: [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
list1 = [1,2,3]
list2 = [4,5,6]
list3 = [7,8,9]
list = [list1,list2,list3]  		     #多个列表组成嵌套列表
print("list:",list)					#list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("list[1]:",list[1])      		#list[1]: [4, 5, 6]
print("list[1][1]:",list[1][1])		#list[1][1]: 5

nobel_prize_dict = {"物理学家":["伦琴","爱因斯坦","波尔"],"化学家":["欧内斯特·卢瑟福","范特霍夫","玛丽·居里"],"医学家":["埃米尔·阿道夫·冯·贝林","罗伯特·科赫","屠呦呦"]}
#遍历嵌套字典
for key,value in nobel_prize_dict.items():
  print("获得诺贝尔奖的" + str(key) + ":",end = ' ')
  for item in value:
    print(item,end = ', ')
  print()
'''
获得诺贝尔奖的物理学家: 伦琴, 爱因斯坦, 波尔, 
获得诺贝尔奖的化学家: 欧内斯特·卢瑟福, 范特霍夫, 玛丽·居里, 
获得诺贝尔奖的医学家: 埃米尔·阿道夫·冯·贝林, 罗伯特·科赫, 屠呦呦,
'''
avatar
文章
阅读
粉丝