一文搞懂Python中列表List和元组Tuple的使用

Python 中列表（List）和元组（Tuple）

在 Python 中，列表和元组都是序列类型，具有一些相似的操作。但是它们的性质不同，我们需要正确地选择它们来存储和操作数据。下面我们来一步步地介绍这两种序列类型的性质和使用方法。

列表（List）

列表是一种可变序列类型。它的每个元素可以是不同类型的对象，列表内的元素可以随意地进行添加、删除和修改。

创建列表

列表可以使用中括号 [ ] 或者内置函数 list() 来创建。例如：

# 创建一个空列表
list1 = []

# 创建一个带有元素的列表
list2 = [1, 2, 3, 'hello', 'world']

# 使用 list() 函数创建列表
list3 = list('abc')

访问列表元素

我们可以使用下标（索引）来访问列表中的元素。下标从 0 开始，从左往右依次增加，从右往左则从 -1 开始，依次递减。例如：

list1 = [1, 2, 3, 'hello', 'world']

# 访问列表元素
print(list1[0])     # 1
print(list1[3])     # 'hello'
print(list1[-1])    # 'world'

列表切片

通过切片（slice）操作，我们可以获取列表中的一段子列表。切片操作使用 : 符号，形式为 [start:end:step]，其中 start 表示切片的起始位置，end 表示切片的结束位置（不包含），step 表示切片的步长。例如：

list1 = [1, 2, 3, 'hello', 'world']

# 获取子列表
print(list1[2:4])       # [3, 'hello']
print(list1[:3])        # [1, 2, 3]
print(list1[::-1])      # ['world', 'hello', 3, 2, 1]

列表的修改

列表是一种可变类型，我们可以通过下标来修改它的值。例如：

list1 = [1, 2, 3, 'hello', 'world']

# 修改列表元素
list1[3] = 'Python'
print(list1)    # [1, 2, 3, 'Python', 'world']

我们还可以使用列表的一些内置方法来修改它的值或者结构。例如：

list1 = [1, 2, 3, 'hello', 'world']

# 添加元素
list1.append('Python')
print(list1)    # [1, 2, 3, 'hello', 'world', 'Python']

# 删除元素
list1.remove('hello')
print(list1)    # [1, 2, 3, 'world', 'Python']

# 插入元素
list1.insert(0, 0)
print(list1)    # [0, 1, 2, 3, 'world', 'Python']

# 合并列表
list2 = [4, 5]
list1.extend(list2)
print(list1)    # [0, 1, 2, 3, 'world', 'Python', 4, 5]

列表的拷贝

当我们想要对列表进行拷贝时，需要注意它的性质。列表的赋值和拷贝都只是对列表的引用进行了复制和传递。如果直接将列表赋值给一个新的变量，那么这个新变量和原列表都指向了同一个地址。

因此，我们需要使用 copy() 方法或者切片操作来进行列表的拷贝。例如：

list1 = [1, 2, 3, 'hello', 'world']

# 使用赋值进行拷贝
list2 = list1
list2[3] = 'Python'
print(list1)    # [1, 2, 3, 'Python', 'world']
print(list2)    # [1, 2, 3, 'Python', 'world']

# 使用 copy() 方法进行拷贝
list3 = list1.copy()
list3[3] = 'Java'
print(list1)    # [1, 2, 3, 'Python', 'world']
print(list3)    # [1, 2, 3, 'Java', 'world']

# 使用切片进行拷贝
list4 = list1[:]
list4[3] = 'PHP'
print(list1)    # [1, 2, 3, 'Python', 'world']
print(list4)    # [1, 2, 3, 'PHP', 'world']

示例1：列表作为函数参数

我们可以使用列表作为函数的参数，将列表传递给函数并在函数内对列表进行修改。例如：

# 定义函数
def modify_list(lst):
    lst.append('hello')
    lst[1] = 'Python'

# 调用函数
list1 = [1, 2, 3]
modify_list(list1)
print(list1)    # [1, 'Python', 3, 'hello']

示例2：列表解析

列表解析（List Comprehension）是一种简洁而强大的列表创建方式。它可以很方便地对列表进行过滤、映射和计算。例如：

# 创建一个列表
list1 = [1, 2, 3, 4, 5]

# 过滤偶数
list2 = [x for x in list1 if x % 2 == 0]
print(list2)    # [2, 4]

# 映射平方
list3 = [x ** 2 for x in list1]
print(list3)    # [1, 4, 9, 16, 25]

# 计算和
sum1 = sum([x ** 2 for x in list1])
print(sum1)     # 55

元组（Tuple）

元组是一种不可变序列类型。它的每个元素可以是不同类型的对象，但是元组内的元素不允许进行添加、删除和修改。

创建元组

元组可以使用小括号 ( ) 或者内置函数 tuple() 来创建。例如：

# 创建一个空元组
tuple1 = ()

# 创建一个带有元素的元组
tuple2 = (1, 2, 3, 'hello', 'world')

# 使用 tuple() 函数创建元组
tuple3 = tuple('abc')

访问元组元素

我们可以使用下标（索引）来访问元组中的元素。元组同样从 0 开始，从左往右依次增加，从右往左则从 -1 开始，依次递减。例如：

tuple1 = (1, 2, 3, 'hello', 'world')

# 访问元组元素
print(tuple1[0])     # 1
print(tuple1[3])     # 'hello'
print(tuple1[-1])    # 'world'

元组切片

元组同样支持切片操作，使用方式与列表相同。

元组操作

虽然元组是不可变类型，但是我们可以通过一些操作来创建新的元组。

例如，我们可以将两个或多个元组连接起来形成一个新的元组，可以使用 + 符号：

tuple1 = (1, 2, 3)
tuple2 = ('hello', 'world')

# 连接元组
tuple3 = tuple1 + tuple2
print(tuple3)    # (1, 2, 3, 'hello', 'world')

我们也可以将一个元组复制多次来形成一个新的元组，可以使用 * 符号：

tuple1 = ('hello', 'world')

# 复制元组
tuple2 = tuple1 * 3
print(tuple2)   # ('hello', 'world', 'hello', 'world', 'hello', 'world')

元组解包

元组解包（Tuple Unpacking）是一种非常方便的语法，可以将元组中的多个元素一次性地解包给多个变量。例如：

tuple1 = ('hello', 'world')

# 元组解包
word1, word2 = tuple1

print(word1)    # 'hello'
print(word2)    # 'world'

示例1：元组作为函数返回值

元组通常可以作为函数的返回值，用来返回多个值。例如：

# 定义函数
def calculate(a, b):
    return (a + b, a - b, a * b)

# 调用函数
x, y, z = calculate(3, 4)
print(x, y, z)  # 7, -1, 12

示例2：元组作为字典键

元组通常也可以作为字典的键值，因为元组是不可变类型，它的内容是固定的，不会发生更改。

# 创建字典
dict1 = {('hello', 'world'): [1, 2, 3]}

# 使用元组作为键访问字典
print(dict1[('hello', 'world')])     # [1, 2, 3]

总结

在 Python 中，列表和元组都是序列类型，但是它们的性质不同。列表是可变类型，可以任意修改；而元组是不可变类型，一旦创建就无法更改。我们需要根据实际需要选择合适的数据类型，并学会使用它们的相应方法和技巧。