【基础】列表与元组的基本操作

-Method.webp)
# 1. 列表与元组的基本概念**

列表和元组是 Python 中两种重要的有序数据结构，用于存储和组织数据。列表是一个可变序列，允许元素的添加、删除和修改，而元组是一个不可变序列，一旦创建就不能修改。列表和元组在数据存储、处理和算法实现中都有广泛的应用。

# 2. 列表的基本操作

### 2.1 列表的创建和初始化

#### 2.1.1 使用中括号创建列表

最基本的方法是使用中括号 `[]` 来创建列表，列表中的元素之间用逗号分隔。例如：

my_list = [1, 2, 3, 4, 5]

#### 2.1.2 使用列表推导式创建列表

列表推导式提供了一种更简洁的方式来创建列表，它使用一个表达式来生成列表中的每个元素。语法如下：

[expression for item in iterable]

例如，以下代码创建一个包含数字 1 到 10 的列表：

my_list = [i for i in range(1, 11)]

### 2.2 列表的元素访问和修改

#### 2.2.1 通过索引访问元素

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

my_list = [1, 2, 3, 4, 5]
print(my_list[0])  # 输出 1

#### 2.2.2 通过切片访问元素

切片操作允许我们访问列表中连续的一段元素。语法如下：

my_list[start:end:step]

其中：

* `start` 是起始索引（可选）
* `end` 是结束索引（可选）
* `step` 是步长（可选，默认值为 1）

例如，以下代码创建一个包含列表中偶数元素的新列表：

my_list = [1, 2, 3, 4, 5]
even_list = my_list[1::2]  # [2, 4]

#### 2.2.3 修改列表元素

列表中的元素可以通过索引赋值进行修改。例如：

my_list = [1, 2, 3, 4, 5]
my_list[2] = 10
print(my_list)  # 输出 [1, 2, 10, 4, 5]

### 2.3 列表的常用操作

#### 2.3.1 列表的追加和删除

* `append()` 方法将元素追加到列表的末尾。
* `insert()` 方法将元素插入到指定索引处。
* `remove()` 方法删除第一个匹配的元素。
* `pop()` 方法删除并返回指定索引处的元素。

#### 2.3.2 列表的排序和反转

* `sort()` 方法对列表中的元素进行排序。
* `reverse()` 方法反转列表中的元素。

#### 2.3.3 列表的合并和拆分

* `extend()` 方法将另一个列表的元素追加到当前列表。
* `+` 运算符可以合并两个列表。
* `split()` 方法将列表拆分成多个子列表。

# 3.1 元组的创建和初始化

元组是 Python 中另一种有序且不可变的数据结构，与列表类似，但具有不同的特性。元组的创建和初始化可以使用以下两种方法：

#### 3.1.1 使用圆括号创建元组

最简单的方法是使用圆括号将元素括起来创建元组。例如：

my_tuple = (1, 2, 3)

此代码创建一个包含三个元素的元组，元素分别是 1、2 和 3。

#### 3.1.2 使用元组推导式创建元组

元组推导式是一种简洁的方式，可以从可迭代对象中创建元组。其语法与列表推导式类似，但使用圆括号而不是方括号。例如：

my_tuple = tuple(x for x in range(1, 4))

此代码创建一个包含三个元素的元组，元素分别是 1、2 和 3。

### 3.2 元组的元素访问和修改

#### 3.2.1 通过索引访问元素

与列表类似，可以使用索引访问元组中的元素。索引从 0 开始，表示元组中的第一个元素。例如：

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

#### 3.2.2 元组元素不可修改

与列表不同，元组中的元素是不可修改的。这意味着无法直接修改元组中的单个元素。例如：

my_tuple = (1, 2, 3)
my_tuple[0] = 4  # 报错：TypeError: 'tuple' object does not support item assignment

### 3.3 元组的常用操作

#### 3.3.1 元组的比较和哈希

元组支持比较操作，如相等（==）、不等（!=）、小于（<）、大于（>）、小于等于（<=）和大于等于（>=）。元组的比较基于其元素的比较。

元组还支持哈希操作。这意味着可以使用元组作为字典的键。

#### 3.3.2 元组的解包和转换

元组解包是一种将元组中的元素分配给变量的便捷方式。例如：

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c)  # 输出：1 2 3

元组还可以转换为其他数据结构，如列表和字符串。例如：

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
my_string = ', '.join(my_tuple)

# 4. 列表与元组的应用实践

### 4.1 列表与元组在数据存储中的应用

#### 4.1.1 存储有序数据

列表和元组都是有序数据结构，可以用来存储有序的数据。例如，我们可以使用列表来存储一个待办事项列表，其中每个元素都是一个待办事项。

tasks = ["买牛奶", "做饭", "打扫房间"]

我们可以使用索引来访问列表中的特定元素。例如，以下代码访问列表中的第一个元素（“买牛奶”）：

first_task = tasks[0]

元组也是有序数据结构，但与列表不同，元组是不可变的。这意味着元组中的元素不能被修改。这使得元组非常适合存储不会改变的数据，例如日期或时间。

date_of_birth = (1990, 1, 1)

#### 4.1.2 存储不可变数据

元组是不可变的，这意味着元组中的元素不能被修改。这使得元组非常适合存储不会改变的数据，例如日期或时间。

date_of_birth = (1990, 1, 1)

如果我们尝试修改元组中的元素，我们会得到一个错误：

>>> date_of_birth[0] = 1991
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

### 4.2 列表与元组在数据处理中的应用

#### 4.2.1 列表的循环遍历

列表可以很容易地使用 `for` 循环进行遍历。以下代码遍历列表中的每个元素并打印其值：

for task in tasks:
    print(task)

#### 4.2.2 元组的解包操作

元组可以使用解包操作来将元组中的元素分配给多个变量。以下代码将元组 `date_of_birth` 中的元素分配给变量 `year`, `month`, 和 `day`：

year, month, day = date_of_birth

### 4.3 列表与元组在算法实现中的应用

#### 4.3.1 列表的栈和队列实现

列表可以很容易地用来实现栈和队列。栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。

以下代码使用列表实现了一个栈：

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def is_empty(self):
        return len(self.items) == 0

以下代码使用列表实现了一个队列：

class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        return self.items.pop(0)

    def is_empty(self):
        return len(self.items) == 0

#### 4.3.2 元组的哈希表实现

元组可以用来实现哈希表。哈希表是一种数据结构，它允许我们根据键快速查找值。

以下代码使用元组实现了一个哈希表：

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in range(size)]

    def hash(self, key):
        return key % self.size

    def set(self, key, value):
        hash_value = self.hash(key)
        self.table[hash_value].append((key, value))

    def get(self, key):
        hash_value = self.hash(key)
        for k, v in self.table[hash_value]:
            if k == key:
                return v
        return None

# 5.1 列表与元组的生成器表达式

### 5.1.1 生成器表达式的语法和用法

生成器表达式是一种简洁高效的创建列表或元组的方式。其语法如下：

(expression for item in iterable if condition)

其中：

* `expression`：生成器表达式的输出表达式，可以是任意合法的 Python 表达式。
* `item`：生成器表达式中循环变量，用于遍历可迭代对象 `iterable`。
* `iterable`：可迭代对象，可以是列表、元组、集合等。
* `condition`：可选的条件表达式，用于过滤可迭代对象中的元素。

生成器表达式不会立即创建列表或元组，而是返回一个生成器对象。生成器对象在需要时才生成元素，从而节省了内存空间。

### 5.1.2 生成器表达式的应用场景

生成器表达式在以下场景中特别有用：

* **创建过滤后的序列：**使用 `if` 条件可以过滤可迭代对象中的元素，只生成满足条件的元素。
* **创建映射后的序列：**使用 `expression` 表达式可以对可迭代对象中的元素进行映射，生成新的序列。
* **创建嵌套序列：**生成器表达式可以嵌套使用，创建多维序列。
* **节省内存：**生成器表达式只在需要时生成元素，避免了创建不必要的中间序列，节省了内存空间。

**示例：**

# 创建一个包含偶数的列表
even_numbers = [x for x in range(10) if x % 2 == 0]

# 创建一个包含字符串长度的元组
string_lengths = tuple(len(x) for x in ["apple", "banana", "cherry"])