[Python知识库]Python入门学习（六）

目录

什么是dict

dict语法定义：

Python读取dict元素

Python添加dict元素

Python更新dict元素

Python刪除dict元素

Python dict的特点

查询速度快

有序与无序

key不可变

Python遍历dict

Python操作dict的其他方法

获取dict的所有key

获取dict所有的value

清除所有元素

什么是Set

Python读取set元素

Python添加set元素

Python删除set元素

Python操作set的其他方法

不会报错的删除方法discard()

清除所有元素的方法clear()

集合的子集和超集

什么是dict

前面的文章，我们已经知道了，List和tuple可以用来表示顺序集合，例如，班里同学的名字：

# List: 
['张三','李四','王五']
# tuple：
('张三','李四','王五')

或者考试的成绩：

# List：
[45,69,75]
# tuple:
(45,69,75)

如果我们想将同学的名字和成绩一一对应起来，那么就需要我们通过下标循环进行对应，如下：

names = ['张三','李四','王五']
scores = [45,69,75]
index = 0
for name in names:
    score = scores[index]
    print('name = {},score = {}'.format(name,score))
    index = index + 1

事实上，我们可以得到这样的映射。

张三 ==> 45
李四 ==> 69
王五 ==> 75

但是这样使用两个list，始终有些麻烦，尤其是需要变换一个列表的顺序后，另外一个列表也需要做同样的变换，否则就可能出现对应不上的问题。

这时，我们就需要学习一下新的知识点了， Python中提供了dict，dict就是专门这种映射的，使用dict可以方便的保存“名字”-->“成绩”的映射。

在dict中，每一项包含一个key和一个value，key和value是一一对应的。说白了就是跟map和object一样，是键值对。

dict语法定义

方式一：

# dict语法定义：
d = {
    '张三':45,
    '李四':69,
    '王五':75
}

知道了dict后，那么解决上面的问题是不是就简单了很多。我们可以把学生姓名定义为key，成绩定义为value。

在定义里，我们使用花括号{}表示这是一个dict，然后key和value之间使用冒号：分隔，并且每一组key:value的最后，以逗号，表示这一组的结束。

我们也可以使用以下方式定义个dict。

方式二：

d = dict()
print(d) # ==>{}

不过这种定义方式，默认得到的是一个空dict，需要调用函数往里面添加数据，我们后面会继续学习。

Python读取dict元素

首先创建一个dict，保存名字和成绩的对应关系。

# dict语法定义：
d = {
    '张三':45,
    '李四':69,
    '王五':75
}

dict提供通过key找到对应的value的功能，通过d[key]的形式，就可以得到对应的value。

# dict语法定义：
d = {
    '张三':45,
    '李四':69,
    '王五':75
}

print(d['张三']) # ==>45
print(d['王五']) # ==>75

这和list通过下标找到对应位置的元素是类似的。

回顾一下前面使用下标的方式访问list元素的时候，当下标不存在时，就会引发错误，在dict中，也是一样的，当对应的key不存在时，也会引发错误。

d = {
    '张三':45,
    '李四':69,
    '王五':75
}

print(d['张三']) # ==>45
print(d['赵六']) # ==>抛出异常
# 抛出异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: '赵六'

它的意思是key不存在，因此我们在需要通过key找到value时，一定要先判断key存不存在，然后才使用上面的方式获取对应的value，以避免错误。

if '张三' in d:
    print(d['张三']) # ==> 45
if '赵六' in d： # 赵六不存在，所以不会走下面的逻辑
    print(d['赵六'])  

除了使用下标的方式还可以通过key来获取对应的value。这种方法不会引起错误，dict本身提供get方法，把key当作参数传递给get方法，就可以获取对应的value，当key不存在时，也不会报错，而是返回None。

print(d.get('张三')) # ==>45
print(d.get('赵六')) # ==>None

Python添加dict元素

dict和tuple不一样，dict是可变的，我们随时可以往dict中添加新的key-value。

# dict语法定义：
d = {
    '张三':45,
    '李四':69,
    '王五':75
}

需要往里面添加赵六的成绩时，可以使用赋值语句往里面添加元素：

d['赵六'] = 72
print(d)

实际上，value可以是任意类型的元素，可以是list、tuple等，假如赵六近两次成绩分别是72，73，则可以使用赋值语句往dict中添加list元素。

d['赵六'] = [72,73]
print(d)

此后，如果赵六的第三次成绩也出来了，是90，则可以先通过key把对应的value查询出来，然后再往类型是list的value中添加第三次的成绩。

d['赵六'].append(90)
print(d)

Python更新dict元素

通过赋值语句就可以更新元素。

赋值语句：

1. 当key不存在时，往dict中添加对应的key: value元素。
2. 当key存在时，会更新dict，用新的value替换原来的value。

注意：在使用赋值语句往dict中添加元素时，为了避免不必要的覆盖问题，我们需要先判断key是否存在，然后再做更新。

Python刪除dict元素

????????dict提供便捷的pop()方法，允许我们快速删除元素，pop()方法需要指定需要删除的元素的key，并返回对应的value。

????????需要注意的是，pop()方法的参数是dict中的key，当key不存在时，同样会引起错误。

Python dict的特点

查询速度快

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

有序与无序

????????在Python3.5之前，dict中的元素是无序的，也就是dict中元素的插入顺序和打印顺序未必一致，比如使用Python3.5之前的版本执行以下代码：

d = {
    '张三': 45,
    '李四': 69,
    '王五': 75,
    '赵六': 90
}
print(d) # ==>{'赵六': 90,'李四': 69,'张三': 45,'王五': 75}

可以看到，打印的顺序和定义的顺序并不一致。

但是在Python3.6、Python3.7版本中，却得到了有序的结果。

d = {
    '张三': 45,
    '李四': 69,
    '王五': 75,
    '赵六': 90
}
print(d) # ==>{ '张三': 45,'李四': 69,'王五': 75,'赵六': 90}

为什么在不同的版本中，会得到不一样的结果呢？这是因为底层的实现发生了改变，我们可以认为在Python3.6的版本以后，dict是有序的，但是一般而言，为了避免不必要的误解，一般在需要有序的dict时，我们会使用一种叫做Ordereddict的字典，来确保有序。

key不可变

????????对于基础数据类型，字符串、数字等，这些都是不可变的，可以作为dict的key，而对于复杂数据类型，经过前面的学习，我们知道tuple是不可变的，list是可变的，因此tuple可以作为dict的key，但是list不可以作为dict的key，否则将会报错。

key = (1, 2, 3) # 以tuple作为key
d[key] = True
key = [1, 2, 3]
d[key] = True
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

如上所示，如果将list作为dict的key，将会引起错误。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。

Python遍历dict

????????通过直接print(d)，我们打印出来的是完整的一个dict；有时候，我们需要把dict中m一定条件的元素打印出来，比如成绩超过60的，在这种情况下，我们需要则需要遍历dict（这种时候需要使用for循环），并通过条件判断把满足条件的打印出来。
遍历dict有两种方法， 第一种是遍历dict的所有key，并通过key获得对应的value。????????

d = {
    '张三': 45,
    '李四': 60,
    '王五': 75,
    '赵六': 86
}
for key in d: # 遍历d的key
    value = d[key]
    if value > 60:
        print(key, value)
# ==> 王五75
# ==> 赵六86

第二种方法是通过dict提供的items()方法，items()方法会返回dict中所有的元素，每个元素包含key和value。

for key, value in d.items():
    if value > 60:
        print(key, value)
# ==> 王五75
# ==> 赵六86

Python操作dict的其他方法

获取dict的所有key

????????dict提供keys()函数，可以返回dict中所有的key。

d = {
    '张三': 45,
    '李四': 60,
    '王五': 75,
    '赵六': 86
}
for key in d.keys():
    print(key)

# ==> 张三
# ==> 李四
# ==> 王五
# ==> 赵六

获取dict所有的value

????????dict提供values()函数，可以返回dict中所有的value。

d = {
    '张三': 45,
    '李四': 60,
    '王五': 75,
    '赵六': 86
}
for value in d.values():
    print(value)

# ==> 45
# ==> 60
# ==> 75
# ==> 86

清除所有元素

????????dict提供clear()函数，可以直接清除dict中所有的元素。

d = {
    '张三': 45,
    '李四': 60,
    '王五': 75,
    '赵六': 86
}
print(d) # ==> {'张三': 45,'李四': 60,'王五': 75,'赵六': 86}

d.clear()
print(d) # ==> {}

什么是Set

在前面，我们学习了dict，知道dict的key是不重复的，当我们往dict里添加一个相同key的value时，新的value将会覆盖旧的value。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。
set和list类似，拥有一系列元素，但是set和list不一样，set里面的元素是不允许重复的，而list里面可以包含相同的元素；set与list的另一个区别是，set里面的元素是没有顺序的。

创建set的方式是使用set()，并传入一个list，list的元素将会被转换成set的元素。

s = set([1, 4, 3, 2, 5])
print(s) # ==> set([1, 2, 3, 4, 5])

需要注意的是，上述打印的形式类似 list， 但它不是 list，仔细看还可以发现，打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。
另外，set不能包含重复的元素，我们传入重复的元素看看会发生什么。

s = set([1, 4, 3, 2, 5, 4, 2, 3, 1])
print(s) # ==> set([1, 2, 3, 4, 5])

可以看到，在传入set()的list中，包含了重复的元素，但是打印的时候，相同的元素只保留了一个，重复的元素都被去掉了，这是set的一个重要特点。

Python读取set元素

????????由于set里面的元素是没有顺序的，因此我们不能像list那样通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中，这个时候我们可以使用in来判断某个元素是否在set中。
????????比如，存储了班里同学名字的set。

names = ['张三','李四','王五','Xiaobai']
name_set = set(names)

'王五' in name_set # ==> True

'赵六' in name_set # ==> False

'xiaobai' in name_set # ==> False

这个时候是否输出了不符合预期的结果？'Xiaobai'是在name_set里面的，为什么输出了False呢？这是因为set元素是区分大小写的，必须大小写完全匹配，才能判断该元素在set里面。

Python添加set元素

我们通过set()传入list的方法创建了set，如果set在使用过程中需要往里面添加元素，这个时候应该怎么添加呢？
set提供了add()方法，我们可以使用add()方法，往set里面添加元素。

比如，班里面来了新的同学，名字叫Xiaobai。

names = ['zhangsan','lisi','wangwu']

name_set = set(names)
name_set.add('Xiaobai')
print(name_set) # ==> set(['Xiaobai','zhangsan','lisi','wangwu'])

可以看到，'Xiaobai'已经添加到name_set里面去了。对于set，如果添加一个已经存在的元素，不会报错，也不会改变什么。

names = ['zhangsan','lisi','wangwu']

name_set = set(names)
name_set.add('zhangsan')
print(name_set) # ==> set(['zhangsan','lisi','wangwu'])

有些时候需要批量往set里面添加元素，如果一个一个add是比较麻烦的，有没有批量往set里面添加元素的方法呢？
set提供了update()方法，可以一次性给set添加多个元素。

names = ['zhangsan','lisi','wangwu']
new_names = ['zhangsan1','lisi1','wangwu1']
name_set = set(names)
name_set.update(new_names)
print(name_set) # ==> set(['zhangsan','lisi','wangwu','zhangsan1','lisi1','wangwu1'])

Python删除set元素

和list、dict一样，有时候我们也需要考虑删除set的元素。
set提供了remove()方法允许我们删除set中的元素。

names = ['zhangsan','lisi','wangwu']

name_set = set(names)
name_set.remove('zhangsan')
print(name_set) # ==> set(['lisi','wangwu'])

需要注意的是，如果remove的元素不在set里面的话，那么将会引发错误。

names = ['zhangsan','lisi','wangwu']

name_set = set(names)
name_set.remove('zhangsan')
print(name_set) # ==> set(['lisi','wangwu'])
name_set.remove('zhangsan')
# 引起错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'zhangsan'

因此，使用remove()方法，我们需要格外小心，需要提前判断要remove()的元素是否在set里面，确保存在后，再进行remove。

Python操作set的其他方法

不会报错的删除方法discard()

除了使用remove()方法删除元素以外，还可以使用discard()方法删除元素，并且，和remove()不同的是，当元素不存在时，使用discard()并不会引发错误，所以使用discard()是更加高效的一个方法。

names = ['zhangsan','lisi','wangwu']

name_set = set(names)
name_set.remove('zhangsan')
print(name_set) # ==> set(['lisi','wangwu'])
name_set.remove('zhangsan')
print(name_set) # ==> set(['lisi','wangwu'])

清除所有元素的方法clear()

和dict一样，set也提供了clear()方法，可以快速清除set中的所有元素。

names = ['zhangsan','lisi','wangwu']

name_set = set(names)

print(name_set) # ==> set(['zhangsan','lisi','wangwu'])
name_set.clear()
print(name_set) # ==> set([])

集合的子集和超集

set提供方法判断两个set之间的关系，比如两个集合set，判断其中一个set是否为另外一个set的子集或者超集。

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
# 判断s1是否为s2的子集
s1.issubset(s2) # ==> True
# 判断s2是否为s1的超集
s2.issuperset(s1) # ==> True

判断集合是否重合

有时候需要判断两个集合是否有重合的地方，如果使用传统的方法，需要使用for循环一个一个的去判断，非常麻烦，set提供isdisjoint()方法，可以快速判断两个集合是否有重合，如果有重合，返回False，否则返回True。

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
s1.isdisjoint(s2) # ==> False，因为有重复元素1、2、3、4、5

作者：筱白爱学习！