【Python】列表

文章目录

• 前言
• 一、列表
• 二、创建列表
• • 1. 创建空列表
  • 2. 创建非空列表
• 三、操作列表
• • 1. 新增列表元素
  • • 1.1 `append`方法
    • 1.2 `insert`方法
  • 2. 删除列表元素
  • • 2.1 `pop`方法
    • 2.2 `remove`方法
  • 3. 查找列表元素
  • • 3.1 `in/not in`操作符
    • 3.2 `index`方法
    • 3.3 下标访问列表元素
  • 4. 修改列表元素
  • 5. 遍历列表元素
  • • 5.1 `for`循环遍历列表
    • 5.2 `while`循环遍历列表
  • 6. 子列表提取
  • • 6.1 `[start:stop]`
    • 6.2 切片时忽略边界
    • 6.3 切片时指定步长
    • 6.4 切片时下标允许越界
  • 7. 拼接列表
  • • 7.1 使用`+`拼接两个列表
    • 7.2 使用`+=`操作符
    • 7.3 `extend`方法
• 四、列表常用接口
• • 1. 列表操作
  • 2. 列表的成员函数
• 总结

前言

本文主要介绍Python中的数据类型——列表的相关概念。

一、列表

列表（list）是一种有序和可更改的集合，列表中允许存在重复元素，允许存在不同类型的元素。

二、创建列表

1. 创建空列表

在python中[]表示一个空列表

a = []
print(type(a)) # <class 'list'>
print(a) # []

使用list()函数也可以创建一个空列表

a = list()
print(type(a)) # <class 'list'>
print(a) # []

2. 创建非空列表

创建列表时可以设置初始值

a = [1, 3, 2.2, 'Jinger']
print(type(a)) # <class 'list'>
print(a) # [1, 3, 2.2, 'Jinger']

三、操作列表

1. 新增列表元素

1.1 append方法

append方法可以在列表末尾增加一个元素

a = [1, 3.0, 2.2]
a.append('Jinger')
print(type(a)) # <class 'list'>
print(a) # [1, 3.0, 2.2, 'Jinger']

1.2 insert方法

insert方法可以在任意指定下标（支持负索引）插入一个元素

a = [1, 3.0, 2.2]
a.insert(1, 'Jinger')
print(type(a)) # <class 'list'>
print(a) # [1, 'Jinger', 3.0, 2.2]
a.insert(–1, 'Hello')
print(type(a)) # <class 'list'>
print(a) # [1, 'Jinger', 3.0, 'Hello', 2.2]

负索引： 我们常说的下标都是从列表第一个元素开始往后，从0开始计数的，而负索引则是从列表最后一个元素开始往前，依次为-1, -2, -3… 因此想要访问列表的最后一个元素，直接访问下标为-1的元素即可。

注意： 如果指定下标超出列表中的最大下标，则插入到列表末尾（如果为负索引，则插入列表首部）

a = [1, 3.0, 2.2]
a.insert(100, 'Jinger')
print(type(a)) # <class 'list'>
print(a) # [1, 3.0, 2.2, 'Jinger']
a.insert(–100, 'Hello')
print(type(a)) # <class 'list'>
print(a) # ['Hello', 1, 3.0, 2.2, 'Jinger']

2. 删除列表元素

2.1 pop方法

pop方法可以删除列表的末尾元素，或者删除指定下标的元素

a = [1, 3.0, 2.2]
a.pop()
print(type(a)) # <class 'list'>
print(a) # [1, 3.0]
a.pop(1)
print(type(a)) # <class 'list'>
print(a) # [1]

2.2 remove方法

remove方法可以删除列表中指定的元素

a = [1, 3.0, 2.2, 3.0]
a.remove(3.0)
print(type(a)) # <class 'list'>
print(a) # [1, 2.2, 3.0]

注意： 当列表中存在重复元素时，使用remove方法仅能删除第一次出现的元素

3. 查找列表元素

3.1 in/not in操作符

in/not in操作符可以判断某个元素是否在列表中，如果存在则返回True，不存在则返回False

a = [1, 3.0, 2.2, 3.0]
print(3 in a) # True
print(3 not in a) # False
print(type(a)) # <class 'list'>
print(a) # [1, 3.0, 2.2, 3.0]

3.2 index方法

index方法可以查询指定元素在列表中的下标

a = [1, 3.0, 2.2, 3.0]
print(a.index(2.2)) # 2

3.3 下标访问列表元素

通过[]下标访问操作符可以获取到列表中对应下标的元素（支持负索引）

a = [1, 3.0, 2.2, 3.0]
print(a[3]) # 3.0

4. 修改列表元素

通过[]下标访问操作符还可以修改列表中对应下标的元素的值

a = [1, 3.0, 2.2, 3.0]
a[3] = 4
print(a) # [1, 3.0, 2.2, 4]

5. 遍历列表元素

5.1 for循环遍历列表

Python中的for循环可以直接遍历列表中的元素

a = [1, 3.0, 2.2, 3.0]
for iter in a:
print(iter)

但是对iter进行更改时，列表中的元素不会受到影响（可以理解为是将列表中对应元素的值赋值给了变量iter，所以修改iter不会影响到列表中的元素）

a = [1, 3.0, 2.2, 3.0]
for iter in a:
iter += 1
print(iter) # 2 4.0 3.2 4.0
print(a) # [1, 3.0, 2.2, 3.0]

如果想要通过for循环来修改列表中的元素，可以使用for循环遍历列表元素下标的方式，遍历列表中的元素

a = [1, 3.0, 2.2, 3.0]
n = len(a)
for i in range(n):
a[i] += 1
print(a[i]) # 2 4.0 3.2 4.0
print(a) # [2, 4.0, 3.2, 4.0]

5.2 while循环遍历列表

while循环也可以通过变量列表元素下标的方式来访问列表元素

a = [1, 3.0, 2.2, 3.0]
n = len(a)
i = 0
while i in range(n): # 或者使用 while i < n
a[i] += 1
print(a[i]) # 2 4.0 3.2 4.0
i += 1
print(a) # [2, 4.0, 3.2, 4.0]

6. 子列表提取

6.1 [start:stop]

以[start:stop]的方式可以从列表中提取出：从start起始下标开始，到stop结束下标结束的一组元素（左闭右开）

a = [1, 3.0, 2.2, 3.0]
b = a[1:2]
c = a[0:2]
d = a[0:3]
print(a) # [1, 3.0, 2.2, 3.0]
print(b) # [3.0]
print(c) # [1, 3.0]
print(d) # [1, 3.0, 2.2]

6.2 切片时忽略边界

提取子列表的过程也称作切片的过程，以[start:stop]的方式进行切片时可以忽略起始下标和结束下标

• 如果以[start:]的方式进行切片，则子列表的元素包括起始下标的元素及其后续所有元素；
• 如果以[:stop]的方式进行切片，则子列表的元素包括结束下标之前的所有元素，不包括结束下标的元素
• 如果以[:]的方式进行切片，则子列表的元素包括原列表的所有元素

a = [1, 3.0, 2.2, 3.0]
b = a[1:2]
c = a[1:]
d = a[:2]
e = a[:]

print(a) # [1, 3.0, 2.2, 3.0]
print(b) # [3.0]
print(c) # [3.0, 2.2, 3.0]
print(d) # [1, 3.0]
print(e) # [1, 3.0, 2.2, 3.0]

注意： 切片时所用下标支持负索引

a = [1, 3.0, 2.2, 3.0]
b = a[–3:–1]
print(a) # [1, 3.0, 2.2, 3.0]
print(b) # [3.0, 2.2]

6.3 切片时指定步长

以[start:stop:step]的方式切片可以指定step步长（每访问一个元素后下标自增几步），例如

a = [1, 3.0, 2.2, 3.0]
b = a[0:3:2]
print(a) # [1, 3.0, 2.2, 3.0]
print(b) # [1, 2.2]

注意： 指定的步长可以为负数，表示从后往前提取元素 当步长为负数时，会从右向左遍历（反向切片），start默认为最后一个元素，stop默认为第一个元素（不包括），只有start大于stop才能切到元素，例如

a = [1, 3.1, 2.2, 3.0]
b = a[::–1]
c = a[3:0:–1]
d = a[–1::–2]
print(a) # [1, 3.1, 2.2, 3.0]
print(b) # [3.0, 2.2, 3.1, 1]
print(c) # [3.0, 2.2, 3.1]
print(d) # [3.0, 3.1]

6.4 切片时下标允许越界

如果在切片时，指定的下标超出了有效范围，运行程序不会抛异常，而是会尽可能将符合要求的元素提取出来，例如：

a = [1, 3.0, 2.2, 3.0]
b = a[2:100:1]
c = a[100:0:–1]
print(a) # [1, 3.0, 2.2, 3.0]
print(b) # [2.2, 3.0]
print(c) # [3.0, 2.2, 3.0]

7. 拼接列表

7.1 使用+拼接两个列表

使用+操作符可以将两个列表拼接起来生成一个新列表，该操作不会影响两个原有列表

a = [1, 3.1, 2.2, 3.0]
b = [2.2, 'Jinger']
c = a + b
print(a) # [1, 3.1, 2.2, 3.0]
print(b) # [2.2, 'Jinger']
print(type(c)) # <class 'list'>
print(c) # [1, 3.1, 2.2, 3.0, 2.2, 'Jinger']

7.2 使用+=操作符

使用+=操作符可以将一个列表拼接到另一个列表后面

a = [1, 3.1, 2.2, 3.0]
b = [2.2, 'Jinger']
b += a
print(a) # [1, 3.1, 2.2, 3.0]
print(b) # [2.2, 'Jinger', 1, 3.1, 2.2, 3.0]

7.3 extend方法

使用extend方法也可以将一个列表拼接到另一个列表后面

a = [1, 3.1, 2.2, 3.0]
b = [2.2, 'Jinger']
b.extend(a)
print(a) # [1, 3.1, 2.2, 3.0]
print(b) # [2.2, 'Jinger', 1, 3.1, 2.2, 3.0]

+=操作符和extend方法都可以将一个列表拼接到另一个列表后面，但是extend方法更高效 因为，b += a等价于b = b + a，拼接过程中会先构造出一个临时列表作为拼接后的列表，再将b原本的列表释放，然后将这个临时列表赋值给b 而extend方法则是直接将a列表的元素拼接到b列表后面，避免了不必要的释放操作

四、列表常用接口

Python是一种面向对象的语言，因此创建出来的列表本质是一个对象，这些操作列表的方法都是列表的成员方法。列表的常用接口如下：

1. 列表操作

2. 列表的成员函数

总结

以上就是今天要讲的内容，本文介绍了Python数据类型——列表的相关概念。本文作者目前也是正在学习Python相关的知识，如果文章中的内容有错误或者不严谨的部分，欢迎大家在评论区指出，也欢迎大家在评论区提问、交流。 最后，如果本篇文章对你有所启发的话，希望可以多多支持作者，谢谢大家！