列表数据结构：原理、实现与优化实践

1. 列表与列表项：数据结构中的基础构建块

在计算机科学领域，列表（List）是最基础也最常用的数据结构之一。它就像我们日常生活中使用的购物清单或待办事项表，能够有序地存储和管理多个数据元素。但与纸质列表不同，计算机中的列表具有更强大的动态操作能力。

列表项（List Item）是构成列表的基本单元，每个列表项不仅包含数据本身，还包含与其他列表项的关联信息。这种结构使得列表可以高效地执行插入、删除、遍历等操作。在实际编程中，几乎所有语言都提供了列表的实现，比如Python的list、C++的vector、Java的ArrayList等。

2. 列表的核心特性与实现原理

2.1 顺序存储 vs 链式存储

列表主要有两种实现方式：顺序存储（数组实现）和链式存储（链表实现）。

顺序存储的列表在内存中使用连续的存储空间，就像一排连续的储物柜。这种实现方式的优点是：

• 随机访问速度快（O(1)时间复杂度）
• 缓存友好（局部性原理）
• 实现简单

但缺点也很明显：

• 插入/删除操作可能需要移动大量元素（O(n)时间复杂度）
• 需要预先分配固定大小的空间，可能导致空间浪费或不足

链式存储的列表则像一串珍珠项链，每个节点（珍珠）通过指针（链子）连接。它的优势在于：

• 动态大小，无需预先分配
• 插入/删除操作高效（O(1)时间复杂度，如果知道位置）
• 内存利用率高

但代价是：

• 随机访问需要遍历（O(n)时间复杂度）
• 需要额外空间存储指针
• 缓存不友好

2.2 常见列表操作的时间复杂度

3. 列表的高级变体与应用场景

3.1 双向链表

双向链表在普通链表的基础上，每个节点增加了一个指向前驱节点的指针。这种结构使得双向链表可以双向遍历，适用于需要频繁前后移动的场景，如：

• 浏览器历史记录（前进/后退）
• 音乐播放器的播放列表
• 文本编辑器的撤销/重做功能

3.2 循环链表

循环链表将尾节点的指针指向头节点，形成一个环。这种结构特别适合需要循环处理的场景，比如：

• 操作系统中的进程调度
• 多人游戏的玩家轮流机制
• 轮播图的实现

3.3 跳跃列表（Skip List）

跳跃列表是一种概率性的平衡数据结构，通过在链表上建立多级索引来加速查找。它的查找效率可以达到O(log n)，常用于：

• Redis的有序集合实现
• 需要快速查找的有序数据存储
• 替代平衡树的简单实现

4. 列表在实际编程中的应用技巧

4.1 Python列表的高效使用

Python的list实际上是动态数组的实现，使用时需要注意：

1. 预分配空间：当知道列表大小时，可以预先分配空间避免多次扩容

my_list = [None] * 1000 # 预分配1000个元素的空间

2. 列表推导式比循环append更高效

# 推荐 squares = [x**2 for x in range(1000)] # 不推荐 squares = [] for x in range(1000): squares.append(x**2)

3. 切片操作创建的是新列表，注意内存消耗

new_list = old_list[:] # 创建了完整的副本

4.2 C++ vector的最佳实践

1. 使用reserve()预分配空间

std::vector<int> vec; vec.reserve(1000); // 预分配空间，避免多次扩容

2. 使用emplace_back替代push_back减少拷贝

vec.emplace_back(1, 2, 3); // 直接在容器中构造元素

3. 注意迭代器失效问题

// 在遍历时修改vector可能导致迭代器失效 for(auto it = vec.begin(); it != vec.end(); ) { if(condition) { it = vec.erase(it); // erase返回下一个有效迭代器 } else { ++it; } }

5. 常见问题与性能优化

5.1 如何选择列表的实现方式？

选择数组实现（如Python list、C++ vector）当：

• 需要频繁随机访问
• 元素数量相对稳定
• 内存使用效率是关键

选择链表实现（如Python collections.deque、C++ list）当：

• 需要频繁在头部/中间插入删除
• 元素数量变化大
• 不需要随机访问

5.2 列表操作的性能陷阱

1. 在列表头部插入：对于数组实现是O(n)操作，频繁使用应考虑链表
2. 列表合并：使用extend()比+=或循环append更高效
3. 成员检查：in操作在列表中是O(n)，频繁使用应考虑集合(set)

5.3 内存管理技巧

1. 对于大型列表，考虑使用生成器表达式替代列表推导式

# 列表推导式（立即计算，占用内存） big_list = [x**2 for x in range(1000000)] # 生成器表达式（惰性计算，节省内存） big_gen = (x**2 for x in range(1000000))

2. 使用array模块处理数值型数据更节省空间

import array int_array = array.array('i', [1, 2, 3, 4]) # 比list更节省内存

3. 及时删除不再需要的大列表并调用gc.collect()

del big_list import gc gc.collect()

6. 列表与其他数据结构的比较

6.1 列表 vs 数组

虽然术语有时混用，但严格来说：

• 数组长度固定，列表长度可变
• 数组存储同类型元素，列表可以混合类型（在动态语言中）
• 数组通常更节省内存，但操作灵活性较低

6.2 列表 vs 集合(Set)

集合的特点是：

• 无序
• 元素唯一
• 查找操作O(1)时间复杂度

当需要快速判断元素是否存在时，集合是更好的选择。

6.3 列表 vs 字典(Dict)

字典提供键值对存储：

• 通过键快速查找值（O(1)）
• 无序存储
• 内存开销更大

当需要通过键快速访问数据时，字典更合适。

7. 算法中的列表应用

7.1 排序算法实现

许多排序算法都基于列表操作：

• 快速排序的分区操作
• 归并排序的合并操作
• 插入排序的逐个插入

7.2 图的邻接表表示

图可以用列表的列表来表示：

graph = [ [1, 2], # 节点0的邻居 [0, 3], # 节点1的邻居 [0, 3], # 节点2的邻居 [1, 2] # 节点3的邻居 ]

7.3 动态规划中的备忘录

列表常用于存储子问题的解：

# 斐波那契数列的动态规划实现 def fib(n): dp = [0, 1] + [0]*(n-1) for i in range(2, n+1): dp[i] = dp[i-1] + dp[i-2] return dp[n]

8. 现代编程语言中的列表实现

8.1 Python的列表优化

Python的list实际上实现了：

• 过度分配策略（分配比实际需要更多的空间）
• 摊销O(1)的append操作
• 特殊处理小整数和常用对象

8.2 Java的ArrayList vs LinkedList

ArrayList：

• 基于动态数组
• 默认初始容量10
• 扩容策略是增加50%

LinkedList：

• 双向链表实现
• 实现了Deque接口
• 每个元素有更多内存开销

8.3 JavaScript的Array特性

JavaScript数组：

• 实际上是对象
• 可以稀疏（有"洞"）
• length属性可写
• 提供丰富的功能性方法(map, filter, reduce等)

9. 列表在系统设计中的应用

9.1 实现队列和栈

列表可以轻松实现其他数据结构：

# 用列表实现栈 stack = [] stack.append('a') # 入栈 item = stack.pop() # 出栈 # 用collections.deque实现队列 from collections import deque queue = deque() queue.append('a') # 入队 item = queue.popleft() # 出队

9.2 LRU缓存实现

结合字典和双向链表可以实现高效的LRU缓存：

from collections import OrderedDict class LRUCache: def __init__(self, capacity): self.cache = OrderedDict() self.capacity = capacity def get(self, key): if key not in self.cache: return -1 self.cache.move_to_end(key) return self.cache[key] def put(self, key, value): if key in self.cache: self.cache.move_to_end(key) self.cache[key] = value if len(self.cache) > self.capacity: self.cache.popitem(last=False)

9.3 事件循环中的就绪队列

在事件驱动架构中，列表常用于管理待处理事件：

• Node.js的事件队列
• GUI应用中的消息队列
• 游戏引擎中的事件系统

10. 性能测试与对比

10.1 Python列表操作基准测试

import timeit # 测试append性能 print(timeit.timeit('lst.append(None)', setup='lst = []', number=1000000)) # 测试insert(0)性能 print(timeit.timeit('lst.insert(0, None)', setup='lst = []', number=1000)) # 测试in操作性能 print(timeit.timeit('999999 in lst', setup='lst = list(range(1000000))', number=100))

10.2 不同语言列表实现对比

10.3 何时考虑使用第三方库

对于性能关键的应用，可以考虑：

• NumPy数组（数值计算）
• Pandas Series（数据处理）
• blist（Python的可扩展列表实现）

11. 列表的内存布局与CPU缓存

理解列表在内存中的实际存储方式对性能优化很重要：

1. 数组式列表在内存中是连续的，这带来：

   • 良好的缓存局部性
   • 预取友好
   • SIMD指令优化可能

2. 链表式列表在内存中是分散的，导致：

   • 缓存不命中率高
   • 预取困难
   • 额外指针开销

3. 现代CPU的缓存行（通常64字节）意味着：

   • 小元素可以多个装入一个缓存行
   • 随机访问可能导致缓存行浪费
   • 顺序访问能充分利用缓存

12. 函数式编程中的列表操作

现代语言提供了丰富的列表高阶函数：

12.1 Map/Filter/Reduce模式

numbers = [1, 2, 3, 4, 5] # Map squares = list(map(lambda x: x**2, numbers)) # Filter evens = list(filter(lambda x: x % 2 == 0, numbers)) # Reduce from functools import reduce sum = reduce(lambda x, y: x + y, numbers)

12.2 列表生成式的高级用法

# 条件过滤 [x for x in range(10) if x % 2 == 0] # 嵌套循环 [(x, y) for x in range(3) for y in range(3)] # 字典生成式 {x: x**2 for x in range(5)} # 集合生成式 {x % 3 for x in range(10)}

12.3 惰性求值与生成器

# 生成器表达式 gen = (x**2 for x in range(1000000)) # 不立即计算 # 生成器函数 def squares(n): for x in range(n): yield x**2 # 使用itertools进行高效列表操作 import itertools first_ten = itertools.islice(squares(100), 10)

13. 并发环境下的列表安全

13.1 线程安全考虑

Python的列表操作不是原子性的，多线程环境下需要锁：

from threading import Lock list_lock = Lock() shared_list = [] def safe_append(item): with list_lock: shared_list.append(item)

13.2 替代方案

1. queue.Queue - 线程安全的队列实现
2. multiprocessing.Manager().list() - 进程间共享的列表
3. 不可变列表（tuple） - 避免修改带来的问题

13.3 无锁编程技巧

在某些场景下可以使用：

• 写时复制(Copy-on-Write)模式
• 乐观锁（版本号控制）
• 持久化数据结构（创建新版本而非修改）

14. 列表的持久化存储

14.1 序列化方法比较

14.2 数据库存储策略

1. 关系型数据库：

   • 将列表存储为JSON字符串
   • 使用关联表表示关系
   • 数组类型（如PostgreSQL的array）

2. NoSQL数据库：

   • 文档数据库的嵌套数组
   • 键值数据库的序列化值

14.3 内存映射文件

对于超大列表，可以使用：

import numpy as np # 创建内存映射数组 arr = np.memmap('large_array.dat', dtype='int32', mode='w+', shape=(1000000,))

15. 列表的调试与性能分析

15.1 常见问题排查

1. 索引越界：

   try: item = my_list[index] except IndexError: print(f"列表长度只有{len(my_list)}，尝试访问{index}")

2. 修改列表同时迭代：

   # 错误方式 for item in my_list: if condition(item): my_list.remove(item) # 可能导致意外行为 # 正确方式 my_list[:] = [item for item in my_list if not condition(item)]

3. 浅拷贝问题：

   original = [[1, 2], [3, 4]] copy = original[:] # 浅拷贝 copy[0][0] = 99 # 修改会影响original！

15.2 性能分析工具

1. timeit模块 - 测量代码片段执行时间
2. cProfile - 分析函数调用频率和耗时
3. memory_profiler - 跟踪内存使用情况
4. objgraph - 可视化对象引用关系

import cProfile def list_operations(): lst = [] for i in range(100000): lst.append(i) lst.sort(reverse=True) cProfile.run('list_operations()')

16. 列表在算法面试中的常见问题

16.1 经典算法题

1. 两数之和：在列表中找到两个数使它们的和等于目标值
2. 合并两个有序列表：将两个已排序列表合并为一个
3. 反转链表：原地反转一个链表
4. 环形链表检测：判断链表是否有环
5. 删除链表的倒数第N个节点

16.2 解题技巧

1. 双指针法：快慢指针解决链表问题
2. 递归法：适用于链表反转等问题
3. 虚拟头节点：简化边界条件处理
4. 画图辅助：可视化指针变化过程

16.3 示例：反转链表

class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def reverse_list(head): prev = None current = head while current: next_node = current.next current.next = prev prev = current current = next_node return prev

17. 列表的可视化表示

17.1 控制台可视化

def print_list(lst): print("[" + " -> ".join(map(str, lst)) + "]") def print_linked_list(head): nodes = [] while head: nodes.append(str(head.val)) head = head.next print(" -> ".join(nodes) + " -> None")

17.2 图形化工具

1. Python的turtle模块绘制链表
2. Graphviz可视化复杂结构
3. Jupyter Notebook的内置显示
4. 在线可视化工具（如Visualgo）

17.3 调试器中的列表检查

现代IDE如PyCharm、VSCode提供：

• 列表内容展开查看
• 自定义可视化配置
• 条件断点调试列表操作

18. 列表的替代数据结构

18.1 数组.array

对于同类型数据更高效：

import array int_array = array.array('i', [1, 2, 3]) # 'i'表示整数

18.2 NumPy数组

数值计算首选：

import numpy as np arr = np.array([1, 2, 3], dtype=np.float32)

18.3 Pandas Series

带标签的一维数组：

import pandas as pd s = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

18.4 内存视图

零拷贝数据共享：

data = bytearray(b'hello') view = memoryview(data)

19. 列表在Web开发中的应用

19.1 模板中的列表渲染

Flask/Jinja2示例：

from flask import Flask, render_template app = Flask(__name__) @app.route('/') def index(): items = ['Apple', 'Banana', 'Orange'] return render_template('index.html', items=items)

<!-- index.html --> <ul> {% for item in items %} <li>{{ item }}</li> {% endfor %} </ul>

19.2 JSON API响应

from flask import jsonify @app.route('/api/items') def get_items(): items = ['Item1', 'Item2', 'Item3'] return jsonify({'items': items})

19.3 分页实现

def paginate(items, page, per_page): start = (page - 1) * per_page end = start + per_page return items[start:end]

20. 列表的历史与发展

20.1 早期编程语言中的列表

1. Lisp（1958年）：基于链表的核心数据结构
2. Fortran（1957年）：数组是主要数据结构
3. C（1972年）：需要手动管理数组和指针

20.2 现代语言的创新

1. Python（1991年）：灵活的list类型
2. JavaScript（1995年）：动态数组特性
3. Java（1995年）：Collections框架
4. Go（2009年）：切片(slice)设计

20.3 未来趋势

1. 更智能的内存管理
2. 自动并行化操作
3. 与GPU计算的更好集成
4. 持久化数据结构的普及

21. 列表在机器学习中的应用

21.1 数据预处理

# 特征列表 features = [ [1.2, 3.4, 5.6], [7.8, 9.0, 1.2], [3.4, 5.6, 7.8] ] # 标签列表 labels = [0, 1, 0]

21.2 批量训练

def batch_generator(data, batch_size): for i in range(0, len(data), batch_size): yield data[i:i + batch_size]

21.3 超参数搜索

param_grid = { 'learning_rate': [0.1, 0.01, 0.001], 'batch_size': [16, 32, 64], 'layers': [[64], [64, 32], [64, 32, 16]] }

22. 列表在游戏开发中的使用

22.1 游戏对象管理

class GameObject: def __init__(self, x, y): self.x = x self.y = y # 游戏对象列表 game_objects = [GameObject(10, 20), GameObject(30, 40)] # 游戏循环 def game_loop(): for obj in game_objects: update(obj) render(obj)

22.2 动画帧序列

animation_frames = [ load_image('frame1.png'), load_image('frame2.png'), load_image('frame3.png') ] current_frame = 0 def update_animation(): global current_frame current_frame = (current_frame + 1) % len(animation_frames) return animation_frames[current_frame]

22.3 关卡设计

level1 = [ "##########", "#........#", "#..P.....#", "#....E...#", "##########" ]

23. 列表在嵌入式系统中的应用

23.1 内存受限环境

1. 使用静态数组替代动态列表
2. 预分配固定大小
3. 避免频繁的内存分配/释放

23.2 循环缓冲区实现

#define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int head = 0; int tail = 0; void enqueue(int value) { buffer[head] = value; head = (head + 1) % BUFFER_SIZE; } int dequeue() { int value = buffer[tail]; tail = (tail + 1) % BUFFER_SIZE; return value; }

23.3 寄存器映射

typedef struct { volatile uint32_t CTRL; // Control register volatile uint32_t STATUS; // Status register volatile uint32_t DATA[8]; // Data buffer } DeviceRegisters;

24. 列表的跨语言互操作

24.1 Python与C/C++交互

1. ctypes:

from ctypes import * lib = CDLL('mylib.so') int_array = (c_int * 10)() # 创建C数组 lib.process_array(int_array, 10)

2. Cython:

cdef extern from "stdlib.h": void* malloc(size_t size) void free(void* ptr) def c_list_example(): cdef int* arr = <int*>malloc(10 * sizeof(int)) try: for i in range(10): arr[i] = i # 使用数组... finally: free(arr)

24.2 Python列表与NumPy数组转换

import numpy as np py_list = [1, 2, 3, 4] np_array = np.array(py_list) # 列表转NumPy数组 new_list = np_array.tolist() # NumPy数组转列表

24.3 JSON作为通用交换格式

import json data = {'numbers': [1, 2, 3], 'text': ['a', 'b', 'c']} json_str = json.dumps(data) # 序列化为JSON字符串 # 在其他语言中解析 # JavaScript: JSON.parse(json_str) # Java: new JSONObject(json_str)

25. 列表的极限性能优化

25.1 预分配与重用

# 不好的做法：不断扩展列表 result = [] for item in source: result.append(process(item)) # 好的做法：预分配 result = [None] * len(source) for i, item in enumerate(source): result[i] = process(item)

25.2 使用内置函数

# 不好的做法：显式循环 total = 0 for num in numbers: total += num # 好的做法：使用sum total = sum(numbers)

25.3 避免不必要的复制

# 不好的做法：创建不必要的副本 def process_data(data): data = list(data) # 不必要的复制 # 处理数据... # 好的做法：直接操作原始数据（如果允许修改） def process_data(data): # 直接处理data...

26. 列表的线程安全实现

26.1 细粒度锁

from threading import Lock class ThreadSafeList: def __init__(self): self._list = [] self._lock = Lock() def append(self, item): with self._lock: self._list.append(item) def __getitem__(self, index): with self._lock: return self._list[index] # 其他方法...

26.2 不可变列表

from functools import reduce def immutable_append(lst, item): return lst + [item] # 创建新列表 # 函数式风格操作 new_list = reduce(immutable_append, items, [])

26.3 乐观并发控制

class OptimisticList: def __init__(self): self._list = [] self._version = 0 def modify(self, index, value): while True: old_version = self._version old_value = self._list[index] # 计算新值... new_value = compute_new_value(old_value) # 检查版本 if self._version == old_version: self._list[index] = new_value self._version += 1 break

27. 列表在函数式编程范式中的应用

27.1 递归处理

def sum_list(lst): if not lst: return 0 return lst[0] + sum_list(lst[1:]) # 尾递归优化版本 def sum_list_tail(lst, acc=0): if not lst: return acc return sum_list_tail(lst[1:], acc + lst[0])

27.2 高阶函数组合

from functools import reduce # 组合map和filter numbers = [1, 2, 3, 4, 5] result = reduce( lambda acc, x: acc + x, map(lambda x: x * 2, filter(lambda x: x % 2 == 0, numbers)), 0 )

27.3 惰性求值模式

def lazy_map(func, iterable): for item in iterable: yield func(item) # 使用 squares = lazy_map(lambda x: x**2, range(1000000)) first_ten_squares = list(itertools.islice(squares, 10))

28. 列表的异常处理模式

28.1 安全访问

def safe_get(lst, index, default=None): try: return lst[index] except IndexError: return default

28.2 空列表处理

# 不好的做法：显式检查 if len(items) > 0: process(items[0]) # 好的做法：利用空列表为False的特性 if items: process(items[0])

28.3 类型检查

def process_items(items): if not isinstance(items, (list, tuple)): raise TypeError("Expected list or tuple") # 处理items...

29. 列表的测试策略

29.1 单元测试示例

import unittest class TestListOperations(unittest.TestCase): def setUp(self): self.test_list = [1, 2, 3] def test_append(self): self.test_list.append(4) self.assertEqual(self.test_list, [1, 2, 3, 4]) def test_insert(self): self.test_list.insert(1, 99) self.assertEqual(self.test_list, [1, 99, 2, 3]) def test_pop(self): item = self.test_list.pop() self.assertEqual(item, 3) self.assertEqual(self.test_list, [1, 2])

29.2 边界条件测试

1. 空列表操作
2. 单元素列表操作
3. 重复元素处理
4. 极大列表性能
5. 并发访问测试

29.3 属性测试

使用hypothesis库进行属性测试：

from hypothesis import given import hypothesis.strategies as st @given(st.lists(st.integers())) def test_list_reverse_twice_is_original(lst): assert lst[::-1][::-1] == lst

30. 列表的替代设计模式

30.1 迭代器模式

class ListIterator: def __init__(self, data): self._data = data self._index = 0 def __iter__(self): return self def __next__(self): if self._index < len(self._data): result = self._data[self._index] self._index += 1 return result raise StopIteration # 使用 for item in ListIterator([1, 2, 3]): print(item)

30.2 观察者模式

class ObservableList: def __init__(self): self._list = [] self._observers = [] def add_observer(self, observer): self._observers.append(observer) def append(self, item): self._list.append(item) for observer in self._observers: observer(item)

30.3 代理模式

class ListProxy: def __init__(self, real_list): self._real_list = real_list def __getitem__(self, index): print(f"Accessing index {index}") return self._real_list[index] def __len__(self): return len(self._real_list) # 其他魔术方法...

31. 列表在分布式系统中的应用

31.1 分片处理

def process_in_chunks(data, chunk_size, process_func): results = [] for i in range(0, len(data), chunk_size): chunk = data[i:i + chunk_size] # 可以在这里将chunk发送到不同worker result = process_func(chunk) results.append(result) return results

31.2 一致性哈希环

import hashlib class ConsistentHash: def __init__(self, nodes, replica=3): self.ring = [] for node in nodes: for i in range(replica): key = f"{node}:{i}".encode() hash_val = int(hashlib.md5(key).hexdigest(), 16) self.ring.append((hash_val, node)) self.ring.sort() def get_node(self, key): hash_val = int(hashlib.md5(key.encode()).hexdigest(), 16) for node in self.ring: if hash_val <= node[0]: return node[1] return self.ring[0][1]

31.3 MapReduce模式

def map_function(item): return (item % 10, item) def reduce_function(key, values): return (key, sum(values)) def map_reduce(data, map_func, reduce_func): # Map阶段 mapped = [map_func(item) for item in data] # Shuffle阶段 shuffled = {} for key, value in mapped: if key not in shuffled: shuffled[key] = [] shuffled[key].append(value) # Reduce阶段 return [reduce_func(key, values) for key, values in shuffled.items()]

32. 列表在区块链中的应用

32.1 区块链数据结构

class Block: def __init__(self, index, timestamp, data, previous_hash): self.index = index self.timestamp = timestamp self.data = data self.previous_hash = previous_hash self.hash = self.calculate_hash() def calculate_hash(self): # 简化的哈希计算 return hash((self.index, self.timestamp, self.data, self.previous_hash)) class Blockchain: def __init__(self): self.chain = [self.create_genesis_block()] def create_genesis_block(self): return Block(0, "01/01/2023", "Genesis Block", "0") def add_block(self, new_block): new_block.previous_hash = self.chain[-1].hash new_block.hash = new_block.calculate_hash() self.chain.append(new_block)

32.2 默克尔树实现

import hashlib def build_merkle_tree(transactions): if not transactions: return None current_level = [hashlib.sha256(tx.encode()).hexdigest() for tx in transactions] while len(current_level) > 1: next_level = [] for i in range(0, len(current_level), 2): left = current_level[i] right = current_level[i + 1] if i + 1 < len(current_level) else left combined = left + right next_level.append(hashlib.sha256(combined.encode()).hexdigest()) current_level = next_level return current_level[0]

32.3 UTXO模型

未花费交易输出(UTXO)模型通常使用列表来跟踪：

class UTXOSet: def __init__(self): self.utxos = [] # 未花费交易输出列表 def add_utxo(self, tx_output): self.utx