Python内置数据结构

当然有！Python 提供了许多内置的数据结构，这些数据结构在编写高效的算法和处理数据时非常有用。下面是一些常见的 Python 内置数据结构的详细介绍：

基本类型

1. 列表（List）

列表是一个有序的集合，可以包含任意类型的元素，支持索引、切片、添加、删除、修改等操作。

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 访问元素
print(my_list[0])  # 输出: 1

# 切片
print(my_list[1:3])  # 输出: [2, 3]

# 添加元素
my_list.append(6)
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

# 删除元素
my_list.remove(3)
print(my_list)  # 输出: [1, 2, 4, 5, 6]

2. 元组（Tuple）

元组是一个不可变的有序集合，一旦创建就不能修改。元组通常用于存储一组相关的数据。

# 创建一个元组
my_tuple = (1, 2, 3, 4, 5)

# 访问元素
print(my_tuple[0])  # 输出: 1

# 切片
print(my_tuple[1:3])  # 输出: (2, 3)

3. 集合（Set）

集合是一个无序的不重复元素集合，主要用于去重和集合运算。

# 创建一个集合
my_set = {1, 2, 3, 4, 5}

# 添加元素
my_set.add(6)
print(my_set)  # 输出: {1, 2, 3, 4, 5, 6}

# 删除元素
my_set.remove(3)
print(my_set)  # 输出: {1, 2, 4, 5, 6}

# 集合运算
another_set = {4, 5, 6, 7, 8}
print(my_set & another_set)  # 输出: {4, 5, 6} (交集)
print(my_set | another_set)  # 输出: {1, 2, 4, 5, 6, 7, 8} (并集)
print(my_set - another_set)  # 输出: {1, 2} (差集)

4. 字典（Dictionary）

字典是一个键值对集合，键必须是唯一的，通常用来存储映射关系。

# 创建一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 访问元素
print(my_dict['a'])  # 输出: 1

# 添加或修改元素
my_dict['d'] = 4
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 删除元素
del my_dict['b']
print(my_dict)  # 输出: {'a': 1, 'c': 3, 'd': 4}

高级类型

5. 栈（Stack）

栈是一种后进先出（LIFO, Last In First Out）的数据结构，通常使用列表来实现。

# 使用列表实现栈
stack = []

# 压栈（添加元素）
stack.append(1)
stack.append(2)
stack.append(3)
print(stack)  # 输出: [1, 2, 3]

# 弹栈（移除元素）
print(stack.pop())  # 输出: 3
print(stack)  # 输出: [1, 2]

6. 队列（Queue）

队列是一种先进先出（FIFO, First In First Out）的数据结构，通常使用 collections.deque 来实现。

from collections import deque

# 使用 deque 实现队列
queue = deque()

# 入队（添加元素）
queue.append(1)
queue.append(2)
queue.append(3)
print(queue)  # 输出: deque([1, 2, 3])

# 出队（移除元素）
print(queue.popleft())  # 输出: 1
print(queue)  # 输出: deque([2, 3])

7. 优先队列/堆（Priority Queue）

优先队列是一种每次取出优先级最高的元素的数据结构，通常使用 heapq 模块来实现。

import heapq

# 创建一个优先队列
priority_queue = []

# 添加元素
heapq.heappush(priority_queue, (1, 'task1'))
heapq.heappush(priority_queue, (3, 'task3'))
heapq.heappush(priority_queue, (2, 'task2'))

# 取出优先级最高的元素
print(heapq.heappop(priority_queue)) # 输出: (1, 'task1')
print(heapq.heappop(priority_queue)) # 输出: (2, 'task2')
print(heapq.heappop(priority_queue)) # 输出: (3, 'task3')

import heapq

# 创建一个堆
heap = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
heapq.heapify(heap)
print(heap) # 输出: [0, 1, 2, 3, 7, 5, 4, 6, 8, 9]

# 添加元素
heapq.heappush(heap, -1)
print(heap) # 输出: [-1, 0, 2, 3, 1, 5, 4, 6, 8, 9, 7]

# 删除最小元素
min_element = heapq.heappop(heap)
print(min_element) # 输出: -1
print(heap) # 输出: [0, 1, 2, 3, 7, 5, 4, 6, 8, 9]

8. 双端队列（Deque）

双端队列是一种可以在两端高效添加和删除元素的数据结构，使用 collections.deque 来实现。

from collections import deque

# 创建一个双端队列
deque = deque([1, 2, 3])

# 从右端添加元素
deque.append(4)
print(deque) # 输出: deque([1, 2, 3, 4])

# 从左端添加元素
deque.appendleft(0)
print(deque) # 输出: deque([0, 1, 2, 3, 4])

# 从右端删除元素
deque.pop()
print(deque) # 输出: deque([0, 1, 2, 3])

# 从左端删除元素
deque.popleft()
print(deque) # 输出: deque([1, 2, 3])

9. 树（Tree）

树是一种分层的数据结构，最常见的是二叉树。我们通常通过定义一个节点类来实现树。

class TreeNode:
    def __init__(self, value=0, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

# 创建一个二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

# 遍历二叉树（例如，前序遍历）
def preorder_traversal(node):
    if node:
        print(node.value, end=' ')
        preorder_traversal(node.left)
        preorder_traversal(node.right)

preorder_traversal(root)  # 输出: 1 2 4 5 3

10. 图（Graph）

图是一种由节点（顶点）和边组成的复杂数据结构，通常使用字典来表示邻接表。

# 使用字典实现图的邻接表
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# 深度优先搜索（DFS）
def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')
    for next in graph[start]:
        if next not in visited:
            dfs(graph, next, visited)

dfs(graph, 'A')  # 输出: A B D E F C

# 广度优先搜索（BFS）
from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            visited.add(vertex)
            print(vertex, end=' ')
            queue.extend([node for node in graph[vertex] if node not in visited])

bfs(graph, 'A')  # 输出: A B C D E F

11. 计数器（Counter）

collections 模块中的 Counter 类用于计数，可用于统计元素出现的次数。

from collections import Counter

# 创建一个计数器
counter = Counter(['a', 'b', 'c', 'a', 'b', 'a'])
print(counter) # 输出: Counter({'a': 3, 'b': 2, 'c': 1})

# 访问计数
print(counter['a']) # 输出: 3
print(counter['d']) # 输出: 0 (不存在的元素计数为0)