Python-集合类型

 

集合类型

 

set 称做由不同的元素组成的集合,集合(set)的成员通常被称做集合元素(set

elements)Python 把这个概念引入到它的集合类型对象里。集合对象是一组无序排列的可哈希的值

 

 

但是因为集合本身是无序的,你不可以为集合创建

索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值。

 

集合(sets)有两种不同的类型,可变集合(set)不可变集合(frozenset)

 

对可

变集合(set),你可以添加和删除元素,对不可变集合(frozenset)则不允许这样做。请注意,可变

集合(set)不是可哈希的,因此既不能用做字典的键也不能做其他集合中的元素。不可变集合

(frozenset)则正好相反,即,他们有哈希值,能被用做字典的键或是作为集合中的一个成员。

 

创建集合类型和给集合赋值:

用集合的工厂方法 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'>

>>> type(t)

<type'frozenset'>

>>> len(t)

6

 

访问集合中的值

>>> 'b' in t

True

>>> 'rsc' in t

False

>>> for i int:

...     print i,

...

b h k o p s

 

 

更新集合:

>>> s

set(['c', 'e', 'h','o', 'p', 's'])

>>>s.add('rsc')

>>> s

set(['c', 'e', 'h','o', 'rsc', 'p', 's'])

 

>>>s.update('pypi')

>>> s

set(['c', 'e', 'i','h', 'o', 'rsc', 'p', 's', 'y'])

>>>s.remove('rsc')

>>> s

set(['c', 'e', 'i','h', 'o', 'p', 's', 'y'])

 

 

 

删除集合中的成员和集合

>>> s

set(['c', 'e', 'i','h', 'o', 'p', 's', 'y'])

>>> del s

 

集合类型操作符:

成员关系 (in, not in)

>>>s=set('rscpass')

>>> s

set(['a', 'p', 's','r', 'c'])

>>> 'a' in s

True

>>> 'ba' ins

False

 

集合等价/不等价

集合等价/不等价与集合的类型或集合成员的顺序无关,

只与集合的元素有关。

 

>>> t

frozenset(['b', 'h','k', 'o', 'p', 's'])

>>> s

set(['a', 'p', 's','r', 'c'])

>>> s == t

False

>>> s != t

True

 

 

子集/超集

 “小于符号( <, <= )

用来判断子集,大于符号( >, >= )用来判断超集。

 

只有当第一个集合是第二个集合的严格子集时,我们才称第一个集合小于第二个集合,

同理,只有当第一个集合是第二个集合的严格超集时,我们才称第一个集合大于第二个集合。

 

>>>set('shop') < set('cheeseshop')

True

>>>set('bookshop') >=set('shop')

True

 

 

联合( | )

联合(union)操作和集合的 OR(又称可兼析取(inclusivedisjunction))其实是等价的

联合符号有一个等价的方法,union().

 

>>> s

set(['a', 'p', 's','r', 'c'])

>>> t

frozenset(['b', 'h','k', 'o', 'p', 's'])

>>> s | t

set(['a', 'c', 'b','h', 'k', 'o', 'p', 's', 'r'])

 

 

交集( & )

intersection()

>>> s

set(['a', 'p', 's','r', 'c'])

>>> t

frozenset(['b', 'h','k', 'o', 'p', 's'])

>>> s &t

set(['p', 's'])

 

差补/相对补集( �C )

两个集合(s t)的差补或相对补集是指一个集合 C,该集合中的元素,只属于集合 s,而不属

于集合 t。差符号有一个等价的方法,difference().

>>> s

set(['a', 'p', 's','r', 'c'])

>>> t

frozenset(['b', 'h','k', 'o', 'p', 's'])

>>> s - t

set(['a', 'c', 'r'])

 

对称差分( ^ )

和其他的布尔集合操作相似,对称差分是集合的 XOR(又称异或

 C,该集合中的元素,只能是属于集合 s 或者集合 t

的成员,不能同时属于两个集合

>>> s

set(['a', 'p', 's','r', 'c'])

>>> t

frozenset(['b', 'h','k', 'o', 'p', 's'])

>>> s ^ t

set(['a', 'c', 'b','h', 'k', 'o', 'r'])

 

 

混合集合类型操作

 

如果左右两个操作数的类型相同,既都是可变集合或不可变集合, 则所产生的结果类型是相同

的,但如果左右两个操作数的类型不相同(左操作数是 set,右操作数是 frozenset,或相反情况)

则所产生的结果类型与左操作数的类型相同,上例中可以证明这一点。还要注意,加号不是集合类

型的运算符:

>>> t

frozenset(['b', 'h','k', 'o', 'p', 's'])

>>> s

set(['a', 'p', 's','r', 'c'])

>>> t | s

frozenset(['a', 'c','b', 'h', 'k', 'o', 'p', 's', 'r'])

>>> t &s

frozenset(['p', 's'])

 

 

 

(Union) Update ( |= )

这个更新方法从已存在的集合中添加(可能多个)成员,此方法和 update()等价

 

>>> s

set(['a', 'p', 's','r', 'c'])

>>>u=frozenset(s)

>>> u

frozenset(['a', 'p','s', 'r', 'c'])

>>> s|=set('pypi')

>>> s

set(['a', 'c', 'i','p', 's', 'r', 'y'])

 

 

 

保留/交集更新( &= )

 

>>> s

set(['a', 'p', 's','r', 'c'])

>>> s &= set('shop')

  File "<stdin>", line 1

    s & = set('shop')

        ^

SyntaxError: invalidsyntax

>>> s &=set('shop')

>>> s

set(['p', 's'])

 

 

 

差更新 ( �C= )

对集合 s t 进行差更新操作 s-=t,差更新操作会返回一个集合,该集合中的成员是集合s

除掉集合 t 中元素后剩余的元素。此方法和 difference_update()等价.

 

 

len()

把集合作为参数传递给内建函数 len(),返回集合的基数(或元素的个数)

 

>>> len(s)

7

>>> s

set(['a', 'c', 'b','h', 'k', 'o', 'r'])

                                             

 

set() and frozenset()

set() frozenset()工厂函数分别用来生成可变和不可变的集合。

 

 

 

集合类型方法

方法名称操作

s.issubset(t)  如果st的子集,则返回 True,否则返回 False

s.issuperset(t) 如果ts的超集,则返回 True,否则返回 False

s.union(t)  返回一个新集合,该集合是st的并集

s.intersection(t)  返回一个新集合,该集合是st的交集

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

s.symmetric_difference(t)返回一个新集合,该集合是 s t 的成员,但不是st共有的

成员

s.copy() 返回一个新集合,它是集合 s 的浅复制

 

可变集合类型的方法

方法名    操作

s.update(t)  t 中的元素修改 s, 即,s 现在包含st的成员

s.intersection_update(t)  s 中的成员是共同属于st的元素。

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

s.symmetric_difference_update(t)s 中的成员更新为那些包含在st中,但不 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 中的所有元素

7.6 集合类型操作符、函数和方法

函数/方法名等价运算符说明

所有集合类型

len(s)  集合基数: 集合 s 中元素的个数

set([obj])  可变集合工厂函数; obj 必须是支持迭代的,由 obj

的元素创建集合,否则创建一个空集合

frozenset([obj])  不可变集合工厂函数; 执行方式和 set()方法相同,

但它返回的是不可变集合

obj in s 成员测试:obj s 中的一个元素吗?

obj not in s  非成员测试:obj 不是 s 中的一个元素吗?

s == t  等价测试: 测试st是否具有相同的元素?

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.intersec- tion(t) s& t 交集操作:s t 中的元素

s.difference(t) s -t  差分操作: s 中的元素,而不是 t 中的元素

s.symmetric_difference(t)s^ t  对称差分操作:s t 中的元素,但不是st共有

的元素

s.copy() 复制操作:返回 s (浅复制)副本

函数/方法名字操作符等价描述

仅用于可变集合

s.update(t)  s |= t (Union) 修改操作: t 中的成员添加 s

s.intersection_update(t)s &= t  <span style="font-fa

YWSOS.COM 平台代运维解决方案
 评论
 发表评论
姓   名:

Powered by AKCMS