python+PyQt5高效实现Windows文件快速检索工具

import sys
import os
import time
import subprocess
from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
    QLineEdit, QPushButton, QListWidget, QLabel, QProgressBar, 
    QMessageBox, QCheckBox, QMenu, QAction, QFileDialog, QSplitter
)
from PyQt5.QtCore import Qt, QThread, pyqtSignal
from PyQt5.QtGui import QFont

class SearchWorker(QThread):
    """后台搜索线程，负责文件系统遍历"""
    update_progress = pyqtSignal(int)          # 已扫描文件数
    found_file = pyqtSignal(str)               # 找到的文件路径
    search_complete = pyqtSignal()             # 搜索完成信号
    error_occurred = pyqtSignal(str)           # 错误信号
    current_dir = pyqtSignal(str)              # 当前搜索目录

    def __init__(self, search_term, search_paths, include_hidden):
        super().__init__()
        self.search_term = search_term.lower()
        self.search_paths = search_paths
        self.include_hidden = include_hidden
        self.cancel_search = False
        self.file_count = 0
        self.found_count = 0

    def run(self):
        """执行搜索操作"""
        try:
            self.file_count = 0
            self.found_count = 0
            
            # 遍历所有指定路径
            for path in self.search_paths:
                if self.cancel_search:
                    break
                self._search_directory(path)
            
            self.search_complete.emit()
        except Exception as e:
            self.error_occurred.emit(str(e))

    def _search_directory(self, path):
        """递归搜索目录"""
        if self.cancel_search:
            return

        # 通知UI当前搜索目录
        self.current_dir.emit(path)
        
        try:
            # 使用高效的文件系统遍历
            with os.scandir(path) as entries:
                for entry in entries:
                    if self.cancel_search:
                        return

                    try:
                        # 跳过隐藏文件/目录（根据设置）
                        if not self.include_hidden and entry.name.startswith('.'):
                            continue

                        # 处理目录
                        if entry.is_dir(follow_symlinks=False):
                            # 跳过系统目录提升速度
                            if entry.name.lower() in [
                                '$recycle.bin', 
                                'system volume information', 
                                'windows', 
                                'program files', 
                                'program files (x86)'
                            ]:
                                continue
                            self._search_directory(entry.path)
                        # 处理文件
                        else:
                            self.file_count += 1
                            # 每100个文件更新一次进度
                            if self.file_count % 100 == 0:
                                self.update_progress.emit(self.file_count)
                            
                            # 检查文件名是否匹配
                            if self.search_term in entry.name.lower():
                                self.found_file.emit(entry.path)
                                self.found_count += 1
                    except PermissionError:
                        continue  # 跳过权限错误
                    except Exception:
                        continue  # 跳过其他错误
        except PermissionError:
            return  # 跳过无权限目录
        except Exception:
            return  # 跳过其他错误

    def cancel(self):
        """取消搜索"""
        self.cancel_search = True


class FileSearchApp(QMainWindow):
    """文件搜索应用程序主窗口"""
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Windows文件快速检索工具")
        self.setGeometry(100, 100, 1000, 700)
        self.init_ui()
        self.search_thread = None
        self.current_selected_file = ""
        self.last_search_time = 0

    def init_ui(self):
        """初始化用户界面"""
        # 主窗口设置
        main_widget = QWidget()
        self.setCentralWidget(main_widget)
        main_layout = QVBoxLayout(main_widget)
        
        # 使用分割器布局
        splitter = QSplitter(Qt.Vertical)
        main_layout.addWidget(splitter)
        
        # 控制面板
        control_panel = self.create_control_panel()
        splitter.addWidget(control_panel)
        
        # 结果面板
        result_panel = self.create_result_panel()
        splitter.addWidget(result_panel)
        
        # 设置分割比例
        splitter.setSizes([200, 500])
        
        # 状态栏
        self.status_bar = self.statusBar()
        self.selected_file_label = QLabel("未选择文件")
        self.status_bar.addPermanentWidget(self.selected_file_label)
        self.status_bar.showMessage("就绪")
        
        # 应用样式
        self.apply_styles()

    def create_control_panel(self):
        """创建控制面板"""
        panel = QWidget()
        layout = QVBoxLayout(panel)
        
        # 搜索输入区域
        search_layout = QHBoxLayout()
        self.search_input = QLineEdit()
        self.search_input.setPlaceholderText("输入文件名或扩展名 (例如: *.txt, report.docx)")
        self.search_input.returnPressed.connect(self.start_search)
        search_layout.addWidget(self.search_input)
        
        self.search_button = QPushButton("搜索")
        self.search_button.clicked.connect(self.start_search)
        self.search_button.setFixedWidth(100)
        search_layout.addWidget(self.search_button)
        layout.addLayout(search_layout)
        
        # 选项区域
        options_layout = QHBoxLayout()
        self.include_hidden_check = QCheckBox("包含隐藏文件和系统文件")
        options_layout.addWidget(self.include_hidden_check)
        
        self.search_drives_combo = QCheckBox("搜索所有驱动器")
        self.search_drives_combo.stateChanged.connect(self.toggle_drive_search)
        options_layout.addWidget(self.search_drives_combo)
        
        self.browse_button = QPushButton("选择搜索目录...")
        self.browse_button.clicked.connect(self.browse_directory)
        self.browse_button.setFixedWidth(120)
        options_layout.addWidget(self.browse_button)
        options_layout.addStretch()
        layout.addLayout(options_layout)
        
        # 当前搜索目录显示
        self.current_dir_label = QLabel("搜索目录: 用户目录")
        self.current_dir_label.setStyleSheet("color: #666; font-style: italic;")
        layout.addWidget(self.current_dir_label)
        
        # 驱动器选择区域
        self.drive_selection_widget = QWidget()
        drive_layout = QHBoxLayout(self.drive_selection_widget)
        drive_layout.addWidget(QLabel("选择要搜索的驱动器:"))
        
        # 添加可用驱动器
        self.drive_buttons = []
        for drive in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
            if os.path.exists(f"{drive}:\\"):
                btn = QCheckBox(f"{drive}:")
                btn.setChecked(True)
                self.drive_buttons.append(btn)
                drive_layout.addWidget(btn)
        
        drive_layout.addStretch()
        layout.addWidget(self.drive_selection_widget)
        self.drive_selection_widget.setVisible(False)
        
        # 进度显示
        progress_layout = QHBoxLayout()
        self.progress_label = QLabel("准备搜索...")
        progress_layout.addWidget(self.progress_label)
        progress_layout.addStretch()
        
        self.file_count_label = QLabel("已找到: 0 文件")
        self.file_count_label.setAlignment(Qt.AlignRight)
        progress_layout.addWidget(self.file_count_label)
        layout.addLayout(progress_layout)
        
        # 进度条
        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 100)
        self.progress_bar.setValue(0)
        layout.addWidget(self.progress_bar)
        
        return panel

    def create_result_panel(self):
        """创建结果面板"""
        panel = QWidget()
        layout = QVBoxLayout(panel)
        layout.addWidget(QLabel("搜索结果:"))
        
        self.result_list = QListWidget()
        self.result_list.itemSelectionChanged.connect(self.update_selected_file_info)
        self.result_list.itemDoubleClicked.connect(self.open_file)
        self.result_list.setContextMenuPolicy(Qt.CustomContextMenu)
        self.result_list.customContextMenuRequested.connect(self.show_context_menu)
        layout.addWidget(self.result_list, 1)
        
        return panel

    def apply_styles(self):
        """应用UI样式"""
        self.setStyleSheet("""
            QMainWindow { background-color: #f0f0f0; }
            QLineEdit {
                padding: 8px;
                font-size: 14px;
                border: 1px solid #ccc;
                border-radius: 4px;
            }
            QListWidget {
                font-family: Consolas, 'Courier New', monospace;
                font-size: 12px;
                border: 1px solid #ddd;
            }
            QProgressBar {
                text-align: center;
                height: 20px;
            }
            QPushButton {
                padding: 6px 12px;
                background-color: #4CAF50;
                color: white;
                border: none;
                border-radius: 4px;
            }
            QPushButton:hover { background-color: #45a049; }
            QPushButton:pressed { background-color: #3d8b40; }
            QCheckBox { padding: 5px; }
        """)
        
        # 设置全局字体
        font = QFont("Segoe UI", 10)
        QApplication.setFont(font)

    def toggle_drive_search(self, state):
        """切换驱动器搜索选项显示"""
        self.drive_selection_widget.setVisible(state == Qt.Checked)

    def browse_directory(self):
        """选择搜索目录"""
        directory = QFileDialog.getExistingDirectory(self, "选择搜索目录", os.path.expanduser("~"))
        if directory:
            self.current_dir_label.setText(f"搜索目录: {directory}")
            self.search_drives_combo.setChecked(False)
            self.drive_selection_widget.setVisible(False)

    def start_search(self):
        """开始搜索操作"""
        # 防抖处理
        current_time = time.time()
        if current_time - self.last_search_time < 1.0:
            return
        self.last_search_time = current_time
        
        # 验证输入
        search_term = self.search_input.text().strip()
        if not search_term:
            QMessageBox.warning(self, "输入错误", "请输入搜索关键词")
            return
        
        # 准备搜索
        self.result_list.clear()
        self.file_count_label.setText("已找到: 0 文件")
        self.status_bar.showMessage("正在搜索...")
        
        # 确定搜索路径
        if self.search_drives_combo.isChecked():
            selected_drives = []
            for btn in self.drive_buttons:
                if btn.isChecked():
                    drive = btn.text().replace(":", "")
                    selected_drives.append(f"{drive}:\\")
            
            if not selected_drives:
                QMessageBox.warning(self, "选择错误", "请至少选择一个驱动器")
                return
                
            self.current_dir_label.setText(f"搜索目录: {len(selected_drives)}个驱动器")
            search_paths = selected_drives
        else:
            current_dir_text = self.current_dir_label.text()
            if current_dir_text.startswith("搜索目录: "):
                search_path = current_dir_text[6:]
                if not os.path.exists(search_path):
                    search_path = os.path.expanduser("~")
            else:
                search_path = os.path.expanduser("~")
            
            search_paths = [search_path]
            self.current_dir_label.setText(f"搜索目录: {search_path}")
        
        # 创建并启动搜索线程
        if self.search_thread and self.search_thread.isRunning():
            self.search_thread.cancel()
            self.search_thread.wait(1000)
        
        self.search_thread = SearchWorker(
            search_term, 
            search_paths, 
            self.include_hidden_check.isChecked()
        )
        
        # 连接信号
        self.search_thread.found_file.connect(self.add_result)
        self.search_thread.update_progress.connect(self.update_progress)
        self.search_thread.search_complete.connect(self.search_finished)
        self.search_thread.error_occurred.connect(self.show_error)
        self.search_thread.current_dir.connect(self.update_current_dir)
        
        # 更新UI状态
        self.search_button.setEnabled(False)
        self.search_button.setText("停止搜索")
        self.search_button.clicked.disconnect()
        self.search_button.clicked.connect(self.cancel_search)
        
        # 启动线程
        self.search_thread.start()

    def add_result(self, file_path):
        """添加搜索结果"""
        self.result_list.addItem(file_path)
        count = self.result_list.count()
        self.file_count_label.setText(f"已找到: {count} 文件")
        self.status_bar.showMessage(f"找到 {count} 个匹配文件")

    def update_progress(self, file_count):
        """更新进度显示"""
        self.progress_label.setText(f"已扫描 {file_count} 个文件...")
        self.progress_bar.setRange(0, 0)  # 不确定模式

    def update_current_dir(self, directory):
        """更新当前搜索目录"""
        self.status_bar.showMessage(f"正在搜索: {directory}")

    def search_finished(self):
        """搜索完成处理"""
        self.progress_bar.setRange(0, 100)
        self.progress_bar.setValue(100)
        
        if self.search_thread:
            self.progress_label.setText(
                f"搜索完成！共扫描 {self.search_thread.file_count} 个文件，"
                f"找到 {self.search_thread.found_count} 个匹配项"
            )
            self.status_bar.showMessage(f"搜索完成，找到 {self.result_list.count()} 个匹配文件")
        
        # 重置搜索按钮
        self.search_button.setText("搜索")
        self.search_button.clicked.disconnect()
        self.search_button.clicked.connect(self.start_search)
        self.search_button.setEnabled(True)

    def cancel_search(self):
        """取消搜索"""
        if self.search_thread and self.search_thread.isRunning():
            self.search_thread.cancel()
            self.search_thread.wait(1000)
            
            self.progress_bar.setRange(0, 100)
            self.progress_bar.setValue(0)
            self.progress_label.setText("搜索已取消")
            self.status_bar.showMessage(f"已取消搜索，找到 {self.result_list.count()} 个文件")
            
            self.search_button.setText("搜索")
            self.search_button.clicked.disconnect()
            self.search_button.clicked.connect(self.start_search)
            self.search_button.setEnabled(True)

    def open_file(self, item):
        """打开文件"""
        file_path = item.text()
        self.current_selected_file = file_path
        try:
            os.startfile(file_path)
        except Exception as e:
            QMessageBox.critical(self, "打开文件错误", f"无法打开文件:\n{str(e)}")

    def show_error(self, error_msg):
        """显示错误信息"""
        QMessageBox.critical(self, "搜索错误", f"搜索过程中发生错误:\n{error_msg}")
        self.cancel_search()

    def show_context_menu(self, position):
        """显示右键菜单"""
        if not self.result_list.selectedItems():
            return
            
        selected_item = self.result_list.currentItem()
        file_path = selected_item.text()
        self.current_selected_file = file_path
        
        menu = QMenu()
        
        # 添加菜单项
        open_action = QAction("打开文件", self)
        open_action.triggered.connect(lambda: self.open_file(selected_item))
        menu.addAction(open_action)
        
        open_location_action = QAction("打开文件所在位置", self)
        open_location_action.triggered.connect(self.open_file_location)
        menu.addAction(open_location_action)
        
        copy_path_action = QAction("复制文件路径", self)
        copy_path_action.triggered.connect(self.copy_file_path)
        menu.addAction(copy_path_action)
        
        menu.exec_(self.result_list.mapToGlobal(position))
    
    def open_file_location(self):
        """打开文件所在位置"""
        if not self.current_selected_file:
            return
            
        try:
            subprocess.Popen(f'explorer /select,"{self.current_selected_file}"')
        except Exception as e:
            QMessageBox.critical(self, "打开位置错误", f"无法打开文件所在位置:\n{str(e)}")
    
    def copy_file_path(self):
        """复制文件路径"""
        if not self.current_selected_file:
            return
            
        clipboard = QApplication.clipboard()
        clipboard.setText(self.current_selected_file)
        self.status_bar.showMessage(f"已复制路径: {self.current_selected_file}", 3000)
    
    def update_selected_file_info(self):
        """更新文件信息显示"""
        selected_items = self.result_list.selectedItems()
        if not selected_items:
            self.selected_file_label.setText("未选择文件")
            self.current_selected_file = ""
            return
            
        file_path = selected_items[0].text()
        self.current_selected_file = file_path
        
        try:
            # 获取文件信息
            file_size = os.path.getsize(file_path)
            file_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(os.path.getmtime(file_path)))
            
            # 格式化文件大小
            if file_size < 1024:
                size_str = f"{file_size} B"
            elif file_size < 1024*1024:
                size_str = f"{file_size/1024:.2f} KB"
            else:
                size_str = f"{file_size/(1024*1024):.2f} MB"
            
            # 更新状态栏
            file_name = os.path.basename(file_path)
            self.selected_file_label.setText(
                f"{file_name} | 大小: {size_str} | 修改时间: {file_time}"
            )
        except:
            self.selected_file_label.setText(file_path)


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = FileSearchApp()
    window.show()
    sys.exit(app.exec_())

with os.scandir(path) as entries:
    for entry in entries:
        if entry.is_dir():
            # 处理目录
        else:
            # 处理文件

if entry.name.lower() in [
    '$recycle.bin', 
    'system volume information', 
    'windows', 
    'program files', 
    'program files (x86)'
]:
    continue

self.file_count += 1
if self.file_count % 100 == 0:
    self.update_progress.emit(self.file_count)

self.search_thread = SearchWorker(...)
self.search_thread.start()