python_列表笔记

 

目录

1. 列表简介：

2. 列表的创建：

3. 列表的方法：

    3.1 增加、删除

     3.2 列表元素的访问

     3.3 slice切片截取

     3.4 列表的遍历、排序           

     3.5 多维列表

---

1. 列表简介：

     用来存储任意类型任意数量的数据集合
    内存分析：是一块连续的内存空间，列表中存放的是对象的地址，例如s=[1,'a']，该对象s指向了一块连续的内存空间，内存空间
    中存放的是对象1、对象‘a’的内存地址

2. 列表的创建：

    2.1 定义创建：
        list = [1,2,'s']
    2.2 list()创建，所有能够用来迭代的均可以用这种方式来创建
        list = list() #创建了一个空列表对象
        list = list('wuhengtao') #创建了一个列表对象，内容为w/u/h/e/n/g....
    2.3 range()转化为序列
        list = list(range(0,10,1)) #创建了一个从0到9的列表对象
    2.4 推导式创建列表
        list = [x * 2 for x in range(5)] #意思是，将X值×2，循环0-4的数值
        输出就是0、2、4、6、8
        联合判断语句：
        list = [x * 2 for x in range(100) if x % 9 == 0]
        

3. 列表的方法：

 

常用方法
    list.append(x)             增加元素     将元素X增加到列表的尾部
    list.extend(aList)         增加元素    将列表aList所有元素加到列表list尾部
    list.insert(index,x)    增加元素    在列表指定位置index处插入元素x
    list.remove(x)            删除元素    在列表中删除首次出现的元素x
    list.pop([index])        删除元素    删除并返回list指定位置index处的元素，默认是最后一个元素
    list.clear()            删除所有元素    但不删除列表对象
    list.index(x)            访问元素    返回第一个x的索引位置，如果不存在抛出异常
    list.count(x)            统计        统计x在列表中出现的次数
    len(list)                长度        返回列表中包含元素的个数/长度
    list.reverse()            翻转列表    将列表中的数据原地翻转 1,2,3,4 >>> 4,3,2,1
    list.sort()                排序        列表中的元素原地排序
    list.copy()                浅拷贝        返回列表的浅拷贝数据：
                                        (初步认识，可能不准确)
                                        浅拷贝：对于序列来说，浅拷贝只会拷贝第一层数据，也就是列表的对象对应的连续内存对空地址，并不会将连续内存空间上的具体每一个内存重新创建
                                        深拷贝：拷贝第一层数据的同时，还会拷贝内存空间中每一个内存地址进行重新创建
                                        EXP：
                                            list=[1,2,'a']
                                            #浅拷贝
                                            listCopy = copy.copy(list) #此时，listCopy是一个新对象，但是该对象[1,2,'a']中每一个对象的内存地址还是以前(list中)的
                                            #深拷贝
                                            listDeepCopy = copy.deepcopy(list) #此时，listDeepCopy是一个新对象，并且该对象中的每一个对象也都是新创建的对应了新的内存地址

    3.1 增加、删除

        在操作时，尽量不要在列表的中间进行增加和删除，尽量在尾部。因为列表的中间添加数据时，后面的数据会对内存进行挨个复制进行重新赋值。
        3.1.1 append():在列表的尾部添加元素，是效率最快，最推荐的方式(不会产生新对象)
            a = [10,20]
            a.append(30)
            a = [10,20,30]
        
        3.1.2 +：通过+来拼接列表，但是这种操作会产生很多赋值操作，不建议(产生了新对象)
            a=[10,20] # a是一个对象
            a = a + [30] # [30]又产生了一个对象，并且a+[30]又产生了一个新对象，最终赋值给a,a对象的地址已经发生了改变
            >>>[10,20,30]
        
        3.1.3 extend()：原地操作，将目标列表的所有元素添加至本列表的尾部，不产生新对象,适用于两个列表拼接
            a=[10,20]
            a.extend([50,60])
            >>>[10,20,50,60]
        3.1.4 insert():在列表的指定位置插入元素，设计大量列表操作时，尽量避免使用，因为设计到很多赋值操作
            a=[10,20,30]
            a.insert(1,100)
            >>>[10,100,20,30]
        3.1.5 乘法扩展
            a=[10]
            b = a * 3
            >>>b=[10,10,10]
        3.1.6 del删除：实际上是将后面的下标复制然后移动位置
            a=[1,2,5,3,4]
            del a[2]
            >>>[1,2,3,4]
        3.1.7 pop():删除指定位置的元素，并将该元素返回，如果没有指定，默认删除最后一个元素
            a=[10,20,30,40]
            b=a.pop()  #此时b=40 a=[10,20,30]
            c=a.pop(1) #此时指定删除下标为1的元素，c=20, a=[10,30]
        3.1.8 remove(),删除首次出现的制定元素，不是下标，如果不存在则刨出异常
            a=[10,20,30,410]
            a.remove(410) #删除410这个元素

     3.2 列表元素的访问

  对于一个列表元素，我们时常需要进行访问来完成各种操作。

       a = [1,2,3,4,5,6,7,8,9]

       3.2.1 通过下标访问：a[1]=2:访问列表中第二个元素，但是下标不能超过列表长度，否则会抛出异常

       3.2.2 index(): 

                 a.index(5)=4  在列表a中搜索5的首次出现的位置

                 a.index(5,2,8)=4 范围搜索列表a中从第二个元素开始到第八个元素结束，5出现的位置

        3.2.3 count()

                 返回指定元素在列表中出现的次数

                a.count(5)=1   表示5这个元素在列表a中出现了一次

        3.2.4 len()

                返回列表的长度：len(a)=10  表示列表a一共有十个元素

        3.2.5 成员资格判断

                 判断20在列表a中是否存在  20 in a  >>>false

     3.3 slice切片截取

                语法：[start:end:step] --- [开始下标:结束下标:步长]

                注意：截取的结尾下标是不被包含的，即包头不包尾 

                EXP：a=[1,2,3,4,5,6,7]

               a[1,5,1]=[2,3,4,5] 意思是从下标为1开始截取到下标为5的，步长为1

               a[1::2]=[2,4,6]  意思是从第二个开始到结束，步长为2

     3.4 列表的遍历、排序           

             for x in a:

                  print(x)

            排序：a.sort()，即可完成让列表a正序排序并且不会生成新对象

                       a = sorted(a) 这是生成新对象并且完成排序

                       max(a)/min(a)/sum(a) 最大值、最小值、求和(适用于元素类型均为整数时)

     3.5 多维列表

            概念：多维列表就是列表里面的元素也是列表,EXM:table=[1,2,3,[10,20,30],['A','B']]

           可以通过下标的方式进行访问:table[3][0]=10,意思就是访问的table列表的第四个下标值的第0个下标值