# 用workbuddy对Windows 全盘重复文件扫描实战：从"要跑几十小时"到"约 70 分钟跑完"（附完整 Python 代码）

> 本文记录一次在 Windows 上做"全盘重复文件查找"的真实过程：最初用 PowerShell 哈希，1 小时只处理了不到 1 万个文件、照此估算要跑几十小时；改用 **三轮过滤 + Python 多进程** 后，**83 万个文件从枚举到出结果约 70 分钟**。全程**只读扫描，不删除任何文件**。文章给出可落地的完整代码和六条关键避坑经验。

---

## 一、问题与目标

电脑上重复文件越来越多：重复下载的安装包、"某某文件 (1)" 的拷贝、同一份资料在不同文件夹里存了好几份……想查一下"整个 C 盘到底有多少重复文件、占了多少空间"，却发现市面上的小工具要么不全、要么要上传文件（有隐私顾虑），于是决定自己写一个。

**目标很明确：**

1. 扫整个 C 盘、所有类型文件；
2. 判定标准是**内容字节级完全一致**（不是仅同名）；
3. **只读**，只出清单，绝不误删。

最终效果：83 万个文件中，找到 **132,533 个内容完全一致的重复组**，合计约 **29.25 GB** 的冗余空间。

---

## 二、总体思路：三轮过滤，先快后准

如果对全盘每个文件都直接算哈希，会非常慢（哈希要读完整文件，大文件尤其耗时）。所以核心是**先用便宜的信息筛掉大部分"不可能重复"的文件**，只对真正可疑的小集合做昂贵操作。

| 轮次 | 操作 | 依据 | 作用 |
|---|---|---|---|
| 第 1 轮 | 按**文件大小**分组 | 大小不同的文件，内容必然不同 | 用 `stat` 就能完成，几乎不读文件内容，极快 |
| 第 2 轮 | 对大小相同的组，算**文件头哈希**（如前 1MB 的 MD5） | 同大小但文件头不同 → 内容必不同 | 大量"同大小不同内容"的文件在这一步被剔除，不用读全文 |
| 第 3 轮 | 对文件头一致的"近重复组"，算**全文 MD5** | 内容字节级一致才算真重复 | 最终确认，保证 100% 准确 |

**为什么这样是准确的？**

- 大小不同 → 不可能重复，直接排除，不会漏判；
- 大小相同但文件头不同 → 不可能重复，排除；
- 大小相同 + 文件头相同 → 只能说明"可能相同"，必须再全文哈希确认；若全文哈希也相同，才是内容完全一致的重复。
- 因此结果与"全部全文哈希"**完全等价**，但读取量从"读全文"降到"只读每个候选的前 1MB + 近重复组的全文"，I/O 大幅减少。

实测：83 万文件 → 大小分组后只剩约 **78.9 万个候选** → 文件头哈希后只剩约 **44.5 万个**需要全文哈希 → 最终 **13.25 万个真重复组**。每一轮都把工作量砍掉一大块。

---

## 三、实现要点（关键代码）

### 1. 安全遍历：junction 不递归、跳过权限错误、跳过 0 字节

Windows 的用户目录里有大量**符号链接/目录联接（junction）**，例如 "Application Data"、"Local Settings"、"My Documents" 都指向 `AppData` 里的真实位置。如果递归时顺着链接走，会**死循环或重复遍历**。

`os.walk` 默认 `followlinks=False`，不会顺着符号链接目录下钻，天然规避了死循环；再配合 `onerror` 忽略权限错误，并跳过 0 字节文件（0 字节文件哈希都相同，是无意义噪音）：

```python
def onerror(err):
    pass  # 权限不足等错误直接跳过

candidates = []
for root, dirs, files in os.walk('C:\\', onerror=onerror):
    for fn in files:
        p = os.path.join(root, fn)
        try:
            st = os.lstat(p)          # 不跟随符号链接
            if os.path.islink(p):
                continue
            sz = st.st_size
            if sz > 0:
                candidates.append((p, sz))
        except Exception:
            pass
```

### 2. 多进程哈希：`hashlib` + `Pool` + `__main__` 守卫

哈希是 CPU+IO 混合密集，用 `multiprocessing.Pool` 起 N-1 个进程并行，比单进程快数倍。`hashlib` 是 C 实现，逐文件开销远小于 PowerShell 的 `Get-FileHash` cmdlet。

**Windows 下多进程的一个关键坑**：子进程会重新 import 主模块，如果枚举/分组逻辑写在模块顶层，会在每个子进程里再跑一遍。所以必须把主逻辑放进 `if __name__ == '__main__':`：

```python
import os, hashlib
from collections import defaultdict
from multiprocessing import Pool, cpu_count

HDR = 1 << 20  # 1MB 文件头

def header_hash(path):
    try:
        sz = os.path.getsize(path)
        if sz == 0:
            return (path, None)
        h = hashlib.md5()
        with open(path, 'rb') as f:
            h.update(f.read(HDR))
        return (path, (sz, h.hexdigest()))
    except Exception:
        return (path, None)

def full_hash(path):
    try:
        h = hashlib.md5()
        with open(path, 'rb') as f:
            for chunk in iter(lambda: f.read(1 << 20), b''):
                h.update(chunk)
        return (path, h.hexdigest())
    except Exception:
        return (path, None)

def main():
    candidates = []
    for root, dirs, files in os.walk('C:\\', onerror=onerror):
        for fn in files:
            p = os.path.join(root, fn)
            try:
                st = os.lstat(p)
                if os.path.islink(p) or st.st_size == 0:
                    continue
                candidates.append((p, st.st_size))
            except Exception:
                pass

    # 第 1 轮：按大小分组
    by_size = defaultdict(list)
    for p, sz in candidates:
        by_size[sz].append(p)
    size_groups = [v for v in by_size.values() if len(v) > 1]
    del by_size
    paths = [p for g in size_groups for p in g]

    ncpu = max(1, cpu_count() - 1)
    # 第 2 轮：文件头哈希
    with Pool(ncpu) as pool:
        hdr_res = list(pool.imap_unordered(header_hash, paths, chunksize=256))

    hdr_map = defaultdict(list)
    for p, res in hdr_res:
        if res:
            hdr_map[res].append(p)
    near = [v for v in hdr_map.values() if len(v) > 1]
    flat = [p for g in near for p in g]

    # 第 3 轮：全文哈希
    with Pool(ncpu) as pool:
        full_res = list(pool.imap_unordered(full_hash, flat, chunksize=256))

    groups = defaultdict(list)
    for p, fh in full_res:
        if fh:
            groups[fh].append(p)
    dups = [sorted(v) for v in groups.values() if len(v) > 1]
    dups.sort(key=lambda g: -os.path.getsize(g[0]))

    # 写出结果（示例打印）
    print(f"重复组数: {len(dups)}")
    for i, g in enumerate(dups, 1):
        print(f"组{i} ({os.path.getsize(g[0])}字节 x {len(g)}):")
        for p in g:
            print("   ", p)

if __name__ == '__main__':
    main()
```

> 说明：第 2 轮 `header_hash` 返回的是 `(大小, 头哈希)`，组内必须"大小和头都一致"才进入第 3 轮，逻辑与正文描述一致。

### 3. 后台执行的正确姿势：别用 `Start-Process` 脱钩

这是本次踩的第二个坑。为了让长任务"后台跑、不阻塞"，我一开始用了 `Start-Process -NoNewWindow` 把 Python 程序**脱钩**启动，结果：

- 进程脱离当前会话，**我看不到它的进度**；
- 也**收不到它完成的通知**，只能靠反复去看输出文件，非常被动。

**正确做法**：把长任务作为一个**受管的后台任务**直接运行主进程（而不是再包一层 `Start-Process`），这样既保留标准输出（进度可见），又能在完成时收到提醒。如果要"脱机跑"，则明确把输出重定向到日志文件，并接受"完成后自己去查"这个事实，而不是假装还能监控它。

---

## 四、实测数据

同一台 Windows 机器、同一个 C 盘：

| 阶段 | 数量 | 说明 |
|---|---|---|
| 文件枚举 | 836,891 个 | 遍历全盘，跳过 junction / 权限错误 / 0 字节 |
| 大小分组后候选 | 49,949 组 / 788,907 个 | 去掉"大小唯一"的文件 |
| 文件头哈希 | 788,907 个 | 多进程并行 |
| 近重复组 | 132,540 组 | 大小+文件头一致 |
| 全文哈希 | 445,488 个 | 最终确认 |
| **真重复组** | **132,533 组** | 445,447 个重复文件实例 |
| **可释放空间** | **29.25 GB** | 多余副本占用 |

**性能对比**：最初用 PowerShell `Get-FileHash`，实测每秒仅 **2–3 个文件**，照此速度 78.9 万候选要跑几十小时；换 Python 多进程后，全文哈希阶段吞吐约 **300+ 文件/秒**，**哈希吞吐提升约百倍**。再叠加三轮过滤（第 1、2 轮先筛掉 39 万个不必读全文的文件），全盘 83 万文件**约 70 分钟完成**。（主要瓶颈是杀毒软件对每个被读文件的实时扫描，多进程能较好地绕开单点串行。）

> ⚠️ 需要强调：13 万个重复组里，绝大多数是系统/程序文件（Windows、Program Files、AppData 中的重复 DLL、安装包、缓存），**这些不能删**。真正适合清理的是个人目录（桌面/下载/文档/图片/音乐/视频）里的重复——本次约 **914 个**文件，主要在"下载"目录（865 组）。

---

## 五、安全边界（最重要的一条）

技术能做到"找出来"，但"删不删、删哪些"必须谨慎。我把结果分三档：

| 档位 | 范围 | 处理建议 |
|---|---|---|
| ✅ 可安全清理 | 桌面/下载/文档/图片/音乐/视频，且非应用数据 | 同组保留一份、删除其余副本 |
| ⚠️ 需谨慎勿删 | 微信数据库（`Documents\WeChat Files\...\*.db`）、游戏文件、应用缓存 | 内容虽同，但属程序运行数据，删了会损坏软件 |
| 🚫 系统/程序 | Windows、Program Files、AppData | 绝不手动删除 |

**全程只读**是底线：脚本只做枚举、读取、哈希，从不调用删除/移动/改名。清单出来后，是否清理、清理哪些，应逐个确认后再用"回收站"方式处理，而不是直接 `del`。

---

## 六、避坑总结（一句话版）

1. **先按大小分组、再比文件头、最后比全文** —— 三轮过滤，既快又不漏。
2. **遍历别顺着 junction 走**（`os.walk` 默认不跟随链接，别改）—— 否则死循环。
3. **别用 PowerShell `Get-FileHash` 扫全盘** —— 杀毒软件实时扫描 + cmdlet 逐文件开销，慢到不可用；用 Python 多进程。
4. **Windows 多进程记得 `if __name__ == '__main__'` 守卫** —— 否则子进程重复跑主逻辑。
5. **后台长任务别用 `Start-Process` 脱钩** —— 会失去进度和完成通知。
6. **只读，不删** —— 结果分档，"微信数据库/游戏/系统文件"一律勿动。

---

## 结语

重复文件查找这件事，难点不在"算哈希"，而在**怎么把 83 万个文件里"不可能重复"的部分先用便宜办法筛掉**，以及对 Windows 的 junction、杀毒软件、权限错误的兼容处理。三轮过滤 + 多进程，是一套简单、准确、可落地的方案。代码可直接运行，改个盘符即可用于其他磁盘。

> 声明：本文方法仅用于个人电脑自查，所有操作均为只读；清理重复文件前请自行确认，避免误删重要数据。


本文记录一次在 Windows 上做"全盘重复文件查找"的真实过程：最初用 PowerShell 哈希，1 小时只处理了不到 1 万个文件、照此估算要跑几十小时；改用 三轮过滤 + Python 多进程 后，83 万个文件从枚举到出结果约 70 分钟。全程只读扫描，不删除任何文件。文章给出可落地的完整代码和六条关键避坑经验。

用workbuddy对Windows 全盘重复文件扫描实战：从"要跑几十小时"到"约 70 分钟跑完"（附完整 Python 代码）

本文记录一次在 Windows 上做"全盘重复文件查找"的真实过程：最初用 PowerShell 哈希，1 小时只处理了不到 1 万个文件、照此估算要跑几十小时；改用 **三轮过滤 + Python 多进程** 后，**83 万个文件从枚举到出结果约 70 分钟**。全程**只读扫描，不删除任何文件**。文章给出可落地的完整代码和六条关键避坑经验。

编程语言

开发工具

运维

Windows全盘重复文件扫描效率优化实战：基于Python多进程与三轮过滤策略，83万文件70分钟完成，较PowerShell提速百倍。覆盖安全遍历、哈希分组、避坑指南，提供完整可运行代码，只读扫描不删文件。

日志文件

代码解释

数据库

Windows

Python

2026上云采购 | AI焕新·智启新局

workbuddy

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

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

社区新版编辑器体验调研

用workbuddy对Windows 全盘重复文件扫描实战：从"要跑几十小时"到"约 70 分钟跑完"（附完整 Python 代码）-腾讯云开发者社区-腾讯云

用workbuddy对Windows 全盘重复文件扫描实战：从"要跑几十小时"到"约 70 分钟跑完"（附完整 Python 代码）

用workbuddy对Windows 全盘重复文件扫描实战：从"要跑几十小时"到"约 70 分钟跑完"（附完整 Python 代码）

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐