区块链听起来玄，它脚下只有两个东西：**指纹**和**链**。

搞懂这两样，「去中心化」「不可篡改」「挖矿」这些词就都有了落点。下面用一段 **36 行**的 Python 把这两个东西拆开，代码只用标准库，完整贴出来，复制成一个文件就能跑。

先说结论：**区块链能保证「谁改了都看得出来」，但「改不动」不是靠链本身，是靠挖矿贵和账本分布得够广。** 后半句很多人不知道，而它恰好是最关键的一半。

### 一、所谓「指纹」，就是一段内容的哈希

任何一段文字，都能算出一个固定长度的「指纹」。这里用的是 SHA-256：

```python
def 指纹(内容: str) -> str:
    """算一个内容的「指纹」：SHA-256，固定 64 位十六进制。"""
    return hashlib.sha256(内容.encode("utf-8")).hexdigest()
```

它有三个性子，都实用：

```text
张三转给李四 10 元
  94e9c50945854c9604074c1e1b45565bd7b33a33108d06a950e81fb3f795e899
张三转给李四 11 元
  ce3454188f618aff7a29d023ab41f9db5510be3a4d347acc8ce27e07d61188f0

只改了 1 个数字，64 位指纹里有 58 位不同。
```

**第一，长度固定。** 内容再长再短，指纹都是 64 位。所以它的体积和原文无关。

**第二，改一点点就变一片。** 只把「10」改成「11」，64 位里 58 位全变了。它不是「改一位变一位」，而是整个重排。这一点很重要：**你没法微调内容，让指纹恰好变成你指定的那一个。** 这里要说清区别——「凑一个完全指定」做不到，但「碰上一个宽松条件」是能做到的，后者正是挖矿（第四节细讲）。

这个「58」不是眼估的，用一行代码就能自己数：

```python
a, b = 指纹("张三转给李四 10 元"), 指纹("张三转给李四 11 元")
print(sum(x != y for x, y in zip(a, b)))    # 输出 58
```

再换一个例子，换三种改法，结论一样（下面这段可以直接跑，用的是另一个示例串）：

```python
基准 = "A 转账给 B 10 个币"
for 说明, 新 in [("金额改11", "A 转账给 B 11 个币"),
                 ("删空格",   "A 转账给 B10 个币"),
                 ("加句号",   "A 转账给 B 10 个币。")]:
    a, b = 指纹(基准), 指纹(新)
    不同 = sum(x != y for x, y in zip(a, b))
    print(f"{说明}: 64 位中 {不同} 位不同（{不同/64*100:.0f}%）")
```

输出：

```text
金额改11: 64 位中 54 位不同（84%）
删空格: 64 位中 62 位不同（97%）
加句号: 64 位中 62 位不同（97%）
```

改一个字符，八成到九成七的位全变。**任何「改动小、变化也小」的规律都不存在**，所以也没法靠微调让指纹变成一个指定的值（但可以反复试，去碰一个宽松条件，见第四节）。

**第三，只能正着算、不能反着推。** 给定内容算指纹很容易，给定指纹想还原内容，做不到。所以指纹可以公开——公开了也泄露不了原文。

有了这三条，指纹就可以当「防伪标记」用：内容一动，标记就对不上。

### 二、「链」不是文件排队，是指纹互相咬合


![区块链哈希链咬合与篡改演示](https://developer.qcloudimg.com/http-save/yehe-11921380/19bf2399a16cf388036e41a674a90b5f.png)
一个区块里放三样东西：序号、记录、上一块的指纹。然后**这三样一起**算自己的指纹：

```python
def 造块(序号: int, 记录: str, 上一块指纹: str) -> dict:
    """一个区块 = 序号 + 记录 + 上一块的指纹，三者一起算自己的指纹。"""
    自己的指纹 = 指纹(f"{序号}|{记录}|{上一块指纹}")
    return {"序号": 序号, "记录": 记录, "上一块": 上一块指纹, "指纹": 自己的指纹}
```

串起来的过程就一句：**每造一个块，把它的指纹留给下一个块。**

```python
def 造链(记录们: list[str]) -> list[dict]:
    块们 = []
    上一块 = "0" * 64          # 第一块前面没有块，用 64 个 0 占位
    for i, 记录 in enumerate(记录们):
        块 = 造块(i, 记录, 上一块)
        块们.append(块)
        上一块 = 块["指纹"]
    return 块们
```

跑出来的结构长这样：

```text
第0块  张三转李四 10 元
        上一块指纹 0000000000000000…
        自己的指纹 2dd4d4f1292f675a…
第1块  李四转王五 3 元
        上一块指纹 2dd4d4f1292f675a…     ← 正好是第 0 块的指纹
        自己的指纹 ce19a319e277105c…
第2块  王五转赵六 1 元
        上一块指纹 ce19a319e277105c…     ← 正好是第 1 块的指纹
        自己的指纹 bc6c0971dc34c73d…
```

看那两层缩进：**第 1 块记的「上一块指纹」，和第 0 块自己的指纹完全相同。** 这就是「链」的全部含义——不靠文件名排序，靠每一块都把前一块的指纹刻在自己身上。

**完整代码就这 36 行，复制成一个 `.py` 文件直接跑：**

```python
import hashlib

def 指纹(s):
    return hashlib.sha256(s.encode()).hexdigest()

def 造块(序号, 记录, 上一块指纹):
    自己的指纹 = 指纹(f"{序号}|{记录}|{上一块指纹}")
    return {"序号": 序号, "记录": 记录, "上一块": 上一块指纹, "指纹": 自己的指纹}

def 造链(记录们):
    块们, 上一块 = [], "0" * 64
    for i, 记录 in enumerate(记录们):
        块 = 造块(i, 记录, 上一块)
        块们.append(块)
        上一块 = 块["指纹"]
    return 块们

def 查链(块们):
    问题, 上一块 = [], "0" * 64
    for 块 in 块们:
        if 块["上一块"] != 上一块:
            问题.append(f"第{块['序号']}块 前指纹对不上")
        if 指纹(f"{块['序号']}|{块['记录']}|{块['上一块']}") != 块["指纹"]:
            问题.append(f"第{块['序号']}块 内容被改过")
        上一块 = 块["指纹"]
    return 问题

if __name__ == "__main__":
    链 = 造链(["张三转李四 10 元", "李四转王五 3 元", "王五转赵六 1 元"])
    print("原始链校验:", 查链(链) or "全部对得上")
    链[1]["记录"] = "李四转王五 300 元"
    print("只改记录:", 查链(链))
    链[1]["指纹"] = 指纹(f"{链[1]['序号']}|{链[1]['记录']}|{链[1]['上一块']}")
    链[2]["上一块"] = 链[1]["指纹"]
    链[2]["指纹"] = 指纹(f"{链[2]['序号']}|{链[2]['记录']}|{链[2]['上一块']}")
    print("连指纹一起改:", 查链(链) or "全部对得上（篡改被抹平）")
```

跑出来是三行：

```text
原始链校验: 全部对得上
只改记录: ['第1块 内容被改过']
连指纹一起改: 全部对得上（篡改被抹平）
```

这三行就是后面第三节要展开的全部内容。**先把这段跑通，再看文字**，会顺得多。

### 三、改了会怎样：先看到「被发现」，再看到「被抹平」

**第一步，只改记录。**

把第 1 块的「3 元」偷偷改成「300 元」，别的不动，然后重算整条链：

```text
校验原始链： 全部对得上 ✓
把「3 元」改成「300 元」后重新校验：
  ✗ 第 1 块：内容被改过（指纹变了）
```

立刻被抓到。因为重新算出来的指纹，和链上存着的旧指纹对不上。

**第二步，连指纹一起改。**

一个稍微用点功的篡改者会想到：那把指纹也算一遍、一起改掉不就行了？那就把第 1 块的指纹重算，并且把新指纹接给第 2 块，第 2 块再重算……一路补到链尾。

```text
把第 1、2 块的指纹一起重算后，校验结果：
  全部对得上 ✓ —— 篡改被「抹平」了！
```

**这个结果必须直说：光靠「用哈希把块串起来」，挡不住愿意重算的人。**

那「不可篡改」到底靠什么？靠另外两件事。

### 四、「改不动」其实靠这两个东西

**第一件：挖矿，让「重算」变得很贵。**

前面那个链条，重算一个块的指纹只要一瞬间。所以真实区块链加了一道门槛：**区块的指纹必须以若干个 0 开头**，不满足就不许挂上去。

想得到这种指纹没有窍门，只能换着数字一个个试：

```python
def 块哈希(序号, 数据, 前一个, nonce):
    # 多加一个 nonce 参与哈希，其余和上面的 造块 完全一致
    return 指纹(f"{序号}|{数据}|{前一个}|{nonce}")

def 挖矿(序号, 数据, 前一个, 难度=4):
    nonce = 0
    while True:
        h = 块哈希(序号, 数据, 前一个, nonce)
        if h.startswith("0" * 难度):
            return nonce, h
        nonce += 1
```

**注意这里和第二节的 `造块()` 是什么关系**：`造块()` 的哈希原料是「序号|记录|上一块指纹」三段，`块哈希()` 是同样三段**再多加一个 nonce**。这不是两套算法，是同一套哈希多串了一个可以随便改的数字——**那个数字就是给挖矿试的**。链上的每一块，都是「挖矿成功后的造块」：试出合适的 nonce，然后把它连同序号、记录、前指纹一起算进指纹里。

这个循环的意义在于**不对称**：

- 挖的人很贵：要试成千上万次，试到运气好为止
- 验的人很便宜：拿到结果算一次哈希，看是不是前导零就行

所以改一个块，不光要改内容，还得把这个块、以及它后面所有块全部重新「挖」一遍。链越长、难度越高，这个代价涨得越快。这就是「挖矿耗电」的由来——它不是在算什么高深东西，就是在做这种重复试错。

这里有一个很直观的实测。它用一个**单独的小脚本**跑（不是把上面那条三块的链重挖一遍）。脚本做的就是这两件事：

```python
def 块哈希(序号, 数据, 前一个, nonce):
    return 指纹(f"{序号}|{数据}|{前一个}|{nonce}")

def 挖矿(序号, 数据, 前一个, 难度=4):
    nonce = 0
    while True:
        h = 块哈希(序号, 数据, 前一个, nonce)
        if h.startswith("0" * 难度):
            return nonce, h
        nonce += 1

# 挖一个块（序号 2、数据「A 转账给 B 10 个币」、前一个哈希全零）
nonce, h = 挖矿(2, "A 转账给 B 10 个币", "0" * 64, 难度=4)
print(nonce, h)     # 146377  00002216162002da...
```

挖出来之后，**保持 nonce 不变、只改数据**，看前导零还剩几个：

```text
原始块     hash=00002216162002da…   前导零 4 个 ✓ 合格
金额改 11  hash=9957befef4f2098c…   前导零 0 个 ✗ 不合格
删个空格   hash=7b413493bcc22da9…   前导零 0 个 ✗ 不合格
加个句号   hash=30a35f116a78b5c6…   前导零 0 个 ✗ 不合格
```

**辛苦挖出来的「合格」标记，改一个字符就没了。** 想让这个块重新合格，唯一的办法是拿新内容从头再试一遍那个数字。（在本文机器上挖这一个块约 0.2 秒，换机器会有波动，别当绝对基准。）

这里要说清「贵」到底贵到什么程度。上面难度 4 要试十几万次，耗时零点二秒——那是**玩具级**。

真实比特币的全网算力在几百 EH/s 到 1 ZH/s 这个量级之间（`1 EH/s = 10^18 次/秒`，`1 ZH/s = 1000 EH/s`）。**这是外部公开数据的量级，不是本文实测**，而且在持续变化——2025 年前后已经多次触及 1000 EH/s 附近，写这篇文章时取 700 EH/s 作为中间值来估算。

按 700 EH/s、十分钟一个块算，出一个块全网要算大约 `7×10^20 × 600 ≈ 4×10^23` 次哈希。**这个数字会随全网算力涨而涨，下面那些「多少年」的估算也会跟着变**，看量级就行。

换成单台机器是什么概念？按这个总量倒推：

| 单机算力 | 挖出一个块需要的期望时间 |
|---|---|
| 普通 CPU（约 10 MH/s） | 约 13 亿年 |
| 高端 GPU（约 1 GH/s） | 约 1300 万年 |
| 单台 ASIC（约 100 TH/s） | 约 133 年 |

（这三个数字是按「全网总量 ÷ 单机速率」估算的期望值，量级参考，不是实测。）

所以「挖矿让篡改变贵」不是一句形容词：**改一个块，要重做它以及它后面所有块的挖矿工作量，而这个工作量是按「全网算力 × 十分钟一个块」计价的。** 想靠改历史获利，得先付得起这张账单。

这也解释了为什么挖矿的难度要定期调整。算力在涨，如果难度不变，挖一个块会越来越快，改账本也就越来越便宜。所以比特币设计成每 2016 个块（大约两周）看一次实际出块速度：快了就把难度调高，慢了就调低，目标是把出块间隔稳定在 10 分钟左右。**难度不是为了显得难，是为了让「改一个块的成本」始终维持在高位。**

**第二件：账本存在很多节点上。**

就算你算力足，把自己手里那份账本改成「合法」的，问题是你只有一份。真实区块链的账本同时存在成千上万个节点上，每个节点自己校验。你改自己那份，别人那份没变，网络一对比就知道谁的是假的。

这里还要靠一条规则：**最长链为准。** 想让别人接受你改过的历史，你得比全网诚实节点更快地重算出更长的链。算力不到一半的时候，这件事基本上做不到——这就是「51% 攻击」这个词的由来：只有掌握超过一半算力，才有机会把假链接上去。

**这两件事一起，才叫「不可篡改」。** 单看哈希链，它只做到「改了看得出来」。

### 五、真实的区块里装了什么

前面为了讲清原理，一个块只放了「一条记录」。真实区块链的一个块，装的东西多得多，但结构是同一个思路：

| 装的东西 | 作用 | 对应本文演示 |
|---|---|---|
| 上一块的指纹 | 把链接起来 | `上一块` 字段 |
| 一批交易 | 这一个块记录的所有转账 | `记录`（演示里只放一条） |
| 时间戳 | 这一块大概什么时候产生 | 演示里省略了 |
| 难度值 | 当时挖矿要求几个前导零 | 演示里固定成 4 |
| 一个随机数 | 就是挖矿试出来的那个数 | `nonce` |

注意「一批交易」这一项：真实一个块里有成百上千笔转账。那怎么用一个指纹代表这批交易？做法是把它们两两配对算指纹、再配对再算，最后收成一个总指纹（叫默克尔根），块头里只存这个总指纹。

这么做的好处很实际：**要验证「某笔转账在不在这块里」，不需要把上千笔都算一遍**。顺着那棵「指纹树」往下走几层就能定位到它，计算量小得多。这也是为什么交易所、钱包都强调「到区块浏览器上核对」——核对的就是这条指纹链。

还有一点值得知道：块的容量是有上限的。比特币的基础块上限是 1MB，SegWit 之后改用「权重」计量，按权重最多约 4MB，所以实际看到的块经常超过 1MB。不管具体数字，结论一样：**装满就只能等下一块。所以交易多的时候要排队，谁给的矿工费高出块就优先被打包**——这个现象不是「区块链设计缺陷」，是「每个块容量固定 + 出块间隔固定」这两个设定直接推出来的结果。

### 六、几个常见误解

**误解一：「数据上了链就可信。」**

链只保证「写进去之后改不了」，不保证「写进去的是真的」。如果有人一开始就把假数据写进链、按规矩挖好矿，这条链从算法上无懈可击，但它记的是假的。**区块链解决的是「事后篡改」，不是「事前造假」。**

**误解二：「区块链一定更安全。」**

它的安全性来自「改动成本高于收益」。如果一条链上只有几个节点、算力很低，那 51% 攻击的成本可能并不高。**安全是相对的，取决于这条链有多大。**

**误解三：「哈希很难，所以区块链很复杂。」**

哈希本身是个很朴素的函数：输入一串字节，输出一串字节。上面那个 `hashlib.sha256(...)` 一行就完事。区块链的复杂不在哈希，在**怎么让成千上万个互不信任的节点对同一份账本达成一致**——那是共识算法的事，跟哈希是两码事。

### 七、想自己动手看的话

上面所有输出都能复现。别抄片段，**直接用第二节那段完整代码**（36 行，复制成一个 `.py` 文件），它已经带了程序入口，跑起来就能看到三行输出。然后在这基础上动手改：

**第一步**，先原样跑一遍，确认看到的是这三行：

```text
原始链校验: 全部对得上
只改记录: ['第1块 内容被改过']
连指纹一起改: 全部对得上（篡改被抹平）
```

**第二步**，在 `if __name__` 里加一行，把链打印出来，看第 1 块存的「上一块」，是不是正好等于第 0 块自己的「指纹」。这一步能让你把「链」这个字和代码对上。

```python
for 块 in 链:
    print(块["序号"], 块["上一块"][:16], 块["指纹"][:16])
```

**第三步**，把 `链[1]["记录"]` 改成别的值，同时**把 `if __name__` 里那三行重算指纹的代码注释掉**（就是 `链[1]["指纹"] = ...`、`链[2]["上一块"] = ...`、`链[2]["指纹"] = ...` 这三行），再跑一遍。你会看到校验报「内容被改过」——这就是篡改被发现的瞬间。

**第四步**，把那三行取消注释，再跑一遍。校验又会全过——亲手做出这个「被抹平」的结果，比读十篇讲不可篡改的文章都直观，因为你会真正理解为什么还需要挖矿和分布式。

跑完这四步，你手上有一条能自己改、自己验的链。它包括 36 行代码、三行输出，和两次亲手改出来的不同结果。

区块链听起来玄，它脚下只有两个东西：指纹和链。 搞懂这两样，「去中心化」「不可篡改」「挖矿」这些词就都有了落点。下面用一段 36 行的 Python 把这两个东西拆开，代码只用标准库，完整贴出来，复制成一个文件就能跑。 先说结论：区块链能保证「谁改了都看得出来」，但「改不动」不是靠链本身，是靠挖矿贵和账本分布得够广。 后半句很多人不知道，而它恰好是最关键的一半。 一、所谓「指纹」，就是一段内容的哈

区块链的原理：36 行 Python 看懂指纹与链

编程语言

用36行Python代码拆解区块链核心：哈希指纹如何串联成链，篡改如何被识别，挖矿与多节点如何真正保障不可篡改。附完整可运行代码，直观演示修改数据、重算指纹的全过程。

区块链

Python

ASIC

4核4G3M云服务器 新用户低至38元/年！

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

区块链的原理：36 行 Python 看懂指纹与链-腾讯云开发者社区-腾讯云

区块链的原理：36 行 Python 看懂指纹与链

区块链的原理：36 行 Python 看懂指纹与链

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐