python学习随笔(五)_内置数据结构_set,dict

封装和解构
封装
    将多个值使用逗号分割,组合在一起
    本质上返回一个元组,只是省掉了小括号
    t1 = (1,2)#定义元组
    t1 = 1,2#将1,2封装成元组
解构
    把线性结构的元素解开，并顺序的赋给其它变量
    左边接纳的变量数要和右边解开的元素个数一致
lst = [3, 5]
first, second = lst
print(first, second)

a,b = b,a
右边先封装成元组,左边解构#封装和结构
左边是一个标识符直接是赋值
解构只要左右数目必须一致就没问题
赋值表达式先算右边
*变量名 接受 不能单独使用
*变量名  收集后组成一个列表    #列表也可以有一个元素
 

字典
d = {'a':100,'b':200}

下划线是一个合法标识符
惯例是定义一个不关系的变量

-------------------------------------------------------------------------------

set    #可变的,无序的,不重复的元素的集合,可迭代

set定义初始化
    #s = {}    #特例,定义字典
    s = set()    #定义空set
    s = set(iterable)
    s = {1,2}    #set,常用

set的元素
    set的元素必须hash    #可变的都不可以hash,不可变的可hash
    set是不可变的,set本身是不可hash的
    set非线性结构,不可索引
    set可迭代
    #hash()    #函数算出来的就是门牌号码,时间复杂度O(1)
set增加
    add(elem)    #一个
        增加一个元素到set中,如果元素存在什么都不做
    update(*others)    #多个
        合并到其他元素到集合中
        参数必须是一个可迭代对象
        就地修改
set删除    #set删除很快因为求hash直接找门牌号,但是数据好不容易加载到内存中去说移除就移除要思量一下有没有必要
    remove(elem)
        从set中移除一个元素
        元素不存在，抛出KeyError异常。#因为把元素当做一个key来认,它是独一无二的
    discard(elem)
        从set中移除一个元素
        元素不存在，什么都不做
    pop() -> item
        移除并返回任意的元素。为什么是任意元素？
        空集返回KeyError异常
    clear()    移除所有元素

set修改、查询
    修改
        set没有修改,要么删除要么加入新元素
    查询    #用hash查看
        非线性结构,无法索引
    遍历
        可以迭代所有元素
    成员运算符
        in,not in 判断元素是否在set中    #直接算hash O(1)#list要遍历O(1)

set和线性结构
    线性结构的查询时间复杂度是O(n)，即随着数据规模的增大而增加耗时
    set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1)，查询时间和数据规模无关
    
集合
基本概念
    全集#所有元素的集合
    子集subset和超集superset
        #如果集合A所有元素都在B中,A是B的子集,B是A的超集
    真子集和真超集#A是B的子集,且A不等于B
    并集    #多个集合合并的结果
    交集    #多个集合的公共部分
    差集    #集合中除去和其他集合公共部分
集合运算
    并集
        union(*others)    #返回多个集合合并后的新集合
        A | B 运算符 等同于A.union(B)    #返回新集合
        update(*others)    #多个集合合并,就地修改
        |=        #A|=B,等同于update,把A集合就地修改成A,B和的并集

其他和并集都相似,下面只介绍函数和符号

    交集
         intersection(*others) 或 &
         intersection_update(*others) 或 &=

    差集
        difference(*others) 或 -
        difference_update(*others) 或 -=
    对称差集
        #集合A和B，由所有不属于A和B的交集元素组成的集合，记作（A-B）∪（B-A）        
        symmetric_differece(other) 或 ^
        symmetric_differece_update 或 ^=

    issubset(other)、<=
        判断当前集合是否是另一个集合的子集
     set1 < set2
        判断set1是否是set2的真子集
    issuperset(other) 或者 >=      #set1.issuperset(set2)
        判断当前集合是否是other的超集
    set1 > set2
        判断set1是否是set2的真超集
    isdisjoint(other)
        当前集合和另一个集合没有交集
        没有交集，返回True
----------------------------------------------------------------------------------

数据结构有哪些?
可hash有哪些?
列表和链表的区别,有哪些优缺点?
线性结构就是可索引的

如果可以在内存中做集合计算得到结果,就少找数据库,可以节省时间

------------------------------------------------------------------------

字典dict
    key-value键值对的数据的集合#因为高效所以常用
    ***可变的,无序的,key不重复
    *****key必须hash

字典dict定义 初始化
**    d = dict()或者d = {}    #后者常用
**    dict(**kwargs) 使用name=value对初始化一个字典    #dict(a=1,b=2)
    dict(iterable, **kwarg) 使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构
        d = dict(((1,'a'),(2,'b'))) 或者 d = dict(([1,'a'],[2,'b'])
    dict(mapping, **kwarg) 使用一个字典构建另一个字典
        #如果遇到一个集合是引用类型,更改时要小心两个字典都会更改
**     d = {'a':10, 'b':20, 'c':None, 'd':[1,2,3]}    #常用前面是k都面是v
    类方法dict.fromkeys(iterable, value)
        d = dict.fromkeys(range(5))
        d = dict.fromkeys(range(5),0)
字典元素的访问
    d[key]
        返回key对应的值value
        key不存在抛出KeyError异常
    get(key[, default])
        返回key对应的值value
        key不存在返回缺省值，如果没有设置缺省值就返回None
        #设置缺省值返回缺省值
    setdefault(key[, default])
        返回key对应的值value
        key不存在，添加kv对，value设置为default，并返回default，如果default没有设置，缺省为None

#python中所以函数都有返回值,只不过是返回none或者返回缺省值(没有的时候)

字典增加和修改
    d[key] = value
        将key对应的值修改为value
        key不存在添加新的kv对
    update([other]) -> None
        使用另一个字典的kv对更新本字典
        key不存在，就添加
        key存在，覆盖已经存在的key对应的值
        就地修改
d.update(red=1)
d.update((('red',2),))    #定义元组有一个元素后面加逗号,可用type()查看类型
d.update({'red':3})

字典删除
    d.pop(key[, default])
        key存在，移除它，并返回它的value
         key不存在，返回给定的default
        default未设置，key不存在则抛出KeyError异常
     d.popitem()    #没有参数,任意移除一个
        移除并返回一个任意的键值对
        字典为empty，抛出KeyError异常
    d.clear()    清空字典
    del语句    #着像删除了一个对象，本质上减少了一个对象的引用，del 实际上删除的是名称，而不是对象

字典遍历    #三种,遍历k,遍历v,遍历k,v
    for ... in dict
        遍历key
            for k in d:
                print(k)
            for k in d.keys():
                print(k)

        遍历value
            for k in d:
                print(d[k])
            for k in d.keys():
                print(d.get(k))
            for v in d.values():
                print(v)
        遍历item，即kv对    #可以单独遍历k,v
            for item in d.items():
                print(item)
            for item 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)
总结
     Python3中，keys、values、items方法返回一个类似一个生成器的可迭代对象，不会把函数的返回结果复制到内存中
    Dictionary view对象，可以使用len()、iter()、in操作
    字典的entry的动态的视图，字典变化，视图将反映出这些变化
    keys返回一个类set对象，也就是可以看做一个set集合。如果values都可以hash，那么items也可以看做是类set对象
     Python2中，上面的方法会返回一个新的列表，占据新的内存空间。所以Python2建议使用iterkeys、
itervalues、iteritems版本，返回一个迭代器，而不是返回一个copy

字典遍历和移除
    字典遍历过程中不可以改变长度
    用while循环移除相当清空,不如直接用clear()

#正确的做法
d = dict(a=1, b=2, c='abc')
keys = []            #新创建一个列表,然后遍历
for k,v in d.items():
    if isinstance(v, str):    #判断类型
        keys.append(k)
for k in keys:        #遍历另一个列表
    d.pop(k)
print(d)

字典的key
    字典的key要求和set一样,set可以看成是简化版的dict
    key必须可hash,前面已经说过,可以用hash()测试

defaultdict    #缺省字典

调用模块的两种方法
一:只导入模块
import collections
d = collections.defauledict()

二:导入模块下的函数    #这个好用
from collections import defaultdict
d = defaultdict()

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

OrderedDict    #有序字典
from collection import OrderedDict#导入模块
格式 collections.OrderedDict([items])
    key并不是按照加入的顺序排列，可以使用OrderedDict记录顺序
    有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印
    3.6版本的Python的字典就是记录key插入的顺序（IPython不一定有效果）