标签:add on() ror 去除 ash size 删除 包含 超出
集合对象是一组无序排列的可哈希的值,集合成员可以做字典的键。集合有两种类型:可变集合,可以添加和删除元素,可变集合不是可哈希的,不能用作字典的键也不能作为其它集合中的元素;不可变集合相反,有哈希值,可用作字典的键或作为集合中的一个成员。
集合创建的唯一方法-用集合的工厂方法set()和frozenset()
>>> s = set(‘cheeseshop‘)
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> t = frozenset(‘bookshop‘)
>>> t
frozenset([‘b‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> type(s)
<type ‘set‘>
>>> len(s)
6
>>> len(t) == len(s)
True
>>> s == t
False
可以遍历查看集合成员或检查某项元素是否是一个集合中的成员。
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> ‘k‘ in s
False
>>> for i in s:
... print i,
...
c e h o p s
用各种集合内建的方法和操作符添加和删除集合的成员。
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> s.add(‘z‘)
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘, ‘z‘])
>>> s.update(‘pypi‘)
>>> s
set([‘c‘, ‘e‘, ‘i‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘, ‘y‘, ‘z‘])
>>> s.remove(‘z‘)
>>> s
set([‘c‘, ‘e‘, ‘i‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘, ‘y‘])
>>> s -= set(‘pypi‘)
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘s‘])
令集合超出它的作用范围,或调用del将他们直接清除出当前的名称空间。
>>> del s
成员关系(in,not in):某个元素是否是一个集合中的成员;
集合等价/不等价:两个集合相等是指对每个集合而言,当且仅当其中一个集合中的每个成员同时也是另一个集合中的成员,也可以说每个集合必须是另一个集合的子集,即s<=t和t<=s的值均为真(True),集合等价/不等价与集合的类型或集合成员的顺序无关,只与集合的元素有关。
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> t
frozenset([‘b‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> s == t
False
>>> set(‘posh‘) == set(‘shop‘)
True
子集/超集:Set用python的比较操作符检查某集合是否是其他集合的超集或子集。"小于"符号(<,<=)用来判断子集,"大于"符号(>,>=)用来判断超集。
>>> set(‘shop‘) < set(‘cheeseshop‘)
True
>>> set(‘bookshop‘) >= set(‘shop‘)
True
联合(|):联合(union)操作和集合的OR等价,两个集合的联合是一个新集合,该集合中的每个元素都至少是其中一个集合的成员。联合有一个等价的方法,union()
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> t
frozenset([‘b‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> s | t
set([‘c‘, ‘b‘, ‘e‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>>
交集(&):交集操作比作集合的AND(或合取)操作,两个集合的交集是一个新集合,该集合中的每个元素同时是两个集合中的成员,即属于两个集合的成员。交集符号有一个等价的方法,intersection()。
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> t
frozenset([‘b‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> s & t
set([‘h‘, ‘s‘, ‘o‘, ‘p‘])
差补/相对补集(-):两个集合(s和t)的差补或相对补集是指一个集合C,该集合中的元素,只属于集合s,而不属于集合t。差符号有一个等价的方法,difference()
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> t
frozenset([‘b‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> s - t
set([‘c‘, ‘e‘])
对称差分(^):对称差分是集合的XOR(又称"异或"),两个集合(s和t)的对称差分是指另一个集合C,该集合中的元素,只能是属于集合s或集合t的成员,不能同时属于两个集合,对称差分有一个等价的方法,symmetric_difference()
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> t
frozenset([‘b‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> s ^ t
set([‘b‘, ‘e‘, ‘k‘, ‘c‘])
混合集合类型操作:如果两个操作数的类型相同,即都是可变集合或不可变集合,则所产生的结果类型是相同的,如果左右两个操作数的类型不相同(左操作数是set,右操作数是frozenset,或相反情况),则所产生的结果类型与左操作数的类型相同。
>>> s
set([‘c‘, ‘e‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘])
>>> t
frozenset([‘b‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> s | t
set([‘c‘, ‘b‘, ‘e‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
>>> t | s
frozenset([‘c‘, ‘b‘, ‘e‘, ‘h‘, ‘k‘, ‘o‘, ‘p‘, ‘s‘])
(union)Update(|=):从已存在的集合中添加(可能多个)成员,和update等价
>>> s = set(‘cheeseshop‘)
>>> u = frozenset(s)
>>> s |= set(‘pypi‘)
>>> s
set([‘c‘, ‘e‘, ‘i‘, ‘h‘, ‘o‘, ‘p‘, ‘s‘, ‘y‘])
Retention/Intersection Update(&=):保留(或交集更新)操作保留与其他集合的共有成员。此方法和intersection_update()等价。
>>> s
set([‘p‘, ‘c‘, ‘e‘, ‘h‘, ‘s‘, ‘o‘])
>>> s &= set(‘shop‘)
>>> s
set([‘h‘, ‘s‘, ‘o‘, ‘p‘])
>>>
Difference Update(-=):对集合s和t进行差更新操作s -= t,差更新操作会返回一个集合,该集合中的成员是集合s去除掉集合t中元素后剩余的元素。此方法和difference_update()等价。
>>> s
set([‘p‘, ‘c‘, ‘e‘, ‘h‘, ‘s‘, ‘o‘])
>>> s -= set(‘shop‘)
>>> s
set([‘c‘, ‘e‘])
Symmetric Difference Update(^=):对集合s和t进行对称差分更新操作(s^=t)会返回一个集合,该集合中的成员仅是原集合s或另一个集合t中的成员。此方法和symmetric_difference_update()等价。
>>> s
set([‘p‘, ‘c‘, ‘e‘, ‘h‘, ‘s‘, ‘o‘])
>>> t = frozenset(‘bookshop‘)
>>> s ^= t
>>> s
set([‘c‘, ‘b‘, ‘e‘, ‘k‘])
len():返回集合的基数(或元素的个数)
set()和frozenset():set()生成可变集合,frozenset()生成不可变集合,不提供参数,生成空集合;参数必须是可迭代的,即一个序列或迭代器,或支持迭代的对象,例如一个文件或字典。
方法名称 |
操作 |
s.issubset(t) |
如果s是t的子集,则返回True,否则返回False |
s.issuperset(t) |
如果t是s的超集,则返回True,否则返回False |
s.union(t) |
返回一个新集合,该集合是s和t的并集 |
s.intersection(t) |
返回一个新集合,该集合是s和t的交集 |
s.difference(t) |
返回一个新集合,该集合是s的成员,但不是t的成员 |
s.symmetric_difference |
返回一个新集合,该集合是s或t的成员,但不是s和t共有的成员 |
s.copy() |
返回一个新集合,该集合是s的浅复制 |
方法名称 |
操作 |
s.update(t) |
用t中的元素修改s,即s现在包含 |
s.intersection_update() |
s中的成员是共同属于s和t的元素 |
s.symmetric_difference_update(t) |
s中的成员更新为那些包含在s或t中,但不是s和t共有的元素 |
s.add(obj) |
在集合s中添加对象obj |
s.remove(obj) |
从集合s中删除对象obj,如果obj不是集合s中的元素(obj not in s),将引发KeyError错误。 |
s.discard(obj) |
如果obj是集合s中的元素,从集合s中删除对象obj |
s.pop() |
删除集合s中的任意一个对象,并返回它 |
s.clear() |
删除集合s中的所有元素 |
附录:集合类型总结表
函数/方法名 |
等价操作符 |
说明 |
所有集合类型 |
||
len(s) |
集合基数:集合s中元素的个数 |
|
set([obj]) |
可变集合工厂函数:obj必须是支持迭代的,由obj中的元素创建集合,否则创建一个空集合 |
|
frozenset([obj]) |
不可变集合工厂函数:执行方式和set()相同,但它返回的是不可变集合 |
|
obj in s |
成员测试:obj是s中的一个元素吗? |
|
obj not in s |
非成员测试:obj不是s中的一个元素吗? |
|
s == t |
等价测试,测试s和t是否具有相同的元素? |
|
s != t |
不等价测试,与==相反 |
|
s < t |
(严格意义上)子集测试:s!=t且s中所有的元素都是t的成员 |
|
s.issubset(t) |
s <= t |
子集测试(允许不严格意义上的子集):s中所有的元素都是t的成员 |
s > t |
(严格意义上)超集测试:s!=t且t中所有的元素都是s的成员 |
|
s.issuperset(t) |
s >= t |
超集测试(允许不严格意义上的超集):t中所有的元素都是s的成员 |
s.union(t) |
s | t |
合并集合:s或t中的元素 |
s.intersection(t) |
s & t |
交集操作:s和t中的元素 |
s.difference(t) |
s – t |
差分操作:s中的元素,而不是t中的元素 |
s.symmetric_difference |
s ^ t |
对称差分操作:s或t中的元素,但不是s和t共有的元素 |
s.copy() |
复制操作:返回s的浅复制副本 |
|
仅用于可变集合 |
||
s.update(t) |
s |= t |
(Union)修改操作:将t中的成员添加到s |
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中的成员 |
s.add(obj) |
加操作:将obj添加到s |
|
s.remove(obj) |
删除操作:将obj从s中删除,如果s中不存在obj,将引发KeyError |
|
s.discard(obj) |
丢弃操作:remove()的友好版本,如果s中存在obj,从s中删除它 |
|
s.pop() |
pop操作:移除并返回s中的任意一个元素 |
|
s.clear() |
消除操作:移除s中的所有元素 |
标签:add on() ror 去除 ash size 删除 包含 超出
原文地址:https://www.cnblogs.com/mrlayfolk/p/11980278.html