5 字典、集合

一、字典

　　字典同样是一个序列，不过字典的元素是由 key（键，可理解为关键字或名称）与 values （值）组成。就好像我们查字典，一个拼音对应着与之关联的一个或多个汉字，拼音就 key，而对应的 汉字就是 values。其中每一个元素都是“key:values”的形式，并且每个元素间 以逗号分隔。

　　说明：这种能够通过名称引用值的数据类型称做映射（mapping），字典是 python 中唯 一内建的映射类型。映射的概念好像比较难懂，以我个人的理解，映射就是名称集合与值集合的对应关系。名称集合中每个名称都是唯一的（即 key 不可重复），并有唯一的值 （key 与 value 相对应）；值集合中，值可以是唯一的也可以是重复的，但每个值也只能 有唯一的名称。

 

定义：{key1:value1,key2:value2}

特性：

1. key-value结构

2. key必须可hash、且必须为不可变数据类型、必须唯一

3. 可存放任意多个值、可修改、可以不唯一

4. 无序

 

字典的创建可以直接按格式创建，也可以使用 dict()方法进行创建。

• dict(**kwarg)：参数**kwarg 为可变关键字参数。

• dict(mapping, **kwarg)：参数 mapping 为映射函数。

• dict(iterable, **kwarg)：参数 iterable 为可迭代对象。

d = {}  # 创建空字典
d = dict()  # 创建空字典 
d = {'name':['路飞','索隆','山治'],'age':'22','sex':'男'}  # 创建字典
d = dict(name='路飞',age =22)  # 通过可变参数创建字典
d = dict([('name','路飞'), ('age','22')])    # 通过可迭代对象（列表）创建字典

另外，还有一种字典的创建方式，通过 fromkeys(seq,value)方法进行创建，参数 seq 为包 含 key 的序列，参数 value 为 key 的默认值。

k = ['波多','新垣'] # key 的列表
d1 = dict.fromkeys(k) # 仍 key 的列表创建字典
d2 = dict.fromkeys(k,'哦哦') # 仍 key 的列表创建字典，并赋予默认值 
print(d1) # 显示输出结果为：{'波多': none, '新垣': none} 
print(d2) # 显示输出结果为：{'波多': '哦哦', '新垣': '哦哦'}

 

查询：

首先，查询字典中的元素。我们可以使用 items()方法，通过 items()方法可以获取到字典中所有元素的迭代器

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.items())  # 显示输出结果为：dict_items([('name', '路飞'), ('age', 22)])

然后，查询字典中元素的键。 我们可以使用 keys()方法，通过 keys()方法可以获取到字典中所有元素键的迭代器。 

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.keys())  # 显示输出结果为：dict_keys(['name', 'age'])

最后，查询字典中元素的值。查询元素值有多种方法：
第一种，通过键可以获取相对应的值：字典[键]

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d['name'])  # 显示输出结果为：路飞
print(d['age'])  # 显示输出结果为：22

第二种，通过 get(k,default)方法查询，参数 k 为查询的键，参数 default 为未查询到结果 时的默认值。 

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.get('name','海贼王'))  # 显示输出结果为：路飞
print(d.get('sex','人妖'))  # 显示输出结果为：人妖

第三种、通过 values()方法可以获取到字典中所有元素值的迭代器。 

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.values())  # 显示输出结果为：dict_values(['路飞', 22])

 

添加元素：

添加单个元素：
首先，可以通过“字典[键]=值”的方式进行添加，如果字典中不存在相同的键则自动添加， 否则修改已存在的键所对应的值。

d = {"name":"路飞","age":20}
d["sex"] = "男"   # 添新元素到字典
d["船员"] = "索隆", "山治"     # 添加值为元组的新元素到字典
print(d)    # 输出结果为:{'name': '路飞', 'age': 20, 'sex': '男', '船员': ('索隆', '山治')}

另外，还可以通过 setdefault(k,default)方法进行添加，参数 k 为指定的键，参数 default 为默认值。当字典中存在指定的键时，能够返回该键所对应的值；如果不存在指定的键时， 则会返回参数 default 中设置的值，同时，在字典中会添加新元素，新元素的键即为参数 k，值即为参数 default。 

d = {"name":"路飞","age":20}
print(d.setdefault('name', '索隆'))  # 字典中存在相应的键，则返回该键对应的值，显示输 出结果为：路飞
print(d.setdefault('sex', '男'))  # 字典中不存在相应的键，则返回 default 参数的值，显 示输出结果为：男
print(d)  # 当字典中不存在相应的键时，添加新元素，显示输出结果为：{'name': '路飞', 'age': 20, 'sex': '男'}

添加多个元素：通过 update(m,kwargs)方法进行添加，参数 m（mapping）为映射函数， kwargs 为可变参数。 

d = {"name":"路飞","age":20}
d.update(sex="男",money=15)   # 通过可变参数添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d = {"name":"路飞","age":20}
d.update((("sex","男"),("money",15)))  # 通过元组添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d = {"name":"路飞","age":20}
d.update([("sex","男"),("money",15)])  # 通过列表添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d = {"name":"路飞","age":20}
d.update({"sex":"男","money":15})  # 通过列表添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d1 = {"name":"路飞","age":20}
d2 = {"sex":"男","money":15}
d1.update(d2)   # 合并字典元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

 

修改元素：

修改某个键对应的元素：字典[键]=新值

d = {"name":"路飞","age":20}
d["name"] = "索隆"
print(d)    #{'name': '索隆', 'age': 20}

 

删除元素：

使用 del 指令可以通过键删除某个元素：del 字典[键] 

d = {"name":"路飞","age":20}
del d["age"]
print(d)    #{'name': '路飞'}

 

可以使用clear()删除字典中的所有项或元素

d = {"name":"路飞","age":20}
d.clear()
print(d)    # {}

 

取出元素与元素值 ：

使用 popitem()方法在字典中取出元素。 

d = {"name":"路飞","age":20}
print(d.popitem())  #('age', 20)
print(d)    #{'name': '路飞'}

以使用 pop(k,default)方法在字典中取出指定元素的值，参数 k 为指定元素 的键，参数 default 为未取到结果时的默认值。 

d = {"name":"路飞","age":20}
print(d.pop("age"))  #20
print(d.pop("sex","男"))  #男
print(d)    #{'name': '路飞'}

 

设置默认值：

d = {"name":"路飞","age":20}
print(d.setdefault('name', '索隆'))  # 字典中存在相应的键，则返回该键对应的值，显示输 出结果为：路飞
print(d.setdefault('sex', '男'))  # 字典中不存在相应的键，则返回 default 参数的值，显 示输出结果为：男
print(d)  # 当字典中不存在相应的键时，添加新元素，显示输出结果为：{'name': '路飞', 'age': 20, 'sex': '男'}

 

其他：

字典也支持使用以下方法：
clear()：清空字典
copy()：复制字典：
len()：获取字典元素数量
max()：获取字典中最大的键
min()：获取字典中最小的键
同时，字典也支持通过 in 和 not in 进行成员关系的判断

 

二、集合

集合通过 set(iterable)方法创建，参数 iterable 为可迭代对象。 

s1 = set("好好学习天天向上") # 将字符串分解为单个字符，作为集合的元素创建集吅
s2 = set(('好好', '学习', '天天', '想上'))  # 将元组分解为单个元素，作为集吅元素创建集合
s3 = set(['好好', '学习', '天天', '想上'])  # 将列表分解为单个元素，作为集吅元素创建集合
print(s1)   #{'好', '上', '学', '天', '习', '向'}
print(s2)   #{'想上', '好好', '天天', '学习'}
print(s3)   #{'想上', '好好', '天天', '学习'}

 

特性：

1. 集合可以通过可迭代对象（字符串、元组、列表等）进行创建；

2. 集合中的元素不可重复； 

3. 集合中的元素无序排列。 

 

添加：

集合添加元素的方法有两种。
添加单个元素：使用 add(element)函数，参数 element 为集合允许添加的元素（例如数字、 字符串、元组等）。
添加多个元素：使用 update(iterable)函数，参数 iterable 为可迭代对象。

s1 = {1,2,3}
s2 = {'123'}
s3 = {'abc'}

s1.add(4)
s2.update(['4','5','6'])    # 添加列表到集合，列表元素会被分解为单个元素后添加到集合
s3.update('de')  # 添加字符串到集合，字符串会被分解为单个元素后添加到集合

print(s1)   #{1, 2, 3, 4}
print(s2)   #{'5', '4', '123', '6'}
print(s3)   #{'abc', 'e', 'd'}

 

删除：

集合删除元素的方法有两种。
第一种：使用 remove(element)方法删除指定元素，参数 element 为需要删除的元素。
第二种：使用 discard(element)方法删除指定元素，参数 element 为需要删除的元素。

当集合中不存在这两个方法参数中填入的元素时，remove()方法会抛出异常，而 discard() 方法则没有仸何影响。

s1 = {1,2,3}
s2 = {'123'}
s3 = {'abc'}

s1.remove(1)
s1.discard(4)
print(s1)   #{2, 3}
s1.remove(4)
print(s1)   # traceback (most recent call last):
  　　　　　　　  file "e:/python/test/test1.py", line 367, in <module>
    　　　　　    s1.remove(4)
　　　　　　　  keyerror: 4

 

取出元素：

使用pop()，由于集合是无序的，pop返回的结果不能确定，切当集合为空时调用pop会抛出异常。

s1 = {1,2,3}
print(s1)   #{1, 2, 3}
print(s1.pop()) # 1
print(s1)   #{2, 3}

 

清空：

s1 = {1,2,3}
s1.clear()
print(s1)   # set()

 

交集/并集/补集/差集:

首先我们来看张图，理解交集、并集、补集、差集的概念。

假设有集吅 a{1,2,3}和 b{3,4,5}。
交集：a 和 b 中相同部分的内容，{3}。
并集：a 和 b 去重后的全部内容，{1,2,3,4,5}。
补集：a 去除与 b 相交部分后的内容，{1,2}。
差集：a 和 b 不相交部分的全部内容，{1,2,4,5}。

 

创建集合

s1 = set('python')
s2 = set('pycharm')

交集操作：获取两个集合*有的元素

print(s1 & s2)    #{'y', 'p', 'h'}
print(s1.intersection(s2))  #{'y', 'p', 'h'}

并集操作：获取两个集合去除重复元素后的全部元素

print(s1 | s2)    #{'p', 'a', 'o', 't', 'c', 'm', 'n', 'r', 'h', 'y'}
print(s1.union(s2))  #{'p', 'a', 'o', 't', 'c', 'm', 'n', 'r', 'h', 'y'}

 补集操作：获取当前集合去除与另一集合交集元素后的全部元素

print(s1 - s2)    #{'o', 't', 'n'}
print(s1.difference(s2))  #{'o', 't', 'n'}
print(s2 - s1)    #{'a', 'c', 'm', 'r'}
print(s2.difference(s1))  #{'a', 'c', 'm', 'r'}

差集操作：获取两个集合去除交集元素后的全部元素

print(s1 ^ s2)    #{'c', 'n', 'a', 't', 'r', 'm', 'o'}
print(s1.symmetric_difference(s2))  #{'c', 'n', 'a', 't', 'r', 'm', 'o'}

 

difference_update(set)函数，能够将当前集合和指定集合进行补集运算，并将当前集合内容更新为运算结果

s1 = set('1234')
s2 = set('456')
s1.difference(s2)    # 该操作对 s1 内容无影响
print(s1)    # s1 无变化，显示输出结果为：{'3', '4', '2', '1'}
s1.difference_update(s2)    # 更新集合 s1 的内容为 s1-s2 后的结果
print(s1)   #{'3', '1', '2'}

intersection_update(set) 函数，能够将当前集合和指定集合进行交集运算，并将当前集合内容更新为运算结果

s1 = set('1234')
s2 = set('456')
s1.intersection(s2)    # 该操作对 s1 内容无影响
print(s1)    # s1 无变化，显示输出结果为：{'2', '1', '4', '3'}
s1.intersection_update(s2)    # 更新集合 s1 的内容为 s1 & s2 后的结果
print(s1)   #{'4'}

 

symmetric_difference_update(set) 函数，能够将当前集合和指定集合进行差集运算，并将当前集合内容更新为运算结果

s1 = set('1234')
s2 = set('456')
s1.symmetric_difference(s2)    # 该操作对 s1 内容无影响
print(s1)    # s1 无变化，显示输出结果为：{'2', '1', '4', '3'}
s1.symmetric_difference_update(s2)    # 更新集合 s1 的内容为 s1 ^ s2 后的结果
print(s1)   #{'2', '5', '3', '1', '6'}

 

另外，我们还可以使用“not in”，判断操作符前方的值是否未被后方的序列包含（非成员关系）。
在集合中，我们同样可以使用这两个操作符。
另外，我们还可以通过以下方法，判断一个集合是否另外一个集合的子集或超集以及没有 交集。
isdisjoint(set)：可以判断集合是否与指定集合不存在交集，参数 set 为集合；如果成立返回结果为 true，否则为 false。
issubset(set)：可以判断集合是否指定集合的子集，参数 set 为集合；如果成立返回结果为 true，否则为 false。
issuperset(set)：可以判断集合是否指定集合的超集，参数 set 为集合；如果成立返回结果为 true，否则为 false。

s1 = set('好好学习')
s2 = set('天天想上')
s3 = set('好好学习天天想上')
print('好' in s1)    # true
print('好' not in s2)    # true
print(s1.isdisjoint(s2))    # true
print(s1.issubset(s3))  # true
print(s3.issuperset(s1))    #true

 

复制集合

a = set('红酥手黄藤酒')   # 创建集合存入变量 a
b = a    # 创建变量 b 引用变量 a 的集合
c = a.copy()    # 创建变量 c 复制变量 a 的值
print(a)    #{'手', '酒', '红', '黄', '酥', '藤'}
print(b)    #{'手', '酒', '红', '黄', '酥', '藤'}
print(c)    #{'手', '藤', '酥', '酒', '红', '黄'}
a.remove('红')    # 删除变量 a 中集合的一个元素
print(a)    #变量 a 发生改变,{'手', '黄', '酒', '酥', '藤'}
print(b)    # 变量 b 因为引用变量 a，同样发生改变,{'酥', '藤', '手', '黄', '酒'}
print(c)    #变量 c 没有改变,{'酥', '藤', '酒', '手', '黄', '红'}

代码中，b = a 实际上是将 b 指向了 a 的内容，所以当 a 的内容发生变化时，b 同步发生了变化。
而 c = a.copy()则是将 a 的内容真正进行了复制，不再受 a 的变化影响。

 

其他

集合也支持 len()方法进行元素数量的获取，也支持 max()方法和 min 方法获取集合中的最大元素与最小元素