python基础学习（字典 和 集合）

Python（字典篇 and 集合）

说到字典，我想到大部分初学者第一时间想到的就是新华字典，但是现在要讲的是在python当中的字典，字典具有无序性，可变性，可迭代性，可增减性。

那第一我们先说说字典的结构：

dict_1={"key":value}

注意：key一定要是不可变元素。

所谓字点常常由俩个元素组成；key（键），value(值)，可以想象一下，字典就想现实中的新华字典一样，而key就像是平时查字典时的首字母，身份证一样；而value就像是身份证中包含的身份信息一样，只有你向字典输入你的key才会返回你要的信息，所以当我们需要字典里所含的值时我们可以输入 字典名称【key】这个就=键所含的值。

比如：

dict_1={"小明":"18岁","小华":"20岁"} #字典的建立
print(dict_1["小明"]) #此时电脑输出value是18岁

当们知道了字典的结构后，就要学会字典的建立了，字典的建立常常有俩种方法。

直接建立

比如：

dict_1={"key":value}

这种方法比较简单也比较直接，能清晰的知道直接的key与value。

利用 dict() 函数

dict是python中的一种内置函数，大白话就是要记得！

比如：

dict_1=dict(key=value)
print(dict_1)

效果就是：

{"key":value}

这中方法个人认为比较简便实用。

看以下代码：

li=[1,2,3,4,5,6,7,8,9]
li2=[1,2,3,4,5,6,7,8,9]
print(dict(zip(li,li2)))

此时输出的是：

{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}

zip()函数可以将可迭代对象重新组成打包为然后存储在计算机当中，注意是存储并不是可以立马使用，他就像刚出土的矿石一样需要一定的加工后才可以使用，可以用list()，dict()，tuple()，set()等函数进行一个加工（类型转换）才可以由输出函数进行输出。

注意：如果zip()函数整合的对象不能一 一对应的话那么多出来的元素会被自动删除。

可迭代对像是什么呢？

所谓可迭代对象就是能一个一个提取里面元素的东西，可以用for循环进行遍历的类型。

字典的元素增加

像在列表当中有append() 和 extend()函数一样，字典也有自己的方法：

update(key=value) 函数

dict_1={} #这是一个空字典
print(dict_1.update("小华":18)) #使用update()进行增加

运行结果：

{"小华":18}

修改字典

修改字典通常会使用俩种方法：

update() 函数法

这函数不仅有增加的用法，还有修改的方法；当key在字典当中已经存在的话，就会将key中的值进行一个替换。

索引法替换

该方法可以用key对字典进行一个索引然后进行替换。

实例：

dict_1={"小明":"18岁","小华":"20岁"} #字典的建立
dict_1["小明"]="19岁" #进行替换
print(dict_1)

输出结果：

{"小明":"19岁","小华":"20岁"}

删除元素

有增加那么当然有删除了。

del

该函数可以通过key对字典元素进行删除。

del 列表名称【key】就可以对字典进行一个删除处理：

dict_1={"小明":"18岁","小华":"20岁"} #字典的建立
del dict_1["小明"] #进行删除
print(dict_1)

输出结果：

{"小华":"20岁"}

pop(key, default) 方法

pop(key,default)方法也可以对字典进行一个删除处理：
补充一点，注意：pop不但完成了删除字典中元素的这个动作，还将删除的元素做成了一个返回值，想看到删除的是什么，可用print（）来输出出来
dict_1={"小明":"18岁","小华":"20岁"}
print(dict_1.pop("小明","不存在"))

注意如果使用pop()方法中的key不存在，此时就要再设置一个参数，防止报错哦！

比如：

li=[1,2,3,4,5,6,7,8,9]
li2=[1,2,3,4,5,6,7,]
dict=dict(zip(li,li2))
print(dict)
print(dict.pop(10,"none")) #此时的不存在

那么输出结果就是：none。

当然这个可以自己设置不一定要是none。

popitem() 方法

在老版本的python当中是随机删除一组键和值，但在python3.7后就变成了固定的删除最后一个删除的键和值。

dict_1={"小明":"18岁","小华":"20岁"}
dict_1.popitem() #3.7python后就是删除"小华":"20岁"

结果是：

{"小明":"18岁"}

clear() 方法

其意义就是删除字典中所的元素最后变成一个空字典{}。

copy() 方法

copy()方法可以叫做浅复制，所谓浅复制就是复制后的字典不受原字典的删除或增加影响：

dict_1={"小明":"18岁","小华":"20岁"}
dict_2=dict_1.copy()
del dict_1["小明"]
print(dict_1)
print(dict_2)

结果是：

{"小华":"20岁"}

items()，keys()，values()

items()

可以将字典中的所有key and value全部提取出来：

dict_1={"小明":"18岁","小华":"20岁"}
print(dict_1.items)

结果：

dict_items([('小华', 18), ('小明', 19)])

可以通过for循环进行遍历提取key and value：

dict={"小华":18,"小明":19}
key=[] #创建空列表，当作一个容器来接受变量来放入列表
value=[] #以上同理
for k,v in dict.items(): #通过for循环进行遍历逐步提取出dict.items中的各个元素，注意：这里因为有俩个变量所以提取也是俩个俩个的提取
key.append(k) #append()用该内置函数来将变量提取到list容器里面
value.append(v) #与上同理
print(key) #不用说了很简单
print(value)

结果是：

["小华","小明"]
[18,19]

也可以进行一个判断字典里面是否含有这个元素：

dict={"小华":18,"小明":19}
key=[] #创建空列表，当作一个容器来接受变量来放入列表
value=[] #以上同理
for k,v in dict.items(): #通过for循环进行遍历逐步提取出dict.items中的各个元素，注意：这里因为有俩个变量所以提取也是俩个俩个的提取
if k=="小华": #进行判断
x="存在"
else:
x="不存在"
print(x)

结果：

存在

keys() 方法

keys()方法就是获取字典中的所有key：

这个也可以同理写出判断是否有这个key在字典里面：

多说无益，直接来：

dict_1=dict(小华=18,小明=19)
print(dict_1)
print(dict_1.keys())
i=0
li=[]
pople=input("你要查询的人")
for i in dict_1.keys(): #通过for循环进行遍历
li.append(i)
if pople in li:
print("存在")
else:
print("None")
print(li)

values() 方法

values()方法的使用就如同keys差不多，只不过输出的全部都是字典里的值。

嵌套式字典

顾名思义就是字典里面装了一个小字，可以有多个。

dict_2={"小明":{"老家":"广州的","身高":180},"小华":{"老家":"北京的","身高":185}}

这就是一个嵌套式字典，像是这种嵌套式字典可以用来存储海量数据，可以配套使用items()，keys()，values()等函数使用，也可以用循环进行遍历。

def x(name, home, shengao):
dict_2={"小明":
{"老家":"广州","身高":180},
"小华":
{"老家":"北京","身高":185}
}

这就是一个嵌套式字典，像是这种嵌套式字典可以用来存储海量数据

list_1=[]
list_2=[]
if name in dict_2:
for k,v in dict_2[name].items():
list_1.append(k)
list_2.append(v)
print(list_2)
if home in list_2 and shengao in list_2:
print(dict_2[name])
return True
else:
return False
#进行判断

name=input("你的姓名")
home=input("老家：")
shengao=int(input("身高：")) #小心因为字典里存储的数据是整形注意类型转化
q=x(name,home,shengao)
print(f"是否正确{q}")

fromkeys() 方法

用fromkeys方法建立的字典都有一个共同特点就是他们的key可以不同但是他们的值是一样的，当值相同但是key不同的时候可以用fromkeys([key]，value)来创建字典来使用。

函数的结构：

dict_1=fromkeys([key],value)

注意value只能有一个。

print(dict_1)

输出结果：

{"key":value,"key":value}

集合

说到集合就会让人像到高中数学中的集合其实大差不差，python的集合与高中数学的集合大差不差，可以说是非常的像，说了这么多，那就说说集合的结构吧。

集合的结构

{元素}

集合的特性是无序性，集合里面的元素是没有顺序的，具有可迭代性，且里面的元素必须是不可变的元素。那就说说什么是不可变的元素，所谓不可变元素就是定值不能被改变，且还有唯一性，就是其中的元素不能重复，如果重复就会被自动的删除为一个。

集合的建立

set()

set()函数，建立的是可变集合，就是其中的元素可以被改变，可将可迭代对象转换成集合；且自动的去掉重复元素。

li=[1,1,2,3,4,5,6,]
print(set(li)) #自动的删除重复元素，将列表这个可迭代对象转换成集合

输出结果：

{1,2,3,4,5,6}

frozenset()

其建立的集合是不可变的，也就是不可变类型，可以作为字典的key，但里面的元素不能被增加或减少，一句话就是不能被改变，当然可以被for循环遍历。

li=[1,1,2,3,4,5,6,]
set_1=frozenset(li)
set_2=set()
for i in set_1: #利用for循环进行一个遍历操作
set_2.add(i)
print(set_2)
list_3=list(set_2) #将遍历好的集合转换成列表
print(list_3)

输出结果：

{1,2,3,4,5,6}
[1,2,3,4,5,6,]

总结：如果列表当中有相同的元素可将其转换成集合再转换为列表。

直接建立

jihe={元素}

注意：{}是空字典不是空集合。

jihe={1,2,3,4}
print(jihe)

输出结果是：

{1,2,3,4}

可变集合的改变

add() 函数与 update

set_1={1,2,3,4}
print(set_1.add(5))
print(set_1.update(5))

输出结果：

{1,2,3,4,5}

注意：其集合一定要是可变集合。

pop() 函数的使用

这个函数随机删除集合中的元素。

remove() 函数

set_1={1,2,3}
print(set_1.remove(1))

结果：

{2,3}

set_1={1,2,3}
print(set_1.remove(0))

结果：抛出异常。

discard() 方法

set_1={1,2,3,}
print(set_1.discard(1))

输出结果：

{2,3}

set_1={1,2,3}
print(set_1.discard(0))

输出结果：None。

从这里可以看出：discard()函数如果删除了一个集合里面没有的元素，不会有影响代码的运行。

集合运算符

分别有并集（|）、补集（^）、交集（&）、差集（-）。

并集

与数学当中的集合一样：都是两集合的归总。

实例：

set_1={1,2,3}
set_2={4,5,6}
print(set_1|set_2)

结果是：

{1,2,3,4,5,6}

补集

在python中的补集是俩个集合不同时拥有的的元素集合叫做补集。

set_1={1,2,3}
set_2={4,5,6}
print(set_1^set_2)

结果是：

{1,2,3,4,5,6}

交集（&）

与补集正好相反，交集是俩集合共有的元素：

set_1={1,2,3}
set_2={4,5,6}
print(set_1&set_2)

结果：

{1,2,3,4,5,6}

差集（-）

就是把其中一个集合独有元素组成一个新的集合。

set_1={1,2,3}
set_2={4,5,6}
print(set_1-set_2)

结果是：

{123}

发现很明显那个集合在-好之前就输出其独特的元素。

子集与真子集；超集与真超集

当set_1>=set_2时输出为True，说set_1是set_2的超集，set_2是set_1的子集。

当set_1>set_2就说set_1是set_2的真超集，反之就是真子集。

集合实例

def wordsbook(): #定义函数

print("Welcome to the Words Book")
print("单词本*")
print("增加单词，删除单词，查看单词")
li=["增加单词","删除单词","查看单词"]
#构建平台界面

words_list=set(())
#建立集合

判断语句防止输入不相关的内容

while(True):
choose=input("你的功能：")
if choose not in li:
print("请重新输入")
else:
break

判断用户的使用功能：

if chooseli[0]:
words=input("你想添加的单词：")
if words in words_list:
print("这个单词你已经存过了")
print(words_list[words])
else:
words_list.update({words})
print(words_list)
if chooseli[1]:
del_words=input("你想删除的单词")
if del_words in words_list:
words_list.discard(del_words)
print(words_list)
elif del_words"全部":
words_list.clear()
else:
print("里面没有这个单词")
if chooseli[2]:
print(words_list)

wordsbook()

用while循环来实现多次使用该函数（程序）
while True:
#判断语句来获取用户使用意向
shiyong=input("请问还要使用吗")
if shiyong=="yes":
wordsbook()
else:
print("感谢使用")
break