Python Lists详解！

发表于 更新于 分类于 阅读次数： 本文字数： 9.4k 阅读时长 ≈ 9 分钟

嗨，你好啊，我是猿java

这篇文章，我们将详细的分析 Python Lists（列表）。

什么是 Python Lists？

Python Lists（列表）就像其他语言中的动态大小数组（例如 Java 中的 ArrayList）。简单来说，列表是一组用方括号 [ ] 包围并用逗号分隔的东西的集合。

列表是一种序列数据类型，用于存储数据的集合。元组和字符串是其他类型的序列数据类型。

这里我们使用 [] 创建一个 Python 列表。

1
2
my_list = ["Hello", "World", "Python"]
print(my_list)

输出:

1
["Hello", "World", "Python"]

列表是 Python 语言中最简单的容器之一。列表不一定总是同质的，这使得它成为 Python 中最强大的工具。单个列表可以包含整数、字符串以及对象等数据类型。列表是可变的，因此它们可以在创建后进行修改。

如何创建列表？

在 Python 中，可以通过将序列放在方括号 [] 内来创建列表。与集合不同，列表不需要内置函数来创建。

注意：与集合不同，列表可以包含可变元素。

创建列表的复杂度

  • 时间复杂度：O(1)
  • 空间复杂度：O(n)

下面通过几个示例来展示 Python是如何创建列表的。

示例1: 在 Python 中创建列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Python 程序演示列表的创建

# 创建一个空列表
List = []
print("空列表: ")
print(List)

# 创建一个数字列表
List = [10, 20, 14]
print("\n数字列表: ")
print(List)

# 创建一个字符串列表并使用索引访问
List = ["Hello", "World", "Python"]
print("\n列表项: ")
print(List[0])
print(List[2])

输出:

1
2
3
4
5
6
7
8
9
空列表: 
[]

数字列表: 
[10, 20, 14]

列表项: 
Hello
Python

示例1: 创建包含多个不同或重复元素的列表

列表可以包含具有不同位置的重复值，因此在创建列表时可以传递多个不同或重复的值。

1
2
3
4
5
6
7
8
9
# 创建一个包含重复值的数字列表
List = [1, 2, 4, 4, 3, 3, 3, 6, 5]
print("\n使用数字创建的列表: ")
print(List)

# 创建一个包含混合类型值的列表
List = [1, 2, 'Hello', 4, 'For', 6, 'World']
print("\n使用混合值创建的列表: ")
print(List)

输出:

1
2
3
4
5
使用数字创建的列表: 
[1, 2, 4, 4, 3, 3, 3, 6, 5]

使用混合值创建的列表: 
[1, 2, 'Hello', 4, 'For', 6, 'World']

如何访问列表元素？

Python 使用索引运算符 [] 来访问列表中的项，索引必须是整数。嵌套列表可以使用嵌套索引进行访问。

示例 1：从列表中访问元素

1
2
3
4
5
6
7
8
9
# Python 程序演示从列表中访问元素

# 创建一个包含多个值的列表
List = ["Hello", "World", "Python"]

# 使用索引号访问列表中的元素
print("从列表中访问元素")
print(List[0])
print(List[2])

输出:

1
2
3
从列表中访问元素
Hello
Python

示例 2：从多维列表中访问元素

1
2
3
4
5
6
7
# 创建一个多维列表（通过在列表中嵌套列表）
List = [['Hello', 'World'], ['Python']]

# 使用索引号访问多维列表中的元素
print("从多维列表中访问元素")
print(List[0][1])
print(List[1][0])

输出:

1
2
3
从多维列表中访问元素
World
Python

负索引

在 Python 中，负序列索引表示从列表末尾的位置。无需计算偏移量（如 List[len(List)-3]），只需写 List[-3] 即可。负索引表示从末尾开始，-1 表示最后一项，-2 表示倒数第二项，等等。

1
2
3
4
5
6
7
8
9
10
List = [1, 2, 'Hello', 4, 'For', 6, 'World']

# 使用负索引访问元素
print("使用负索引访问元素")

# 打印列表的最后一个元素
print(List[-1])

# 打印列表的倒数第三个元素
print(List[-3])

输出:

1
2
3
使用负索引访问元素
Hello
For

负索引访问列表元素的复杂度

  • 时间复杂度：O(1)
  • 空间复杂度：O(1)

如何获取列表的大小？

使用 len() 函数获取列表的长度。

1
2
3
4
5
6
7
# 创建一个列表
List1 = []
print(len(List1))

# 创建一个数字列表
List2 = [10, 20, 14]
print(len(List2))

输出:

1
2
0
3

如何向列表中添加元素？

使用 append()**

可以使用内置的 append() 函数向列表添加元素。一次只能添加一个元素，若要使用 append() 方法添加多个元素，需要使用循环。元组也可以使用 append() 方法添加到列表中，因为元组是不可变的。与集合不同，可以使用 append() 方法将列表添加到现有列表中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# Python 程序演示向列表中添加元素

# 创建一个列表
List = []
print("初始空列表: ")
print(List)

# 向列表中添加元素
List.append(1)
List.append(2)
List.append(4)
print("\n添加三个元素后的列表: ")
print(List)

# 使用迭代器向列表中添加元素
for i in range(1, 4):
    List.append(i)
print("\n从 1 到 3 添加元素后的列表: ")
print(List)

# 向列表中添加元组
List.append((5, 6))
print("\n添加元组后的列表: ")
print(List)

# 向列表中添加列表
List2 = ['For', 'Python']
List.append(List2)
print("\n添加列表后的列表: ")
print(List)

输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
初始空列表: 
[]

添加三个元素后的列表: 
[1, 2, 4]

从 1 到 3 添加元素后的列表: 
[1, 2, 4, 1, 2, 3]

添加元组后的列表: 
[1, 2, 4, 1, 2, 3, (5, 6)]

添加列表后的列表: 
[1, 2, 4, 1, 2, 3, (5, 6), ['For', 'Python']]

append() 方法复杂度

  • 时间复杂度：O(1)
  • 空间复杂度：O(1)

使用 insert()

append() 方法仅适用于在列表末尾添加元素，若要在指定位置添加元素，则使用 insert() 方法。与 append() 只需一个参数不同，insert() 方法需要两个参数（位置和值）。

1
2
3
4
5
6
7
8
9
10
11
12
# Python 程序演示向列表中添加元素

# 创建一个列表
List = [1, 2, 3, 4]
print("初始列表: ")
print(List)

# 在指定位置添加元素（使用 insert 方法）
List.insert(3, 12)
List.insert(0, 'Python')
print("\n执行插入操作后的列表: ")
print(List)

输出:

1
2
3
4
5
初始列表: 
[1, 2, 3, 4]

执行插入操作后的列表: 
['Python', 1, 2, 3, 12, 4]

insert() 方法复杂度

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

使用 extend()

除了 append() 和 insert() 方法外，还有一种添加元素的方法，即 extend()，该方法用于一次在列表末尾添加多个元素。

注意：append() 和 extend() 方法只能在列表末尾添加元素。

1
2
3
4
5
6
7
8
9
10
11
# Python 程序演示向列表中添加元素

# 创建一个列表
List = [1, 2, 3, 4]
print("初始列表: ")
print(List)

# 使用 extend 方法向列表末尾添加多个元素
List.extend([8, 'Geeks', 'Always'])
print("\n执行扩展操作后的列表: ")
print(List)

输出:

1
2
3
4
5
初始列表: 
[1, 2, 3, 4]

执行扩展操作后的列表: 
[1, 2, 3, 4, 8, 'Geeks', 'Always']

extend() 方法复杂度

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

反转列表

使用 reverse()

1
2
3
4
# 反转列表
mylist = [1, 2, 3, 4, 5, 'Python']
mylist.reverse()
print(mylist)

输出:

1
['Python', 5, 4, 3, 2, 1]

使用 reversed()

reversed() 函数返回一个反向迭代器，可以使用 list() 函数将其转换为列表。

1
2
3
my_list = [1, 2, 3, 4, 5]
reversed_list = list(reversed(my_list))
print(reversed_list)

输出:

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

从列表中删除元素

使用 remove()

可以使用内置的 remove() 函数从列表中删除元素，但如果元素不存在则会引发错误。remove() 方法一次只能删除一个元素，要删除一系列元素，则使用迭代器。remove() 方法删除指定的项。

注意：列表中的 remove() 方法只会删除第一个匹配的元素。

示例 1：

1
2
3
4
5
6
7
8
9
10
11
12
# Python 程序演示从列表中删除元素

# 创建一个列表
List = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
print("初始列表: ")
print(List)

# 使用 remove() 方法从列表中删除元素
List.remove(5)
List.remove(6)
print("\n删除两个元素后的列表: ")
print(List)

输出:

1
2
3
4
5
初始列表: 
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

删除两个元素后的列表: 
[1, 2, 3, 4, 7, 8, 9, 10, 11, 12]

示例 2：

1
2
3
4
5
6
7
# 创建一个列表
List = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
# 使用迭代器方法从列表中删除元素
for i in range(1, 5):
    List.remove(i)
print("\n删除一系列元素后的列表: ")
print(List)

输出:

1
2
删除一系列元素后的列表: 
[5, 6, 7, 8, 9, 10, 11, 12]

remove() 方法复杂度

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

使用 pop()

pop() 函数也可以用于从列表中删除并返回元素，但默认情况下它只删除列表的最后一个元素。要从列表的特定位置删除元素，需要将元素的索引作为参数传递给 pop() 方法。

1
2
3
4
5
6
7
8
9
10
11
List = [1, 2, 3, 4, 5]

# 使用 pop() 方法从列表中删除元素
List.pop()
print("\n弹出元素后的列表: ")
print(List)

# 使用 pop() 方法从特定位置删除元素
List.pop(2)
print("\n弹出特定元素后的列表: ")
print(List)

输出:

1
2
3
4
5
弹出元素后的列表: 
[1, 2, 3, 4]

弹出特定元素后的列表: 
[1, 2, 4]

pop() 方法复杂度

  • 时间复杂度：O(1)/O(n)（删除最后一个元素为 O(1)，删除第一个和中间元素为 O(n)）
  • 空间复杂度：O(1)

切片列表

我们可以使用切片获取子字符串和子列表。在 Python 列表中，有多种方法可以打印包含所有元素的整个列表，但要打印特定范围内的元素，我们使用切片操作。

切片操作在列表上使用冒号 : 进行。

要打印从开始到指定范围的元素，请使用：

1
[: Index]

要打印从开始到负范围的元素，请使用：

1
[:-Index]

要打印从指定索引到末尾的元素，请使用：

1
[Index:]

要打印从指定负索引到末尾的元素，请使用：

1
[-Index:]

要以逆序打印整个列表，请使用：

1
[::-1]

注意：要从列表末尾打印元素，请使用负索引。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Python 程序演示从列表中删除元素

# 创建一个列表
List = ['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']
print("初始列表: ")
print(List)

# 使用切片操作打印指定范围内的元素
Sliced_List = List[3:8]
print("\n在范围 3-8 内的切片元素: ")
print(Sliced_List)

# 打印从预定义点到末尾的元素
Sliced_List = List[5:]
print("\n从第 5 个元素切片到末尾的元素: ")
print(Sliced_List)

# 使用切片操作打印从开始到末尾的所有元素
Sliced_List = List[:]
print("\n使用切片操作打印所有元素: ")
print(Sliced_List)

输出:

1
2
3
4
5
6
7
8
9
10
11
初始列表: 
['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']

在范围 3-8 内的切片元素: 
['L', 'O', 'W', 'O', 'R']

从第 5 个元素切片到末尾的元素: 
['W', 'O', 'R', 'L', 'D']

使用切片操作打印所有元素: 
['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']

负索引列表切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 创建一个列表
List = ['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']
print("初始列表: ")
print(List)

# 使用切片操作从开始到预定义点打印元素
Sliced_List = List[:-6]
print("\n从末尾切片到第 6 个元素的元素: ")
print(Sliced_List)

# 使用负索引列表切片打印范围内的元素
Sliced_List = List[-6:-1]
print("\n从索引 -6 到 -1 切片的元素")
print(Sliced_List)

# 使用切片操作逆序打印元素
Sliced_List = List[::-1]
print("\n逆序打印列表: ")
print(Sliced_List)

输出:

1
2
3
4
5
6
7
8
9
10
11
初始列表: 
['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']

从末尾切片到第 6 个元素的元素: 
['O', 'R', 'L', 'D']

从索引 -6 到 -1 切片的元素
['O', 'W', 'O', 'R', 'L', 'D']

反向打印列表：
['D', 'L', 'R', 'O', 'W', 'O', 'L', 'L', 'E', 'H']

列表推导式

Python 列表推导式用于从其他可迭代对象（如元组、字符串、数组、列表等）创建新列表。列表推导式包括括号内的表达式，该表达式对每个元素执行，并结合 for 循环迭代每个元素。

语法：

1
newList = [ 表达式(元素) for 元素 in 旧列表 if 条件 ]

示例：

1
2
3
4
5
# Python 程序演示列表推导式

# 下列表包含范围 1 到 10 内所有奇数的平方
odd_square = [x ** 2 for x in range(1, 11) if x % 2 == 1]
print(odd_square)

输出：

1
[1, 9, 25, 49, 81]

为了更好地理解，上面的代码等同于以下代码：

1
2
3
4
5
6
7
8
# 为了理解，上述生成等同于
odd_square = []

for x in range(1, 11):
    if x % 2 == 1:
        odd_square.append(x**2)

print(odd_square)

输出：

1
[1, 9, 25, 49, 81]

列表方法

函数 描述
append() 在列表末尾添加一个元素
extend() 将一个列表的所有元素添加到另一个列表
insert() 在指定索引处插入一个元素
remove() 从列表中删除一个元素
clear() 移除列表中的所有元素
index() 返回第一个匹配项的索引
count() 返回作为参数传递的项的数量
sort() 按升序排序列表中的项
reverse() 反转列表中项的顺序
copy() 返回列表的副本
pop() 移除并返回指定索引处的项。如果没有提供索引，则移除并返回最后一项

要了解更多信息，请参阅这篇文章 – Python 列表方法。上述操作会修改列表本身。

列表的内置函数

函数 描述
reduce() 将传递给它的特定函数应用于列表的所有元素，存储中间结果并只返回最终的汇总值
sum() 对列表中的数字求和
ord() 返回给定 Unicode 字符的 Unicode 代码点的整数表示
cmp() 如果第一个列表“比”第二个列表“更大”，则返回 1
max() 返回给定列表的最大元素
min() 返回给定列表的最小元素
all() 如果所有元素为真或列表为空，则返回 true
any() 如果列表中的任何元素为真，则返回 true。如果列表为空，则返回 false
len() 返回列表的长度或大小
enumerate() 返回列表的枚举对象
accumulate() 将传递给它的特定函数应用于列表的所有元素，返回包含中间结果的列表
filter() 测试列表的每个元素是否为真
map() 将给定函数应用于给定可迭代对象的每个项后返回结果列表
lambda() 该函数可以有任意数量的参数，但只有一个表达式，该表达式被计算并返回

常见问题

在 Python 中列表的用途是什么？
列表用于在 Python 中存储项目集合，例如数字、字符串或其他对象。它们常用于：

  • 存储和操作数据序列。
  • 聚合项目以进行迭代。
  • 将多个项目收集为单个变量。
  • 数据操作和分析。

如何创建 Python 列表？
使用方括号 [] 并用逗号分隔项目来创建列表。

1
my_list = [1, 2, 3, 'apple', 'banana']

如何在 Python 中调用列表？
通过引用其变量名来调用（访问）列表，并可以使用索引位置访问元素。

1
2
3
4
my_list = [1, 2, 3, 'apple', 'banana']
print(my_list)           # 输出: [1, 2, 3, 'apple', 'banana']
print(my_list[0])        # 输出: 1
print(my_list[3])        # 输出: 'apple'

如何声明列表？
通过将项目封装在方括号中并赋值给变量来声明列表。

1
2
empty_list = []
my_list = [1, 2, 3, 'apple', 'banana']

如何读取 Python 列表中的值？
使用索引或通过循环迭代列表来读取（访问）列表值。

1
2
3
4
5
6
7
my_list = [1, 2, 3, 'apple', 'banana']
# 访问单个项目
first_item = my_list[0]
second_item = my_list[1]
# 使用 for 循环迭代
for item in my_list:
    print(item)

总结

本文我们对 Python Lists进行了详细的分析，Python Lists（列表）是一种用于存储有序数据集合的序列数据类型。列表用方括号 [] 表示，元素间用逗号分隔。列表支持多种数据类型的混合，并且是可变的，可以动态添加、删除或修改元素。常用方法包括 append()、insert()、remove() 和 pop() 等。列表推导式提供了一种简洁的方式来生成新列表。列表在数据存储、操作和分析中广泛应用。

学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing