1. 前言

序列是一块用来存放多个值的内存空间.Python中常用的数据结构有列表,元组,字典,字符串,集合等. 本篇文章主要讲解列表的常见操作.

2. 列表的定义

列表是python中内置的可变序列,是包含若干元素的有序连续内存空间

所有的元素存放在 [] 中

元素之间用逗号隔开

列表的定义有两种方式:

使用字面值创建列表

使用list()创建列表

实例：

# 使用使用字面值创建列表
# []就代表一个空列别
a = []
print(type(a))
# 使用list()创建列表
b = list()
print(type(b))
# 输出的结果为：
# 
#

列表可以在定义时进行初始化，但与C/Java等里面的数组不同的是，数组只能放同一类型的变量，例如整型数组就只能放整数类型的元素，而列表不同，列表可以存放不同数据类型的元素

示例：

a = [1,2,3]
print(a)
# 输出[1, 2, 3]
b = list((1,2,3))
print(b)
# 输出[1, 2, 3]
c = [1,1.2,"ads",False,[1,2,3]];#也可以存放列表的数据
print(c)
# 输出[1, 1.2, 'ads', False, [1, 2, 3]]

3. 列表的下标访问

对列表的元素，可以通过 列表名[下标] 这种形式进行访问

注意：这里的下标都是从0开始的 ，下标的有效范围是0到列表长度-1

如果超出下标的有效范围，那么就会出现异常

列表的长度可以直接使用内置函数len(列表名)获取

len()不止能求列表的长度，也可以求字符串、元组、字典等这个类型的长度

# 下标的范围[0,2]
a = [1,2,3]
print(len(a))
# 输出结果：3
print(a[1]) #对列表的元素进行访问
# 输出结果：2
a[2] = 5 #对列表的元素进行修改
print(a)
# 输出结果：[1, 2, 5]

python中的下标也可以写成负数的形式

a = [1,2,3]
print(a[len(a)-1])
# 输出结果：3
print(a[-1])
# 输出结果：3

对于这里面的-1可以理解为len(列表名)-1把len(列表名)这个给省略了，也可以理解为是倒数第一个元素，只要能记住，大家怎么理解都行

如果是用负数表示下标，那么下标的有效范围就是[-len(列表名)，-1]

3.1 嵌套列表的下标

在讲列表定义的时候说过列表的元素类型不限制,当然也就可以在列表中存放列表

示例:

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

对于这种列表里面是嵌套的列表,也是支持下标索引的

例如:

a = [[1, 2, 3], [4, 5, 6]]
print(a[0][1])
# 输出结果:
# 2

上面的代码可以分成两步进行理解:

可以把[1,2,3]和[4,5,6]看出是a列表中的两个元素,a[0]就是得到[1,2,3]这个列表

a[0][1]就相当于访问了[1,2,3]这个列表的第二个元素,所以输出结果为2

4. 列表的切片操作

切片操作使Python中有序序列的重要操作之一. 切片操作的本质上是截取一段子序列.

语法格式为: [start: stop: step]

start: 切片的开始位置

stop: 切片的结束位置(但不包含这个位置)

step: 切片的步长,步长可以省略时默认是1,如果是省略可以顺便省略最后一个冒号

示例1:

a = [1, 2, 3, 4, 5, 6, 7]
print(a[2:5])
# 输出结果:
[3, 4, 5]

列表的下标从0开始,因此下标为2的值为3,5下标的值是6,因为是不包含5这个下标的,且默认的步长为1,因此切片出来的值为[3,4,5].

切片操作是很灵活的,除了步长可以省略,前面的两个表示范围的数字也是可以省略的

示例2:

a = [1, 2, 3, 4, 5, 6, 7]
print(a[:])
# [1, 2, 3, 4, 5, 6, 7]
print(a[3:])
# [4, 5, 6, 7]
print(a[:3])
# [1, 2, 3]
print(a[:-1])
# [1, 2, 3, 4, 5, 6]

当前面两个数都省略时,表示的就是整个列表.

省略结束位置,就是从开始位置一直到列表结束

省略开始位置,就是从0下标一直到结束位置(不包括结束位置)

切片操作中的位置也可以写成负数形式

示例3:

带有步长的切片

a = [1, 2, 3, 4, 5, 6, 7]
print(a[::2])
#[1, 3, 5, 7]

步长除了取整数,也可以是负数.如果步长为负数则代表是从后往前取.

a = [1, 2, 3, 4, 5, 6, 7]
print(a[::-1])
# [7, 6, 5, 4, 3, 2, 1]

需要注意的是与下标访问列表元素不同,切片操作不会因为下标越界而抛出异常.而是尽可能地获取到所需要的元素

示例4:

a = [1, 2, 3, 4, 5, 6, 7]
print(a[:100])
# [1, 2, 3, 4, 5, 6, 7]

虽然上面我想要获取的列表元素是a列表下标从0开始到100位置(不包括100)之间的元素,但a列表的长度是远远不够100的,所以在进行切片时,在a列表的尾部时就进行截断了.因此使用切片操作可以使代码具有更强的健壮性

5. 列表的遍历

5.1 使用for循环进行遍历

使用for循环遍历列表有两种方式

方法1:

a = [1, 2, 3]
for elem in a:
    print(elem)
# 1
# 2
# 3

上述代码中,elem相当于使一个临时变量,值就是a列表中的每一个元素

方法2:

a = [1, 2, 3]
for i in range(len(a)):
    print(a[i])
# 1
# 2
# 3

5.2 while循环进行遍历

a = [1, 2, 3]
i = 0
while i < len(a):
    print(a[i])
    i += 1
# 1
# 2
# 3

6.添加列表元素

在列表中新增元素有两种方式,一种是 使用append方法,另一种是使用insert方法

6.1 使用append方法添加元素

append方法是往列表的末尾新增元素,使用的方法很简单

语法: 列表名.append(新增元素)

a = [1, 2, 3]
a.append(4)
print(a)
# [1, 2, 3, 4]

6.2 使用insert方法添加元素

与append方法不同,insert方法可以往指定位置新增元素.

a = [1, 2, 3]
a.insert(1, 'insert')
print(a)
# [1, 'insert', 2, 3]

需要注意的是,如果指定的位置超过了列表的长度,只会插入列表的末尾

a = [1, 2, 3]
a.insert(100, 'insert')
print(a)
# [1, 2, 3, 'insert']

7. 列表的拼接

7.1 使用 + 进行拼接

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)
# [1, 2, 3, 4, 5, 6]

使用 + 拼接本质上是产生了一个更大的列表,不会修改原来的列表

7.2 使用extend 进行拼接

extend 是在原有的列表基础上将另外一个列表进行拼接. 这个方法会修改原来的列表

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
# [1, 2, 3, 4, 5, 6]

7.3 使用 += 进行拼接

a = [1, 2, 3]
b = [4, 5, 6]
a += b
print(a)
# [1, 2, 3, 4, 5, 6]

8. 列表的常用方法

以下是列表中一些常用的内置函数:

方法 说明

列表名.append(x) 将元素x添加到列表的最后位置

列表名.extend(L) 将列表L中的所有元素添加到列表的尾部

列表名.insert(index,x) 在列表的index位置插入元素x

列表名.remove(x) 在列表中删除首次出现的元素x

列表名.pop([index]) 删除并返回列表对象的指定位置的元素,默认为最后一个元素

列表名.clear() 删除列表中所有元素,但保留列表对象

列表名.index(x) 返回第一个值为x的元素下标,做不存在x,则抛出异常

列表名.count(x) 返回指定元素x在列表中的个数

列表名.reverse() 对列表元素进行原地翻转

列表名.sort(key=None,reverse=False) 对列表元素进行原地排序

列表名.copy() 对列表元素进行浅拷贝

len(列表名) 统计列表中元素的个数