python-数据类型之set集合

摘要：集合是中一种基本数据类型，它分为可变集合和不可变集合两种。小于和大于意味着两个集合在比较时不能相等。等于号允许非严格定义的子集和超集。函数的作用是判断集合是否是集合的子集，如果是返回，否则返回。

集合set是Python中一种基本数据类型，它分为可变集合（set）和不可变集合（frozenset）两种。类似于其他语言，集合是一个无序不重复元素集，包括创建集合set、向集合中添加元素、删除集合中的元素、求集合的交集、并集、差集等操作

（一）集合的增删改查
（1）集合的创建与赋值——唯一的方法工厂方法 set()和 frozenset()

>>> l=set()             #空集合
>>> s=set("cheeseshop")  #字符串作为参数
>>> s       
set(["c", "e", "h", "o", "p", "s"])
>>> s1 = set([1,2,3,1,3,4,5])   #list作为参数
>>> s1
set([1, 2, 3, 4])
>>> s2 = set((1,2,3,4,1))     #元组作为参数
>>> s2
set([1, 2, 3, 4])
>>> s3 = set({1:2,2:3})     #字典作为参数
>>> s3
set([1, 2])
>>> b=set(3,4,5)
Traceback (most recent call last):File "", line 1, in 
TypeError: set expected at most 1 arguments, got 3

（2）访问集合的值
遍历查看集合成员或检查某项元素是否是一个集合中的成员:

>>> s
set(["c", "e", "h", "o", "p", "s"])
>>> "k" in s
False
>>> "c" not in s
False
>>> for i in s:
...     print i                 #输出c e h o p s

（3）更新集合
用各种集合内建的方法和操作符添加和删除集合的成员:只有可变集合可以修改不可变集合不可以修改。

>>> 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"])

（4）删除集合中的成员和集合
如果如何删除集合本身，可以像删除任何 Python 对象一样，令集合超出它的作用范围，或调用 del 将他们直接清除出当前的名字空间。

>>> s.remove("z")
>>> s
set(["c", "e", "i", "h", "o", "p", "s", "y"])
>>> s-=set("pypi")
>>> s
set(["c", "e", "h", "o", "s"])
>>>del s                  #删除s集合

集合删除异常：

>>> try:
...    s.remove("444")
... except KeyError,e:
...    print "not exists"
... else:
...    print "success"

集合的替换：（没有修改，只有先删除再增加）
方法一：先删除再增加

>>> s.remove("hig")
>>> type(set("abc"))

>>> s.add("abc")
>>> s
set(["c", "b", "abc", "y", "x", "z"])

方法二：先转换成列表，再修改

>>> t=list(s)
>>> t.append(49)
>>> ss=set(t)
>>> ss
set([49, "add", "5", "4"])

 
setVar.discard(element) 
参数说明： setVar :为一个set类型的变量 element :表示要查找并删除的元素 函数作用： 在集合setVar中查找element元素，如果存在则删除；如果没找到，则什么也不做。该函数没有返回值

>>> sList=set([1,2,3,4,5])
>>> sList.discard(1)
>>> sList.discard(1)
>>> print sList
set([2, 3, 4, 5])

（5）转换
集合与序列间的转换
集合和序列之间的转换跟序列之间互转是一样的，唯一不同 的就是序列转成集合后，重复的元素被去掉了

>>> testStr="python is good"
>>> st=set(testStr)
>>> print st
set([" ", "d", "g", "i", "h", "o", "n", "p", "s", "t", "y"])

集合转字符串时，直接使用str()函 数进行转换，得到的将是集合的字 符串形式。要想真正转成字符串， 我们需要借助字符串连接函数 join()函数来完成。

>>> s1="".join(st)   #但是是无序的
>>> s1
" dgihonpsty"

集合与列表互转

>>> listTest=[1,2,3,2,"a","b"]
>>> sList=set(listTest)
>>> sList
set(["a", 1, 2, 3, "b"])
>>> list1=list(sList)
>>> list1
["a", 1, 2, 3, "b"]

元组与集合互转

>>> tupTest = (1, 2, 3, 2, "a", "b", "a")
>>> sTup=set(tupTest)
>>> sTup
set(["a", 1, 2, 3, "b"])
>>> tup=tuple(sTup)
>>> tup
("a", 1, 2, 3, "b")

(6)pop

>>> s.pop()
"h"
>>> s.clear()
>>> s
set([])

注：pop是随机的如果想删除最后一个,如果想删除最后一个元素时，如下：
先遍历找到这个元素并记录下最后一个数值通过remove删除

>>> s
set(["c", "e", "d", "m", "l", "o", "4", "w", 4])
>>> i=0
>>> value=""
>>> for x in s:
...    if i==8:
...        value=x
...    i+=1
...
>>> value
4
>>> s.remove(value)

(7)clear /copy/ len

sList=set([1,23,4,5])
>>> sList.clear()
>>> print sList
set([])

s2=set([1,2,3,4,5])
>>> s2=sList.copy()
>>> id(s2)
4321621440
>>> id(sList)
4321422360

>>> len(s2)
0

（二）集合的类型操作符
（1）子集超集
“小于”符号( <, <= )用来判断子集
“大于”符号( >, >= )用来判断超集。
“小于” 和 “大于”意味着两个集合在比较时不能相等。等于号允许非严格定义的子集和超集。
Sets 支持严格( < )子集和非严格 ( <= ) 子集, 也支持严格( > )超集和非严格 ( >= )超集。只有当第一个集合是第二个集合的严格子集时，我们才称第一个集合“小于”第二个集合，同理，只有当第一个集合是第二个集合的严格超集时，我们才称第一个集合“大于”第二个集合。

>>> set("shop") < set("cheeseshop")
True
>>> set("bookshop") >= set("shop")
True

（2）联合|（等价于union())
两个集合的联合是一个新集合，该集合中的每个元素都至少是其中一个集合的成员，即，属于两个集合其中之一的成员。

>>> s=set("python")
>>> t=set("hello")
>>> s|t                     #等价于s.union(t)
set(["p", "e", "t", "y", "h", "l", "o", "n"])

（3）交集&（等价于intersection())
两个集合的交集是一个新集合，该集合中的每个元素同时是两个集合中的成员，即，属于两个集合的成员。

>>> s=set("python")
>>> t=set("hello")
>>>s&t             #等价于 s.intersection(t)
set(["h", "o"])

（4）差补/相对补集(-)(等价于difference())
两个集合(s 和 t)的差补或相对补集是指一个集合 C，该集合中的元素，只属于集合 s，而不属于集合 t。

>>> s
set(["h", "o", "n", "p", "t", "y"])
>>> t
set(["h", "e", "l", "o"])
>>> s-t
set(["y", "p", "t", "n"])

（5）对称差分( ^ ) （等价于symmetric_difference())
两个集合(s 和 t)的对称差分是指另外一个集合 C,该集合中的元素，只能是属于集合 s 或者集合 t的成员，不能同时属于两个集合。

set(["h", "o", "n", "p", "t", "y"])
>>> t
set(["h", "e", "l", "o"])
>>> s^t
set(["e", "l", "n", "p", "t", "y"])

(6) issuperset方法所用是判断集合st1是否是集合st2的父集，如果是返回 True，否则返回False。

>>> s1=set([1,2,3,4])
>>> s2=set([2,3])
>>> s1.issuperset(s2)

True
(7) issubset函数的作用是判断集合s1是否是集合s2的子集，如果是返回True，否则返 回False。

>>> s1=set([1,2,3,4,5])
>>> s2=set([2,3])
>>> s2.issubset(s1)
True

(8) 集合的成员运算符
集合里也可以使用成员运算符，in和not in，判断某个对象是 否是集合中的成员。

s1 = set([“a”,”b”])
>>> "a" in s
True
>>> "x" in s
False

(三) 不可变集合
Python中还有一种不可改变的集合，那就是 frozenset，不像set集合，可 以增加删除集合中的元素，该集合中的内容是不可改变的，类似于字符串、 元组。如果试图改变不可变集合中的元素，就会报AttributeError错误。 不可变集合，除了内容不能更改外，其他功能及操作跟可变集合set一样

f1 = f1=frozenset("python")
print f1
f2 = frozenset([1,2,3,2,44,3])
print f2