Python集合

创建集合：

s = {'P', 'y', 't', 'h', 'o', 'n'} s = set(['P', 'y'])  # 从列表创建s = set()  # 空集合print type(s)  #<class 'set'>d = {}  # 空字典print type(d)  #<class 'dict'>

集合可以有任意数量的元素，它们可以是不同的类型

（例如：数字、元组、字符串等）。但是，集合不能有可变元素（例如：列表、集合或字典）

123	s = {1, 2, 3}  # ×××的集合s = {1.0, 'Python', (1, 2, 3)}  # 混合类型的集合s = {1, 2, [3, 4]}  # 报错，不能有可变元素

集合的特性：

1、无序性，不支持是索引

2、互异性，每个元素只能出现一次  

3、确定性   s in set   

集合与内置函数

all() 如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；函数等价于：

12	print all(['a', 'b', 'c', 'd'])  #列表list，元素都不为空或0print all([0, 1,2, 3])  # False 列表list，存在一个为0的元素

#空元组、空列表返回值为True，这里要特别注意。

any(iterable)说明：参数iterable：可迭代对象；

如果当iterable所有的值都是0、''或False时，那么结果为False，如果所有元素中有一个值非0、''或False，那么结果就为True

    

12	print any(['a', 'b', 'c', 'd']) #Trueprint any((0, '', False)) #False

enumerate()返回一个枚举对象，其中包含了集合中所有元素的索引和值（配对）。

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

   

#enumerate(sequence, [start=0]) start -- 下标起始位置。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']print list(enumerate(seasons)) #[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]print list(enumerate(seasons, start=1))  # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

seq = ['one', 'two', 'three']for i, element in enumerate(seq):    print i, seq[i]

等价于

12345

i=0    seq = ['one', 'two', 'three']for element in seq:    print i, seq[i]    i +=1

len()返回对象（字符、列表、元组等）长度或项目个数

str = "runoob"print len(str)             # 字符串长度6l = [1,2,3,4,5]print len(l)               # 列表元素个数5

max()返回给定参数的最大值，参数可以为序列。

print "max(80, 100, 1000) : ", max(80, 100, 1000) #max(80, 100, 1000) :  1000print "max(-20, 100, 400) : ", max(-20, 100, 400)print "max(-80, -20, -10) : ", max(-80, -20, -10)print "max(0, 100, -400) : ", max(0, 100, -400)

min()返回给定参数的最小值，参数可以为序列。

print "min(80, 100, 1000) : ", min(80, 100, 1000) #80print "min(-20, 100, 400) : ", min(-20, 100, 400)print "min(-80, -20, -10) : ", min(-80, -20, -10)print "min(0, 100, -400) : ", min(0, 100, -400)

sorted(iterable[, cmp[, key[, reverse]]])

参数说明：iterable -- 可迭代对象。cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

a = [5,7,6,3,4,1,2]b = sorted(a)print a,b #[5, 7, 6, 3, 4, 1, 2] [1, 2, 3, 4, 5, 6, 7] L=[('b',2),('a',1),('c',3),('d',4)]print sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   #[('a', 1), ('b', 2), ('c', 3), ('d', 4)] students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]print sorted(students, key=lambda s: s[2])  # 按年龄排序  [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]print sorted(students, key=lambda s: s[2], reverse=True)  # 按降序  [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

sum()返回集合的所有元素之和

不可变集合  frozenset , frozenset 是不可变的，所以没有添加或删除元素的方法。

1	s = frozenset('Python')

s.copy()

s.union(）

s.difference(）

s.symmetric_difference(）

s.intersection(）

s.isdisjoint(）

s.issubset(）

s.issuperset(）

集合的方法：

增加：

set.copy()                      返回集合的浅拷贝  

set.add()                      将元素添加到集合中

set.update()                   用自己和另一个的并集来更新这个集合

                     

A= set('boy')A.add('python')print A  #set(['y', 'python', 'b', 'o'])  是把要传入的元素做为一个整个添加到集合中 A.update('Hello')print A  #set(['b', 'e', 'python', 'H', 'l', 'o', 'y'])  ,传入的元素拆分，做为个体传入到集合中 A = {'runoob'}A.add('134')  B=A.copy()print A  # set(['134', 'runoob'])print B # set(['runoob', '134'])

删除：

set.clear()          删除集合中的所有元素                              

set.discard()        删除集合中的一个元素（如果元素不存在，则不执行任何操作）          

set.pop()            删除并返回任意的集合元素（如果集合为空，会引发 KeyError）                       

set.remove()         删除集合中的一个元素（如果元素不存在，会引发 KeyError）

A= set('python')A.discard('P')  #删除不存在的元素不会报错print AA.remove('p')   #删除不存在的元素会报错print A    # set(['h', 'o', 'n', 't', 'y'])print A.pop()  #h,删除并返回任意的集合元素print A    #set(['o', 'n', 't', 'y'])A.clear()print A   #set([])

更新：

set.difference_update()     

set.intersection_update()           用自己和另一个的交集来更新这个集合

set.symmetric_difference_update()   用自己和另一个的对称差来更新这个集合

A = set('abcd')B = set('cdef')A.intersection_update(B)  #返回None，用结果更新Aprint  A  #set(['c', 'd'])A = set('abcd')B = set('cdef')A.difference_update(B)  #返回None，用结果更新Aprint A  #set(['a', 'b'])A = set('abcd')B = set('cdef')A.symmetric_difference_update(B)  #返回None，用结果更新Aprint A  #set(['a', 'b', 'e', 'f'])

查询：

set.union()                     将集合的并集作为一个新集合返回

set.difference()                将两个或多个集合的差集作为一个新集合返回                

set.symmetric_difference()      将两个集合的对称差作为一个新集合返回

set.intersection()              将两个集合的交集作为一个新集合返回

set.isdisjoint()             如果两个集合有一个空交集，返回 True                                          

set.issubset()               如果另一个集合包含这个集合，返回 True

set.issuperset()             如果这个集合包含另一个集合，返回 True

                                                                                                          

A = set('abcd')B = set('cdef')C = set('ab')D = set('xyz')print C < A  , C.issubset(A)  # 判断C是否是A的子集print A > C  , A.issuperset(C)  # 判断A是否是C的超集print A.isdisjoint(B),A.isdisjoint(D) #判断两个集合是否不相交print A | B, A.union(B)  # 判断A和B的并集，合并A和Bprint A & B, A.intersection(B)  # 判断A和B的交集，set(['c', 'd'])  只获取A和B中相同的部分print A - B , A.difference(B)      # 求A和B的差集，set(['a', 'b']) ，只获取A中不同的部分print A ^ B , A.symmetric_difference(B)  #A和B的对称差集  set(['a', 'b', 'e', 'f']) ，只获取两个集合不同的部分