创建集合：
s = {'P', 'y', 't', 'h', 'o', 'n'}
s = set(['P', 'y']) # 从列表创建
s = set() # 空集合
print type(s) #
d = {} # 空字典
print type(d) #
集合可以有任意数量的元素，它们可以是不同的类型
（例如：数字、元组、字符串等）。但是，集合不能有可变元素（例如：列表、集合或字典）
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；函数等价于：
print all(['a', 'b', 'c', 'd']) #列表list，元素都不为空或0 print all([0, 1,2, 3]) # False 列表list，存在一个为0的元素
#空元组、空列表返回值为True，这里要特别注意。
any(iterable)说明：参数iterable：可迭代对象；
如果当iterable所有的值都是0、''或False时，那么结果为False，如果所有元素中有一个值非0、''或False，那么结果就为True
print any(['a', 'b', 'c', 'd']) #True print 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]
等价于
i=0 seq = ['one', 'two', 'three'] for element in seq: print i, seq[i] i +=1
len()返回对象（字符、列表、元组等）长度或项目个数
str = "runoob" print len(str) # 字符串长度6 l = [1,2,3,4,5] print len(l) # 列表元素个数5
max()返回给定参数的最大值，参数可以为序列。
print "max(80, 100, 1000) : ", max(80, 100, 1000) #max(80, 100, 1000) : 1000 print "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) #80 print "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 是不可变的，所以没有添加或删除元素的方法。
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 A
A.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，用结果更新A
print A #set(['c', 'd'])
A = set('abcd')
B = set('cdef')
A.difference_update(B) #返回None，用结果更新A
print A #set(['a', 'b'])
A = set('abcd')
B = set('cdef')
A.symmetric_difference_update(B) #返回None，用结果更新A
print 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和B
print 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']) ，只获取两个集合不同的部分