Python Data Structures Cheat Sheet

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

# 创建
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)                  # 查找元素位置

# 创建
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)                 # 查找元素位置

# 创建
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)  # 判断是否无交集

# 创建
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()                   # 清空字典

from collections import deque
from queue import Queue

# 使用deque
q = 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()                          # 是否已满

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

# 也可以用collections.deque
from collections import deque
stack = deque()
stack.append(1)                   # 入栈
item = stack.pop()                # 出栈

# 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 中的用户