[Python] 列表和元组详解

收录专栏：[Python]

在 Python 中，列表和元组是最常用的序列数据类型，它们用于存储一组数据。虽然它们的用途非常相似，但在一些特性上有明显的区别。本文将面向刚学习 Python 的读者，详细讲解列表和元组的概念、操作方法及其区别，并通过经典示例帮助你更好地掌握这些内容。

---

什么是列表

列表是 Python 中最常用的数据结构之一，它可以存储多个元素，并且这些元素的类型可以不同。列表是可变的，即可以修改其内容，比如增加、删除、修改元素。

列表的创建

创建列表非常简单，有两种常见的方式：

# 方法一：使用 []
alist = []

# 方法二：使用 list()
alist = list()

我们还可以在创建时为列表添加初始元素：

alist = [1, 2, 3, 4]
print(alist)  # 输出：[1, 2, 3, 4]

Python 列表可以包含不同类型的数据：

alist = [1, "Hello", True]
print(alist)  # 输出：[1, 'Hello', True]

访问和修改列表元素

我们可以通过下标来访问列表中的元素。下标从 0 开始，即第一个元素的下标是 0，最后一个元素的下标是 len(列表) - 1。

alist = [1, 2, 3, 4]
print(alist[0])  # 输出：1

使用下标也可以修改列表中的元素：

alist = [1, 2, 3, 4]
alist[2] = 100  # 将下标为 2 的元素修改为 100
print(alist)    # 输出：[1, 2, 100, 4]

如果下标超出列表的范围，会抛出 IndexError 异常：

alist = [1, 2, 3, 4]
print(alist[100])  # 会抛出异常：IndexError: list index out of range

切片操作

通过切片，我们可以一次取出一组连续的元素，返回的是一个子列表。切片的语法是 [开始下标:结束下标]，注意它是前闭后开区间，也就是说，取值到 结束下标 - 1 为止。

alist = [1, 2, 3, 4]
print(alist[1:3])  # 输出：[2, 3]

省略切片的开始或结束边界，可以获取到列表的开头或末尾：

print(alist[1:])  # 输出：[2, 3, 4] 从下标 1 到末尾
print(alist[:3])  # 输出：[1, 2, 3] 从头开始到下标 2
print(alist[:])   # 输出：[1, 2, 3, 4] 获取整个列表

还可以为切片操作指定步长，控制取元素时跳过多少步：

alist = [1, 2, 3, 4, 5, 6, 7, 8]
print(alist[::2])  # 输出：[1, 3, 5, 7] 每次跳过 2 步

通过使用负数步长，可以反向切片：

print(alist[::-1])  # 输出：[8, 7, 6, 5, 4, 3, 2, 1] 反转列表

遍历列表

我们可以使用**for 循环**遍历列表中的元素：

alist = [1, 2, 3, 4]
for elem in alist:
    print(elem)

也可以使用下标来遍历列表，并对元素进行修改：

alist = [1, 2, 3, 4]
for i in range(len(alist)):
    alist[i] = alist[i] * 2
print(alist)  # 输出：[2, 4, 6, 8]

新增、查找、删除元素

1. append()：向列表尾部追加元素

alist = [1, 2, 3]
alist.append(4)
print(alist)  # 输出：[1, 2, 3, 4]

2. insert()：在指定位置插入元素

alist = [1, 2, 3]
alist.insert(1, 'Hello')
print(alist)  # 输出：[1, 'Hello', 2, 3]

3. in：查找元素是否存在

alist = [1, 2, 3]
print(1 in alist)  # 输出：True
print(10 in alist) # 输出：False

4. pop()：删除指定下标的元素

alist = [1, 2, 3, 4]
alist.pop(2)  # 删除下标为 2 的元素
print(alist)  # 输出：[1, 2, 4]

5. remove()：删除指定元素

alist = [1, 2, 3, 4]
alist.remove(2)  # 删除值为 2 的元素
print(alist)  # 输出：[1, 3, 4]

列表拼接

1. 使用 + 拼接两个列表

alist = [1, 2, 3]
blist = [4, 5, 6]
print(alist + blist)  # 输出：[1, 2, 3, 4, 5, 6]

2. 使用 extend() 将一个列表追加到另一个列表

alist = [1, 2, 3]
blist = [4, 5, 6]
alist.extend(blist)
print(alist)  # 输出：[1, 2, 3, 4, 5, 6]

---

什么是元组

元组和列表非常相似，它也是一个可以存储多个元素的序列数据类型。不同的是，元组是不可变的，也就是说一旦创建就不能修改其中的元素。

元组的创建

创建元组和创建列表类似，有两种方式：

# 方法一：使用 ()
atuple = (1, 2, 3)

# 方法二：使用 tuple()
atuple = tuple([1, 2, 3])

可以创建一个空元组：

empty_tuple = ()

元组也可以存储不同类型的数据：

atuple = (1, "Hello", True)
print(atuple)  # 输出：(1, 'Hello', True)

访问元组元素

与列表一样，元组也可以通过下标来访问：

atuple = (1, 2, 3)
print(atuple[1])  # 输出：2

元组的不可变性

与列表不同的是，元组不能修改。例如，下面的代码会报错：

atuple = (1, 2, 3)
atuple[1] = 100  # 会抛出异常：TypeError: 'tuple' object does not support item assignment

---

列表和元组的区别

特性	列表（List）	元组（Tuple）
可变性	可变（可以增删改）	不可变（无法修改）
符号	[]	()
性能	速度较慢	速度较
性	可变（可以增删改）	不可变（无法修改）
符号	[]	()
性能	速度较慢	速度较快
内存占用	占用更多内存	占用较少内存
用途	动态数据存储	静态数据存储
是否支持增删改	支持	不支持
使用场景	需要频繁修改数据时	数据不可变时（如坐标、函数返回多个值）

总结：

• 当需要修改数据时（如增删改），使用列表。
• 当数据不需要修改时（如固定的一组值），使用元组。元组的性能更好，且占用的内存较少。

---

经典题目测试

通过以下测试题目，你可以巩固对列表和元组的理解。

题目 1：创建一个包含不同类型元素的列表

创建一个包含以下元素的列表：整数 10，字符串 "Hello"，布尔值 True，并输出列表。

# 请写出你的代码：
my_list = [10, "Hello", True]
print(my_list)  # 输出：[10, 'Hello', True]

题目 2：修改列表中的元素

给定列表 [1, 2, 3, 4]，将第二个元素修改为 100，并打印修改后的列表。

# 请写出你的代码：
my_list = [1, 2, 3, 4]
my_list[1] = 100
print(my_list)  # 输出：[1, 100, 3, 4]

题目 3：切片操作

给定列表 [10, 20, 30, 40, 50]，使用切片获取前 3 个元素并输出。

# 请写出你的代码：
my_list = [10, 20, 30, 40, 50]
print(my_list[:3])  # 输出：[10, 20, 30]

题目 4：查找元素是否存在

给定列表 [5, 10, 15, 20]，检查是否存在数字 10 和数字 30，并打印结果。

# 请写出你的代码：
my_list = [5, 10, 15, 20]
print(10 in my_list)  # 输出：True
print(30 in my_list)  # 输出：False

题目 5：使用元组存储多个值

定义一个函数，返回一个元组 (10, 20)，并分别获取其中的两个值进行打印。

# 请写出你的代码：
def get_values():
    return 10, 20

x, y = get_values()
print(f"x = {x}, y = {y}")  # 输出：x = 10, y = 20

题目 6：删除列表中的元素

给定列表 [1, 2, 3, 4, 5]，删除其中的第 3 个元素，并输出结果。

# 请写出你的代码：
my_list = [1, 2, 3, 4, 5]
my_list.pop(2)
print(my_list)  # 输出：[1, 2, 4, 5]

题目 7：拼接两个列表

给定两个列表 [1, 2] 和 [3, 4]，使用两种方式拼接它们并输出结果。

# 请写出你的代码：
list1 = [1, 2]
list2 = [3, 4]

# 方法一：使用 +
print(list1 + list2)  # 输出：[1, 2, 3, 4]

# 方法二：使用 extend
list1.extend(list2)
print(list1)  # 输出：[1, 2, 3, 4]

---

结语

通过这篇博客，我们详细讲解了 Python 中的 列表 和 元组，并展示了如何使用它们来存储和操作数据。列表和元组是 Python 中的基本数据类型，理解它们的区别以及何时使用它们对于编写高效、清晰的代码非常重要。

在需要修改数据的情况下，列表是一个非常好的选择；而元组在数据不可变时表现出色，特别适合作为返回多个值或固定数据的容器。

通过上面的经典示例和题目测试，希望你对列表和元组的概念有了更深的理解。继续多练习和探索 Python 的这些基础数据结构，你将能够更加熟练地处理各种数据任务！