wk_03

Posted 2020-08-05

集合

集合对象是一组无序排列的可哈希的值，集合成员可以做字典中的键。注意，由于集合本身是无序，你不可以为集合创建索引或执行切片操作，也没有键可用来获取集合中元素的值。
通常对于Python的内置数据结构，list set bytearray dict 是不可hash的，所以不能作为set的元素，通常来说，内置类型，不可变类型是可hash的，可变类型是不可hash的。
集合分为可变集合（set）和不可变集合（frozenset），对于可变集合你可以添加删除元素，对于不可变集合则不允许这么操作。

集合的定义和使用

集合的定义

注意不能使用{}来定义为集合，这是由于{}默认定义为字典。

In [1]: s = set()

In [2]: type(s)
Out[2]: set

In [3]: s = {}

In [4]: type(s)
Out[4]: dict

In [5]: s = {1,2,3,4}

In [6]: type(s)
Out[6]: set

访问集合中的值

In [16]: s = set(‘dota‘)

In [17]: s
Out[17]: {‘a‘, ‘d‘, ‘o‘, ‘t‘}

In [18]: ‘a‘ in s
Out[18]: True

In [19]: for i in s:
   ....:     print(i) 
t
d
a
o

更新集合的元素

• add

• update

In [7]: s = set(‘dota‘)

In [8]: s
Out[8]: {‘a‘, ‘d‘, ‘o‘, ‘t‘}

In [9]: t = frozenset(‘dota‘)

In [10]: t
Out[10]: frozenset({‘a‘, ‘d‘, ‘o‘, ‘t‘})

In [11]: type(s)
Out[11]: set

In [12]: type(t)
Out[12]: frozenset

In [13]: s.add(‘er‘)

In [14]: s
Out[14]: {‘a‘, ‘d‘, ‘er‘, ‘o‘, ‘t‘}

In [15]: t.
t.copy                  t.difference            t.intersection          t.isdisjoint            t.issubset              t.issuperset            t.symmetric_difference  t.union

In [23]: s.add(‘er‘)

In [24]: s
Out[24]: {‘a‘, ‘d‘, ‘er‘, ‘o‘, ‘t‘}

In [5]: s.add(‘a‘)

In [6]: s
Out[6]: {‘a‘, ‘d‘, ‘er‘, ‘o‘, ‘t‘}

In [7]: s.update((‘e‘,‘r‘))

In [8]: s
Out[8]: {‘a‘, ‘d‘, ‘e‘, ‘er‘, ‘o‘, ‘r‘, ‘t‘}

In [9]: s.update([‘i‘,‘b‘])

In [10]: s
Out[10]: {‘a‘, ‘b‘, ‘d‘, ‘e‘, ‘er‘, ‘i‘, ‘o‘, ‘r‘, ‘t‘}

In [11]: s.update({‘d‘,‘z‘})

In [12]: s
Out[12]: {‘a‘, ‘b‘, ‘d‘, ‘e‘, ‘er‘, ‘i‘, ‘o‘, ‘r‘, ‘t‘, ‘z‘}

通过上面的举例我们可以得出：

• frozenset是不可变集合不能更改集合内的元素。

• 可变集合中add方法只能添加一个元素，并且添加的元素是无序的。

• 可变集合中update是添加一组元素，这组元素可以是任意个。组可以是元组、列表、可变集合。

• 不管是add还是update添加元素一旦元素已经存在，集合不会发生任何改变。

通过集合元素的唯一性我们可以将一个列表内的元素进行去重，但是这种方法对于元素的顺序没有什么要求。

In [16]: lst = [2,3,4,5,2,3,4,7,5]

In [17]: list(set(lst))
Out[17]: [2, 3, 4, 5, 7]

删除集合的元素

• remove

• discard

• pop

• clear

In [18]: s
Out[18]: {‘a‘, ‘b‘, ‘d‘, ‘e‘, ‘er‘, ‘i‘, ‘o‘, ‘r‘, ‘t‘, ‘z‘}

In [19]: s.remove(‘a‘)

In [20]: s
Out[20]: {‘b‘, ‘d‘, ‘e‘, ‘er‘, ‘i‘, ‘o‘, ‘r‘, ‘t‘, ‘z‘}

In [22]: s.discard(‘g‘)

In [23]: s.discard(‘o‘)

In [24]: s
Out[24]: {‘b‘, ‘d‘, ‘e‘, ‘er‘, ‘i‘, ‘r‘, ‘t‘, ‘z‘}

In [25]: s.pop()
Out[25]: ‘b‘

In [26]: s
Out[26]: {‘d‘, ‘e‘, ‘er‘, ‘i‘, ‘r‘, ‘t‘, ‘z‘}

In [28]: s.clear()

In [29]: s
Out[29]: set()

• remove和discard都是删除指定元素。两者的区别是remove删除若是集合没有元素会报KeyError的错误，而discard则不会报错。

• pop是删除任意的元素

• clear是清除集合所有的元素

集合的集合运算

• s.union(t)：返回一个新集合，该集合是s和t的并集

• s.intersection(t)：返回一个新集合，该集合是s和t的交集

• s.difference(t)：返回一个新集合该集合是s的成员，但不是t的成员

• s.symmetric_difference(t)：返回一个新集合，该集合是s或t的成员，但不是s和t共有的成员

In [30]: s1 = {1,2,3,4,5}

In [31]: s2 = {2,4,5,6,7}

In [32]: s1.union(s2)
Out[32]: {1, 2, 3, 4, 5, 6, 7}

In [33]: s1.intersection(s2)
Out[33]: {2, 4, 5}

In [34]: s1.difference(s2)
Out[34]: {1, 3}

In [35]: s2.difference(s1)
Out[35]: {6, 7}

In [36]: s1.symmetric_difference(s2)
Out[36]: {1, 3, 6, 7}

• s.issuperset(t)：如果t是s的超集，则返回True，否则返回False

• s.issubset(t)：如果s是t的子集则返回True，否则返回False

• s.isdisjoint(t)：如果s与t不相交则返回True，否则返回False

In [45]: s
Out[45]: {2, 3}

In [46]: s1
Out[46]: {1, 2, 3, 4, 5}

In [48]: s.issubset(s1)
Out[48]: True

In [49]: s.issuperset(s1)
Out[49]: False

In [50]: s1.issuperset(s)
Out[50]: True

In [53]: s = set([8])

In [54]: s
Out[54]: {8}

In [55]: s.isdisjoint(s1)
Out[55]: True

• s.difference_update(t)：s中的成员是属于s但不包含在t中的元素

• s.intersection_update(t)：s中的成员是共同属于s和t的元素

• s.symmetric_difference_update(t)：s中的成员更新为那些包含在s或t中，但不是s和t共有的元素

In [58]: s1
Out[58]: {1, 2, 3, 4, 5}

In [59]: s2
Out[59]: {2, 4, 5, 6, 7}

In [60]: s1.intersection_update(s2)

In [61]: s2
Out[61]: {2, 4, 5, 6, 7}

In [62]: s1
Out[62]: {2, 4, 5}

In [63]: s1.difference_update(s2)

In [64]: s1
Out[64]: set()

In [65]: s2
Out[65]: {2, 4, 5, 6, 7}

In [66]: s1.symmetric_difference_update(s2)

In [67]: s1
Out[67]: {2, 4, 5, 6, 7}

In [68]: s2
Out[68]: {2, 4, 5, 6, 7}

集合的操作符

方法名	等价操作符	说明
s.issubset(t)	s <= t	子集测试：s中所有的元素都是t的成员
s.issubset(t)	s >= t	超集测试：t中所有的元素都是s的成员
s.union(t)	s	t
s.intersection(t)	s & t	交集操作：s和t中的元素
s.difference(t)	s - t	差分操作：s中的元素，而不是t中的元素
s.symmetric_difference(t)	s ^ t	对称差分操作：s或t中的元素，但不是s和t共有的元素
s.intersection_update(t)	s &= t	交集修改操作：s中包括s和t中共有的成员
s.difference_update(t)	s -= t	差分修改操作：s中包括仅属于s但不属于t的成员
s.symmetric_difference_update(t)	s ^= t	对称差分修改操作：s中包括仅属于s或仅属于t的成员

字典

字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。
注意，你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以把不可变或可变的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。
键值对在字典中以这样的方式标记：d = key1 : value1, key2 : value2 。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。
记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。
字典是 dict 类的实例/对象。
其实字典可以简单的用以下说明：

• 字典是一个key value结构

• 字典的value可以是任意值

• 字典的key必须是可hash的值

• 字典的key是唯一的

字典的定义

In [1]: d1 = dict()

In [2]: type(d1)
Out[2]: dict

In [3]: d2 = {}

In [4]: type(d2)
Out[4]: dict

In [5]: d3 = {‘a‘:1,‘b‘:2}

In [6]: type(d3)
Out[6]: dict

字典元素

In [8]: d
Out[8]: {‘a‘: 1, ‘b‘: 2}

In [9]: d[‘a‘]
Out[9]: 1

In [11]: d[‘a‘]=11

In [12]: d
Out[12]: {‘a‘: 11, ‘b‘: 2}

In [15]: d[‘c‘]=3

In [16]: d
Out[16]: {‘a‘: 11, ‘b‘: 2, ‘c‘: 3}

增加、修改