Python容器数据类型、操作、比较

集合容器

    1、列表：

        1、特征

            1、列表是一个有序集合，所有元素按照先后顺序排序。即：先进来的站在最前头
            2、列表可以有 增、删、查、改 的操作
            3、列表可以对元素分配下标（索引、位置）
            4、列表可以存储任何类型的数据或容器
            5、定义列表：变量名=[值1,值2,值3,...,值n]
            6、定义空列表：变量名=[]

        2、列表--增：

            1、列表.append(值)
                将括号中的值加入到列表末尾
            2、列表.insert(下标,值)
                在指定下标处，插入值，前面元素不变，后面元素依次后移
            3、列表.extend(列表)
                合并列表，将括号中的列表添加到列表中，按序添加

        3、列表--改：

            1、列表[下标]=值

            2、列表[切片]=值 （这种操作会将指定的列表片段更换我指定的值，但是赋值号邮编必须是一个可迭代对象，并且切片长度可以和可迭代对象的长度不一致，因此，这种操作也有可能改变列表的长度）

        4、列表--删：

            1、列表pop()
                删除末尾元素，并返回此值，
            2、列表pop(下标)
                根据下标删除，并返回此值
            3、del 列表[下标]
                根据元素下标删除，无返回值
            4、列表.clear()
                清空列表

        5、列表--查

            1、列表[下标]
                根据下标查找值，引用该值
            2、列表.index(值)
                根据值查找其在列表中的位置(下标)，并返回该下标，若有多个该值，则返回第一个索引
            3、列表.count(值)
                统计该值在列表中出现的次数并改回统计结果
            4、len(列表)
                计算列表长度，并返回该长度值
            5、max(列表)、min(列表)
                查询列表最大值、最小值，并返回该值
                但列表中的值必须是同类型的数据，例如：都是数字，或者都是字母，或者都是列表或者都是元组

        6、列表--判断

            1、in
            2、not in
            判断元素是否存在于列表中

        7、列表--脚本操作

            1、重复列表  * 、+
                +表示将两个列表组合成一个列表
                *表示将一个列表中的元素重复多次

        8、列表--排序

            1、列表.reverse()
                反转列表元素，对原列表直接操作，返回空值
            2、列表.sort()
                对原列表进行由小到大排序，属于直接操作，返回空值
            3、sorted(列表)
                对参数列表进行排序，原列表不会变化，会返回一个排序后的新列表

        9、列表--切片

            1、列表[num1:num2:num3]
                num1 表示起始位置，num2 表示终止位置，num3 表示步长
                默认值：num1 = 0 num2 =列表长度，num3 = 1 
                num2 位置元素不会包含在内

        10、列表--遍历

            1、while 循环使用下标遍历
            2、for 迭代循环遍历

    2、元组：

        1、元组是一个有序容器，可按下标查找值
        2、元组=操作受限的列表。元组不可增、删、改。但可以查找。

    3、列表<-->元组：

        1、列表=list(元组)
        2、元组=tuple(列表)
        3、以上两种操作都是返回一个新的列表、元组，并不会改变原来的 ，实现列表，元组之间的相互转换。

    3、字典：

        1、使用大括号括起来，使用键值对进行存储
        2、具有极快的查找速度
        3、只能根据 键 查找对应的 值
        4、定义空字典：a={}
        5、定义字典：a={key1:value1,key2:value2,key3:value3,....,keyn:valuen}
        6、键 （key）必须是不可变类型：如字符串，数字，元组。
        7、键 必须是唯一的，不可以重复
        8、值可以是任意类型的数据或容器
        9、键值对的存储顺序是无序的，即：存放顺序与放入顺序是没有关系的
        

        1、字典--增/改

            1、字典[键]=值
                1、若字典里已经有该键值，则会将原有的覆盖，即实现了字典的修改
                2、若字典里没有该键，则会添加改键并赋值

            2、字典--删

                1、字典.pop(键)
                    将该键对应的值删除并返回该值
                2、del 字典[键]
                    根据键删除值，返回空类型（无返回值）
                3、字典.popitem()
                    随机删除一个
                4、字典.clear()
                    清空字典

            3、字典--查

                1、字典[键]
                    根据键查找值，并返回
                2、字典.get(键,[默认值])
                    通过字典中的 get 方法查找对应的键值，如果没有该键值则返回None或者自己设置的默认值
                3、len(字典)
                    求字典长度，一个键值对占据一个长度
                4、str(字典)
                    字典转化为字符串显示
                5、dict.keys()
                    把字典中的所有键值，收集为一个列表并改回该列表，但该列表类型为：class'dict_keys',和 list 类型不一样
                5、dict.values()
                    把字典中的所有值，收集为一个列表并返回该列表，但其类型为：class'dict_values'
                5、dict.items()
                    把字典中的所有键值对，收集为一个列表并返回该列表，但其类型为：class'dict_items'
                6、以上三中类型是字典中的内置函数，返回的数据并不是严格意义上的列表，因为返回的数据无法使用列表的内置方法

            4、字典--判断

                1、in
                2、not in
                3、判断字典键、值或者键值对是否在字典中   A in dict

            5、字典--遍历

                1、for key in dict.keys():
                    print('%s-->%s'%(key,dict[key]))
                    通过遍历键，遍历字典
                2、for key in dict():
                    print('%s-->%s'%(key,dict[key]))
                3、for k,v in dict.items():
                    print('%S-->%S'%(k,v))

            6、字典--其他

                1、dict,copy()
                    返回一个复制的字典，内容一样，地址不同
                2、dict.fromkeys(seq,[,values])
                    以 seq 序列中的元素作为键，values为值，创建一个新的列表
                3、dict.setdefault(key,default=None)
                    和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default 如果键在字典中，返回这个键所对应的值。
                    如果键不在字典中，向字典中插入这个键，并且以default为这个键的值，并返回 default。default的默认值为None
                4、dict.update(dict2)
                    把 dict2 中的键值对更新至 dict 中。
                    相当于列表中的 extend 函数

        4、集合

            1、set是一个无序，不能重复的集合容器，所以可以用来过滤重复元素。
            2、定义空集和：a=set()    （注意不是 {} ，若是 a={} 则是创建空字典
            3、定义集合：a={值1,值2,....,值n}
            
            4、集合中不能存储不能进行哈希计算的数据类型。如 列表、字典、甚至集合都不能存放在集合中
            5、可进行哈希运算的数据类型才可以存储在集合中。如 数值型、字符串、布尔类型、空值类型、元组
            

            1、集合--增

                1、set.add(值)
                    向集合中添加一个元素
                2、set.update(值)
                    将一个可迭代的内容，一一加入，例如列表、元组、字典、集合、字符串
                    注意：如果添加字典，则只会将 键 添加进去。
                        若果是字符串，则会将每一个字符逐个加入

            2、集合--删

                1、set.remove(值)
                    移除指定的值。若值不存在，会报错
                2、set.discard(值)
                    同上，但值不存在不会报错
                3、set.pop()
                    随机删除一个
                4、set.clear()
                    清空集合

            3、set--集合操作

                1、并集：|
                2、交集：&   intersection
                3、差集：-    different
                4、判断：in
                5、联合：union    例如；A.union(B) 合并A，B 并返回合并后的集合
                6、子集：issubset    例如：A.issubset(B)   A是B的子集，返回布尔值
                7、父集：issuperset        例如：A.issuperset(B)   A是B的父级，返回布尔值
        

        5、容器特性比较

 

            1、列表--字典：

                1、列表查找速度随着元素的增多而增多，而字典以键查找值，查找速度极快
                2、列表占用内存较小，而字典则占用较大内存（以空间换时间）

            2、列表--元组

                1、元组是被“束缚”着的列表
                2、列表能进行的元素修改、增删操作都无法在元组上实现
                3、二者都可以用下标查找元素