Python字典和集合讲解 Python字典和集合讲解

一、Python字典

1.什么是字典
2.字典的创建方式

2.1 通过其他字典创建
2.2 通过关键字参数创建
2.3 通过键值对的序列创建
2.4 通过dict和zip结合创建

3.字典的访问

3.1 根据键访问值
3.2 使用get（）方法访问值

4.in 和 not in 在字典中的使用

5.修改和添加字典中的元素

6.删除字典中的元素

7.更新字典

8.获取字典视图的三个方法

9.遍历字典

10.字典的特点

11.复制字典

二、Python集合（set）

1.什么是集合

2.集合创建

3.集合的判断操作

4.集合添加元素

5.集合删除元素

6.集合间的关系

一、Python字典
1.什么是字典

Python内置的数据结构之一，与列表一样是一个可变序列
以键值对的方式存储数据，字典是一个无序的序列
在存储数据时要经过hash(key)的计算，计算的结果就是存储的位置，因此字典的键值对顺序并不是按照存储时的先后顺序决定的，而是经过计算得到的存储位置。
字典中的键必时不可变序列，否则当键改变时，hash计算的结果就会发生变化，导致存储位置发生变化。因此键必须要使用不可变序列

文章图片

字典的实现原理：

与查新华字典类似，差字典是先根据部首或者拼音查找相应的页码，Python中的字典是根据 key去查找value的所在位置

2.字典的创建方式

#字典创建的两种方式#第一种，使用花括号dict_1 = {'num':'20210101','name':'Liming','sex':'male'}print(dict_1)#第二种，使用内置函数dict()

2.1 通过其他字典创建

dict_2 = dict(dict_1)print(dict_2)print(dict_2 is dict_2)# True

2.2 通过关键字参数创建

dict_3 = dict(num = "20210101",name = "Liming",sex = 'male')print(dict_3)print(dict_1 == dict_3)#Trueprint(dict_1 is dict_3)#False

2.3 通过键值对的序列创建

dict_4 = dict([('num',"20210101"),('name',"Liming"),('sex',"male")])print(dict_3)

2.4 通过dict和zip结合创建

dict_5 = dict(zip(['num','name','sex'],['20210101','Liming','male']))print(dict_5)if dict_1 == dict_2 == dict_3 == dict_4 == dict_5:#判断字典的值是否相同print("创建字典的5种方式相同")else:print("创建字典的5种方式不同")

字典种的键是唯一的，创建字典时若出现“键”相同的情况，则后定义的“键-值”对将覆盖先定义的“键-值”对。

x = {'a':1,'b':2,"b":3}print(x)#运行结果{'a': 1, 'b': 3}

fromkeys()方法创建字典：当所有的键对应同一个值的时候，可以使用fromkeys创建字典
dict.fromkeys(seq[,value])：seq:为字典“键”的值列表value：为设置键序列(seq)的值，省略时默认为None

dict_1 = dict.fromkeys(['zhangsan','wangwu'])print(dict_1)dict_2 = dict.fromkeys(['zhang_san','wang_wu'],18)print(dict_2)dict_3 = dict.fromkeys(['zhang_san','wang_wu'],b)print(dict_3)#从下面四行代码可以看出，当他们值为可变序列并且引用地址相同时，类似于浅copydict_3['wang_wu'].pop()print(dict_3)dict_3['wang_wu'].append(10)print(dict_3)#运行结果{'zhangsan': None, 'wangwu': None}{'zhang_san': 18, 'wang_wu': 18}{'zhang_san': [18], 'wang_wu': [18]}{'zhang_san': [], 'wang_wu': []}{'zhang_san': [10], 'wang_wu': [10]}

3.字典的访问

3.1 根据键访问值

字典中每个元素表示一种映射关系，将提供的“键‘作为下标可以访问对应的值
如果字典中不存在这个”键“，则会抛出异常

#根据键访问值dict_1 = {"name":"张飞","age":18,"sex":"male"}print(dict_1["name"])print(dict_1["sex"])#print(dict_1["x"])指定的键不存在，抛出异常

3.2 使用get（）方法访问值

在访问字典时，若不确定字典中是否由某个键，可通过get（）方法进行获取。
若该键存在，则返回对应的值
若该键不存在，则返回默认值
语法格式

语法格式：

dict.get([key[,default = None])
key:要查找的键
default：默认值，默认为None，可自行设置需要输出的默认值。如果指定的键不存在，则返回默认值，当default为空时，返回None

#使用get()方法访问值dict_1 = {"name":"张飞","age":18,"sex":"male"}print(dict_1.get("name"))print(dict_1.get("x"))#返回Noneprint(dict_1.get("x",18))#当键不存在时，输出设置的默认值，并不会把键x存入dect_1print(dict_1.get("age",19))#当键存在时，输出age原本的值

4.in 和 not in 在字典中的使用
判断键是否在字典中

#in和not in在字典中的使用：判断键是否在字典中dict_1 = {"name":"张飞","age":18,"sex":"male"}print("name" in dict_1)#Trueprint("张飞" in dict_1)#Falseprint("张飞" not in dict_1)#True

5.修改和添加字典中的元素
当以指定键为下标为字典元素赋值时，有两种含义：

若该键存在字典中，则表示修改该键对应的值
若该键不存在字典中，则表示添加一个新的键值对，也就是添加一个新元素到字典中

dict_1 = {"name":"张飞","age":18}print(dict_1)dict_1["name"] = "李四"#name键存在字典dict_1中，所以此处为修改name的值print(dict_1)dict_1["sex"] = "male"#sex键不存在字典dict_1中，所以此处为添加新的键值对print(dict_1)#输出结果{'name': '张飞', 'age': 18}{'name': '李四', 'age': 18}{'name': '李四', 'age': 18, 'sex': 'male'}

6.删除字典中的元素
删除字典元素： del命令clear()方法pop()方法popitem()方法
del命令：根据”键“删除字典中的元素

dict_1 = {"name":"张飞","age":18,"sex":"male"}del dict_1["name"]print(dict_1)#运行结果{'age': 18, 'sex': 'male'}

clear()方法：用于清除字典中所有元素，其语法格式如下：

dict_1 = {"name":"张飞","age":18,"sex":"male"}dict_1.clear()print(dict_1)#运行结果{}

pop()方法：用于获取指定”键“的值，并将这个键值对从字典中移除，并返回该键的值。

dict.pop(key[,default])
key:要被删除的键
default：默认值，当字典中没有要被删除的key时，该方法返回指定的默认值

dict_1 = {"name":"张飞","age":18,"sex":"male"}print(dict_1.pop("age"))#删除键age与其值，pop（）方法的返回值为，删除的该键的值print(dict_1)print(dict_1.pop('age',17))print(dict_1)print(dict_1.pop('name',"里斯"))print(dict_1)

popitem()方法：用于随机获取一个键值对，将其删除，并以元组的方式返回被删除的键值对

dict.popitem() :该方法无参数

dict_1 = {"name":"张飞","age":18,"sex":"male"}x = dict_1.popitem()print(x,type(x))print(dict_1)#运行结果('sex', 'male') {'name': '张飞', 'age': 18}

7.更新字典
使用update()方法：可以将新字典的键值对，一次性全部添加到当前字典中
如果两个字典存在相同的键，则以新字典中的值为准，更新当前字典
dict.updata(dict2)

dict:当前字典
dict2：新字典

dict_1 = {"name":"张飞","age":18}dict_2 = {"name":"李四","sex":"male"}dict_1.update(dict_2)print(dict_1)print(dict_2)#运行结果{'name': '李四', 'age': 18, 'sex': 'male'}{'name': '李四', 'sex': 'male'}

8.获取字典视图的三个方法

文章图片

key（）方法

#keys()方法：获取字典中所有的keydict_1 = {"name":"张飞","age":18,"sex":"male"}key_1 = dict_1.keys()print(key_1,type(key_1)) #可以看出获取到了字典所有的键，并存放在了一个貌似列表的dict_keys视图中key_2 = list(key_1)#将对象key_1视图变成列表,并不改变原来的key_1视图print(key_1)print(key_2)#运行结果dict_keys(['name', 'age', 'sex']) dict_keys(['name', 'age', 'sex'])['name', 'age', 'sex']

values()方法

#values()方法：获取字典中所有的valuedict_1 = {"name":"张飞","age":18,"sex":"male"}value_1 = dict_1.values()print(value_1,type(value_1)) #可以看出获取到了字典所有的值，并存放在了一个貌似列表的dict_values视图中value_2 = list(value_1)print(value_1)print(value_2)#运行结果dict_values(['张飞', 18, 'male']) dict_values(['张飞', 18, 'male'])['张飞', 18, 'male']

items(）方法

#items()方法：获取字典中所有的键值对dict_1 = {"name":"张飞","age":18,"sex":"male"}items_1 = dict_1.items()#可以看出获取到了字典所有的键值对，并将键值对存放在了元组中，再把元组存放在列表中，视图类型为：dict_itemsprint(items_1,type(items_1))items_2 = list(items_1)#将视图转换成列表print(items_2)items_3 = tuple(items_2)#将列表转换成元组print(items_2)print(items_3)#运行结果dict_items([('name', '张飞'), ('age', 18), ('sex', 'male')]) [('name', '张飞'), ('age', 18), ('sex', 'male')][('name', '张飞'), ('age', 18), ('sex', 'male')](('name', '张飞'), ('age', 18), ('sex', 'male'))

9.遍历字典
使用for循环遍历，列表、元组和集合的组合时

当变量x为一个时，x会直接获取列表（元组）的值
当变量x,y···的个数刚好与列表（元组）的个数相同时，则直接将值依次赋给变量

注意：只有在使用列表和元组和集合的两两组合时才能这样使用。

"""使用for循环遍历，列表和元组的组合时，·当变量x为一个时，x会直接获取列表（元组）的值·当变量x,y···的个数刚好与列表（元组）的个数相同时，则直接将值依次赋给变量"""a = [('Mary', 'C',"d"),('Jone', 'java',"d"),('Lily', 'Python',"d"),('Lily', 'Python',"d")]for x in a:print(x)#列表里面存储的元组，只有一个变量x，所以将元组直接赋值给xprint("============================================")for x,y,z in a:#列表里面存储的元组，每个元组里面存储了3个元素，刚好可以用三个变量xyz接收这三个元素print(x,y,z)print("============================================")a = (['Mary', 'C',"d"],['Jone', 'java',"d"],['Lily', 'Python',"d"],['Lily', 'Python',"d"])for x in a:#元组里面存储的列表，只有一个变量x，所以将元组直接赋值给xprint(x)print("============================================")for x,y,z in a:#元组里面存储的列表，每个列表里面存储了3个元素，刚好可以用三个变量xyz接收这三个元素print(x,y,z)#运行结果('Mary', 'C', 'd')('Jone', 'java', 'd')('Lily', 'Python', 'd')('Lily', 'Python', 'd')============================================Mary C dJone java dLily Python dLily Python d============================================['Mary', 'C', 'd']['Jone', 'java', 'd']['Lily', 'Python', 'd']['Lily', 'Python', 'd']============================================Mary C dJone java dLily Python dLily Python da = {('Mary', 'C',"A"),('Jone', 'java',"B"),('Lily', 'Python',"C"),('Lily', 'Python',"D")}for x in a:#集合里面存储的元组，只有一个变量x，所以将元组直接赋值给xprint(x)for x,y,z in a:#集合里面存储的元组，每个元组里面存储了3个元素，刚好可以用三个变量xyz接收这三个元素print(x,y,z)#运行结果('Mary', 'C', 'A')('Lily', 'Python', 'D')('Jone', 'java', 'B')('Lily', 'Python', 'C')Mary C ALily Python DJone java BLily Python C

遍历字典中所有的键值对

使用items()方法，该方法以列表的形式返回可遍历的键值对元组

stu_class = {'Mary': 'C','Jone': 'java','Lily': 'Python','Lilo': 'Python'}for name,cla in stu_class.items():print(name,"选修的课程为：",cla)#运行结果Mary 选修的课程为： CJone 选修的课程为： javaLily 选修的课程为： PythonLilo 选修的课程为： Python

遍历字典中所有的键

当不需要字典中的值时，可使用keys()方法，只遍历字典中的键，该方法以列表返回一个字典中所有的键

stu_class = {'Mary': 'C','Jone': 'java','Lily': 'Python','Lilo': 'Python'}for name in stu_class.keys():print(name)#运行结果MaryJoneLilyLilo

遍历字典中所有的值

当只关心字典所包含的值时，可以使用values()方法，该方法以列表形式返回字典中所有的值

stu_class = {'Mary': 'C','Jone': 'java','Lily': 'Python','Lilo': 'Python'}for cla in stu_class.values():print(cla)#运行结果CjavaPythonPython

10.字典的特点

字典中所有的元素都是一个键值对（key - value） ,key不允许重复，但是value可以重复
字典中的元素是无序的
字典中的key是不可变对象（不可变序列）
字典页可以根据需要动态伸缩
字典会浪费较大的内存，是一种使用空间换时间的数据

11.复制字典
直接赋值：对象的引用
浅复制（copy()方法）：拷贝父对象，引用对象内部的子对象
深复制（deepcopy()方法）:copy模块的deepcopy()方法，完全复制父对象及其子对象

dict1 = {'user':'runoob','num':[123]}dict2 = dict1#引用对象dict3 = dict1.copy()#浅复制，深复制父对象，子对象不复制，还是引用import copydict4 = copy.deepcopy(dict1) #深复制，完全复制父对象和子对象print(1,dict1,id(dict1))#1 {'user': 'runoob', 'num': [123]} 1630766832896dict1['user'] = 'root'print(1,dict1,id(dict1))#1 {'user': 'root', 'num': [123, 23]} 1630766832896print(2,dict2,id(dict2))#2 {'user': 'root', 'num': [123, 23]} 1630766832896print(3,dict3,id(dict3))#3 {'user': 'runoob', 'num': [123, 23]} 1630766833088print(4,dict4,id(dict4))#4 {'user': 'runoob', 'num': [123]} 1630767214080

二、Python集合（set）
1.什么是集合

python语言提供的内置数据结构
与列表和字典一样，都属于可变序列
集合是没有value的字典
集合类型与其他类型最大的区别在于，它不包含重复元素

文章图片

2.集合创建

#集合创建方式一：使用{}set_1 = {"Python","Hello",90}print(set_1)set_2 = {1,1,2,3,4,4,"Python","Python"}#集合中的元素不允许重复print(set_2)set_3 = {1,2.2,(1,2,3,4),"Python"}print(set_3)#set_4 = {1,2.2,[1,2,3,4]}# 代码报错：集合中的元素不允许为可变数据类型（可变序列）#集合创建方式二：使用内置函数 set():将字符出、列表、元组、range()等对象转化成集合set_4 = set("python")print(set_4)set_5 = set([1,2,3,4,5])print(set_5)set_6 = set((1,2,"Hello"))print(set_6)set_7 = set(range(5))print(set_7)set_8 = set()#创建空集合print(set_8)set_9 = {}print(type(set_9))# :所以创建空集合的时候，不能直接使用{}

3.集合的判断操作
in或者notin　:判断元素是否在集合中

set_1 = {10,20,30,40,50}print(10 in set_1)#Trueprint(100 in set_1)#Falseprint(20 not in set_1)#Falseprint(100 not in set_1)#True

4.集合添加元素
集合添加元素：add()方法、update()方法
set_1.add(x)方法：如果数据项x不在结合set_1中，将x添加到set_1中（一次添加一个元素，元素不重复的前提下）
set_1.update(T)方法：合并结合T中的元素到当前集合set_1中，并自动去除重复元素（至少添加一个元素，元素不重复的前提下）

#集合添加元素set_1 = {1,2.2,"Python"}set_2 = {(1,2,True,"Hello"),2.2,"Python","China"}set_1.add((1,2,True,"Hello"))print(set_1)set_1.update(set_2)print(set_1)set_1.update([10,20,30])#可以添加集合中的元素print(set_1)set_1.update((40,50,60))#可以添加元组中过的元素print(set_1)#运行结果{1, 2.2, (1, 2, True, 'Hello'), 'Python'}{1, 2.2, 'China', (1, 2, True, 'Hello'), 'Python'}{1, 2.2, 'China', 10, (1, 2, True, 'Hello'), 20, 'Python', 30}{1, 2.2, 'China', 40, 10, (1, 2, True, 'Hello'), 50, 20, 'Python', 60, 30}

5.集合删除元素
集合删除元素：remove()方法discard()方法pop()方法clear()方法
S.remove(x)方法：如果x在集合S中，移除该元素；如果x不存在则抛出异常
S.discard(x)方法：如果x在集合S中，移除该元素；如果x不存在不会报错

set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}set_1.remove(1)print(set_1)# set_1.remove(1)#集合中无元素1，执行此代码会抛出异常set_1.discard(2.2)print(set_1)set_1.discard(2.2)#集合中无元素2.2，不过执行此代码不会抛出异常print(set_1)#运行结果{(1, 2, True, 'Hello'), 2.2, 'Python'}{(1, 2, True, 'Hello'), 'Python'}{(1, 2, True, 'Hello'), 'Python'}

S.pop()方法：随机删除并返回集合中过的一个元素，如果集合为空则抛出异常
S.clear()方法：清空集合

set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}print(set_1.pop())print(set_1)set_1.clear()print(set_1)#set_1.pop() #集合为空，执行此行代码，会抛出异常#运行结果1{2.2, 'Python', (1, 2, True, 'Hello')}set()

6.集合间的关系
两个集合是否相等==、!=、is、notis