[python] 基于WatchDog库实现文件系统监控

Watchdog库是Python中一个用于监控文件系统变化的第三方库。它能够实时监测文件或目录的创建、修改、删除等操作，并在这些事件发生时触发相应的处理逻辑，因此也被称为文件看门狗。

Watchdog库的官方仓库见：watchdog，Watchdog库的官方文档见：watchdog-doc。Watchdog库的安装命令如下：

python -m pip install -U watchdog

注意：Watchdog库最新版本（2.1.5以上版本）需在Python3.9以上版本运行。若使用Python3.4或3.5，应选用Watchdog版本低于1.0.0；若使用Python3.6至3.8，应选用Watchdog版本低于2.0.0。

目录

• 1 使用示例
  
• 2 参考
  

1 使用示例

基础示例
以下示例程序将以递归方式监控指定目录及其子文件夹中文件系统的变化情况，包括文件或文件夹的创建、修改、移动、删除，并将这些变化记录到控制台中：

1. import sys
2. # 导入logging模块，用于记录程序运行时的日志信息
3. import logging
4. # 从watchdog.observers模块中导入Observer类，用于监控文件系统的变化
5. from watchdog.observers import Observer
6. # 从watchdog.events模块中导入LoggingEventHandler类，用于处理文件系统事件并记录日志
7. from watchdog.events import LoggingEventHandler
9. if __name__ == "__main__":
10.     # 配置日志记录的基本设置
11.     # level=logging.INFO表示只记录INFO级别及以上的日志信息
12.     # format='%(asctime)s - %(message)s'指定日志的输出格式，包含时间戳和日志消息
13.     # datefmt='%Y-%m-%d %H:%M:%S'指定时间戳的格式
14.     logging.basicConfig(level=logging.INFO,
15.                         format='%(asctime)s - %(message)s',
16.                         datefmt='%Y-%m-%d %H:%M:%S')
17.     # 指定要监控的文件夹路径，该文件夹必须存在
18.     path = "demo_folder"
19.     # 创建一个LoggingEventHandler对象，用于处理文件系统事件并记录日志
20.     event_handler = LoggingEventHandler()
21.     # 创建一个Observer对象，用于监控文件系统的变化
22.     observer = Observer()
23.     # 安排观察者监控指定路径下的文件系统事件
24.     # event_handler是事件处理程序
25.     # path是要监控的路径
26.     # recursive=True表示递归监控该路径下的所有子文件夹
27.     observer.schedule(event_handler, path, recursive=True)
28.     # 启动观察者，开始监控文件系统的变化
29.     observer.start()
30.     try:
31.         # 当观察者处于活动状态时，持续循环
32.         while observer.is_alive():
33.             # 等待1秒，让观察者有时间处理文件系统事件
34.             observer.join(1)
35.     finally:
36.         # 停止观察者，结束文件系统的监控
37.         observer.stop()
38.         # 等待观察者线程结束
39.         observer.join()

复制代码

Watchdog事件类介绍
Watchdog库提供了一系列事件类，用于监控文件系统的各种变化，这些变化包括：

• 创建事件on_create：涵盖文件和文件夹的创建情况，当有新的文件或者文件夹在监控路径下生成时触发相应事件。
  
• 删除事件on_delete：当文件或者文件夹被从监控路径中移除时触发，分别有针对文件和文件夹的不同事件类。
  
• 修改事件on_modified：文件夹内新增、删除文件或子文件夹等内容变化时触发文件夹修改事件。
  
• 移动 / 重命名事件on_moved：文件或文件夹的位置发生移动，或者名称被更改时触发相应事件，该事件会记录原路径和新路径。
  

基于这些变化Watchdog库中存在8个事件类：
事件类名触发场景FileCreatedEvent新文件被创建时触发DirCreatedEvent新文件夹被创建时触发FileDeletedEvent文件被删除时触发DirDeletedEvent文件夹被删除时触发FileModifiedEvent文件内容被修改时触发DirModifiedEvent文件夹内容（如添加、删除子文件或子文件夹）发生变化时触发FileMovedEvent文件被移动或重命名时触发DirMovedEvent文件夹被移动或重命名时触发注意：在某些情形下，多个Watchdog事件可能会一同触发，这往往和文件系统操作的特性以及Watchdog对这些操作的响应机制有关。例如，当移动一个文件时，会同时触发FileMovedEvent（文件移动事件）和FileDeletedEvent（文件删除事件），因为移动文件的操作在源路径上相当于删除文件，同时在目标路径上会触发FileCreatedEvent（文件创建事件）。
以下代码的主要功能是监控指定目录下文件系统的各种事件，如文件或目录的创建、删除、移动和修改，并对这些事件进行重写和相应的处理：

1. # 该类用于处理文件系统事件，如文件的创建、删除、修改等
2. from watchdog.events import FileSystemEventHandler
3. from watchdog.observers import Observer
5. # 定义一个自定义的文件事件处理类，继承自FileSystemEventHandler
6. class FileEventHandler(FileSystemEventHandler):
7.     def __init__(self):
8.         FileSystemEventHandler.__init__(self)
9.         # 初始化一个空列表，用于存储文件名
10.         self.file_names = []  
12.     # 当文件或目录被移动时触发此方法
13.     def on_moved(self, event):
14.         # 判断是否是目录移动
15.         if event.is_directory:
16.             # 打印目录移动的信息
17.             print(f"目录从 {event.src_path} 移动到 {event.dest_path}")
18.         else:
19.             # 打印文件移动的信息
20.             print(f"文件从 {event.src_path} 移动到 {event.dest_path}")
22.     # 当文件或目录被创建时触发此方法
23.     def on_created(self, event):
24.         # 判断是否是目录创建
25.         if event.is_directory:
26.             # 打印目录创建的信息
27.             print(f"目录已创建: {event.src_path}")
28.         else:
29.             # 打印文件创建的信息
30.             print(f"文件已创建: {event.src_path}")
31.             # 从文件的完整路径中提取文件名
32.             file_full_name = str(event.src_path.split('/')[-1])
33.             if file_full_name.endswith('.csv'):
34.                 # 如果是csv文件，将其添加到文件名列表中
35.                 self.file_names.append(file_full_name)
36.             # 打印文件名列表
37.             print(self.file_names)
39.     # 当文件或目录被删除时触发此方法
40.     def on_deleted(self, event):
41.         # 判断是否是目录删除
42.         if event.is_directory:
43.             # 打印目录删除的信息
44.             print(f"目录已删除: {event.src_path}")
45.         else:
46.             # 打印文件删除的信息
47.             print(f"文件已删除: {event.src_path}")
49.     # 当文件或目录被修改时触发此方法，注释代码表示不触发修改事件
50.     # def on_modified(self, event):
51.     #     pass
53. if __name__ == "__main__":
54.     # 创建一个Observer对象，用于监控文件系统的变化
55.     observer = Observer()
56.     # 创建一个自定义的文件事件处理对象
57.     event_handler = FileEventHandler()
58.     # 定义要监控的目录
59.     watch_directory = "demo_folder"
60.     # 将事件处理对象和要监控的目录添加到观察者中，并设置为递归监控
61.     observer.schedule(event_handler, watch_directory, recursive=True)
62.     # 启动观察者，开始监控文件系统的变化
63.     observer.start()
64.     try:
65.         # 当观察者处于活动状态时，持续循环
66.         while observer.is_alive():
67.             # 等待1秒，让观察者有时间处理文件系统事件
68.             observer.join(1)
69.     finally:
70.         # 停止观察者，结束文件系统的监控
71.         observer.stop()
72.         # 等待观察者线程结束
73.         observer.join()

复制代码

快照功能
采用基于定时器的批处理策略，合并并延迟频繁的文件变更事件，能够有效降低系统负载。具体做法是：当系统检测到文件首次变动时，启动可重置的计时器，在设定的延迟期内累积后续变更事件，待计时器超时后，再统一通过对比当前文件系统状态与上次缓存快照，可精准识别所有变更项。具体实现代码如下：

1. import time
2. import os
3. import threading
4. from watchdog.observers import Observer
5. from watchdog.events import *
6. from watchdog.utils.dirsnapshot import DirectorySnapshot, DirectorySnapshotDiff
9. class FileChangeHandler(FileSystemEventHandler):
10.     def __init__(self, monitored_path, delay=0.5):
11.         # 调用父类构造函数
12.         super().__init__()
13.         # 被监控的目录路径
14.         self.monitored_path = monitored_path
15.         self.delay = delay
16.         # 定时器对象，用于延迟检查
17.         self.delay_timer = None
18.         # 快照用于记录指定目录在某个时间点的状态，包含了目录下所有文件和子目录的信息，
19.         # 记录目录的初始快照
20.         self.initial_snapshot = DirectorySnapshot(self.monitored_path)
22.     def on_any_event(self, event):
23.         # 通过定时器减少不必要的检查
24.         # 如果定时器已存在，取消它
25.         if self.delay_timer:
26.             self.delay_timer.cancel()
27.         # 创建一个新的定时器，延迟后执行检查快照的操作
28.         # 通过快照检测文件系统变化
29.         self.delay_timer = threading.Timer(self.delay, self._check_directory_changes)
30.         self.delay_timer.start()
32.     def _check_directory_changes(self):
33.         # 获取当前目录的新快照
34.         new_snapshot = DirectorySnapshot(self.monitored_path)
35.         # 计算新旧快照之间的差异
36.         snapshot_difference = DirectorySnapshotDiff(self.initial_snapshot, new_snapshot)
37.         # 更新初始快照为新快照
38.         self.initial_snapshot = new_snapshot
39.         # 清空定时器
40.         self.delay_timer = None
41.         # 打印目录变化信息
42.         self._print_changes(snapshot_difference)
44.     def _print_changes(self, diff):
45.         # 打印文件和目录的创建、删除、修改和移动信息
46.         print("创建的文件:", diff.files_created)
47.         print("删除的文件:", diff.files_deleted)
48.         print("修改的文件:", diff.files_modified)
49.         print("移动的文件:", diff.files_moved)
50.         print("修改的目录:", diff.dirs_modified)
51.         print("移动的目录:", diff.dirs_moved)
52.         print("删除的目录:", diff.dirs_deleted)
53.         print("创建的目录:", diff.dirs_created)
55. class DirectoryMonitor:
56.     def __init__(self, monitored_path):
57.         # 被监控的目录路径
58.         self.monitored_path = monitored_path
59.         # 创建一个观察者对象
60.         self.directory_observer = Observer()
62.     def start_monitoring(self):
63.         # 创建文件变化处理对象
64.         change_handler = FileChangeHandler(self.monitored_path)
65.         # 安排观察者监控指定目录，递归地监控子目录
66.         self.directory_observer.schedule(change_handler, self.monitored_path, recursive=True)
67.         # 启动观察者
68.         self.directory_observer.start()
70.     def stop_monitoring(self):
71.         # 停止观察者
72.         self.directory_observer.stop()
73.         # 等待观察者线程结束
74.         self.directory_observer.join()
76. if __name__ == "__main__":
77.     monitor = DirectoryMonitor("demo_folder")
78.     # 开始监控
79.     monitor.start_monitoring()
80.     try:
81.         while True:
82.             time.sleep(1)
83.     except KeyboardInterrupt:
84.         monitor.stop_monitoring()

复制代码

多文件夹监控
以下代码展示了通过schedule方法为每个目录注册事件处理程序，实现对多个目录的同步监控：

1. from watchdog.observers import Observer
2. from watchdog.events import FileSystemEventHandler
3. class CustomFileEventHandler(FileSystemEventHandler):
4.     def on_created(self, event):
5.             patterns = [“*.jpg”， “*.png”， “*.gif”]  # 只监控图片文件    def on_modified(self， event)：        print(f“图片文件有变化：{event.src_path}”)
6.         entity = "directory" if event.is_directory else "file"
7.         print(f"{entity} on_created: {event.src_path}")
9. if __name__ == "__main__":
10.     file_observer = Observer()
11.     monitored_directories = ['demo_folder', 'demo_folder2']
12.     file_event_handler = CustomFileEventHandler()
13.     for directory in monitored_directories:
14.         # 为每个目录注册事件处理程序
15.         file_observer.schedule(file_event_handler, directory, recursive=True)
16.     file_observer.start()
17.     try:
18.         # 当观察者处于活动状态时，持续循环
19.         while file_observer.is_alive():
20.             # 等待1秒，让观察者有时间处理文件系统事件
21.             file_observer.join(1)
22.     finally:
23.         # 停止观察者，结束文件系统的监控
24.         file_observer.stop()
25.         # 等待观察者线程结束
26.         file_observer.join()

复制代码

2 参考

• watchdog
  
• watchdog-doc
  
• Python神器之使用watchdog监控文件变化
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！