python基础——列表

python基础——列表

介绍

名称：list

定界符：[]

形式：listname=[元素1，元素2…,元素n]

元素特点：同一个列表的元素的数据类型可以各不相同，可以是实数，字符，等等特殊的是元素可以是列表，因为使用列表的话可以来回嵌套，形成多维列表，解决复杂问题的时候会很方便。

如上图完成基础列表的创建，内部元素是元组，构成多维"数组"（上述的元组可以替换成列表，字符串，字典等）

其他：

• 内置数据可变
• 有序，使用下标（类似c的数组）
• 元素查找速度很慢
• 在列表尾部新增和删除元素速度快，但是在其他位置比较慢
• 列表的长度可变，当列表的元素增加或者删除的时候，列表的长度会自动扩展或者收缩

创建

可以使用直接赋值法和list()函数调用

直接赋值，可以赋值空列表和列表

list()函数调用，也就是将其他的数据类型转化为列表

首先，我们先进行对他的简单使用

上述完成了不同数据类型的转化，可以发现，他们都是可迭代对象（Iterable），那么什么是可迭代对象呢，Python中，列表、元组、字典、集合、字符串等类型的数据可以使用for ..in...的语法从其中依次取到数据来使用，这样的过程称为遍历，也叫迭代（如果不太理解的话，可以在完成循环的学习之后再来看这个）。其中字典转化时，只保留了key值，具体部分在字典篇会有详解。

其中迭代对象和迭代器的部分可以看一下下面这个视频，如果理解不了也不影响这一块的学习。

『教程』几分钟听懂迭代器_哔哩哔哩_bilibili

访问

索引访问

列表中，比较经典的就是索引访问了

索引访问分为正向访问和逆向访问

正向访问从0开始，正向加即可

逆向访问从-1开始，依次递减

for循环访问

注意：

索引下表如果超过范围的话，就会报错；访问空列表的话，不能用索引访问。

index（）函数使用

获取参数在主体中出现的首次位置

下图是函数在列表中的使用，当要查找的数不在列表中时，会报错

同理也可以在字符串中使用

上图是一个常见的错误，如果搜索z，那么系统会认为z是一个变量名，错误。我们要查找的是字符z，所以要用字符表示的’z‘。

同理，元组也可以使用index（）函数查找，但是字典不可以。

计数

计数主要我认为是两个函数的使用，一个是len(),另一个是count()

len（）

将列表作为参数放入括号中就可以计算出参数的长度，同理元组，字符串，字典，集合等都可以作为参数。

count（）

获取参数在主体中出现的次数，如不出现则为0，不会报错

sum()

对列表的元素进行求和运算，对非数值型列表运算需要指定start参数，同样适用于元组、range

sum(x,start=0) 返回序列x所有元素之和，返回start+sum(x)

>>> sum(range(1, 11))      #sum()函数的start参数默认为0
55
>>> sum(range(1, 11), 5)   #指定start参数为5，等价于5+sum(range(1,11))
60

max()和min()

max(列表)、min(列表)：返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。

修改

首先要搞清楚python列表的内存管理形式

列表中包含的是元素值的引用，而不是直接包含元素值

下标修改元素

通过下标来修改序列中元素的值或通过可变序列对象自身提供的方法来增加和删除元素时，序列对象在内存中的起始地址是不变的

a和b指向指向同一个内存，修改时相互影响！

在此补充浅复制和深复制

1）浅复制：复制父对象，不会复制对象的内部的子对象。

2）深复制：完全复制了父对象及其子对象

浅复制举例 （第一层修改没有影响,更深层次修改有影响）

import copy
a=[1,2,3,[1,2,3,[5,6]]]
c= copy.copy(a) //浅拷贝
c[3][0]=9
    c[1]=0

深复制举例（对于a和d，d是一个全新的 列表，和a互不影响)

import copy
a=[1,2,3,[1,2,3,[5,6]]]
c= copy.copy(a) //浅拷贝
c[3][0]=9
c[1]=0
d=copy.deepcopy(a) //深拷贝

增加

+运算符在列表中的使用

相应的对应内部内存管理

严格意义上来讲，这并不是真的为列表添加元素，而是创建了一个新列表，并将原列表中的元素和新元素依次复制到新列表的内存空间。由于涉及大量元素的复制，该操作速度较慢，在涉及大量元素添加时不建议使用该方法。

为验证以上结论，查询他们的地址

append()

使用列表对象的append()方法在当前列表尾部追加元素，原地修改列表（不改变列表在内存中的首地址），是真正意义上的在列表尾部添加元素，速度较快。

+=运算符

适用范围：+=操作数是序列类型，把列表和元组、集合、字典甚至map对象、range对象里的元素连接到一起。append适用于列表.

extend()

使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()方法来增加列表元素也不改变其内存首地址，属于原地操作

insert()

使用列表对象的insert()方法将元素添加至列表的指定位置

列表的insert()可以在列表的任意位置插入元素，但由于列表的自动内存管理功能，insert()方法会引起插入位置之后所有元素的移动，这会影响处理速度。

用乘法来扩展列表对象

将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复

当使用*运算符将包含列表的列表重复并创建新列表时，并不是复制子列表值，而是复制已有元素的引用。因此，当修改其中一个值时，相应的引用也会被修改

删除

del删除，删除指定位置上的元素，也就是用索引删除

remove函数删除元素首次出现元素的地方，当不存在此函数的时候抛出异常

pop函数删除，使用列表的pop(i)方法删除并返回指定位 置i（默认为最后一个）上的元素，如果给定的索引超出了列表的范围则抛出异常。

重点例题讲解

删除此列表的所有1

>>> x = [1,2,1,2,1,2,1,2,1]
>>> for i in x:
        if i == 1:
           x.remove(i)
>>> x
>>>[2, 2, 2, 2]

>>> x = [1,2,1,2,1,1,1]
>>> for i in x:
        if i == 1:
            x.remove(i)
>>> x
>>>[2, 2, 1]

上面的两个解决思路都是错误的，出现这个问题的原因是列表的自动内存管理功能。在删除列表元素时，Python会自动对列表内存进行收缩并移动列表元素以保证所有元素之间没有空隙，增加列表元素时也会自动扩展内存并对元素进行移动以保证元素之间没有空隙。每当插入或删除一个元素之后，该元素位置后面所有元素的索引就都改变了。

正确的解决思路是

>>> x = [1,2,1,2,1,1,1]
>>> for i in x[::]:
        if i == 1:
           x.remove(i)

或者逆向

>>> x = [1,2,1,2,1,1,1]
>>> for i in range(len(x)-1,-1,-1):  
        if x[i]==1:
            del x[i]

成员资格判断

in和not in操作符：使用in和not in来判断一个元素是否存在于列表中，返回结果为“True”或“False”。

>>> aList[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
>>> 3 in aList
True
>>> 18 in aList
False
>>> bList = [[1], [2], [3]]
>>> 3 in bList
False
>>> [3] in bList
True

切片

接下来是列表之中最重要的一个部分

切片使用2个冒号分隔的3个数字来来截

第一个数字表示切片开始位置（默认为0）。

第二个数字表示切片截止（但不包含）位置（默认为列表长度）。

第三个数字表示切片的步长（默认为1），当步长省略时可以顺便省略最后一个冒号。例如[2:4],[2:4:1]

左闭右开

切片操作一使用切片获取列表部分元素 使用切片可以返回列表中部分元素组成的新列表。与使用索引作为下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::] #返回包含所有元素的新列表

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[::-1] #逆序的所有元素

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

>>> aList[::2] #偶数位置，隔一个取一个

[3, 5, 7, 11, 15]

>>> aList[1::2] #奇数位置，隔一个取一个

[4, 6, 9, 13, 17]

>>> aList[3::] #从下标3开始的所有元素

[6, 7, 9, 11, 13, 15, 17]

>>> aList[3:6] #下标在[3, 6)之间的所有元素

[6, 7, 9]

>>> aList[0:100:1] #前100个元素，自动截断

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[100:] #下标100之后的所有元素，自动截断

[]

>>> aList[100] #直接使用下标访问会发生越界

IndexError: list index out of range

>>> aList[-15:3] #进行必要的截断处理

[3, 4, 5]

>>> len(aList)

10

>>> aList[3:-10:-1] #位置3在位置-10的右侧，-1表示

反向切片

[6, 5, 4]

>>> aList[3:-5] #位置3在位置-5的左侧，正向切片

[6, 7]

使用切片为列表增加元素

可以使用切片操作在列表任意位置插入新元素，不影响列表对象的内存地址，属于原地操作。

>>> aList = [3, 5, 7]

>>> aList[len(aList):]

[]

>>> aList[len(aList):] = [9] #在列表尾部增加元素

>>> aList[:0] = [1, 2] #在列表头部插入多个元素

>>> aList[3:3] = [4] #在列表中间位置插入元素

>>> aList

[1, 2, 3, 4, 5, 7, 9]

使用切片替换和修改列表中的元素

>>> aList = [3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3] #替换列表元素

>>> aList

[1, 2, 3, 9]

>>> aList[3:] = [4, 5, 6] #切片连续，等号两边的列表长度可以不相等

>>> aList

[1, 2, 3, 4, 5, 6]

>>> aList[::2] = [0]*3 #隔一个修改一个

>>> aList

[0, 2, 0, 4, 0, 6]

>>> aList[::2] = ['a', 'b', 'c'] #隔一个修改一个

>>> aList

['a', 2, 'b', 4, 'c', 6]

>>> aList[1::2] = range(3) #序列解包的用法

>>> aList

['a', 0, 'b', 1, 'c', 2]

>>> aList[1::2] = zip('abc', range(3)) #map、filter、zip对象都支持这样的用法

>>> aList

['a', ('a', 0), 'b', ('b', 1), 'c', ('c', 2)]

>>> aList[::2] = [1] #切片不连续时等号两边列表长度必须相等

ValueError: attempt to assign sequence of size 1 to extended slice of 
size 3

使用切片删除列表中的元素

>>> aList = [3, 5, 7, 9]
>>> aList[:3] = [] #删除列表中前3个元素

>>> aList

[9]

也可以结合使用del命令与切片结合来删除列表中的部分元素，并且切片元素可以不连续

>>> aList = [3, 5, 7, 9, 11]
>>> del aList[:3] #切片元素连续

>>> aList

[9, 11]

>>> aList = [3, 5, 7, 9, 11]
>>> del aList[::2] #切片元素不连续，隔一个删一个

>>> aList

[5, 9]

切片返回的是列表元素的浅复制

列表排序

使用sort（）函数排序

>>> aList.sort() #默认是升序排序

>>> aList.sort(reverse = True) #降序排序

>>> aList.sort(key = lambda x:len(str(x)))
#按转换成字符串的长度排序
升序

使用内置函数sorted（）对列表进行排序并返回新表

>>> aList

[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]

>>> sorted(aList) #升序排序

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> sorted(aList,reverse = True) 
#降序排序

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

列表使用reserve（）进行排序

>>> aList = [3, 4, 5, 6, 7, 9, 11, 
13, 15, 17]
>>> aList.reverse()

>>> aList

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

使用内置函数reversed()对列表元素进行逆序排列并返回迭代对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HOb9lt0V-1668673833230)(C:\Users\zfy\AppData\Roaming\Typora\typora-user-images\image-20221101192558047.png)]

= lambda x:len(str(x)))
#按转换成字符串的长度排序
升序

**使用内置函数sorted（）对列表进行排序并返回新表**

```python
>>> aList

[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]

>>> sorted(aList) #升序排序

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> sorted(aList,reverse = True) 
#降序排序

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

列表使用reserve（）进行排序

>>> aList = [3, 4, 5, 6, 7, 9, 11, 
13, 15, 17]
>>> aList.reverse()

>>> aList

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

使用内置函数reversed()对列表元素进行逆序排列并返回迭代对象