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()