python数据类型 集合set(无序)

集合： set

   集合是可变的容器
   集合内的数据对象都是唯一的(不能重复多次的)
   集合是无序的存储结构，集合中的数据没有先后顺序关系
   集合内的元素必须是不可变对象
   集合是可迭代对象
   集合是相当于只有键没有值的字典(键则是集合的数据)

创建空的集合：
 set()

创建非空的集合：

  s = {1, 2, 3, 4}

集合的构造函数　set
　set() 创建一个空的集合对象(不能用{}来创建一个空的集合)
　set(iterable) 用可迭代对象创建一个新的集合对象

示例：
　　s = set() #　s为空的集合
　 s = {3, 5, 7, 9}
  s = set("abc")  # s = {"a","b", "c"}
  s = set({1:"1", 2:"2", 3:"3"})  # s = {1, 2, 5}
  s = set(range(1:10:3)) #s = {1, 4, 7}





集合的运算：

　　交集，　并集，　补集，　子集，　超集


运算符：
　＆　｜　－　^ <  <=  > >=  == !=

in / not in

＆　生成两个集合的交集：
  s1 =(1, 2, 3)
  s2 =(2, 3, 4)
  s1 & s2  # (2, 3)

| 生成两个集合的并集
 s1 = {1, 2, 3}
 s2 = {2, 3, 4}
 s1 | s2  # {1, 2, 3, 4}

- 生成两个集合的补集：

 s1 = {1, 2, 3}
 s2 = {2, 3, 4}
 s1 - s2   #　{1}
 ＃生成属于s1　但不属于s2的所有元素的集合


^ 生成两个集合的对称补集
 s1 = {1, 2, 3}
 s2 = {2, 3, 4}
 s1 ^ s2 {1, 4}

 >　判断一个集合是另一个集合的超集

 <　判断一个集合是另一个集合的子集

　{1, 2, 3} > {1, 2} # True

  {2, 3, 1} > {3, 2} # ??? True

{2, 3, 4} <  {1, 2, 3, 4} #True

== /  !=　集合相同和不同
{1, 2, 3}  = {3,  2,  1}  #True
{1, 2, 3} != {2,  3,  4}  #True


in / not in  　　　运算符

　  in 等同于字典的in, 用于集合中，　当某个值存在于集合中，　返回True,
     否则返回False

     not in  与  in  返回值相反

集合的 in/ not in 运算符的速度快于序列

能用于集合的函数：
       能用于所有的容器中
      len(x)
      max(x)
      min(x)
      sum(x)
      any(x)
      all(x)
集合是可迭代对象：

例题：(集合练习)

    经理有： 曹操， 刘备， 周瑜

    技术员有： 曹操， 周瑜， 张飞， 赵云

    用集合求：
        1.   即是经理也是技术员的有谁？(交集)
        2.   是经理， 但不是技术员的有谁？(补集)
        3.   是技术人员， 但不是经理的都有谁 ()
        4.   张飞是经理吗？(    in manager     )
        5.   身兼一职的人都有谁？     (   )
        6.   经理和技术员共有多少人


python3集合的常用方法：
   >>> help(set)

或：
  python_base_docs_


S.add(e)    在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e) 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误

S.discard(e)    从集合S中移除一个元素e;

S.clear()   清空集合内的所有元素

S.copy()    将集合进行一次浅拷贝

S.pop() 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常

S.update(s2)    用 S与s2得到的全集更新变量S

以下内容可以用运算符操作代替  
S.difference(s2)    用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合

S.difference_update(s2) 等同于 S = S ^ s2

S.intersection(s2)  等同于S & s2

S.intersection_update(s2)   等同于S = S & s2

S.isdisjoint(s2)    如果S与s2交集为空返回True,非空则返回False

S.issubset(s2)  如果S与s2交集为非空返回True,空则返回False

S.issuperset(...)   如果S为s2的子集返回True,否则返回False

S.symmetric_difference(s2)  返回对称补集,等同于 S ^ s2

S.symmetric_difference_update(s2)   用S 与 s2的对称补集更新 S
S

.union(s2) 生成 S 与 s2的全集


集合推导式：
    集合推导式是用来可迭代对象来生成集合的表达式

    语法：
     {表达式 for 变量 in 可迭代对象[if 真值表达式]}
     　　注：　[ ] 内的内容可省略

　　示例：
    numbers = (1, 2, 3, 3, 3, 4, 5, 2)
　　  s = {x for x in number} #　去除重复的元素


集合可变的　不能作为字典的键

固定集合　frozenset
    
固定集合是不可变的，　无序的，　　含有不重复元素的集合
作用：
　　　固定集合可以作为字典的键，　还可以作为集合的值

创建空的固定集合
    fs = frozenset()

创建非空的固定集合：
 
  frozenset(iterable)  用可迭代对象创建新的固定集合

　示例：　　　
　   
     fz = frozenset([2, 3, 5, 7])  # frozenset({2, 3, 5, 7})

运算：

　　 ＆　　交集
　　 ｜　　并集
　　  - 　补集
       ^ 　对称补集
       < <= > >= == !=
       (以上运算与set相同)


固定集合方法：
　　相当于集合的全部方法(去掉修改集合的方法(增删改))


列表　　字典　　　集合　　(三个可变的优缺点)

　　１．　　　都为可变
　　２．　　　列表的尾部插入速度比较快,　查中间插入和头插数据速度慢
　　３．　　　列表有序
　　４．　　　字典(哈希存储)添加，　删除，　修改速度快于列表
　　５．　　　集合的添加，删除快于列表，　且不能存储重复元
　
　哈希存储(3, 8, 5, 1, 6)
   hash(x) = x *(x + 1) % 10

练习：

　　　输入一段字符串，　打印所有输入过的字符串，　但重复的只打印一次，

　　（不要求打印的顺序与输入顺序一致）
　　

　　输入：　abcdabcaba
    打印：
  　　　a b c d
  2. 输入一段字符串，　打印出这个字符串中出现过的字符以及出现过的次数：
  　如：
  　　　　输入abcdabcaba
   打印如下：　　
   　
     a  :  4次
     ｂ :  3次
     c  :  2次
     d  : 1ci

 　　　注：　不要求打印顺序