首页 > 代码库 > wk_03

wk_03

集合

集合对象是一组无序排列的可哈希的值,集合成员可以做字典中的键。注意,由于集合本身是无序,你不可以为集合创建索引或执行切片操作,也没有键可用来获取集合中元素的值。
通常对于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}

增加、修改

wk_03