文件监控——watchdog详解

最新推荐文章于 2024-08-27 15:30:51 发布
最新推荐文章于 2024-08-27 15:30:51 发布
阅读量7.8k 收藏 29
点赞数 5
分类专栏： python 工具包 文章标签： 文件及文件夹监控 watchdog python 跨系统 详解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jerry_liufeng/article/details/109603462
版权

文章目录

文件监控——watchdog详解

一、官方文档（需要细节选择去官网，需要了解和应用范例看本文即可）

https://pythonhosted.org/watchdog/
官网上的：User’s Guide，主要看API相关这里即可

  1. 安装
  2. 快速开始
  3. API 相关

二、watchdog安装

watchdog需要在python2.6以上的版本工作，如果使用的是Linux//FreeBSD/Mac OS X 系统，python已经安装了，但是需要保证python的版本至少是python2.7（学习用最好还是使用3.6以上的版本吧）
下面有三种不同的安装方法：选择第一种最简单的就行了，可以简便的不要自求麻烦。

1. Installing from PyPI using pip
pip install watchdog
2. Installing from source tarballs
$ wget -c http://pypi.python.org/packages/source/w/watchdog/watchdog-0.8.2.tar.gz
$ tar zxvf watchdog-0.8.2.tar.gz
$ cd watchdog-0.8.2
$ python setup.py install
3. Installing from the code repository
$ git clone --recursive git://github.com/gorakhargosh/watchdog.git
$ cd watchdog
$ python setup.py install

在官方还说需要下载一些依赖，但是你使用第一种pip安装的方法基本都不会有这种需求。

三、快速开始（官方范例）

下面我们提供一个简单的示例，该示例以递归方式监视当前目录（这意味着它将遍历所有子目录）以检测更改。 这是我们将要使用的API：

  1. 创建watchdog.observers.Observer线程类的实例
  2. 实现watchdog.events.FileSystemEventHandler的子类（或者在我们的例子中，我们将使用内置的watchdog.events.LoggingEventHandler）。
  3. 通过附加事件处理程序的观察者实例来计划监视一些路径。
  4. 启动观察者线程并等待它生成事件而不会阻塞我们的主线程。
import sys
import time
import logging
from watchdog.observers import Observer # 监控
from watchdog.events import LoggingEventHandler # 触发事件

if __name__=='__main__':
    logging.basicConfig(level=logging.INFO,
                        format='%(asctime)s - %(message)s',
                        datefmt='%Y-%m-%d %H:%M:%S')
    path = sys.argv[1] if len(sys.argv) > 1 else '.'
    event_handler = LoggingEventHandler() # 监控处理事件的方法,这个类非常重要,可以根据自己的需要重写
    observer = Observer() # 定义监控类,多线程类 thread class
    observer.schedule(event_handler,'./monitor_folder_1', recursive=True) # 指定监控路径/触发对应的监控事件类
    observer.start()# 将observer运行在同一个线程之内,不阻塞主进程运行,可以调度observer来停止该线程
    try:
        while True:
            time.sleep(1) # 监控频率（1s1次，根据自己的需求进行监控）
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

四、API Reference（翻译官网）

观察者模型主要有三个角色：observer、event_handler、被监控的文件夹。三者原本是独立的，主要通过observer.schedule函数将三者串起来，意思为observer不断检测调用平台依赖代码对监控文件夹进行变动检测，当发现改变时，通知event_handler处理。
watchdog.event
模型：watchdog.events
简介：文件系统事件和时间处理的程序
原作者： yesudeep@google.com (Yesudeep Mangalapilly)

1. Event Class

首先考虑一下关于文件和文件夹的相关操作有那些?
无外乎:

  • 创建(FileCreatedEvent/DirCreateEvent)
  • 移动(FileMovedEvent/DirMovedEvent)
  • 删除(FildDeletedEvent/DirDeletedEvent)
  • 修改(FileModifiedEvent/DirModifiedEvent)

对文件/文件夹的监控也就无非以上的操作了，watchdog对文件夹的监控也就是针对上述需求进行设计的
Event Classes也就包含了大概八个类（都分别依赖于watchdog.events.FileSystemEvent 和watchdog.events.FileSystemMovedEvent）：

  • class watchdog.events.FileMovedEvent(src_path, dest_path)
  • class watchdog.events.DirMovedEvent(src_path, dest_path)
  • class watchdog.events.FileModifiedEvent(src_path)
  • class watchdog.events.DirModifiedEvent(src_path)
  • class watchdog.events.FileCreatedEvent(src_path)
  • class watchdog.events.DirCreatedEvent(src_path)
  • class watchdog.events.FileDeletedEvent(src_path)
  • class watchdog.events.DirDeletedEvent(src_path)
2. Event handler Classes事件处理类
官方文件中对Event Handler Classes的说明：
class watchdog.events.FileSystemEventHandler[source]
	Bases: object
	Base file system event handler that you can override methods from.
	
	dispatch(event)[source]
	Dispatches events to the appropriate methods.
	Parameters:	event (FileSystemEvent) – The event object representing the file system event.
	
	on_any_event(event)[source]
	Catch-all event handler.
	Parameters:	event (FileSystemEvent) – The event object representing the file system event.
	
	on_created(event)[source]
	Called when a file or directory is created.
	Parameters:	event (DirCreatedEvent or FileCreatedEvent) – Event representing file/directory creation.
	
	on_deleted(event)[source]
	Called when a file or directory is deleted.
	Parameters:	event (DirDeletedEvent or FileDeletedEvent) – Event representing file/directory deletion.
	
	on_modified(event)[source]
	Called when a file or directory is modified.
	Parameters:	event (DirModifiedEvent or FileModifiedEvent) – Event representing file/directory modification.
	
	on_moved(event)[source]
	Called when a file or a directory is moved or renamed.
	Parameters:	event (DirMovedEvent or FileMovedEvent) – Event representing file/directory movement.

上述也就说明了watchdog的触发事件的方法为：

  • dispatch
  • on_any_event
  • on_create
  • on_delete
  • on_modified
  • on_moved

对应到

3. watchdog.observers.api
class watchdog.observers.api.ObservedWatch(path, recursive)
Bases: object
An scheduled watch.
Parameters:	
	path – Path string.
	recursive：
		True if watch is recursive; 
		False
		otherwise.is_recursive：Determines whether subdirectories are watched for the path.
path：The path that this watch monitors

Observer用以监控文件的变化，根据触发事件调用相关联的事件处理方法来执行。

observer是threading.Thread的子类，通过observer.start()使之运行在一个线程之中，不阻塞主线程的运行，然后可以调用observer.stop()来停止该进程.

observer.schedule(event_handler,path,recursive=False)
# event_handler:触发事件的操作方法
# path：监控的文件或者目录
# recursive：如果监控的是文件则需要设置为True

五、linux中使用watchdog监控文件夹各种操作会触发的监控事件

1. 移除文件：
  1. 文件删除:File_deleted
  2. 文件夹修改 Directory_modified
2. 添加文件：
  1. 文件新建：File_created
  2. 文件夹修改：Directory_modified
3.修改文件：
  1. 两次文件修改：File_modified(显示针对一个备份文件，然后是针对原始文件)
  2. 删除备份文件：File_deleted
  3. 文件夹修改：Directory_modified
4.文件改名：
  1. 文件移动：File_moved
  2. 文件夹修改：Directory_modified
5.使用cp命令复制文件到监控目录：
  1. 文件新建：File_created
  2. 一大堆文件修改操作：Directory_modified
  3. 文件夹修改操作：File_modified

六、应用实例

1.监控文件夹中是否有后缀为".segy"的文件进入
#! /home/liufeng/project
# -*- coding:utf-8 -*-
# Created by jerry_liufeng

# 本模块的功能:<检测文件夹变化>

# 导入watchdog对应模块
from watchdog.observers import Observer
from watchdog.events import *
# 导入时间模块
import time

class FileEventHandler(FileSystemEventHandler):
    # 初始化魔术方法
    def __init__(self):
        FileSystemEventHandler.__init__(self)
        self.fileNameList = [] # 文件名列表（存储文件名）

    # 文件或文件夹移动
    def on_moved(self, event):
        if event.is_directory:
            print("directory moved from {0} to {1}".format(event.src_path,event.dest_path))
        else:
            print("file moved from {0} to {1}".format(event.src_path,event.dest_path))

    # 创建文件或文件夹
    def on_created(self, event):
        if event.is_directory:
            print("directory created:{0}".format(event.src_path))
        else:
            print("file created:{0}".format(event.src_path))
            fileAllName =str(event.src_path.split('/')[-1])
            if fileAllName.endswith('.segy'):
                self.fileNameList.append(fileAllName)
            print(self.fileNameList)
                
    # 删除文件或文件夹
    def on_deleted(self, event):
        if event.is_directory:
            print("directory deleted:{0}".format(event.src_path))
        else:
            print("file deleted:{0}".format(event.src_path))

#     # 修改文件或文件夹
#     def on_modified(self, event):
#         if event.is_directory:
#             print("directory modified:{0}".format(event.src_path))
#         else:
#             print("file modified:{0}".format(event.src_path))

if __name__ == "__main__":
    # 实例化Observer对象
    observer = Observer()
    event_handler = FileEventHandler()
    # 设置监听目录
    dis_dir = "./03_seis_data/"
    observer.schedule(event_handler,dis_dir,True)
    observer.start()
    try:
        while True:
            # 设置监听频率(间隔周期时间)
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

说明：之所以注释掉modified这段代码是因为我关心的是文件的进入，而非文件内容的改变，太过频繁的modified操作会影响我对新增文件数量的判断。

2.监控多个文件夹
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import time

class FileEventHandler(FileSystemEventHandler):
    def __init__(self):
        FileSystemEventHandler.__init__(self)
 
    def on_moved(self, event):
        if event.is_directory:
            print("directory moved from {0} to {1}".format(event.src_path,event.dest_path))
        else:
            print("file moved from {0} to {1}".format(event.src_path,event.dest_path))
 
    def on_created(self, event):
        if event.is_directory:
            print("directory created:{0}".format(event.src_path))
        else:
            print("file created:{0}".format(event.src_path))
 
    def on_deleted(self, event):
        if event.is_directory:
            print("directory deleted:{0}".format(event.src_path))
        else:
            print("file deleted:{0}".format(event.src_path))
 
    def on_modified(self, event):
        if event.is_directory:
            print("directory modified:{0}".format(event.src_path))
        else:
            print("file modified:{0}".format(event.src_path))

if __name__ == "__main__":
    observer = Observer()
    dirs = [r'./monitor_folder_1', r'./monitor_folder_1']
#    dirs = [ r'./monitor_folder_1']
    for dir in dirs:
        event_handler = FileEventHandler()
        observer.schedule(event_handler, dir, True)
    observer.start()
3.文件系统一次操作多次触发各类事件问题解决：

原文参考:https://blog.csdn.net/xufive/article/details/93847372
问题：
文件操作引发的事件比我们想象的多了不少，而且难以在事件函数中做出针对性处理。

在 windows 平台上每一次的文件修改引发两次 modified 事件？在 windows 平台上，由于 watchdog 封装的是 windows 系统的 FileSystemWatcher Events，处理文件的过程中执行了多次文件系统操作，无法避免地触发了多次事件。

改进方案：
如果对监视文件的实时性要求不高，又懒得处理一大堆事件，那么，比较事件前后的文件夹快照就是一个值得尝试的改进方案。实现这个思路，有三个前提条件：

  • 快速获取文件夹快照。幸运的是，watchdog 模块为我们提供了 DirectorySnapshot 功能
  • 可以接受200毫秒的延时。文件操作引发的一大堆事件会集中在一个较短的时间内，一般情况下，在文件操作之后200毫秒获取文件夹快照，是一个不错的间隔
  • 快速比较文件夹快照。这也不是问题，watchdog 模块有 DirectorySnapshotDiff 子模块

改进思路：设置一个定时器， 200毫秒后抓取快照，并与上一张快照比较。每当有事件发生时，检查定时器是否已经启动。如果未启动，则直接启动定时器；否则，说明该事件距离上次事件不足200毫秒，可视为是同一组事件，此时终止定时器，再次重启。具体代码如下：

import time
import os, threading
from watchdog.observers import Observer
from watchdog.events import *
from watchdog.utils.dirsnapshot import DirectorySnapshot, DirectorySnapshotDiff

class FileEventHandler(FileSystemEventHandler):
    def __init__(self, aim_path):
        FileSystemEventHandler.__init__(self)
        self.aim_path = aim_path
        self.timer = None
        self.snapshot = DirectorySnapshot(self.aim_path)
    
    def on_any_event(self, event):
        if self.timer:
            self.timer.cancel()
        
        self.timer = threading.Timer(0.2, self.checkSnapshot)
        self.timer.start()
    
    def checkSnapshot(self):
        snapshot = DirectorySnapshot(self.aim_path)
        diff = DirectorySnapshotDiff(self.snapshot, snapshot)
        self.snapshot = snapshot
        self.timer = None
        
        print("files_created:", diff.files_created)
        print("files_deleted:", diff.files_deleted)
        print("files_modified:", diff.files_modified)
        print("files_moved:", diff.files_moved)
        print("dirs_modified:", diff.dirs_modified)
        print("dirs_moved:", diff.dirs_moved)
        print("dirs_deleted:", diff.dirs_deleted)
        print("dirs_created:", diff.dirs_created)
    
#     def on_moved(self, event):
#         if event.is_directory:
#             print("directory moved from {0} to {1}".format(event.src_path,event.dest_path))
#         else:
#             print("file moved from {0} to {1}".format(event.src_path,event.dest_path))
 
#     def on_created(self, event):
#         if event.is_directory:
#             print("directory created:{0}".format(event.src_path))
#         else:
#             print("file created:{0}".format(event.src_path))
 
#     def on_deleted(self, event):
#         if event.is_directory:
#             print("directory deleted:{0}".format(event.src_path))
#         else:
#             print("file deleted:{0}".format(event.src_path))
 
#     def on_modified(self, event):
#         if event.is_directory:
#             print("directory modified:{0}".format(event.src_path))
#         else:
#             print("file modified:{0}".format(event.src_path))


class DirMonitor(object):
    """文件夹监视类"""
    
    def __init__(self, aim_path):
        """构造函数"""
        self.aim_path= aim_path
        self.observer = Observer()
    
    def start(self):
        """启动"""
        event_handler = FileEventHandler(self.aim_path)
        self.observer.schedule(event_handler, self.aim_path, True)
        self.observer.start()
    
    def stop(self):
        """停止"""
        self.observer.stop()
    
if __name__ == "__main__": 
    monitor = DirMonitor(r"./monitor_folder_1") 
    monitor.start() 
    try: 
        while True: 
            time.sleep(1) 
    except KeyboardInterrupt: 
        monitor.stop()

代码评价：可以使用，问题得到了很好的解决，但是个人感觉触发的事件还是太多了，我们很多时候仅仅需要这个解决方案中的一部分功能而已，所以可以根据博主的思路进行一定的代码重构和更改。

留小星
关注
专栏目录
Linux系统管理（9）——系统状态监控命令top使用详解
请大家直接把问题写在评论区或留言，不要只说一句"你好 或 在吗"，我会尽快回复的。
08-07 614
一个服务器运维管理员，每天早上到公司第一件事 就是端着一杯咖啡 连上服务器，输入top命令 看着满屏幕系统运行参数状态，一股朕日理万机的感觉油然而生 [root@localhost~]#top[参数] 参数：-d 秒数：指定 top 命令每隔几秒更新。默认是 3 秒；-b：使用批处理模式输出。一般和"-n"选项合用，用于把 top 命令重定向到文件中；-n 次数：指定 top 命令执行的次数。一般和"-"选项合用；-p 进程PID：仅查看指定 ID 的进程；-s：使 top 命令在安..
watchdog使用
我的专栏
07-29 1130
 Linux Kernel Version 2.4 Watchdog Setting Guide===============================================1. compile watchdog driver  - cd drv-2.4  - modify following of ../Rules.make if needed      KERNELDIR
docker-watchdog:在给定目录中运行看门狗的简单Docker映像
05-10
Docker看门狗 在给定目录中运行看门狗的简单Docker映像
探索Python监控之眼：watchdog库深度解析
AIGC搞起
07-29 1926
watchdog是一个开源的Python库，专注于文件系统监控。它提供了一个平台独立的API，可以跨操作系统（如Windows、Linux、macOS）使用。通过watchdog，你可以轻松地实现对文件和目录的实时监控，从而触发相应的事件处理程序。watchdog是一个功能强大的Python库，它可以帮助开发者实现文件系统的实时监控。通过本文的介绍，你已经了解了如何安装、使用基本函数、结合场景应用以及解决常见问题。希望这些知识能帮助你在项目中更好地利用watchdog库。
WatchDog 使用经验总结
Python作业辅导员 - 天元浪子
06-27 1万+
首先声明，本文讨论的 watchdog，不是单片机里的 watchdog，也不是 linux 中的 watchdog，而是 python 世界里用来监视文件系统变化的一个第三方模块。在 python 中文件监视主要有两个库，一个是 pyinotify，一个是 watchdog。pyinotify 依赖于 linux 平台的 inotify 机制，只能应用在 linux 平台上。watchdog 则对不同平台的的事件都进行了封装，不仅可以监视 windows 文件系统，也可以监视 linux 的文件系统。
Watchdog简单使用
qq_38622141的博客
01-05 734
对文件夹进行监听，使用on_created、on_moved等方法对文件进行处理。 ps: watchdog监听文件，一堆图片进来时，是按序执行 class FileMonitorHandler(FileSystemEventHandler): def on_created(self, event): file_path = event.src_path print('Add new photo: ', file_path) # 给图片添加读写执...
watchdog基本使用
weixin_30685029的博客
09-12 453
watchdog示例： import sys import time import logging from watchdog.observers import Observer from watchdog.events import LoggingEventHandler if __name__ == "__main__": # 配置日志 ...
watchdog 使用方法
aaron_111的博客
07-23 1757
#include <signal.h> #include <time.h> #include <sys/time.h> #include <linux/watchdog.h> #define WATCHDOG_IOCTL_BASE 'W' #define WDIOC_SETTIMEOUT _IOWR(WATCHDOG_IOCTL_B...
PyPI 官网下载 | watchdog-2.1.5-cp39-cp39-macosx_11_0_arm64.whl
02-07
《PyPI官网下载的watchdog-2.1.5-cp39-cp39-macosx_11_0_arm64.whl——Python监控库详解》 Python作为一个强大的编程语言，拥有丰富的第三方库支持，其中Watchdog库是Python中用于文件系统事件监控的重要工具。本文...
WDTDrv.rar_WDTDrv 事件_w83627_w83627 watchdog_wdtdrv_winbond
09-19
《WinBond W83627 看门狗驱动详解》 在计算机硬件系统中，看门狗定时器（Watchdog Timer，简称WDT）是一种重要的自我保护机制，它能够在系统出现异常或死锁时自动重置系统，确保系统的稳定运行。WinBond W83627是一...
十二、连接池线程池配置——数据库连接池
最新发布
流楚丶格念的博客
08-27 328
在应用系统开发中，池化技术（如对象池、连接池、线程池）被广泛使用，通过复用来减少资源消耗和提升性能。连接池（如数据库连接池、Redis连接池、HTTP连接池）主要通过复用TCP连接来提高效率。本文主要介绍数据库连接池（DBCP）、HTTP连接池（HttpClient）和线程池的配置。 数据库连接池是用来管理数据库连接的技术，可以显著提高应用程序的性能和响应速度。常见的数据库连接池实现有C3P0、DBCP、Druid等。下面以为例进行详细讲解。 使用yaml配置实例如下，万卷不离其宗： 配置说明数据库连接配置
ESP32学习笔记（40）——Watchdog看门狗使用
Leung的博客
07-28 1万+
一、简介 看门狗其实就是一个定时器，从功能上说它可以让微控制器在程序发生意外（程序进入死循环或跑飞）的时候，能重新回复到系统刚上电状态，以保障系统出问题的时候可以重启一次。说的复杂一点，看门狗就是能让程序出问题是能重新启动系统。 ESP-IDF 支持两种类型的看门狗：中断看门狗定时器和任务看门狗定时器（TWDT）。中断看门狗定时器和 TWDT 都可以使用项目配置菜单启用，但是 TWDT 也可以在运行时启用。中断看门狗负责检测 FreeRTOS 任务切换被长时间阻塞的情况。TWDT 负责检测任务长时间不让步
Harmony鸿蒙南向驱动开发-Watchdog接口使用
m0_64420071的博客
04-12 1448
看门狗（Watchdog），又称看门狗计时器（Watchdog timer），是一种硬件计时设备。
watchdog的正确用法
周子plus的专栏
07-06 7229
关于watchdog应该有过单片机学习经历的人，都比较熟悉。但watchdog的正确用法，恐怕大家如果没有经历过实际产品的开发不会有深入的理解。 瑞萨RL78系列的单片机自身带有watchdog，当启用watchdogtimer定时器后，在watchdog timer溢出时间间隔的75%会产生watchdog中断。至于在watchdog中做什么，好多示例程序，都会在中断处理函数中喂狗，使watc
Python watchdog
小天的博客
07-08 470
开发十年，就只剩下这套架构体系了！ >>> ...
python 监目录文件变动，然后在做些其它的操作，watchdog 详细解答
热门推荐
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
01-11 2万+
在实际的开发过程中，有时候需要通过 Python 去监听某文件夹的变动，从而实现针对文件变化的操作。 Python 中有2个不错的库实现了该功能，分别是 pyinotify 和 watchdog 本篇博客为你介绍第三方模块 watchdog 实现对文件夹的监控。 文章目录watchdog 安装与准备官方提供最简单的入门案例重写事件监听指定内容添加多个事件监听特定文件夹，特定后缀的文件记录时间 watchdog 安装与准备 安装就比较简单了 pip install watchdog 项目地址是：https:
python watchdog
weixin_30530523的博客
08-02 469
监视文件变更 #!/usr/bin/python # -*- coding:UTF-8 -*- import time from watchdog.observers import Observer from watchdog.events import RegexMatchingEventHandler class MyHandler(RegexMatchingEventHandler): ...
文件系统监视库(watchdog)
qq_33271629的博客
04-05 620
Watchdog库能够监控文件和目录的创建、修改、删除和移动等操作。它通过使用底层原生API（如Windows的ReadDirectoryChangesW、Linux 2.6+的inotify以及Mac OS X的kqueue或FSEvents）来优先实现高效的监控，如果不支持这些API，则通过轮询磁盘的方式进行监控。总的来说，Python Watchdog库是一个强大而灵活的工具，可以帮助开发者轻松地实现文件系统变化的监控，适用于需要实时响应文件变化的各种应用场景。
Python Watchdog——监控文件系统事件
XerCis的博客
12-03 7257
`Watchdog`是一款用于监控文件系统事件的Python库，对不同平台的事件进行了封装。`Watchdog`优先使用底层原生API，其次再通过轮询磁盘实现监控。
Python使用watchdog监控文件系统
05-31
是的，Python可以使用watchdog库来监控文件系统。watchdog库可以监控文件和目录的创建、删除、修改和移动等操作，并在这些事件发生时触发相应的回调函数。具体来说，可以通过以下步骤来使用watchdog库监控文件系统： 1. 安装watchdog库：可以通过pip命令来安装watchdog库，如下所示： ``` pip install watchdog ``` 2. 创建监控处理类：需要创建一个类，并继承watchdog.events.FileSystemEventHandler类，以处理文件系统事件。可以在这个类中实现on_created、on_deleted、on_modified和on_moved等方法，以处理相应的事件。 3. 创建监控器对象：需要创建一个监控器对象，并指定要监控的目录和处理类。可以使用watchdog.observers.Observer类来创建监控器对象。 4. 启动监控器：需要调用监控器对象的start方法来启动监控器。在监控器启动后，它将持续监控目录中的文件系统事件，并在事件发生时调用相应的处理类方法。 下面是一个简单的示例代码，演示如何使用watchdog库监控文件系统： ```python import time from watchdog.observers import Observer from watchdog.events import FileSystemEventHandler class MyHandler(FileSystemEventHandler): def on_created(self, event): if event.is_directory: print("Directory created: {}".format(event.src_path)) else: print("File created: {}".format(event.src_path)) if __name__ == "__main__": event_handler = MyHandler() observer = Observer() observer.schedule(event_handler, path='.', recursive=False) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join() ``` 在这个示例中，我们创建了一个名为MyHandler的处理类，它继承自FileSystemEventHandler类，并实现了on_created方法，以处理文件创建事件。然后，我们创建了一个监控器对象，并将其与处理类关联起来，指定要监控的目录为当前目录。最后，我们启动了监控器，并持续运行，直到用户按下Ctrl+C键停止监控器。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

留小星

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值