Python实现自动识别并清理电脑C盘的垃圾文件

pip install hashlib

import os
import hashlib
from pathlib import path
from collections import defaultdict

# ==================== 方案 1：查找重复文件 ====================
def find_duplicate_files(search_dir, min_size_mb=0):
    """
    查找目录中的重复文件（基于 md5 哈希）

    参数:
        search_dir: 搜索目录
        min_size_mb: 最小文件大小（mb），忽略小于此值的文件

    返回:
        重复文件字典：{md5: [文件路径列表]}
    """
    search_path = path(search_dir)
    min_size = min_size_mb * 1024 * 1024

    # 第 1 步：按文件大小分组
    size_groups = defaultdict(list)

    print("正在扫描文件...")
    file_count = 0
    for file_path in search_path.rglob('*'):
        if file_path.is_file():
            size = file_path.stat().st_size
            if size >= min_size:
                size_groups[size].append(str(file_path))
                file_count += 1

    print(f"扫描完成: {file_count} 个文件")

    # 第 2 步：对同大小的文件计算 md5
    hash_groups = defaultdict(list)

    for size, files in size_groups.items():
        if len(files) < 2:
            continue  # 只有一个文件，不可能重复

        for file_path in files:
            file_md5 = calculate_md5(file_path)
            hash_groups[file_md5].append(file_path)

    # 第 3 步：筛选出重复的文件组
    duplicates = {md5: paths for md5, paths in hash_groups.items() if len(paths) > 1}

    # 第 4 步：报告
    total_wasted = 0
    for md5, paths in duplicates.items():
        file_size = path(paths[0]).stat().st_size
        wasted = file_size * (len(paths) - 1)  # 浪费的空间 = 单文件大小 × 重复数
        total_wasted += wasted

        print(f"\nmd5: {md5[:8]}... 大小: {file_size / 1024:.1f} kb")
        for p in paths:
            print(f"  - {p}")

    print(f"\n{'='*50}")
    print(f"发现 {len(duplicates)} 组重复文件")
    print(f"可释放空间: {total_wasted / 1024 / 1024:.2f} mb")

    return duplicates


def calculate_md5(file_path, chunk_size=8192):
    """计算文件的 md5 哈希值"""
    md5 = hashlib.md5()
    with open(file_path, 'rb') as f:
        while true:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            md5.update(chunk)
    return md5.hexdigest()


# ==================== 方案 2：查找大文件 ====================
def find_large_files(search_dir, top_n=20, min_size_mb=10):
    """
    查找目录中最大的 n 个文件

    参数:
        search_dir: 搜索目录
        top_n: 返回最大的 n 个文件
        min_size_mb: 最小文件大小（mb）
    """
    search_path = path(search_dir)
    min_size = min_size_mb * 1024 * 1024
    files = []

    print("正在扫描大文件...")
    for file_path in search_path.rglob('*'):
        if file_path.is_file():
            size = file_path.stat().st_size
            if size >= min_size:
                files.append((str(file_path), size))

    # 按大小降序排序
    files.sort(key=lambda x: x[1], reverse=true)

    print(f"\n{'排名':<5} {'大小':<15} {'路径'}")
    print("-" * 80)
    for idx, (path, size) in enumerate(files[:top_n], 1):
        size_str = format_size(size)
        print(f"{idx:<5} {size_str:<15} {path}")

    return files[:top_n]


def format_size(size_bytes):
    """将字节数转为可读格式"""
    for unit in ['b', 'kb', 'mb', 'gb', 'tb']:
        if size_bytes < 1024:
            return f"{size_bytes:.1f} {unit}"
        size_bytes /= 1024


# ==================== 方案 3：清理临时/垃圾文件 ====================
def clean_temp_files(search_dir, dry_run=true):
    """
    清理临时文件和垃圾文件

    参数:
        search_dir: 搜索目录
        dry_run: true=预览，false=执行删除
    """
    temp_extensions = {
        '.tmp', '.temp', '.log', '.bak', '.swp',
        '.cache', '.thumbs', '.old', '.original',
    }

    search_path = path(search_dir)
    cleaned_count = 0
    cleaned_size = 0

    for file_path in search_path.rglob('*'):
        if file_path.is_file() and file_path.suffix.lower() in temp_extensions:
            size = file_path.stat().st_size
            cleaned_size += size

            if dry_run:
                print(f"[预览删除] {file_path} ({format_size(size)})")
            else:
                try:
                    file_path.unlink()
                    print(f"[已删除] {file_path} ({format_size(size)})")
                except permissionerror:
                    print(f"[跳过-被占用] {file_path}")

            cleaned_count += 1

    print(f"\n{'='*50}")
    action = "预览" if dry_run else "清理"
    print(f"{action}完成: {cleaned_count} 个文件")
    print(f"可释放空间: {format_size(cleaned_size)}")


# ==================== 使用示例 ====================
if __name__ == "__main__":
    target_dir = r"d:"

    # 方案 1：查找重复文件（忽略小于 1mb 的）
    # find_duplicate_files(target_dir, min_size_mb=1)

    # 方案 2：查找最大的 20 个文件（超过 10mb 的）
    find_large_files(target_dir, top_n=20, min_size_mb=10)

    # 方案 3：预览临时文件（不删除）
    # clean_temp_files(r"c:\windows\temp", dry_run=true)

def calculate_md5(file_path, chunk_size=8192):
    md5 = hashlib.md5()
    with open(file_path, 'rb') as f:
        while true:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            md5.update(chunk)

for size, files in size_groups.items():
    if len(files) < 2:
        continue  # 跳过唯一大小的文件

wasted = file_size * (len(paths) - 1)

def delete_duplicates(duplicates, keep='newest'):
    for md5, paths in duplicates.items():
        # 按修改时间排序
        paths_with_time = [(p, path(p).stat().st_mtime) for p in paths]
        paths_with_time.sort(key=lambda x: x[1], reverse=(keep == 'newest'))

        # 保留第一份，删除其余
        for path, _ in paths_with_time[1:]:
            os.remove(path)
            print(f"已删除: {path}")

from pil import image
import imagehash

def get_image_hash(image_path):
    img = image.open(image_path)
    return imagehash.phash(img)

# 两张图片的哈希距离 < 5 认为是相似图片

hashlib.sha256()