探秘列表与元组操作，揭秘Python中的有序元素容器

一、初识有序元素容器：列表与元组

Python 中，列表和元组作为有序元素容器，可存储不同类型的数据，满足不同的数据存储需求。

1. 列表（List）：

• 列表使用方括号 [] 定义，元素之间用逗号 , 分隔，支持添加、修改、删除元素。
• 列表中的元素可以是任何数据类型，包括其他列表或元组。
• 列表具有动态大小，可根据需要调整长度。

my_list = [1, 2.5, 'Hello', True]
print(my_list)  # 输出：[1, 2.5, 'Hello', True]

2. 元组（Tuple）：

• 元组使用小括号 () 定义，元素之间用逗号 , 分隔，元素一旦创建不可修改。
• 元组中的元素也可以是任何数据类型，包括其他列表或元组。
• 元组具有固定大小，创建后无法调整长度。

my_tuple = (1, 2.5, 'Hello', True)
print(my_tuple)  # 输出：(1, 2.5, 'Hello', True)

二、探索列表与元组的基本操作

1. len() 函数：获取元素个数

len() 函数可获取列表和元组中元素的个数。

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

print(len(my_list))  # 输出：5
print(len(my_tuple))  # 输出：5

2. 索引（Indexing）：访问特定元素

列表和元组可以使用索引访问特定元素。索引从 0 开始，正向索引可从左向右访问元素，负向索引可从右向左访问元素。

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

print(my_list[0])  # 输出：1
print(my_tuple[0])  # 输出：1
print(my_list[-1])  # 输出：5
print(my_tuple[-1])  # 输出：5

3. 切片（Slicing）：获取元素子集

列表和元组可以使用切片获取元素子集。切片使用冒号 : 表示，语法为 [start:stop:step]。start 表示起始索引，stop 表示结束索引，step 表示步长。如果省略 start，则从列表或元组的开头开始切片；如果省略 stop，则切片到列表或元组的末尾；如果省略 step，则步长为 1。

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

print(my_list[1:3])  # 输出：[2, 3]
print(my_tuple[1:3])  # 输出：(2, 3)
print(my_list[::2])  # 输出：[1, 3, 5]
print(my_tuple[::2])  # 输出：(1, 3, 5)

4. 复制（Copying）：创建新副本

列表和元组可以使用 copy() 方法创建新副本。新副本与原列表或元组独立存在，对新副本的修改不会影响原列表或元组。

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

new_list = my_list.copy()
new_tuple = my_tuple.copy()

new_list[0] = 10
new_tuple[0] = 10

print(my_list)  # 输出：[1, 2, 3, 4, 5]
print(my_tuple)  # 输出：(1, 2, 3, 4, 5)
print(new_list)  # 输出：[10, 2, 3, 4, 5]
print(new_tuple)  # 输出：(10, 2, 3, 4, 5)

5. 连接（Concatenation）：合并两个容器

列表和元组可以使用 + 运算符连接成一个新的列表或元组。

my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
my_tuple1 = (1, 2, 3)
my_tuple2 = (4, 5, 6)

new_list = my_list1 + my_list2
new_tuple = my_tuple1 + my_tuple2

print(new_list)  # 输出：[1, 2, 3, 4, 5, 6]
print(new_tuple)  # 输出：(1, 2, 3, 4, 5, 6)

6. 嵌套（Nesting）：在列表中包含元组或在元组中包含列表

列表和元组可以相互嵌套，形成更加复杂的数据结构。

my_list = [1, 2, [3, 4]]
my_tuple = (1, 2, (3, 4))

print(my_list)  # 输出：[1, 2, [3, 4]]
print(my_tuple)  # 输出：(1, 2, (3, 4))

三、深入理解列表与元组的进阶操作

1. 排序（Sorting）：重新排列元素顺序

列表和元组可以使用 sort() 方法对元素进行排序。sort() 方法默认按升序排序，如果需要按降序排序，可以使用 reverse=True 参数。

my_list = [5, 2, 1, 4, 3]
my_tuple = (5, 2, 1, 4, 3)

my_list.sort()
my_tuple = sorted(my_tuple)  # 元组本身不可修改，因此需要先转换为列表再排序

print(my_list)  # 输出：[1, 2, 3, 4, 5]
print(my_tuple)  # 输出：(1, 2, 3, 4, 5)

2. 元组比较：比较元组中的元素

元组可以使用比较运算符进行比较。比较时，元组中的元素逐个比较，直到找到不同的元素或比较完所有元素。如果比较完所有元素，则比较结果为 True，否则为 False。

my_tuple1 = (1, 2, 3)
my_tuple2 = (1, 2, 3)
my_tuple3 = (1, 2, 4)

print(my_tuple1 == my_tuple2)  # 输出：True
print(my_tuple1 == my_tuple3)  # 输出：False
print(my_tuple1 > my_tuple3)  # 输出：False
print(my_tuple1 < my_tuple3)  # 输出：True

3. 列表推导式（List Comprehension）：简洁地创建列表

列表推导式是一种简洁地创建列表的方式。列表推导式使用方括号 [] 和 for 循环来生成列表中的元素。

my_list = [x for x in range(1, 11)]  # 创建一个包含从 1 到 10 的数字的列表
my_list = [x*2 for x in range(1, 11)]  # 创建一个包含从 2 到 20 的偶数的列表

4. 元组拆包（Tuple Unpacking）：分解元组中的元素

元组拆包是一种将元组中的元素分解成单独的变量的方式。元组拆包使用赋值运算符 = 和小