如果这篇文章对你有所帮助，欢迎点赞收藏加关注
在 Python 中，列表是最常用也是最基本的数据组织结构，所以值得我们深入的学习。
本文不仅讲解了在 Python 中创建和操作列表的基础方法，还进一步探讨了一些实用的高级特性。
初识列表
想象一下，你把一条长纸条均匀剪切成若干小纸片，并将它们按一定顺序排成一行。每张小纸片上都写下不同的内容，而这些内容将会按照纸片的排列顺序被有序地记录下来。
Python 列表就像这些有序排列的小纸片，它是一种有序数据结构，其中包含的各数据项称为‘元素’。这些元素可以是Python支持的任何数据类型，包括数字、字符串、布尔值，甚至是其他列表（嵌套）。
Python 使用方括号[]来初始化列表，其元素间通过逗号分隔。
Python 列表的强大之处在于其灵活性。无论是组织数据、管理任务还是解决其他更复杂问题，列表都是一种高效的数据存储和处理工具，同时它还有助于保持代码的整洁和高效。
创建列表
在 Python 中创建列表是一种常见且简单的操作。你可以根据需要选择不同的方式来构建列表，以便更好的组织你的数据。
单行方式
如果列表的初始元素比较稀少，可以选择使用单行方式创建列表，这种方式简明扼要。
fruits = ["apple", "banana", "cherry"]
多行方式
对于初始元素较多的长列表，为了保持代码的整洁，我们可以选择多行方式创建列表，这种方式可读性强。
numbers = [
1,
2,
3,
4,
5,
]
混合数据类型
Python 列表支持混合数据类型，允许你在一个列表中存储不同类型的数据，从而提供更加灵活的数据组织方式。
mixed_list = ["hello", 3.14, True]
访问列表中的元素
想象一下，你有一排罐子，每个罐子里装着不同类型的糖果。你想从这些罐子里获取特定类型的糖果。你是怎么做的？你看看罐子上的标签，找到你想要的，对吧？
在 Python 列表中，每个元素都像是被装在罐子里的糖果，而元素的“索引”就像是贴在罐子上的标签，帮助我们快速找到特定的元素。
Python 列表使用索引标记元素在列表中的位置。但这里需要注意的是：在 Python 中，索引是从 0 开始计数，而不是从 1 开始。因此，Python 列表的第一个元素是用 0 标记，第二个元素是用 1 标记，然后以此类推。
所以，若要从列表中获取项，你可以使用索引。以下是使用索引从列表中获取元素的代码示例：
# 假设我们有一个水果清单
fruits = ["apple", "banana", "cherry"]
# 访问索引为 0 的第一个水果（apple）
first_fruit = fruits[0]
print(first_fruit) # 输出: apple
# 访问索引为 1 的第二个水果（banana）
second_fruit = fruits[1]
print(second_fruit) # 输出: banana
通过使用列表名称加方括号和索引的方式，我们能方便的访问到该位置的元素。
通过使用索引访问元素是 Python 列表的基本操作。
修改列表
与字符串不同，列表是可变的。这意味着我们可以在列表创建之后仍然可以更改它的内容。
以下是修改列表的一些方法：
追加元素
Python 列表的 append() 方法用于在列表的末尾添加一个新的元素。这个方法只接受一个参数，即要添加到列表末尾的元素。调用 append() 方法后，列表的长度会增加1。
语法如下：list_name.append(element)
下面是代码示例：
fruits.append("orange")
# 解释：我们在水果清单（fruits列表）的末尾添加了“orange”。
# 结果：当前fruits列表更新为 ["apple", "banana", "cherry", "orange"]
插入元素
Python 列表的 insert() 方法用于在列表的指定位置插入一个元素。这个方法接受两个参数：第一个参数是索引值，表示要插入元素的位置；第二个参数是要插入的元素。
当你使用 insert() 方法时，指定的索引值处的元素及其后面的所有元素都会向后移动一个位置，以容纳新插入的元素。如果索引值等于列表的长度，新元素将被添加到列表的末尾；如果索引值大于列表的长度，将会引发 IndexError；如果索引值小于0，新元素将被插入到列表的开始处。
语法如下：list_name.insert(index， element)
下面是代码示例：
fruits.insert(1, "grape")
# 解释：我们在fruits列表的索引 1 处添加了“grape”。
# 结果：当前fruits列表更新为 ["apple", "grape", "banana", "cherry", "orange"]
删除元素
移除列表中与某个元素第一个相匹配的元素。
Python 列表的 remove() 方法用于移除列表中第一次出现的指定元素。如果元素不存在，该方法会引发一个 ValueError 异常。
remove() 方法只接受一个参数，即要移除的元素值。当你调用 remove() 方法时，它会搜索列表中的元素，找到第一个与指定值相匹配的元素并将其从列表中移除。列表中剩余的元素会自动向前移动，以填充被移除元素留下的空隙。
语法如下：list_name.remove(element)
下面是代码示例：
fruits.remove("banana")
# 解释：我们将从fruits列表中删除"banana"。
# 结果：当前fruits列表更新为 ["apple", "grape", "cherry", "orange"]
弹出元素
Python 列表的 pop() 方法用于移除并返回列表中的一个元素。默认情况下，pop() 移除并返回列表的最后一个元素，但你可以通过传递一个索引参数来指定要移除的元素。
语法如下：list_name.pop(index)
下面是代码示例：
removed_item = fruits.pop(1)
# 解释：我们将从fruits列表中删除索引为 1 的元素（"grape"），并将其赋值给变量"removed_item"。
# 结果：当前removed_item的值为"grape"，fruits列表更新为 ["apple", "cherry", "orange"]
扩展列表
Python 列表的 extend() 方法用于将一个迭代对象中的所有元素添加到当前列表的末尾。
extend() 方法接受一个参数，这个参数必须是一个可迭代的对象，如列表、元组、集合、字符串等。
语法如下：list_name.extend(iterable)
下面是代码示例：
more_fruits = ["mango", "pineapple"]
fruits.extend(more_fruits)
# 解释：我们将"more_fruits"中的所有元素追加到fruits列表的末尾。
# 结果：当前fruits列表更新为 ["apple", "cherry", "orange", "mango", "pineapple"]
通用方法
切片操作
Python 列表的切片操作是一种非常有用的特性，它允许你获取列表的子集，而不需要改变原始列表。切片操作使用方括号来获取列表中一定范围的元素。
基本的切片操作有三个参数：起始索引、结束索引和步长。
- 起始索引： 切片开始的索引位置。如果省略起始索引，默认从列表开头开始切片。
- 结束索引： 切片结束的索引位置（不包括此位置的元素）。如果省略结束索引，默认切片到列表末尾。
- 步长： 两个索引之间的间隔。如果为负数时，列表会从后向前进行切片。
下面是切片的语法：list_name[start_index:end_index:step]
下面是代码示例，向你展示了如何使用切片：
# 假设我们有一个不同风味的蛋糕层列表
cake_layers = ["chocolate", "vanilla", "strawberry", "lemon", "red velvet"]
# 切割蛋糕层
slice_of_cake = cake_layers[1:4:2]
# 解释：我们将cake_layers从索引 1 （vanilla）切片到索引 4 （lemon），并且步长为两个元素。
# 结果：slice_of_cake值为 ["vanilla", "lemon"]
列表长度
Python 中的 len() 函数是用来获取序列（如字符串、列表、元组等）长度的内置函数。所谓“长度”，就是指序列中元素的数量。
语法如下：len(list_name)
下面是代码示例：
length = len(fruits)
# 解释：获取fruits列表中元素的数量。
# 结果：长度为 5
列表反转
在 Python 中，列表（list）的 reverse 方法用于将列表中的元素顺序进行反转。这个方法会直接修改原列表，而不是返回一个新的反转后的列表。
语法如下：list_name.reverse()
下面是示例代码：
fruits.reverse()
# 解释：颠倒fruits列表中元素的顺序。
# 结果：当前fruits列表更新为 ["pineapple", "orange", "mango", "cherry", "apple"]
获取索引
在 Python 中，列表（list）的 index 方法用于查找列表中某个值的第一个匹配项的索引位置。如果找到了该值，index 方法将返回它的索引；如果没有找到，将会引发一个 ValueError 异常。
语法如下：list_name.index(element)
下面是代码示例：
index_of_cherry = fruits.index("cherry")
# 解释：查找fruits列表中第一次出现"cherry"的索引。
# 结果：index_of_cherry变量值为 3
检测元素是否存在
在 Python 中，in 关键字是一个用于成员运算的表达式，它用于检查一个对象是否存在于某个序列（如列表、元组、字符串等）中。如果对象存在于序列中，in 表达式将返回 True，否则返回 False。
语法如下：element in list_name
下面是代码示例：
is_apple_present = "apple" in fruits
# 解释：检查fruits列表中是否存在"apple"。
# 结果：is_apple_present变量值为 True
统计
在 Python 中，列表（list）的 count 方法用于统计列表中某个元素出现的次数。当你需要知道某个特定值在列表中出现了多少次时，这个方法非常有用。
语法如下：list_name.count(element)
下面是代码示例：
count_of_orange = fruits.count("orange")
# 解释：计算fruits列表中"orange"出现的次数。
# 结果：count_of_orange变量值为 1
排序
Python 列表的 sort 方法用于对列表中的元素进行排序。这个方法直接修改原列表，使其元素按照一定的顺序排列。默认情况下，sort 方法按照升序对列表进行排序。
语法如下：list_name.sort()
下面是代码示例：
fruits.sort()
# 解释：我们按升序对fruits列表中的元素进行排序。
# 结果：当前fruits列表更新为 ["apple", "cherry", "mango", "orange", "pineapple"]
自定义排序
Python 列表的 sort 方法的 key 参数是一个函数，它接受一个参数并返回一个值，这个值会被用作排序的依据。key 参数允许你自定义排序时比较的键，从而实现对列表中复杂对象的排序。
想象一下，你有一系列食谱卡，每张卡都有一个成分列表。现在，你不想按标题的字母顺序对这些食谱卡进行排序，而是根据每个食谱所需的成分数量对其进行排序。这里我们就可以使用key参数进行自定义排序。
下面是执行此操作的语法：
list_name.sort(key=function)
sorted_list = sorted(list_name, key=function)
现在让我们看一个例子：
假设我们有一个食谱卡列表，其中每张卡片都是一个元组，其中包含食谱名称和所需成分的数量：
recipes = [("Apple Pie", 9), ("Chocolate Cake", 7), ("Salad", 4), ("Pancakes", 6)]
如果我们想根据所需的成分数量对这些食谱卡进行排序，我们可以使用自定义排序功能：
# 定义一个函数，用于从每个配方元组中提取成分的数量
def get_num_ingredients(recipe):
return recipe[1]
# 根据成分的数量对食谱进行排序
recipes.sort(key=get_num_ingredients)
# 结果：食谱内容更新为 [("Salad", 4), ("Pancakes", 6), ("Chocolate Cake", 7), ("Apple Pie", 9)]
- 我们定义了一个函数
get_num_ingredients，该函数将配方元组作为输入并返回元组的第二个元素（成分数量）。 - 然后，我们将此函数用作
sort方法中的key参数。Python 将在每个配方元组上调用此函数，并使用返回的值进行排序。 - 因此，食谱根据所需的成分数量从小到大进行排序。
key 参数非常强大，因为它允许你根据任何可比较的值来排序，而不仅仅是列表元素的直接值。这使得 sort 方法非常灵活，可以应对各种排序需求。
高级特性
列表推导
列表推导是一种在 Python 中用来创建列表的简洁方法。它允许你通过对现有的可迭代对象（比如列表、元组、集合或者其他可迭代对象）应用一个表达式来快速创建新的列表。
示例 1：生成数字的平方
传统方法是先初始化一个空列表，然后遍历数字序列，求出每个数字的平方，并将其追加到列表中。而列表推导能在一行代码中完成同样的任务，直接遍历数字序列并生成平方值的列表。
# 传统方法：
squares = []
for x in range(5):
squares.append(x**2)
# 解释：
# 在传统方法中，我们初始化一个空列表。
# 然后，使用 range() 函数循环遍历从 0 到 4 的数字。
# 对于每个数字x，计算其平方 (x**2) 并将其附加到squares列表中。
# 列表推导：
squares = [x**2 for x in range(5)]
# 解释：
# 通过列表推导，我们可以在一行中实现相同的结果。
# 我们使用紧凑的语法来迭代从 0 到 4 的数字，并直接计算它们的平方，
# 一次性完成squares列表的创建。
示例 2：生成偶数
同样，在生成偶数列表时，也可以使用列表推导来简化代码，首先遍历数字列表，并且仅包含能被 2 整除的数字，从而无需额外的条件语句。
# 传统方法：
even_numbers = []
for x in range(10):
if x % 2 == 0:
even_numbers.append(x)
# 解释：
# 在传统方法中，我们初始化一个空列表 'even_numbers'。
# 然后，使用 range（） 函数循环从 0 到 9 的数字。
# 对于每个数字‘x‘，我们检查它是否为偶数（可被 2 整除），如果是，我们将其附加到even_numbers列表中。
# 列表推导：
even_numbers = [x for x in range(10) if x % 2 == 0]
# 解释：
# 通过列表推导，我们可以更简洁地完成相同目的。
# 我们使用紧凑的语法来迭代从 0 到 9 的数字，并且只包括那些偶数的数字，
# 直接在一行中完成even_numbers列表创建。
示例 3：生成字符串列表
列表推导不仅限于数字运算，还可以将其用于字符串操作。例如，可以在一行中将名称列表转换为大写，从而使代码更加简洁和易读。
# 传统方法：
names = ['Alice', 'Bob', 'Charlie']
uppercase_names = []
for name in names:
uppercase_names.append(name.upper())
# 解释：
# 在传统方法中，我们初始化一个空列表 'uppercase_names'。
# 然后，我们遍历names列表。
# 对于每个元素（字符串），我们调用其 upper() 方法将其转换为大写，并将结果添加到uppercase_names列表中。
# 列表推导：
uppercase_names = [name.upper() for name in names]
# 解释：
# 通过列表推导，我们可以更简洁地方法获得相同的结果。
# 使用一个紧凑的语法来遍历names列表中的元素。
# 使用 upper() 方法将每个元素（字符串）转换为大写，
# 直接在一行中完成uppercase_names列表的创建。
示例 4：生成元组列表
列表推导允许通过嵌套循环结构，以简洁的方式生成组合元素，例如数字对。这种语法消除了传统嵌套循环的复杂性，使得创建组合元素变得轻而易举。
# 传统方法：
pairs = []
for x in range(3):
for y in range(2):
pairs.append((x, y))
# 解释：
# 在传统方法中，我们初始化一个空列表。
# 然后我们使用嵌套循环来遍历 x 和 y 的所有值。
# For each combination, we create a tuple (x, y) and append it to the 'pairs' list.
# 对于每个组合，我们创建一个元组 （x， y） 并将其附加到 'pairs' 列表中。
# 创建元组 (x, y) 并将其附加到pairs列表中。
# 列表推导：
pairs = [(x, y) for x in range(3) for y in range(2)]
# 解释：
# 通过列表推导，我们可以用更紧凑地语法获得相同的结果。
# 我们使用带有嵌套循环的紧凑语法来遍历 x 和 y 的所有值，
# 直接在一行中完成元组列表的创建。
示例 5：生成组合列表
列表推导同时支持条件表达式，以便根据特定条件筛选结果。这使得列表推导在执行多样化的列表生成任务时显得异常强大。
# 传统方法：
combinations = []
for x in range(1, 4):
for y in range(1, 4):
if x != y:
combinations.append((x, y))
# 解释：
# 在传统方法中，我们初始化一个空列表。
# 然后，我们使用嵌套循环来遍历 x 和 y 的所有值。
# 当 x 不等于 y 时，创建一个元组 (x, y) 并将其附加到combinations列表中。
# 列表推导：
combinations = [(x, y) for x in range(1, 4) for y in range(1, 4) if x != y]
# 解释：
# 通过列表推导，我们可以更简洁方式获得相同的结果。
# 我们使用带有嵌套循环和条件表达式的紧凑语法来遍历 x 和 y 的所有值，
# 并且排除 x 等于 y 的情况，
# 直接在一行中完成了元组列表的创建。
嵌套列表
Python 的列表支持嵌套，从而创建多维数据结构，如矩阵和表。这种能力对于表示和操作复杂数据集至关重要。接下来，我们将深入了解如何有效运用嵌套列表。
创建嵌套列表
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
在此示例中，我们定义了一个嵌套列表nested_list其中包含三个内部列表，每个列表表示矩阵中的一行。
访问嵌套列表中的元素
若要访问嵌套列表中的元素，需使用对应每一级列表的索引。例如：
print(nested_list[0][1]) # 输出: 2
此代码访问嵌套列表的第 0 行和第 1 列中的元素，输出值为 2。
循环访问嵌套列表
通过使用嵌套循环，可以逐层遍历嵌套列表。外部循环负责遍历嵌套列表的最外层，而内部循环则负责嵌套列表的内部子元素列表的遍历。例如：
for sublist in nested_list:
for item in sublist:
print(item)
这段代码遍历了nested_list中的每个子列表，并且输出每个子列表中的元素。
示例 1：对嵌套列表中的元素求和
total_sum = 0
for sublist in nested_list:
for item in sublist:
total_sum += item
print("Total Sum:", total_sum)
在此示例中，我们逐个遍历子列表及其内部元素，对嵌套列表中的所有元素求和。
示例 2：在嵌套列表中查找最大值
max_value = float('-inf') # 使用负无穷大初始化
for sublist in nested_list:
for item in sublist:
if item > max_value:
max_value = item
print("Maximum Value:", max_value)
在此示例中，我们通过遍历嵌套列表中的每个子列表及其元素，查找最大值，并在发现更大值时更新max_value变量。
结语
本文深入介绍了 Python 列表的基础知识、常用操作和一些实用高级特性。现在，你已具备充分的知识，能够在各种编程场景中灵活运用这一强大的数据结构。
