首页 > 代码库 > 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