学习总结2019.3.25

元组 (存多个数据，不可变，有序)

定义：在圆括号内用逗号隔开的多个任意类型数据，元组与列表的
    t = (1, ‘a‘, (‘b‘,2))
    t = (1, )

    常用操作：
    索引取值
    t = (1, 2, 3, 2, 3, 2)
    print(t[1])
    print(t[-2])

    切片
    print(id(t))
    nt = t[:-1:]
    print(nt, id(nt))

    长度（item元素个数）
    print(len(t))

    成员运算（in | not in ）

    元组内置方法
    print(t.count(2))  # 该数据集合可以存放相同数据
    print(t.index(2, 2, 3))

    元组中的数据一定不能改变，但是元组中的数据(可变类型)的数据可以改变
    t1 = (1, 2, "abc", True, (1, 2))  # t1永远无法改变
    t2 = (1, 2, [])
    print(t2, type(t2), id(t2), id(t2[2]))
    t2[2].extend((10, 20))
    print(t2, type(t2), id(t2), id(t2[2]))

字典 (存多个数据，无序，可变)

定义：花括号内用逗号分隔开的多组key：value元素
    dict的key：可以为所以不可变类型：int float tuple str bool None， 一般就采用字符串
    dict的value：可以为所以数据类型
    注：key具有唯一性（重复会覆盖旧值），value可以重复

    字典的常用操作：
    增/改/查：
    dic[key] = value
    dic.update({key1:value1,key2:value2......})   添加的参数字典，与dic可以重复，

    就是更新值，新key就是新增
    dic.setdefault(key,value)   key存在不进行操作，key不存在则将key:value存入字典

    删：
    del dic[key]
    dic.pop(key)  删除并返回key
    dic.popitem()  随机删除一组key:value，并返回值

    复制：dic.copy(浅拷贝)
    d1 = {‘list‘: [1, 2]}
    d2 = d1.copy()
    print(id(d1), id(d1[‘list‘]))
    print(id(d2), id(d2[‘list‘]))
    d1[‘list‘].append(‘abc‘)
    print(d2)

    定义空字典：fromkeys
    第一个参数：keys：list|tuple|str，第二个参数：统一的默认value
    d10 = {}.fromkeys([‘a‘, ‘b‘, ‘c‘], ‘‘)
    print(d10)  # {‘a‘: ‘‘, ‘b‘: ‘‘, ‘c‘: ‘‘}

    dic.keys()    # 存放key的集合
    dic.values()    # 存放value的集合
    dic.items()     # 存放key-value的键值对关系的集合
    以上得到的集合不是原生list，无法索引取值，但是可以for循环取值

集合(set) (存多个值，无序，可变),主要用于去重

定义：花括号内用逗号隔开的多个任意类型数据，但数据具有 唯一性
    s1 = set()  # 创建空集合
    s2 = set(‘abc‘，10，True)

    内置方法与使用：
    集合间的运算:（& | ^ - > < ==）
    p_set = {‘a‘, ‘b‘, ‘c‘, ‘egon‘}
    l_set = {‘x‘, ‘y‘, ‘z‘, ‘egon‘}

    交集 & / intersection
    res = p_set & l_set    # {‘egon‘}

    并集  |  /  union
    res = p_set | l_set     # {‘z‘, ‘c‘, ‘y‘, ‘x‘, ‘b‘, ‘a‘, ‘egon‘}

    差集  -  /  difference
    res = p_set - l_set     # {‘x‘, ‘z‘, ‘y‘}

    对称差集   ^  /  symmetric-difference
    res = p_set ^ l_set    # {‘y‘, ‘a‘, ‘b‘, ‘x‘, ‘z‘, ‘c‘}

    p_set.difference_update(l_set)  # 将运算结果赋值给调用者
    p_set = p_set - l_set
    print(p_set)  # {‘c‘, ‘a‘, ‘b‘}
    print(l_set)  # {‘egon‘, ‘z‘, ‘y‘, ‘x‘}

    添加和删除操作：add  /  pop  /remove
    s = set()
    s.add(‘abc‘)
    s.pop()   # 随机删除一个ele元素
    s.remove  # 有ele删除，无ele抛异常

    父子集：
    sup_set = {1, 2, 3, 4, 5}
    sub_set = {1, 2, 3}
    temp_set = {3, 2, 1}
    flag_set = {7, 8, 9}

    print(sup_set > sub_set)
    print(sup_set < sub_set)
    print(temp_set == sub_set)

    isdisjoint 判断两个集合是否没有交集
    res = flag_set.isdisjoint(temp_set)
    print（res)
    res = temp_set.isdisjoint(sup_set)
    print(res)

原文地址：https://www.cnblogs.com/penghengshan/p/10604720.html