集合、字典

集合 set

约定

    1. set 翻译为集合
    2. collection 翻译为集合类型或容器，是一个大概念

特点

    1. 可变的无序的不重复的元素的集合
    2. 集合元素是唯一的不能修改的
     s1 = （）表示的是空集合
    3. 写set时不能出现列表、bytearry、set 、字典，要求set里面的元素可hash
    4.set 元素不可索引
    5.set 可迭代

表示

    set() -> new empty set object
    set (iterable) -> new set object 

set 增加

add （elem)

    1. 增加一个元素到set中
    2.如果元素存在什么都不做

update（*others）

    1. 合并其它元素到set集合中来
    2. 参数others 必须是可迭代对象
    3. 就地修改

set 删除

remove（elem)

    1. 从set中移除一个元素
    2. 元素不存在，抛出KeyError 异常。

discard （elem)

    1. 从set中移除一个元素
    2. 元素不存在什么都不做

pop () -> item

    1. 移除并返回任意的元素
    2.空集返回KeyError异常

clear

    1. 移除所有元素

set 修改、查询

修改

    1. 要么删除、要么加入新的元素

索引

    1. 非线性结构无法索引

遍历

    1. 可迭代所有元素

成员运算符

    1. in 和 not in 判断元素是否在set中
    2.效率非常高

set 成员运算符的比较

    1. list 和 set 的比较
     set in 的效率比较高，因为用的是hash 算法，一个数据经过hash 算法后存到内存中，在找这个数据的时候，再用hash 算法算一下，然后直接去拿那个数据就行了

set 和线性结构

    1.线性结构的查询时间复杂度是O(n),即随着数据规模的增大而增加耗时
    2.set 、 dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1)
    3. 可hash的值
       （1） 数值型int、float、complex
       （2） 布尔型 True、False
        (3) 字符串类型 string、bytes
        (4) tuple
        (5) None
        (6) 以上都是不可变类型，称为可hash类型，hashable
    4. set 元素必须是可hash的

基本概念

全集

    1. 所有元素的集合。例如实数，所有实数组成的集合就是全集

子集 subset 和超集 superset

    1. 一个集合A 所有元素都在另一个集合B内，A是B的子集，B是A的超集

真子集和真超集

    1. A是B 的子集且A 不等于B ，A就是B的真子集，B是A的真超集

并集 ：多个集合合并的结果

交集 ：多个集合的公共部分

差集 ： 集合中除去和其它集合公共部分

集合运算

并集

    1.将两个集合A和B 所有的元素合并到一起，组成的集合称作集合A和集合B 的并集
    2.union (*others)
       返回和多个集合合并后的新的集合
    3.| 运算符重载
        等同union
    4. update（*others）
        和多个集合合并，就地修改
    5. |= 
         等同update

交集

    1.集合A和B，由所属于A且属于B的元素组成的集合
    2.intersection（*others）
       返回和多个集合的交集
    3. & 
       等同intersection
    4. intersection——update（*others）
         获取和多个集合的交集，并就地修改
    5. &=
       等同 interserction_update

差集

    1. 集合A和B，由所属于A且不属于B的元素组成的集合
    2. difference（*others）
        返回和多个集合的并集
    3. —
        等同difference
    4. difference_update(*others)
        获取和多个集合的差集并就地修改
    5. -= 
        等同difference_update

对称差集

    1. 集合A和B，由所有不属于A和B的交集元素组成的集合，
    记作（A-B）∪（B-A）
    2. symmetric_difference(other)
         返回和另一个集合的对称差集
    3. ^
        等同symmetric_difference
    4.symmetric_difference_update(other)
         获取和另一个集合的对称差集并就地修改
    5. ^=
       等同symmetric_difference_update
  1.issubset(other) <=
      判断当前集合是否是另一个集合的子集
  2. set1 < set2
      判断set1是否是set2的真子集
  3. issuperset（other） >=
      判断当前集合是否是other的超集
  4. set1 > set2
      判断set1 是否是set2 的真超集
  5. isdisjoint(other)
      当前集合和另一个集合没有交集
      没有交集，返回True

字典

定义、初始化

  1.d = {} 或者 d = dict()  空集
  2. dict(***kwargs) 使用name=value 对初始化一个字典
  3.dict（iterable,**kwarg) 使用可迭代对象和name=value 对构造字典，不可迭代对象元素必须是一个二元结构
   d = dict(((1,'a'),(2,'b')))或者 d = dict(([1,'a'],[2,'b'])c=300) 
  4.dict(mapping,**kwarg)使用一个字典构建另一个字典
  5. d = {'a':10,'b':20,'c':None,'d':[1,2,3]}
  6.类方法 dict.fromkeys(range(5))
       d = dict.fromkeys(range(5))
       d =  dict.formkeys(ramge(5),0)

字典元素的访问

  1. d[key] = value
     (1)将key对应的值改为value
     (2)KEY 不存在添加新的KV对
  2. update([other]) -> None
      (1)使用另一个字典的KV对更新本字典
      (2)KEY值不存在就添加
      (3)KEY值已经存在就覆盖已经存在的key对应的值
      就地修改

字典删除

  1. pop(key[,default])
     (1)key 存在，移除它，并返回它的value
     (2)key 不存在，并返回他给定的default
     (3) default 未设置，key不存在则抛出KeyError 异常
  2.popitem()
      (1)移除并返回一个任意的键值对
      (2)字典为empty，抛出KeyError
  3. clear()
  4.  del 语句

字典遍历

   for i in dict
  (1) 遍历key
     for key in d:
        print(k)
      
     for k in keys():
         print(k)
  (2) for item in d.items():
        print(item)
      
      for items in d.items():
         print(item[0],item[1])

      for k,v in d.items():
         print(k,v)

      for k,_ in d.items():
          print(k)

      for _,v in d.items():
          print(v)

总结

   1.Python3中，keys、value、items 方法返回一个类似一个生成器的可迭代对象，不会把函数的返回结果复制到内存中
   2. Dictionary view 对象，可以使用len()、iter()、in 操作
   3. 字典的entry 的动态的视图，字典的变化，视图将反应出这些变化
   4. keys 返回一个类set对象，也就是可以看做一个set集合。如果values都可以hash,那么items也可以看做是类set对象
   5.Python2中，上面的方法会返回一个新的列表，占据新的内存空间。所以Python2建议使用iterkeys、itervalues、iteritems版本，返回一个迭代器，而不是返回一个copy

删除

如何在遍历的时候移除元素

   1.d= dict(a=1,b=2,c='abc')
   keys = []
   for k,v in d.itens():
        if isinstance(v,str):
        keys.append(k)

    for k in keys:
        d.pop(k)
    print(d)

key 的要求和set元素要求一致

    1. set 元素就可以看做key,set可以看做dict的简化版
    2.hashable 可哈希才可以作为key,可以使用hash()测试

defaultdict

    collections.defaultdict([default_factory[,...]])
    第一个参数default_factory，缺省值是None,他提供一个初始化函数，当key不存在的时候就调用这个工厂函数来生成KEY值对应的value

    fromcollections import defaultdict
    import random
     
     d1 = defaultdict(list)
     for k in 'abcdefghijklmnopqrstuvwxyz':
         for i in range(random.randint(1,5)):
         d1[k].append(i)
    print(i)

OrdereDict

collections.OrdereDict([items])
   （1） key 并不是按照加入的顺序排列，可以使用OrdereDict记录顺序
   （2）有序字典可以记录元素插入的顺序（输入的顺序）打印的时候也是按照这个顺序打印
   （3）3.6版本的python的字典就是记录key值插入的顺序（ipython不一定有效果）