【基础】Python数据结构与数据类型介绍

# 1. Python数据结构概述**

Python数据结构是用于组织和存储数据的抽象数据类型。它们提供了高效管理和处理数据的机制，是Python编程中至关重要的组成部分。数据结构的类型决定了数据的存储方式、访问方式和操作方式。Python提供了广泛的数据结构，从基本类型到高级类型，满足各种编程需求。

# 2. Python基本数据类型

Python的基本数据类型是构成更高级数据结构的基础。它们包括数值类型、字符串类型和布尔类型。理解这些基本数据类型的特性对于有效地使用Python进行数据处理至关重要。

### 2.1 数值类型

数值类型用于表示数字值，包括整数、浮点数和复数。

#### 2.1.1 整数

整数表示没有小数部分的整数值。它们可以使用十进制（如10）、八进制（如0o12）或十六进制（如0x10）表示。

# 十进制整数
x = 10

# 八进制整数
y = 0o12

# 十六进制整数
z = 0x10

print(type(x))  # <class 'int'>
print(type(y))  # <class 'int'>
print(type(z))  # <class 'int'>

#### 2.1.2 浮点数

浮点数表示带有小数部分的数字值。它们使用科学计数法表示，其中小数点后跟指数。

# 浮点数
x = 3.14

# 科学计数法表示
y = 6.022e23

print(type(x))  # <class 'float'>
print(type(y))  # <class 'float'>

#### 2.1.3 复数

复数表示具有实部和虚部的数字值。它们使用`complex()`函数创建，其中实部和虚部用逗号分隔。

# 复数
x = complex(1, 2)

# 实部
print(x.real)  # 1.0

# 虚部
print(x.imag)  # 2.0

### 2.2 字符串类型

字符串类型用于表示文本数据。它们由一组字符组成，并使用单引号（'）、双引号（"）或三引号（'''或"""）括起来。

#### 2.2.1 字符串的定义和操作

字符串可以通过赋值语句或`str()`函数创建。它们支持各种操作，包括连接、切片和格式化。

# 创建字符串
my_string = 'Hello, world!'

# 连接字符串
new_string = my_string + ' How are you?'

# 切片字符串
print(new_string[0:5])  # Hello

# 格式化字符串
formatted_string = f'My name is {my_name} and I am {my_age} years old.'

#### 2.2.2 字符串的格式化和转换

字符串可以使用`format()`方法或f-字符串格式化。它们还可以使用`int()`、`float()`和`str()`函数进行转换。

# 使用format()方法格式化字符串
formatted_string = 'My name is {} and I am {} years old.'.format(my_name, my_age)

# 使用f-字符串格式化字符串
formatted_string = f'My name is {my_name} and I am {my_age} years old.'

# 将字符串转换为整数
my_int = int(my_string)

# 将字符串转换为浮点数
my_float = float(my_string)

### 2.3 布尔类型

布尔类型表示真假值。它们仅有两个可能的值：`True`和`False`。

#### 2.3.1 布尔值的定义和操作

布尔值可以通过赋值语句或`bool()`函数创建。它们支持逻辑运算符，包括`and`、`or`和`not`。

# 创建布尔值
my_bool = True

# 逻辑运算
print(my_bool and False)  # False
print(my_bool or False)  # True
print(not my_bool)  # False

#### 2.3.2 布尔运算符

布尔运算符用于组合布尔值并产生新的布尔值。

| 运算符 | 描述 |
|---|---|
| `and` | 如果两个操作数都为True，则返回True；否则返回False。 |
| `or` | 如果任何一个操作数为True，则返回True；否则返回False。 |
| `not` | 对操作数取反，即True变为False，False变为True。 |

# 3. Python高级数据类型

### 3.1 列表

#### 3.1.1 列表的定义和操作

列表是一种有序的可变序列，可以存储不同类型的数据元素。列表使用方括号 `[]` 定义，元素之间用逗号 `,` 分隔。例如：

my_list = [1, 2.5, 'Hello', True]

列表支持丰富的操作，包括：

- **添加元素：** 使用 `append()` 方法在列表末尾添加元素，`insert()` 方法在指定位置插入元素。
- **删除元素：** 使用 `remove()` 方法删除指定元素，`pop()` 方法删除指定位置的元素。
- **修改元素：** 直接赋值修改指定位置的元素。
- **切片：** 使用 `[start:end:step]` 语法切片列表，提取指定范围的元素。
- **遍历：** 使用 `for` 循环或 `list comprehension` 遍历列表中的元素。

#### 3.1.2 列表的切片和遍历

**切片**

切片语法 `[start:end:step]` 用于提取列表中指定范围的元素：

- `start`：起始索引（包含）
- `end`：结束索引（不包含）
- `step`：步长（默认为 1）

例如：

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

# 提取从索引 2 到索引 6（不包含）的元素
sub_list = my_list[2:6]  # [3, 4, 5, 6]

# 提取从索引 0 到索引 9，步长为 2 的元素
sub_list = my_list[0:9:2]  # [1, 3, 5, 7, 9]

**遍历**

遍历列表中的元素有两种常见方法：

- **for 循环：**

for element in my_list:
    print(element)

- **列表解析：**

new_list = [element for element in my_list if element % 2 == 0]

### 3.2 元组

#### 3.2.1 元组的定义和操作

元组是一种有序的不可变序列，可以存储不同类型的数据元素。元组使用圆括号 `()` 定义，元素之间用逗号 `,` 分隔。例如：

my_tuple = (1, 2.5, 'Hello', True)

元组支持有限的操作，包括：

- **元素访问：** 使用索引访问元组中的元素。
- **切片：** 使用 `[start:end:step]` 语法切片元组，提取指定范围的元素。
- **遍历：** 使用 `for` 循环或 `tuple comprehension` 遍历元组中的元素。

#### 3.2.2 元组的不可变性

与列表不同，元组是不可变的，这意味着其元素不能被修改或删除。一旦创建，元组的内容就无法更改。这确保了元组数据的完整性和一致性。

### 3.3 字典

#### 3.3.1 字典的定义和操作

字典是一种无序的键值对集合，用于存储和检索数据。字典使用大括号 `{}` 定义，键和值之间用冒号 `:` 分隔，键值对之间用逗号 `,` 分隔。例如：

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

字典支持丰富的操作，包括：

- **添加键值对：** 使用 `my_dict[key] = value` 语法添加键值对。
- **获取值：** 使用 `my_dict[key]` 获取指定键对应的值。
- **删除键值对：** 使用 `del my_dict[key]` 删除指定键对应的键值对。
- **检查键是否存在：** 使用 `in` 操作符检查字典中是否存在指定的键。
- **遍历：** 使用 `for` 循环或 `dict comprehension` 遍历字典中的键值对。

#### 3.3.2 字典的键值对操作

字典中的键必须是不可变的类型，如字符串、数字或元组。值可以是任何类型的数据。

键值对操作包括：

- **获取值：** 使用 `my_dict[key]` 获取指定键对应的值。
- **设置值：** 使用 `my_dict[key] = value` 设置指定键对应的值。
- **删除键值对：** 使用 `del my_dict[key]` 删除指定键对应的键值对。

# 4. Python数据结构的应用

### 4.1 数据结构在数据处理中的应用

数据结构在数据处理中扮演着至关重要的角色，提供了一种组织和管理数据的有效方式。Python中常用的数据结构，如列表、元组和字典，在数据存储、处理和查找方面具有广泛的应用。

#### 4.1.1 列表和元组在数据存储和处理中的应用

**列表**是Python中一种可变的有序数据集合，可以存储不同类型的数据元素。列表在数据存储和处理中非常灵活，支持增删改查等多种操作。例如，我们可以使用列表存储一组学生成绩，并通过索引访问或修改特定学生的成绩。

# 创建一个学生成绩列表
grades = [90, 85, 95, 78, 88]

# 访问第一个学生的成绩
print(grades[0])  # 输出：90

# 修改第三个学生的成绩
grades[2] = 92

# 遍历列表并打印所有成绩
for grade in grades:
    print(grade)

**元组**与列表类似，也是一种有序数据集合，但元组一旦创建就不能被修改。元组的不可变性使其非常适合存储不会改变的数据，如日期或坐标。

# 创建一个元组存储日期
date = (2023, 3, 8)

# 访问元组中的元素
print(date[0])  # 输出：2023
print(date[1])  # 输出：3
print(date[2])  # 输出：8

# 尝试修改元组中的元素（会报错）
try:
    date[0] = 2024
except TypeError:
    print("元组不可变，无法修改元素")

#### 4.1.2 字典在数据查找和映射中的应用

**字典**是一种无序的数据集合，它使用键值对来存储数据。字典在数据查找和映射方面非常高效，可以通过键快速获取对应的数据值。例如，我们可以使用字典存储单词及其含义，并通过单词查找其含义。

# 创建一个单词含义字典
dictionary = {"apple": "水果", "banana": "水果", "car": "交通工具"}

# 通过键查找单词含义
print(dictionary["apple"])  # 输出：水果

# 添加一个新的键值对
dictionary["computer"] = "电子设备"

# 遍历字典并打印所有键值对
for key, value in dictionary.items():
    print(f"{key}: {value}")

### 4.2 数据结构在算法中的应用

数据结构在算法中也扮演着重要的角色，影响着算法的效率和性能。不同的数据结构适用于不同的算法，选择合适的数据结构可以显著提高算法的性能。

#### 4.2.1 列表和栈在深度优先搜索中的应用

**深度优先搜索（DFS）**是一种遍历树或图的算法，它沿着当前路径一直深入，直到无法再深入，然后回溯到上一个未访问的节点继续遍历。列表和栈是DFS中常用的数据结构，用于存储已访问的节点和待访问的节点。

# 使用列表实现深度优先搜索
def dfs(graph, start):
    visited = []  # 已访问的节点列表
    stack = [start]  # 待访问的节点栈

    while stack:
        node = stack.pop()  # 弹出栈顶节点
        if node not in visited:
            visited.append(node)  # 将节点标记为已访问
            for neighbor in graph[node]:  # 遍历节点的邻居
                if neighbor not in visited:
                    stack.append(neighbor)  # 将邻居压入栈中

#### 4.2.2 队列和优先队列在广度优先搜索中的应用

**广度优先搜索（BFS）**是一种遍历树或图的算法，它逐层遍历节点，先访问当前层的节点，然后再访问下一层的节点。队列和优先队列是BFS中常用的数据结构，用于存储待访问的节点。

# 使用队列实现广度优先搜索
def bfs(graph, start):
    visited = []  # 已访问的节点列表
    queue = [start]  # 待访问的节点队列

    while queue:
        node = queue.pop(0)  # 弹出队列首节点
        if node not in visited:
            visited.append(node)  # 将节点标记为已访问
            for neighbor in graph[node]:  # 遍历节点的邻居
                if neighbor not in visited:
                    queue.append(neighbor)  # 将邻居压入队列中

# 5. Python数据结构的优化

### 5.1 数据结构的选择优化

**5.1.1 根据数据特征选择合适的数据结构**

选择数据结构时，需要考虑数据的特征，如数据类型、数据量、数据访问模式等。例如：

- 如果需要存储大量同类型的数据，且数据访问模式主要是顺序访问，则可以使用列表或元组。
- 如果需要存储键值对数据，且需要快速查找，则可以使用字典。
- 如果需要存储有序数据，且需要快速插入和删除，则可以使用堆或优先队列。

**5.1.2 考虑数据结构的时空复杂度**

在选择数据结构时，也需要考虑其时空复杂度。时空复杂度是指数据结构在不同操作下的时间和空间消耗。例如：

- 列表的插入和删除操作的时间复杂度为 O(n)，其中 n 为列表的长度。
- 字典的查找操作的时间复杂度为 O(1)，其中 1 为常数。
- 堆的插入和删除操作的时间复杂度为 O(log n)，其中 n 为堆的大小。

### 5.2 数据结构的性能优化

**5.2.1 使用合适的数据结构算法**

不同的数据结构有不同的算法实现，选择合适的算法可以优化数据结构的性能。例如：

- 使用快速排序算法对列表进行排序，时间复杂度为 O(n log n)。
- 使用哈希表算法实现字典，可以快速查找键值对。
- 使用斐波那契堆算法实现优先队列，可以高效地进行插入和删除操作。

**5.2.2 避免不必要的复制和拷贝**

在使用数据结构时，应避免不必要的复制和拷贝操作。例如：

- 使用切片操作获取列表的一部分，而不是复制整个列表。
- 使用字典的 `copy()` 方法复制字典，而不是直接赋值。
- 使用 `itertools.chain()` 方法连接多个迭代器，而不是创建新的列表。