Python基础语法：基本数据类型（列表）

现实世界中总是存在一组一组的事物。"组"的概念作为基本数据类型的一种，它也是来源于我们去解决现实生活中的一些问题而产生的。它需要有“组”这样的一个数据类型来丰富我们的基本数据类型。

那么在Python中如何来表示“组”的概念呢？

在Python中表示“组”的方式有很多种，并不是只有一种。例如：列表、元组、集合都是可以表示组的数据类型。

1  列表的概述

Python中的列表是一种有序的数据集合，可以包含不同类型的元素。与数组相比，列表更加灵活，可以动态地添加、删除和修改元素。

2  列表的创建

2.1  使用方括号创建列表

我们可以使用方括号[]可以直接创建一个列表。例如：

my_list = [1, 2, 3, "Hello", True]

列表中的元素用英文逗号隔开，可以包含不同类型的元素（可能是字符串、数字、布尔值、列表、字典、元组、集体等）

2.2  使用list()函数创建列表

使用list()函数也可以将其他可迭代对象转换为列表。例如：

my_list = list("Hello")  # 结果为 ['H', 'e', 'l', 'l', 'o']

3  列表的基本操作

3.1  查找列表元素

3.1.1  通过索引访问列表中的元素

通过索引可以访问列表中的元素。索引从0开始。

my_list = [1, 2, 3, "Hello", True]
print(my_list[0])  # 输出：1

3.1.2  通过列表中的元素查找第一个匹配的索引位置

index(value, [start, [stop]]): 返回列表中某个值的第一个匹配项的索引位置。 

my_list = [1, 2, 3, 2, 4]  
index = my_list.index(2)  # index 是 1，因为2第一次出现在索引1的位置

3.1.3  查找列表中某个元素出现的次数

count(value): 返回列表中某个值出现的次数。 

my_list = [1, 2, 3, 2, 2, 4]  
count = my_list.count(2)  # count 是 3，因为2出现了3次

3.1.4  查找列表元素的个数

lst = [1, 2, 3, 4, 5]  
print(len(lst))  # 输出：5

3.1.5  通过切片获取列表中的一部分元素

切片可以获取列表中的一部分元素，并输出一个含有这部分元素的列表。

my_list = [1, 2, 3, "Hello", True]
print(my_list[1:4])  # 输出：[2, 3, 'Hello']

3.1.6  查找列表中的最大数或最小数

在Python中，你可以使用内置的 max() 和 min() 函数来查找列表中的最大数和最小数。这两个函数可以接受一个可迭代对象（如列表）作为参数，并返回其中的最大值或最小值。

# 定义一个列表  
numbers = [4, 2, 9, 7, 5, 1]  # 查找列表中的最大数  
max_num = max(numbers)  
print("最大数是:", max_num)  # 输出：最大数是: 9  # 查找列表中的最小数  
min_num = min(numbers)  
print("最小数是:", min_num)  # 输出：最小数是: 1

3.2  增加列表元素

3.2.1  在列表末尾添加新的元素

append(item) 是 Python 中列表（list）对象的一个方法，用于在列表的末尾添加一个新的元素。这个方法只接受一个参数，即你想要添加到列表中的元素。调用 append() 方法后，该元素会被添加到列表的末尾，并且列表的长度会相应增加。

# 创建一个空列表  
my_list = []  # 使用 append() 方法添加元素  
my_list.append(1)    # 列表变为 [1]  
my_list.append(2)    # 列表变为 [1, 2]  
my_list.append(3)    # 列表变为 [1, 2, 3]  # 打印列表以查看结果  
print(my_list)  # 输出: [1, 2, 3]

值得注意的是，append() 方法不会返回一个新的列表，而是直接修改原来的列表。

3.2.2  在列表末尾一次性追加另一个序列中的多个值（通过迭代）

extend(iterable) 是 Python 中列表（list）对象的另一个方法，用于将一个可迭代对象（如列表、元组、字符串或集合等）中的所有元素添加到列表的末尾。这与 append() 方法不同，append() 是将单个元素添加到列表末尾，而 extend() 是将一个可迭代对象中的所有元素“扩展”到列表中。

使用 extend() 方法时，不需要将可迭代对象转换为列表，它会自动将其元素添加到现有列表中。调用 extend() 后，原列表的长度会增加，等于被扩展的可迭代对象中元素的数量。

# 创建一个列表  
my_list = [1, 2, 3]  # 创建一个要扩展的可迭代对象（另一个列表）  
other_list = [4, 5, 6]  # 使用 extend() 方法将 other_list 中的元素添加到 my_list 的末尾  
my_list.extend(other_list)  # 打印列表以查看结果  
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

3.2.3  在列表中插入元素

insert() 方法是 Python 列表（list）对象的一个非常有用的方法，它允许你在列表的指定位置插入一个元素。这个方法接受两个参数：第一个参数是要插入新元素的位置的索引，第二个参数是要插入的新元素本身。

insert() 方法会改变原来的列表，将新元素添加到指定的索引位置，并将该位置及其之后的所有元素向后移动一位。如果指定的索引超出了列表当前的范围（即大于或等于列表的长度），新元素会被添加到列表的末尾。

# 创建一个列表  
my_list = [1, 2, 3, 5]  # 使用 insert() 方法在索引 3 的位置插入元素 4  
my_list.insert(3, 4)  # 打印列表以查看结果  
print(my_list)  # 输出: [1, 2, 3, 4, 5]

3.2.4  列表的拼接

list1 = [1, 2, 3]  
list2 = [4, 5, 6]  
result = list1 + list2  # 结果为 [1, 2, 3, 4, 5, 6]

3.3  改变列表的元素

3.3.1  索引赋值

在Python中，你可以通过直接访问列表的索引来改变列表中的元素。列表的索引是从0开始的整数，表示元素在列表中的位置。通过指定索引并为其分配一个新值，你可以更改该位置的元素。

# 创建一个列表  
my_list = [1, 2, 3, 4, 5]  # 改变索引为2的元素（即原来的元素3）为新的值10  
my_list[2] = 10  # 打印列表以查看结果  
print(my_list)  # 输出: [1, 2, 10, 4, 5]

请注意，如果你尝试访问或修改一个不存在的索引（即超出了列表当前的范围），Python会抛出一个 IndexError 异常。因此，在修改列表元素之前，确保你访问的索引是有效的。 

3.3.2  切片赋值

你可以使用切片来替换列表中的一部分元素。切片赋值允许你指定一个范围，并将该范围内的元素替换为新的元素或另一个列表的元素。

my_list = [1, 2, 3, 4, 5]  
my_list[1:3] = [10, 20]  # 替换索引1到2（不包含3）的元素  
print(my_list)  # 输出: [1, 10, 20, 4, 5]

3.3.3  改变列表的顺序

3.3.3.1  对原列表元素排序（升序或降序）

list 类型提供了一个 sort() 方法，它用于对列表中的元素进行排序。默认情况下，sort() 方法会按照升序对元素进行排序，但是你也可以通过指定参数来改变排序的顺序。

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]  my_list.sort()  # 默认按升序排序
print(my_list)  # 结果为 [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]

如果你想按照降序排序，你可以使用 sort() 方法的 reverse 参数，并将其设置为 True：

my_list = [5, 2, 3, 1, 4]  my_list.sort(reverse=True)  # 降序排序  
print(my_list)  # 输出: [5, 4, 3, 2, 1]

需要注意的是，sort() 方法会直接修改原始列表，并不会返回一个新的排序后的列表。

如果你希望保留原始列表的顺序，并同时获得一个排序后的列表，你可以使用内置的 sorted() 函数，它返回一个新的排序后的列表，而原始列表保持不变：

my_list = [5, 2, 3, 1, 4]
sorted_list = sorted(my_list)  # 创建一个新的升序排序后的列表
print(sorted_list)  # 输出: [1, 2, 3, 4, 5]
print(my_list)  # 输出: [5, 2, 3, 1, 4]，原始列表未改变

3.3.3.2  反转列表的元素顺序

list 类型有一个方法叫做 reverse()，它用于反转列表中的元素顺序。注意，reverse() 方法会直接修改原始列表，而不会返回一个新的反转后的列表。

my_list = [1, 2, 3, 4, 5]
my_list.reverse()  
print(my_list)  # my_list 现在是 [5, 4, 3, 2, 1]

在上面的例子中，my_list 初始化为 [1, 2, 3, 4, 5]，然后调用 my_list.reverse() 方法后，my_list 的元素顺序就被反转了，变为 [5, 4, 3, 2, 1]。最后，print(my_list) 将输出反转后的列表 [5, 4, 3, 2, 1]。

如果您想要保留原始列表的顺序并同时获得一个反转后的列表，您可以使用切片语法来创建一个新的反转列表，例如：

my_list = [1, 2, 3, 4, 5]  
reversed_list = my_list[::-1]  # 使用切片语法创建反转后的新列表  
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]  
print(my_list)  # 输出: [1, 2, 3, 4, 5]，原始列表未改变

在这个例子中，reversed_list 是通过切片语法 my_list[::-1] 创建的，它表示从列表末尾到开头每隔一个元素取一个，从而实现反转。这种方式不会改变原始 my_list。 

在实际应用中，使用切片或 reverse() 方法通常是反转列表的首选方式，因为它们既简单又高效。如果你需要保留原列表并获取一个反转后的新列表，应该使用切片。如果你只关心修改原列表并不需要新的列表，那么 reverse() 方法是更好的选择。

3.4  删除列表的元素

使用del语句、remove()方法或pop()方法可以删除列表中的元素。

my_list = [1, 2, 3, "Hello", True, 42]del my_list[2]  # 删除指定位置的元素  
my_list.remove('Hello')  # 删除第一个出现的指定元素  
my_list.pop()  # 删除并返回列表末尾的元素

3.4.1 移除列表中第一个匹配到的指定值的元素

remove(value) 方法用于移除列表中第一个匹配到的指定值的元素。如果元素不存在于列表中，它会抛出一个 ValueError。

my_list = [1, 2, 3, 4, 5]  
my_list.remove(3)  # 移除值为3的元素  
print(my_list)  # 输出: [1, 2, 4, 5]

3.4.2   移除列表中指定位置的元素

pop([index]) 方法用于移除列表中的一个元素（默认是最后一个），并返回该元素的值。你也可以指定一个索引来移除指定位置的元素。如果指定的索引超出范围，它会抛出一个 IndexError。 

my_list = [1, 2, 3, 4, 5]  
removed_element = my_list.pop()  # 移除并返回最后一个元素  
print(removed_element)  # 输出: 5  
print(my_list)  # 输出: [1, 2, 3, 4]  removed_element = my_list.pop(1)  # 移除并返回索引为1的元素  
print(removed_element)  # 输出: 2  
print(my_list)  # 输出: [1, 3, 4]

3.4.3  删除单个元素或切片范围内的多个元素

del 语句可以用来删除列表中的单个元素或切片范围内的多个元素。如果尝试删除不存在的索引，del 会抛出一个 IndexError。

my_list = [1, 2, 3, 4, 5]  
del my_list[1]  # 删除索引为1的元素  
print(my_list)  # 输出: [1, 3, 4, 5]  del my_list[1:3]  # 删除索引1到2（不包含3）的元素  
print(my_list)  # 输出: [1, 5]

在选择删除列表元素的方法时，请考虑你的具体需求，例如是否需要保留原列表、是否需要返回新列表，以及是否知道要删除元素的确切值或位置。

4  列表的高级特性

4.1  列表的嵌套

在Python中，列表（list）是一种可以包含任意类型元素的数据结构，其中元素本身也可以是列表，这就是所谓的列表的嵌套（nested lists）。列表的嵌套使得我们可以在单个列表中组织更复杂的数据结构。

4.1.1  创建嵌套列表

你可以通过直接在列表中放入其他列表来创建嵌套列表。

nested_list = [1, 2, [3, 4, 5], 6, [7, [8, 9]]]  

在这个例子中，nested_list 是一个包含整数和子列表的列表。子列表本身也可以包含其他子列表，形成了多层的嵌套结构。

4.1.2  访问嵌套列表的元素

你可以通过索引来访问嵌套列表中的元素。对于嵌套的子列表，你需要使用连续的索引来访问其内部的元素。

nested_list = [1, 2, [3, 4, 5], 6, [7, [8, 9]]]  
print(nested_list[2])       # 输出: [3, 4, 5]  
print(nested_list[2][1])    # 输出: 4  
print(nested_list[4][1][0]) # 输出: 8

4.1.3  修改嵌套列表的元素

你也可以修改嵌套列表中的元素，只要你知道如何访问它。

nested_list = [1, 2, [3, 4, 5], 6, [7, [8, 9]]]  
nested_list[2][1] = 10       # 将子列表中的4改为10  
print(nested_list)           # 输出: [1, 2, [3, 10, 5], 6, [7, [8, 9]]]

当处理嵌套列表时，要注意不要越界访问不存在的索引，这会导致 IndexError。同时，在修改嵌套列表时要小心，确保不会意外地修改到不应该修改的部分。

嵌套列表是Python中非常强大的数据结构，可以用于表示各种复杂的数据关系，如矩阵、树形结构等。掌握如何创建、访问、修改和遍历嵌套列表是Python编程的重要技能之一。

4.2  列表推导式

列表推导式（List Comprehension）是Python中一种非常强大且简洁的语法结构，用于快速生成列表。它通过一个简洁的表达式，结合 for 循环和 if 条件语句（可选），能够在单行代码中构建出新的列表。

列表推导式的基本语法结构为：[expression for item in iterable if condition]。其中，expression是用于生成新元素的表达式，item是iterable（可迭代对象）中的每个元素，condition是可选的过滤条件。这个结构允许你在一行代码中遍历整个可迭代对象，并根据需要应用表达式和过滤条件来生成新的列表。

squares = [x**2 for x in range(10) if x%2 != 0]
print(squares)  # 结果为 [1, 9, 25, 49, 81]

这个列表推导式包含一个条件表达式，用于筛选出满足特定条件的元素。这里是详细解释： 

• range(10)：同样生成一个包含从0到9的整数序列。

• for x in range(10)：遍历这个整数序列，每次循环时x被赋值为序列中的一个整数。

• if x%2 != 0：这是一个条件表达式，用于检查当前的x值是否为奇数。x%2计算x除以2的余数，如果余数不为0（即不等于0），那么x就是一个奇数。这个条件确保只有奇数值的x会被包含在最终的列表中。

• x**2：对满足条件的x值（即奇数）进行平方运算。

• [x**2 for x in range(10) if x%2 != 0]：整个列表推导式会生成一个新的列表，该列表中的元素是range(10)中每个奇数的平方。

• squares = ...：将新生成的列表赋值给变量squares。

• print(squares)：打印变量squares的值。

• 因此，squares的最终值为 [1, 9, 25, 49, 81]，这正好是从0到9中每个奇数的平方。
• 这个列表推导式展示了如何在生成新列表的同时应用条件过滤，只保留满足特定条件的元素。在这个例子中，条件是元素必须是奇数，然后对每个奇数进行平方运算。

5  列表在实际应用中的场景

5.1  存储和管理数据

列表是Python中存储和管理数据的一种非常常见且实用的方式，特别是在数据的顺序非常重要时。列表是一种有序的数据集合，可以包含任意类型的元素，包括数字、字符串、布尔值、其他列表等。这使得列表非常适合用于存储一系列相关的数据项。

以下是一些列表在存储和管理数据方面的主要优点：

1. 有序性：列表中的元素按照它们被添加的顺序进行排列。这使得列表非常适合用于存储需要保持特定顺序的数据，例如时间序列数据、排名列表等。

2. 灵活性：列表可以动态地添加、删除或修改其中的元素。这意味着列表可以随着数据的变化而调整其大小和内容，非常适合用于处理不固定数量的数据。

3. 可索引性：列表中的每个元素都可以通过其索引（位置）进行访问。这使得我们可以轻松地获取、修改或删除列表中的特定元素。

4. 嵌套性：列表可以包含其他列表作为元素，形成嵌套列表。这种嵌套结构使得列表能够表示更复杂的数据结构，如矩阵、树形结构等。

5. 内置方法：Python为列表提供了一系列内置方法，如append()、remove()、sort()等，用于执行常见的列表操作。这些方法使得列表的操作变得简单而高效。

下面是一个简单的示例，演示如何使用列表来存储和管理一系列学生的分数：

# 创建一个空列表来存储学生分数  
scores = []  # 向列表中添加学生分数  
scores.append(90)  
scores.append(85)  
scores.append(78)  
scores.append(92)  # 打印整个列表  
print(scores)  # 输出: [90, 85, 78, 92]  # 访问特定位置的分数  
print(scores[1])  # 输出: 85，访问第二个元素（索引从0开始）  # 修改特定位置的分数  
scores[1] = 88  
print(scores)  # 输出: [90, 88, 78, 92]  # 删除特定位置的分数  
scores.remove(78)  
print(scores)  # 输出: [90, 88, 92]  # 对分数进行排序  
scores.sort()  
print(scores)  # 输出: [88, 90, 92]，现在列表已按升序排列

5.2  实现栈和队列的数据结构

列表确实可以用来实现栈（Stack）和队列（Queue）这两种基本的数据结构。虽然Python中提供了专门的collections.deque来实现队列，但列表本身已经足够灵活，可以通过一些简单的操作来模拟这两种数据结构的行为。

5.3  列表在算法中的应用

许多算法，如排序算法、搜索算法等，都会用到列表。

Python中的列表是一种非常强大和灵活的数据结构，它可以包含不同类型的元素，并且支持各种操作来管理这些元素。