Python3数据结构知识点有哪些

Python3数据结构知识点有哪些

Python3 是一种功能强大的编程语言，提供了丰富的数据结构来帮助开发者高效地处理和组织数据。掌握这些数据结构对于编写高效、可维护的代码至关重要。本文将介绍 Python3 中常用的数据结构及其相关知识点。

1. 列表（List）

列表是 Python 中最常用的数据结构之一，它是一个有序的可变序列，可以存储任意类型的元素。

1.1 创建列表

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

1.2 常用操作

• 访问元素：通过索引访问列表中的元素。

  
  print(my_list[0])  # 输出: 1
  

• 修改元素：通过索引修改列表中的元素。

  
  my_list[0] = 10
  

• 添加元素：使用 append() 方法在列表末尾添加元素。

  
  my_list.append(6)
  

• 删除元素：使用 remove() 方法删除指定元素，或使用 pop() 方法删除指定索引的元素。

  
  my_list.remove(10)
  my_list.pop(0)
  

• 列表切片：使用切片操作获取子列表。

  
  sub_list = my_list[1:3]
  

2. 元组（Tuple）

元组与列表类似，但元组是不可变的，即一旦创建就不能修改。

2.1 创建元组

my_tuple = (1, 2, 3, 4, 5)

2.2 常用操作

• 访问元素：通过索引访问元组中的元素。

  
  print(my_tuple[0])  # 输出: 1
  

• 元组解包：将元组中的元素解包到多个变量中。

  
  a, b, c = my_tuple[:3]
  

3. 集合（Set）

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

3.1 创建集合

my_set = {1, 2, 3, 4, 5}

3.2 常用操作

• 添加元素：使用 add() 方法向集合中添加元素。

  
  my_set.add(6)
  

• 删除元素：使用 remove() 方法删除指定元素。

  
  my_set.remove(1)
  

• 集合运算：支持并集、交集、差集等运算。

  
  set1 = {1, 2, 3}
  set2 = {3, 4, 5}
  union_set = set1 | set2  # 并集
  intersection_set = set1 & set2  # 交集
  difference_set = set1 - set2  # 差集
  

4. 字典（Dictionary）

字典是一种键值对（key-value）结构，键必须是唯一的，值可以是任意类型。

4.1 创建字典

my_dict = {'name': 'Alice', 'age': 25}

4.2 常用操作

• 访问元素：通过键访问字典中的值。

  
  print(my_dict['name'])  # 输出: Alice
  

• 修改元素：通过键修改字典中的值。

  
  my_dict['age'] = 26
  

• 添加元素：通过新的键值对添加元素。

  
  my_dict['gender'] = 'female'
  

• 删除元素：使用 pop() 方法删除指定键的元素。

  
  my_dict.pop('age')
  

5. 字符串（String）

字符串是不可变的字符序列，常用于文本处理。

5.1 创建字符串

my_string = "Hello, World!"

5.2 常用操作

• 访问字符：通过索引访问字符串中的字符。

  
  print(my_string[0])  # 输出: H
  

• 字符串切片：使用切片操作获取子字符串。

  
  sub_string = my_string[0:5]
  

• 字符串拼接：使用 + 操作符拼接字符串。

  
  new_string = my_string + " How are you?"
  

• 字符串格式化：使用 format() 方法或 f-string 进行字符串格式化。

  
  formatted_string = "Name: {}, Age: {}".format('Alice', 25)
  formatted_string_f = f"Name: {'Alice'}, Age: {25}"
  

6. 栈（Stack）和队列（Queue）

栈和队列是两种常用的线性数据结构，Python 中可以使用列表或 collections 模块中的 deque 来实现。

6.1 栈

栈是一种后进先出（LIFO）的数据结构。

stack = []
stack.append(1)  # 入栈
stack.append(2)
stack.pop()  # 出栈，返回 2

6.2 队列

队列是一种先进先出（FIFO）的数据结构。

from collections import deque
queue = deque()
queue.append(1)  # 入队
queue.append(2)
queue.popleft()  # 出队，返回 1

7. 堆（Heap）

堆是一种特殊的树形数据结构，常用于优先队列的实现。Python 中的 heapq 模块提供了堆操作。

7.1 创建堆

import heapq
heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 2)

7.2 常用操作

• 获取最小元素：使用 heappop() 方法获取并删除堆中的最小元素。

  
  smallest = heapq.heappop(heap)  # 返回 1
  

• 堆排序：使用 heapq.heapify() 方法将列表转换为堆。

  
  heap_list = [3, 1, 2]
  heapq.heapify(heap_list)
  

8. 链表（Linked List）

链表是一种动态数据结构，由节点组成，每个节点包含数据和指向下一个节点的指针。Python 中可以使用自定义类来实现链表。

8.1 创建链表

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

# 创建链表
ll = LinkedList()
ll.head = Node(1)
second = Node(2)
third = Node(3)
ll.head.next = second
second.next = third

8.2 常用操作

• 遍历链表：从头节点开始，依次访问每个节点。

  
  current = ll.head
  while current:
    print(current.data)
    current = current.next
  

• 插入节点：在链表的任意位置插入新节点。

  
  new_node = Node(4)
  new_node.next = second.next
  second.next = new_node
  

• 删除节点：删除链表中的指定节点。

  
  second.next = third.next
  

9. 树（Tree）

树是一种层次化的数据结构，由节点和边组成，每个节点可以有多个子节点。Python 中可以使用自定义类来实现树。

9.1 创建树

class TreeNode:
    def __init__(self, data):
        self.data = data
        self.children = []

# 创建树
root = TreeNode(1)
child1 = TreeNode(2)
child2 = TreeNode(3)
root.children.append(child1)
root.children.append(child2)

9.2 常用操作

• 遍历树：可以使用深度优先搜索（DFS）或广度优先搜索（BFS）遍历树。 “`python def dfs(node): if node: print(node.data) for child in node.children: dfs(child)

dfs(root)

## 10. 图（Graph）

图是由节点和边组成的非线性数据结构，常用于表示网络关系。Python 中可以使用字典或自定义类来实现图。

### 10.1 创建图
```python
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D'],
    'C': ['A', 'D'],
    'D': ['B', 'C']
}

10.2 常用操作

• 遍历图：可以使用深度优先搜索（DFS）或广度优先搜索（BFS）遍历图。 “`python def dfs(graph, start, visited=None): if visited is None: visited = set() visited.add(start) print(start) for neighbor in graph[start]: if neighbor not in visited: dfs(graph, neighbor, visited)

dfs(graph, ‘A’) “`

总结

Python3 提供了丰富的数据结构，包括列表、元组、集合、字典、字符串、栈、队列、堆、链表、树和图等。掌握这些数据结构及其常用操作，可以帮助开发者更高效地处理和组织数据，编写出高质量的代码。