set
创新互联的客户来自各行各业，为了共同目标，我们在工作上密切配合，从创业型小企业到企事业单位，感谢他们对我们的要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。专业领域包括网站制作、成都网站建设、电商网站开发、微信营销、系统平台开发。
set（集合|集）：
可变的，无序的，不重复的元素的集合；
set最大用处：去重；
约定：set翻译为集合；collection翻译为集合类型，是一个大概念；
list，链表，栈，queue（两头操作用queue）；
set定义、初始化：
set()-->new empty set object
set(iterable)-->new set object
set的元素：
要求必须可以hash；
目前学过的不可hash的类型有list,bytearray,set；
元素不可以索引（无序）；
set可以迭代（所有集合类型都可迭代）；
例：
In [1]: s1=set() #创建空集合只能用这种方式，{}是留给dict用的
In [2]: s2=set(range(5))
In [3]: s2
Out[3]: {0, 1, 2, 3, 4}
In [4]: s3=set(list(range(10)))
In [5]: s3
Out[5]: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
In [6]: s4={} #{}优先给dict使用
In [7]: type(s4)
Out[7]: dict
In [8]: s5={9,10,11}
In [9]: type(s5)
Out[9]: set
In [10]: s6={(1,2),3,'a'}
In [11]: s7={[1],(1,),1}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
----> 1 s7={[1],(1,),1}
TypeError: unhashable type: 'list'
In [12]: s8={bytearray(b'abc')}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
----> 1 s8={bytearray(b'abc')}
TypeError: unhashable type: 'bytearray'
In [13]: s9={'abc',b'abc'}
In [16]: s10=set(['abc',b'abc']) #虽hash值一样，但可放在set中，不是冲突元素
In [17]: hash(1)
Out[17]: 1
In [18]: hash([1])
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
----> 1 hash([1])
TypeError: unhashable type: 'list'
In [19]: hash('abc')
Out[19]: 7077160064984426464
In [20]: hash(b'abc')
Out[20]: 7077160064984426464
In [21]: hash('abc') == hash(b'abc')
Out[21]: True
In [22]: hash('abc') is hash(b'abc')
Out[22]: False
In [23]: s11=set(s10)
In [24]: s11
Out[24]: {'abc', b'abc'}
set增加元素：
add(elem)，增加一个元素到set中；如果元素存在，什么都不做do nothing；
update(*others)，合并其它元素到set集合中来；参数others必须是可迭代对象；就地修改；
例：
In [25]: s=set()
In [26]: s.add(1)
In [27]: s
Out[27]: {1}
In [28]: s.add(2)
In [29]: s.add(1)
In [30]: s
Out[30]: {1, 2}
In [31]: s.update({1,2,3},{2,3,4}) #update(*other)，把多个集合的元素合并到当前集合，不是解构的概念，others是iterable
In [32]: s
Out[32]: {1, 2, 3, 4}
set删除：
remove(elem)，从set中移除一个元素；元素不存在，抛出KeyError异常，为什么是KeyError，key是hash值，根据hash值来定位删除；
discard(elem)，从set中移除一个元素，元素不存在，do nothing；
pop()-->item，移除并返回任意的元素，为什么是任意元素？无序，不可以索引；空集返回KeyError异常；
clear()，移除所有元素，注意GC；
例：
In [33]: s.remove(2)
In [34]: s
Out[34]: {1, 3, 4}
In [35]: s.discard(5)
In [36]: s.pop()
Out[36]: 1
In [37]: s.pop()
Out[37]: 3
In [38]: s.pop()
Out[38]: 4
In [39]: s.pop()
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
----> 1 s.pop()
KeyError: 'pop from an empty set'
set修改、查询：
修改，要么删除，要么加入新的元素，为什么没有修改？可变类型list,bytearray均不可hash；
查询，非线性结构无法索引；
遍历，可迭代所有元素；
成员运算符，in,not in，效率？很高，相当于用index遍历list，O(1)；
set成员运算符的比较：
list和set比较：
list随着值的增加耗时是数量级的增加；
set，随着值的增加，基本不变，适用于在集合中查找某个值，set中查时先转为key（hash值）再查；
set和线性结构：
线性结构的查询时间复杂度是O(n)，即随着数据规模的增大而增加耗时；
set,dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1)，查询时间和数据规模无关；
可hashable类型：数值型（int,float,complex）；布尔型（True,False）；字符串（string,bytes）；tuple；None；以上都是不可变类型；
注：set的元素必须是可hashable的；
set基本概念：
全集，所有元素的集合，如实数集，所有实数组成的集合就是全集；
子集subset，超集superset，一个集合A所有元素都在另一个集合B内，A是B的子集，B是A的超集；
真子集和真超集，A是B的子集，且A不等于B，A就是B的真子集，B是A的真超集；
并集，多个集合合并的结果；
交集，多个集合的公共部分；
差集，集合中除去和其它集合公共部分；
集合运算：
并集：
将两个集合A和B的所有元素合并到一起，组成的集合称作集合A和集合B的并集；
union(*others)，返回多个集合合并后的新集合；
|，运算符重载，等同union(*others)；
update(*others)，和多个集合合并，就地修改；
|=，等同update(*others)；
例：
In [40]: s1={1,2,3}
In [41]: s2={2,3,4}
In [43]: s1.union(s2)
Out[43]: {1, 2, 3, 4}
In [44]: s1
Out[44]: {1, 2, 3}
In [45]: s2
Out[45]: {2, 3, 4}
In [47]: s3=s2.union(s1)
In [48]: s3
Out[48]: {1, 2, 3, 4}
In [49]: s1 | s2
Out[49]: {1, 2, 3, 4}
In [50]: s2 | s1
Out[50]: {1, 2, 3, 4}
In [51]: s3 |= {5,6} | {7,8} #类似a += 1+2
In [52]: s3
Out[52]: {1, 2, 3, 4, 5, 6, 7, 8}
交集：
集合A和B，属于A且属于B的元素组成的集合；
intersection(*others)，返回多个集合的交集；
&，等同intersection(*others)；
intersection_update(*others)，获取和多个集合的交集，并就地修改；
&=，等同intersection_update(*others)；
例：
In [53]: s1 & s2
Out[53]: {2, 3}
In [54]: s3=s1 & s2
In [55]: s3
Out[55]: {2, 3}
In [56]: s1.intersection(s2)
Out[56]: {2, 3}
In [57]: s2.intersection(s1)
Out[57]: {2, 3}
In [58]: s3.intersection_update(s2)
In [59]: s3
Out[59]: {2, 3}
In [60]: s3.intersection_update(s1)
In [61]: s3
Out[61]: {2, 3}
差集（常用）：
集合A和B，属于A但不属于B的元素组成的集合；
difference(*others)，返回多个集合的差集；
-，等同difference(*others)；
difference_update(*others)，获取和多个集合的差集，并就地修改；
-=，等同difference_update(*others)；
A-B=A-A∩B
A-B=A
A-B=环形
A-B=None
例：
In [62]: s1
Out[62]: {1, 2, 3}
In [63]: s2
Out[63]: {2, 3, 4}
In [64]: s3
Out[64]: {2, 3}
In [65]: s1-s2
Out[65]: {1}
In [66]: s2-s1
Out[66]: {4}
In [67]: s1-=s2
In [68]: s1
Out[68]: {1}
对称差集：
集合A和B，不属于A和B的交集元素组成的集合，记作(A-B)∪(B-A)；
symmetric_difference(other)，返回一个集合的差集；
^，等同symmetric_difference(other)；
symmetric_difference_update(other)，获取和另一个集合的差集，并就地修改；
^=，等同symmetric_difference_update(other)；
例：
In [70]: s1={1,2,3}
In [71]: s2
Out[71]: {2, 3, 4}
In [72]: s1^s2
Out[72]: {1, 4}
In [73]: s2^=s1
In [74]: s2
Out[74]: {1, 4}
In [75]: s1
Out[75]: {1, 2, 3}
issubset(other)，<=，判断当前集合是否是另一个集合的子集；
set1 < set2，判断set1是否是set2的真子集；
issuperset(other)，>=，判断当前集合是否是other的超集；
set1>set2，判断set1是否是set2的真超集；
isdisjoint(other)，当前集合和另一个集合有没有交集，没有交集返回True，用于判断交集；
例：
In [76]: s1={1,4,5,6}
In [77]: s2={1,3,4,5,6}
In [78]: s1>s2
Out[78]: False
In [79]: s1>=s2
Out[79]: False
In [80]: s1 Out[80]: True In [81]: s1<=s2 Out[81]: True In [82]: s1.issubset(s2) Out[82]: True In [83]: s2.issuperset(s1) Out[83]: True In [84]: s1.issuperset(s1&s2) Out[84]: True In [85]: s3=set() In [86]: {}>s3 #{}是dict， --------------------------------------------------------------------------- TypeError Traceback (most recent call last) ----> 1 {}>s3 TypeError: unorderable types: dict() > set() In [88]: set() == s3 Out[88]: True In [89]: s3={10} In [90]: s1 Out[90]: {1, 4, 5, 6} In [91]: s1.isdisjoint(s3) #没有交集返回True Out[91]: True 集合set应用： 共同好友：你好好友A,B,C，他的好友B,C,D，求共同好友？ {'A','B','C'}.intersection({'B','C','D'}) 微信群提醒：xxx与群里其它人都不是微信朋友关系？ userid not in (A | B | C | D) 返回False，A,B,C,D为集合 权限判断： 有一个API，要求权限同时具备A,B,C才能访问，用户权限是B,C,D，判断用户是否能访问API？ A={'A','B','C'} B={'B','C','D'} A >= B返回False A - B == set() #方一，A-B为空集，B包含A A.issubset(B) #方二，A是B的子集 A & B == A #方三 有一个API，要求权限具备A,B,C任意一项就可访问，用户权限是B,C,D，判断用户是否能访问该API？ A={'A','B','C'} B={'B','C','D'} A & B != set() #方1，返回True A.isdisjoint(B) #方2，返回False表示有交集 一个总任务列表，存储所有任务，一个完成的任务列表，找出未完成的任务？ 任务ID不可以重复； 所有任务ID放到一个set中，如A集合； 所有已完成的任务ID放到另一个set中，如B集合； A - B = UNCOMPLETED，未完成任务ID；
文章题目：6内置数据结构_set
URL地址：http://kswsj.cn/article/gochhp.html
