本文详细介绍python中另外两种容器字典（dict）和集合（set）的基本用法。
首发于本人公众号：pythonic生物人
更好的阅读体验请戳：
目录
1、字典
字典创建
字典使用
返回字典中元素个数
判断字典是否存在某个键
取出键对应的值
修改键对应的值
删除字典的某个键值对
返回某个键对应的值，不存在设置默认值替代
删除键对应的值
取出字典中所有键值对
取出字典中所有键
返回字典所有键组成的列表
取出字典中所有值
取出字典中的值并将删除
删除字典中所有的键值对
字典浅复制
2、集合（set）
集合创建
集合使用
两个集合求并集：使用符号&或者union函数
两个集合求差集：使用符号-或者difference函数
求两个集合中不同时存在的元素：使用符号^或者symmetric_difference函数
求集合元素个数：len(set)
成员资格
判断a集合和b集合是否有共同元素（相交）：使用isdisjoint
判断a集合是否属于或等于b集合：使用<=符号，<符号和issubset函数
判断b集合是否包含a集合：使用>=符号，>符号和issuperset函数
元素x添加到a集合中：a.add(x)
移除集合a中元素x：a.remove(x)
移除集合a中元素x：a.discard(x)
任意移除集合a中的一个元素:a.pop()
清空集合a元素：a.clear()
1、字典
字典（dict）是python中的映射容器。
- 字典中存储键（key）值（value）对，通过键调用值，键具有唯一性，值可以不唯一；
- 每个键值对之间使用逗号分隔，键与值之间使用顿号分割；
- 列表、集合、字典因为可修改所以不能作为字典的键；
- 字符串、数值、元组不可修改可以作为字典的键。
- https://docs.python.org/zh-cn/3.7/library/stdtypes.html#mapping-types-dict（官网参考资料）
字典创建
#{}直接创建
In [1]: {"jack":"man", "Rose":"womman"}
Out[1]: {'jack': 'man', 'Rose': 'womman'}
#dict函数创建
In [3]: pre_dict =[("Jack","man"), ("Rose", "woman")]
In [5]: dict(pre_dict)
Out[5]: {'Jack': 'man', 'Rose': 'woman'}
#借助zip创建（zip 将可迭代对象组合成元组列表）
In [7]: dict(zip(["Jack","Rose"], ["man","woman"]))
Out[7]: {'Jack': 'man', 'Rose': 'woman'}
In [22]: {('Jack'):"man", "Rose":"womman"}#元组('Jack')可以作为键
Out[22]: {'Jack': 'man', 'Rose': 'womman'}
In [23]: {['Jack']:"man", "Rose":"womman"}#列表['Jack']可以作为键
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-23-f446b6afe3c5> in <module>
----> 1 {['Jack']:"man", "Rose":"womman"}
TypeError: unhashable type: 'list'
字典使用
主要介绍一下常见的字典方法。
In [2]: print(dir(dict))
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
-
返回字典中元素个数
len(d)，返回字典d中键值对（python中一个键值对称为一个项）的个数。
In [38]: len(a_dict)
Out[38]: 2
-
判断字典是否存在某个键
key in d，存在返回True，不存在返回False。
In [49]: "Jack1" in a_dict
Out[49]: False
In [50]: "Rose" in a_dict
Out[50]: True
-
取出键对应的值
d[key]，当key不存在d中时，报错。
In [41]: a_dict["Jack"]
Out[41]: 'man'
IIn [42]: a_dic["Lucy"]#字典中不存在Lucy，报错。
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-42-c32a1306fe69> in <module>
----> 1 a_dic["Lucy"]
NameError: name 'a_dic' is not defined
-
修改键对应的值
d[key] = value。
In [43]: a_dict
Out[43]: {'Jack': 'man', 'Rose': 'woman'}
In [44]: a_dict["Jack"] = "man1"
In [45]: a_dict
Out[45]: {'Jack': 'man1', 'Rose': 'woman'}
-
删除字典的某个键值对
d.pop(key,value)，如果key存在，删除字典d中key/value键值对；key不存在，返回指定的value；如果value没指定，报错。
In [98]: a_dict
Out[98]: {'Jack': 'man', 'Rose': 'woman'}
In [99]: a_dict.pop("Jack")
Out[99]: 'man'
In [100]: a_dict
Out[100]: {'Rose': 'woman'}
In [101]: a_dict.pop("Jack","Not exit!")
Out[101]: 'Not exit!'
In [102]: a_dict
Out[102]: {'Rose': 'woman'}
-
返回某个键对应的值，不存在设置默认值替代
d.get(key,value)，当d中存在key时，返回key对应的value；当d中不存在key时，返回指定的value，不指定value返回None。
In [56]: a_dict
Out[56]: {'Rose': 'woman'}
In [58]: a_dict.get("Rose","haha")#Rose存在，返回对应值。
Out[58]: 'woman'
In [59]: a_dict.get("Lucy","haha")#Lucy不存在，返回指定value “haha”。
Out[59]: 'haha'
In [60]: print(a_dict.get("Lucy"))#Lucy不存在，返回None。
Out[60]: None
-
删除键对应的值
del d[key]，字典不存在key，报错退出。
In [43]: a_dict
Out[43]: {'Jack': 'man', 'Rose': 'woman'}
In [44]: a_dict["Jack"] = "man1"
In [45]: a_dict
Out[45]: {'Jack': 'man1', 'Rose': 'woman'}
In [46]: del a_dict["Jack"]
In [47]: a_dict
Out[47]: {'Rose': 'woman'}
In [48]: del a_dict["Jack1"]#不存在键Jack1，报错退出。
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-48-5948af1fa264> in <module>
----> 1 del a_dict["Jack1"]
KeyError: 'Jack1'
-
取出字典中所有键值对
d.items()
In [74]: a_dict
Out[74]: {'Rose': 'woman', 'Jack': 'man'}
In [75]: a_dict.items()#items返回字典键值对视图对象，支持迭代，通过list转化为列表。
Out[75]: dict_items([('Rose', 'woman'), ('Jack', 'man')])
In [76]: list(a_dict.items())
Out[76]: [('Rose', 'woman'), ('Jack', 'man')]
-
取出字典中所有键
d.keys()
In [77]: a_dict.keys()
Out[77]: dict_keys(['Rose', 'Jack'])
In [78]: list(a_dict.keys())
Out[78]: ['Rose', 'Jack']
-
返回字典所有键组成的列表
list(d)
In [30]: a_dict
Out[30]: {'Jack': 'man', 'Rose': 'woman'}
In [31]: list(a_dict)
Out[31]: ['Jack', 'Rose']
-
取出字典中所有值
d.values()
In [79]: a_dict.values()
Out[79]: dict_values(['woman', 'man'])
In [80]: list(a_dict.values())
Out[80]: ['woman', 'man']
-
取出字典中的值并将删除
d.pop(key)，返回key对应的键，同时删除该键值对。
In [81]: a_dict
Out[81]: {'Rose': 'woman', 'Jack': 'man'}
In [82]: a_dict.pop("Rose")
Out[82]: 'woman'
In [83]: a_dict
Out[83]: {'Jack': 'man'}
-
删除字典中所有的键值对
d.clear()，删除字典中所有的键值对，返回空字典{}。
In [85]: a_dict
Out[85]: {'Jack': 'man'}
In [86]: a_dict.clear()
In [87]: a_dict
Out[87]: {}
-
字典浅复制
d.copy()
In [89]: a_dict
Out[89]: {'Jack': 'man'}
In [91]: b_dict = a_dict.copy()
In [92]: b_dict
Out[92]: {'Jack': 'man'}
In [93]: b_dict["Jack"] = "man1"
In [94]: b_dict
Out[94]: {'Jack': 'man1'}
In [95]: a_dict
Out[95]: {'Jack': 'man'}
2、集合（set）
https://docs.python.org/zh-cn/3.7/library/stdtypes.html#set-types-set-frozenset（官网参考资料）。集合是非序列和映射python容器，集合中元素无序，可以理解为只有键的字典（集合中不可能有重复元素）；集合并不记录元素索引，所以集合不支持索引、切片或其他序列类的操作。python内置了两种集合类型，set类型可修改，forezenset类型不可变，常见的用途：
- 成员检测（in）；
- 序列容器去除重复项；
- 求交集、并集、差集与对称差集。
集合创建
In [116]: {'a', 'b', 'c', 'd', 'e'}#花括号{}包围创建
Out[116]: {'a', 'b', 'c', 'd', 'e'}
In [117]: set("abcde")#set函数创建
Out[117]: {'a', 'b', 'c', 'd', 'e'}
注意：空的{}表示字典，而不是集合。
集合使用
两个集合求交集：使用&号或者intersection函数。
In [128]: a_set
Out[128]: {'a', 'b', 'c', 'd'}
In [129]: b_set
Out[129]: {'a', 'b', 'c', 'd', 'e'}
In [130]: a_set & b_set #使用&号求交集
Out[130]: {'a', 'b', 'c', 'd'}
In [131]: a_set.intersection(b_set)#intersection函数求交集
Out[131]: {'a', 'b', 'c', 'd'}
-
两个集合求并集：使用符号&或者union函数
In [132]: a_set | b_set#使用符号|
Out[132]: {'a', 'b', 'c', 'd', 'e'}
In [138]: a_set.union(b_set)#使用union函数
Out[138]: {'a', 'b', 'c', 'd', 'e'}
-
两个集合求差集：使用符号-或者difference函数
In [142]: a_set - b_set#使用-符号。返回a_set中存在，而b_set中不存在的一个新集合
Out[142]: set()
In [143]: b_set - a_set#返回b_set中存在，而a_set中不存在的一个新集合
Out[143]: {'e'}
In [144]: a_set.difference(b_set)#使用difference函数。返回a_set中存在，而b_set中不存在的一个新集合
Out[144]: set()
In [145]: b_set.difference(a_set)
Out[145]: {'e'}
-
求两个集合中不同时存在的元素：使用符号^或者symmetric_difference函数
In [146]: a_set ^ b_set
Out[146]: {'e'}
In [147]: a_set.symmetric_difference(b_set)
Out[147]: {'e'}
-
求集合元素个数：len(set)
In [148]: len(a_set)
Out[148]: 4
-
成员资格
In [148]: len(a_set)
Out[148]: 4
In [149]: "a" in a_set
Out[149]: True
In [150]: "x" in a_set
Out[150]: False
-
判断a集合和b集合是否有共同元素（相交）：使用isdisjoint
有共同元素返回False，否则返回True。
In [151]: a_set.isdisjoint(b_set)
Out[151]: False
In [152]: b_set.isdisjoint(a_set)
Out[152]: False
In [153]: a_set.isdisjoint(["x"])
Out[153]: True
-
判断a集合是否属于或等于b集合：使用<=符号，<符号和issubset函数
In [155]: a_set.issubset(b_set)#使用函数issubset，a_set完全属于b_set
Out[155]: True
In [156]: a_set <= b_set#使用符号<=
Out[156]: True
-
判断b集合是否包含a集合：使用>=符号，>符号和issuperset函数
In [162]: b_set.issuperset(a_set)
Out[162]: True
In [163]: b_set >= a_set
Out[163]: True
-
元素x添加到a集合中：a.add(x)
如果x已经存在a中，没任何效果；否则加入。
In [171]: a_set
Out[171]: {'a', 'b', 'c', 'd'}
In [172]: a_set.add("a")#a已存在无任何效果
In [173]: a_set.add("x")#添加x
In [174]: a_set
Out[174]: {'a', 'b', 'c', 'd', 'x'}
-
移除集合a中元素x：a.remove(x)
如果 x 不存在于a中则报错。
In [175]: a_set
Out[175]: {'a', 'b', 'c', 'd', 'x'}
In [176]: a_set.remove("y")#y不存在集合a_set中
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-176-9b11cfe9e098> in <module>
----> 1 a_set.remove("y")
KeyError: 'y'
In [177]: a_set.remove("x")
In [178]: a_set
Out[178]: {'a', 'b', 'c', 'd'}
-
移除集合a中元素x：a.discard(x)
如果元素x 存在于集合a中则将其移除；不存在没任何效果，与remove有细微差别。
In [178]: a_set
Out[178]: {'a', 'b', 'c', 'd'}
In [179]: a_set.discard("x")#a_set不存在x元素，没任何效果，区别于remove函数
In [180]: a_set.discard("d")
In [181]: a_set
Out[181]: {'a', 'b', 'c'}
-
任意移除集合a中的一个元素:a.pop()
如果集合为空则会报错。
In [183]: a_set
Out[183]: {'a', 'b', 'c'}
In [184]: a_set.pop()
Out[184]: 'a'
In [185]: a_set.pop()
Out[185]: 'c'
In [186]: a_set.pop()
Out[186]: 'b'
In [187]: a_set.pop()
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-187-f734613b9ec5> in <module>
----> 1 a_set.pop()
KeyError: 'pop from an empty set'
In [188]: a_set#集合此时已经为空
Out[188]: set()
-
清空集合a元素：a.clear()
In [190]: a_set
Out[190]: {'a', 'b', 'c', 'd'}
In [191]: a_set.clear()
In [192]: a_set
Out[192]: set()
欢迎关注公众号，干活不迷路：
干货，真香
网友评论