Python Data Structures Cheat Sheet

Python Data Structures Cheat Sheet

Cheat Sheet

Python Data Structures

Overview

特性ListTupleSetDictQueueStack
syntax[](){}{k: v}Queue()list
Mutability
Ordered
Duplicates
Index access
Slicing

Note

  1. In CPython 3.6, dictionaries were ordered by implementation detail, but in Python 3.7+ dictionary order was officially made part of the language specification. For more info: Are dictionaries ordered in Python 3.6+?
  2. List vs Tuple: While both can store ordered sequences, tuples are immutable and typically used for fixed collections of items that shouldn’t change (like coordinates or RGB values). Lists are mutable and better for collections that need to be modified.
  3. Set vs List: Sets are optimized for fast membership testing (O(1)) and eliminating duplicates, but don’t maintain order. Use sets when uniqueness matters more than order.
  4. Dict vs List: Dictionaries provide O(1) lookup by key, making them ideal for key-value mappings. Lists require O(n) for lookups by value.
  5. 关于tuple, 注意a = ('A')a = ('A',)的区别。前者是字符串,后者是元组。要创建一个单元素元组,必须在元素后加逗号。
Mutability
  • Mutable: Lists, Sets, Dicts, Queues, Stacks
  • Immutable: Tuples

可变性表示数据结构是否可以在创建后被修改。可变数据结构允许原地修改,而不可变数据结构则在创建后不能更改。这样设计主要出于性能和安全性考虑。不可变数据结构在函数调用中不会被意外修改,因此在多线程环境中更安全。它们也可以用作字典的键或集合的元素,因为它们的哈希值不会改变。

一个常见的pitfall是将可变对象(如列表或字典)作为默认参数传递给函数。这样做可能会导致意外的行为,因为默认参数在函数调用之间共享。

PYTHON
def append_to_list(value, my_list=[]):    my_list.append(value)    return my_listprint(append_to_list(1))  # [1]print(append_to_list(2))  # [1, 2] - unexpected behavior

API Cheat Sheet

List API

PYTHON
# 创建my_list = []                      # 空列表my_list = [1, 2, 3]               # 带初始值的列表my_list = list("abc")             # Create from Iterable : ['a', 'b', 'c']# 访问和修改item = my_list[0]                 # 索引访问my_list[1] = 10                   # 修改元素subset = my_list[1:3]             # 切片: 获取子列表subset = my_list[1:]              # 切片: 从指定位置到末尾subset = my_list[:2]              # 切片: 从开头到指定位置all_elements = my_list[:]         # 切片: 获取所有元素last_element = my_list[-1]        # 负索引访问: 获取最后一个元素# 常用方法my_list.append(4)                 # 添加元素到末尾my_list.insert(1, 5)              # 在指定位置插入my_list.extend([5, 6])            # 扩展列表my_list.pop()                     # 删除并返回最后一个元素my_list.pop(1)                    # 删除并返回指定位置元素my_list.remove(3)                 # 删除第一个值为3的元素my_list.sort()                    # 排序(原地修改)my_list.reverse()                 # 反转(原地修改)len(my_list)                      # 获取长度3 in my_list                      # 成员检测my_list.count(2)                  # 计数my_list.index(3)                  # 查找元素位置

Tuple API

Info

Tuple相比List移除了增删改的API, 它是hashable的,可以作为字典的键或集合的元素。
关于tuple的更多信息,可以学习解密 Python 元组的实现原理

PYTHON
# 创建my_tuple = ()                     # 空元组my_tuple = (1, 2, 3)              # 带初始值的元组,括号可省略my_tuple = tuple([1, 2, 3])       # Create from Iterable# 访问item = my_tuple[0]                # 索引访问subset = my_tuple[1:3]            # 切片# 常用方法len(my_tuple)                     # 长度3 in my_tuple                     # 成员检测my_tuple.count(2)                 # 计数my_tuple.index(3)                 # 查找元素位置

Set API

PYTHON
# 创建my_set = set()                    # 空集合my_set = {1, 2, 3}                # 带初始值的集合my_set = set([1, 2, 2, 3])        # Create from Iterable (自动去重)# 修改my_set.add(4)                     # 添加单个元素my_set.update([4, 5])             # 添加多个元素my_set.remove(1)                  # 删除元素(不存在会报错)my_set.discard(1)                 # 删除元素(不存在不报错)my_set.pop()                      # 随机删除并返回一个元素my_set.clear()                    # 清空集合len(my_set)                       # 长度3 in my_set                       # 成员检测(O(1)复杂度)# 集合操作set1 = {1, 2, 3}set2 = {3, 4, 5}union = set1 | set2         # 并集: {1, 2, 3, 4, 5}intersection = set1 & set2  # 交集: {3}difference = set1 - set2    # 差集: {1, 2}sym_diff = set1 ^ set2      # 对称差集: {1, 2, 4, 5}# 集合关系判断is_subset = set1 <= set2    # 判断是否为子集, or set1.issubset(set2)is_superset = set1 >= set2  # 判断是否为超集, or set1.issuperset(set2)is_disjoint = set1.isdisjoint(set2)  # 判断是否无交集is_subset = set1 <= set2    # 判断是否为子集is_superset = set1 >= set2  # 判断是否为超集is_disjoint = set1.isdisjoint(set2)  # 判断是否无交集

Dict API

PYTHON
# 创建my_dict = {}                      # 空字典my_dict = {"a": 1, "b": 2}        # 带初始值的字典my_dict = dict(a=1, b=2)          # 通过关键字参数创建my_dict = dict([("a", 1), ("b", 2)])  # 从键值对列表创建# 访问和修改value = my_dict["a"]              # 键访问(键不存在会报错)value = my_dict.get("c", 0)       # 键访问(带默认值)my_dict["c"] = 3                  # 添加或修改键值对my_dict.update({"d": 4, "e": 5})  # 批量添加或修改键值对# 删除del my_dict["a"]                  # 删除键值对value = my_dict.pop("b")          # 删除并返回值item = my_dict.popitem()          # 删除并返回最后添加的键值对# 常用方法keys = my_dict.keys()             # 获取所有键values = my_dict.values()         # 获取所有值items = my_dict.items()           # 获取所有键值对len(my_dict)                      # 字典长度"a" in my_dict                    # 键存在检测my_dict.clear()                   # 清空字典

Queue API

PYTHON
from collections import dequefrom queue import Queue# 使用dequeq = deque()                       # 双端队列q.append(1)                       # 添加到右侧q.appendleft(0)                   # 添加到左侧item = q.pop()                    # 从右侧移除item = q.popleft()                # 从左侧移除(队列用法)# 使用Queue(线程安全)q = Queue(maxsize=10)             # 创建队列,可选最大容量q.put(1)                          # 添加元素item = q.get()                    # 获取元素q.task_done()                     # 通知任务完成q.join()                          # 阻塞直到所有元素处理完毕q.qsize()                         # 当前大小q.empty()                         # 是否为空q.full()                          # 是否已满

Stack API

PYTHON
# Python中栈通常用list实现stack = []                        # 空栈stack.append(1)                   # 入栈stack.append(2)                   # 入栈item = stack.pop()                # 出栈peek = stack[-1]                  # 查看栈顶(不删除)is_empty = len(stack) == 0        # 检查是否为空# 也可以用collections.dequefrom collections import dequestack = deque()stack.append(1)                   # 入栈item = stack.pop()                # 出栈

Tricks

PYTHON
# list去重numbers_list = [1, 2, 2, 3, 3, 3]unique_numbers = list(set(numbers_list))  # [1, 2, 3]# 利用集合进行交集、并集、差集等操作users_a = {'Alice', 'Bob', 'Charlie'}users_b = {'Charlie', 'David', 'Eve'}common_users = users_a & users_b  # {'Charlie'}all_users = users_a | users_b     # 所有用户unique_to_a = users_a - users_b   # 只在 A 中的用户

Python Data Structures Cheat Sheet

https://vluv.space/data_struct/

作者

GnixAij

发布于

2025-04-02

更新于

2025-08-12

许可协议

评论