10、数据类型（列表、元组、字典）

一、列表

1、定义：

        有序可变元素集合；与字符串对比，字符串不可变，即不支持对元素赋值更改

2、列表的嵌套：

        列表中的元素也可以是列表

3、列表生成式：

        range(num)  #[0,num)

        range(start,stop,step)  #[start,stop)

        python2中直接生成，python3为节约空间，使用后才生成出来，eg：

        print(range(0,100000,10))=>range(0,100000,10)

4、列表推导式：

        （nums = [1, 2, 3, 4]）

        （1）映射解析（一一对应）：

                [表达式 for 变量 in 列表]，eg：

                print([num ** 2 for num in nums])=>[1, 4, 9, 16]

        （2）过滤（需要符合条件，可能现个数与原个数不同）：

                [表达式 for 变量 in 列表 if 条件]，eg

                print([num ** 2 for num in nums if num % 2 == 0])=>[4, 16]

5、增删改查+其他操作

        （1）增

                a、list.append(new)  #将元素追加到原列表中

                b、插入：list.insert(index,new)  #新元素的下标为index

                c、扩充：list.extend(可迭代对象)  #使用可迭代对象扩充原列表（与append的区别）

                nums = [1, 2, 3, 4]
                tu=(1,2,3,4)
                nums.extend(tu)
                print(nums)=>[1, 2, 3, 4, 1, 2, 3, 4]

                d、加、乘：有点像字符串的样子，但加只能连接两列表（这是与extend的区别）

        （2）删

                a、del语句：非函数或方法，可删除指定元素或直接删除整个变量，eg：del nums[2];  del nums;

                b、pop(index=-1)方法：返回弹出值，原列表也删除掉了该值。

                c、remove（object）方法：参数传入要删除的元素，从左边进行移除，没有返回值

        （3）改：

                list[index]=num，在查询中可以知道怎么找到想要找到的元素

        （4）查：

                a、获取单个元素items[index]

                b、获取元素索引index(value,start,end)从左到右找的

                c、查找列表中某一元素个数count(object)

                d、获取多个元素（与字符串切片同）list[::]

         （5）遍历

                a、根据元素遍历：for x in list:

                b、根据索引遍历：建立索引表，根据索引遍历

                ListIndex = range(len(list))
                for index in ListIndex:
                        print(list[index])

                c、遍历枚举对象

                        枚举对象：通过枚举函数生成的对象，可以将可以遍历的数据对象组成为一个索引序列。

                        索引序列：会同时列出数据下标和数据

                        方法：enumerate(可迭代对象，start=0)，start可以控制索引开始的值

                enu = enumerate(values)
                print(list(enu))=>[(0, 1), (1, 1), (2, 2)]

                d、使用迭代器遍历

                        1、判定可迭代对象：

                                人看能不能用for进行迭代遍历

                                函数判定：

                        from collections.abc import Iterable
                        print(isinstance(values, Iterable))=>True

                        2、迭代器：

                                大概像一个小机器，与可迭代对象关联，有一个指针在可迭代对象第一个元素之前，用next()函数就可以开始对每个元素进行迭代遍历

                        3、判断迭代器：

                                看是否可以作用于next()函数

                                函数判定：

                from collections.abc import Iterator
                print(isinstance(values, Iterator))=>False  #迭代器与可迭代对象不同
                i = iter(values)
                print(i)
                print(isinstance(i, Iterator))=>True
                from collections.abc import Iterable
                print(isinstance(i, Iterable))=>True  #但迭代器是可迭代对象

                        4、迭代器优势：

                                适用于大数据量集合，在迭代到某一元素后才处理元素，其他时候可以不处理该元素，有利于内存；提供了统一的访问接口，使得更加灵活。

                        5、迭代器使用

                it = iter(values)
                next(it)  #第一种
                next(it) #第一种
                next(it) #第一种
                for i in it:  #第二种
                    print(i)
                #这两种不能同时起作用，因为迭代器不能多次迭代

                        6、注意：取出完了再next()会报错StopIteration，迭代器不能多次迭代

        （6）判定：与字符串类似in、not in，同样的，元组字典都可用

         （7）比较：

                a、python2中cmp(o1，o2)函数：o1比o2大返回1,o1与o2同返回0,o1比o2小返回-1；若两个类型不同，比较类型首字母，比如tuple与list

                b、python3中直接使用逻辑比较符进行比较

        （8）排序：

                1、内建函数sorted(iter,key,reverse=False)：对所有可迭代对象进行排序，返回新列表

                        key是一个函数，eg：

                def getKey(x):
                    return x[1]

                        使用sorted，写key=getKey不写小括号，加小括号指调用函数，而此处我们需要在函数内部进行运行：

                stu = [("std2", 18), ("std1", 20), ("std3", 16)]
                resu=sorted(stu)
                print(resu)=>[('std1', 20), ('std2', 18), ('std3', 16)]
                resu1=sorted(stu, key=getKey)
                print(resu1)=>[('std3', 16), ('std2', 18), ('std1', 20)]

                2、list.sort(key,reverse=False)为列表对象方法，与上述区别为不产生新的列表，修改原列表

        （9）打乱：使用random.shuffle(list)进行打乱，直接改变本身

        （10）反转：list.reverse()直接改变本身;切片反转list[::-1]返回列表不改变本身   

二、元组：有序不可变的元素集合

1、定义单个元素的元组：tu=（ele,）#若写的是 tu=（ele）会被编译器解释为int类型，括号用于提升优先级

2、定义多个元素的元组：就逗号分隔就好，元素可多样，元组也可嵌套

3、多个对象以逗号分隔，视为元组

tuple=1,1,2,3,'sad'
print(tuple)=>(1, 1, 2, 3, 'sad')

4、可将列表使用tuple(list)转化为元组

5、操作：

        （1）不可增删改，查与前面同：单个用下标，多个用切片，反转步长相同

        （2）获取：与列表相同对象方法.count(obj)、.index(obj)、len()、max()、min()

        （3）判定：与列表同

        （4）比较：与列表同

        （5）拼接：与列表同。但拼接并不改变元组，因为元组是不可改变的有序集合

        （6）拆包：

        这是一种拆包：tuple=（val1,val2）        tuple[0],tuple[1]

        交换的一个方法就是拆包，先包装为一个元组，再赋值回去

        a,b=1,2
        b,a=a,b
        print(a,b)

三、字典

1、定义（无序的可变键值对集合）

        （1）直接写花括号和键值对

        （2）静态方法（类和对象都可以调用，通常使用类型调用）dict.fromkey(sep,value)

        print(dict.fromkeys("abc", 123))=>{'a': 123, 'b': 123, 'c': 123}

        （3）key不能重复，key必须为不可变类型，可变（列表、字典、可变集合，可以通过查看改变值之后id有没有变来判断是否为可变类型，改值id不变为可变类型比如列表）

        （4）字典存储采用哈希表，将key通过哈希函数映射为整数，再对数组长度进行取余得到数组下标，哈希冲突采用开放定址法

        （5）通过key查找更有意义，且提高了查询效率

2、操作：

        （1）增：dict[key]=value

        （2）删：

                del dict[key]

                val=pop(key[,default])  #若key不存在，返回default，若没写default参数，报错。

                dic.popitem()删掉了最后一个键值对并以元组的形式返回

                dic.clear()字典本身还存在，只是将内容全删掉了

        （3）改：

                dict[key]=xxx

                批量改：dictOld.update(dictNew)，key存在的改掉，不存在的添加

        （4）查询：

                dict[key]，找不到key会报错

                dict.get(key,default)，找不到key，如果没传default返回None，否则返回default

                dict.setdefault(key,default)，与get不同，要是找不到会额外增加新的键值对

        （5）获取值

                dict.values()， dict.keys()， dict.items()返回值为字典的视图对象dict_items([('age', 21), ('address', 'sc')])，也就是会随着字典更新而变化，可以将其转化为元组或列表再使用下标查询；而python2中返回的是列表，可以通过下标查询，想获得3中的效果需要使用 dict.viewvalues()， dict.viewkeys()， dict.viewitems()。

        （6）遍历

                根据key遍历，dict.keys()；根据item遍历，dict.items()；

        （7）计算：len(dict)

        （8）判定：in，not in，但只能判定key在不在

补充：

1、列表删除操作时，谨慎使用for x in list: if 语句:操作：78-Python常用数据类型操作-列表-常用操作-删除操作_哔哩哔哩_bilibili

list = [2, 2, 2, 2, 2, 2, 2, 2, 2]
for x in list:
    if x == 2:
        list.remove(2)
print(list)=>[2, 2, 2, 2]  #执行remove后整体元素会往前平移，有些元素会被判定忽略

2、元组的解包：一对一关系，idx,val=(0,'a'),可以通过idx和val取出数据

        for idx, val in enumerate(values):
            print(idx, val)

3、但是关于枚举对象遍历，我不知道为什么不可以这样

        enu = enumerate(values)
        for idx, val in enu:
            print(idx, val)