This has proven to be a very easy task for *nix systems, but on Windows, getting a file close event is not a simple task. Read below the summary of common methods grouped by OS'es.

# For Linux
On Linux, the filesystem changes can be easily monitored, and in great detail. The best tool for this is the kernel feature called `inotify`, and there is a Python implementation that uses it, called Pynotify.

* ##[Pynotify](http://pyinotify.sourceforge.net/)

 `Pyinotify` is a Python module for monitoring filesystems changes. Pyinotify relies on a Linux Kernel feature (merged in kernel 2.6.13) called `inotify`, which is an event-driven notifier. Its notifications are exported from kernel space to user space through three system calls. `Pyinotify` binds these system calls and provides an implementation on top of them offering a generic and abstract way to manipulate those functionalities.
    
    [Here](http://pyinotify.sourceforge.net/#The_EventsCodes_Class) you can find the list of the events that can be monitored with `Pynotify`.

 **Example usage:**  

    import pyinotify
    
        class EventHandler(pyinotify.ProcessEvent):
            def process_IN_CLOSE_NOWRITE(self, event):
                print "File was closed without writing: " + event.pathname
            def process_IN_CLOSE_WRITE(self, event):
                print "File was closed with writing: " + event.pathname
    
        def watch(filename):
            wm = pyinotify.WatchManager()
            mask = pyinotify.IN_CLOSE_NOWRITE | pyinotify.IN_CLOSE_WRITE
            wm.add_watch(filename, mask)
            
            eh = EventHandler()
            notifier = pyinotify.Notifier(wm, eh)
            notifier.loop()
        
        if __name__ == '__main__':
            watch('/path/to/file')


# For Windows
Situation for Windows is quite a bit more complex than for Linux. Most libraries rely on `ReadDirectoryChanges` API which is restricted and can't detect finer details like file close event. There are however other methods for detecting such events, so read on to find out more.


* ## [Watcher](https://pypi.python.org/pypi/watcher)
 **Note:** Watcher has been last updated in February 2011, so its probably safe to skip this one.

    `Watcher` is a low-level `C` extension for receiving file system updates using the `ReadDirectoryChangesW` API on Windows systems. The package also includes a high-level interface to emulate most of the .NET `FileSystemWatcher` API.  
The closest one can get to detecting file close events with Watcher is to monitor the `FILE_NOTIFY_CHANGE_LAST_WRITE` and/or `FILE_NOTIFY_CHANGE_LAST_ACCESS` events.  

 **Example usage:**

        import watcher
        w = watcher.Watcher(dir, callback)
        w.flags = watcher.FILE_NOTIFY_CHANGE_LAST_WRITE
        w.start()


* ## [Watchdog](https://pypi.python.org/pypi/watchdog/0.5.4)

    Python API and shell utilities to monitor file system events. Easy install: `$ pip install watchdog`. For more info visit the [documentation](https://pythonhosted.org/watchdog/).  
Watchdog on Windows relies on the `ReadDirectoryChangesW` API, which brings its caveats as with Watcher and other libraries relying on the same API.

* ## [Pywatch](https://github.com/cmheisel/pywatch)

    A python near-clone of the Linux `watch` command. The `pywatch.watcher.Watcher` class can be told to watch a set of files, and given a set of commands to run whenever any of those files change. It can only monitor the file changed event, since it relies on polling the [stat's st_mtime](http://linux.die.net/man/2/stat).

 
### Bonus for Windows with NTFS:
* ## [NTFS USN Journal](http://en.wikipedia.org/wiki/USN_Journal)

    The NTFS USN (Update Sequence Number) Journal is a feature of NTFS which maintains a record of changes made to the volume. The reason it is listed as a *Bonus* is because unlike the other entries, it is not a specific library, but rather a feature existing on NTFS system. So if you are using other Windows filesystems (like FAT, ReFS, etc..) this does not apply.  
The way it works it that the system records all changes made to the volume in the USN Journal file, with each volume having its own instance. Each record in the Change Journal contains the USN, the name of the file, and information about what the change was.  

    The main reason this method is interesting for this question is that, unlike most of the other methods, this one provides a way to detect a **file close** event, defined as **USN_REASON_CLOSE**. More information with a complete list of events can be found in this [MSDN article](http://msdn.microsoft.com/en-us/library/windows/desktop/aa365722(v=vs.85).aspx). For a complete documentation about USN Journaling, visit this [MSDN page](http://msdn.microsoft.com/en-us/library/aa363798%28v=VS.85%29.aspx).

    There are multiple ways to access the USN Journal from Python, but the only mature option seems to be the **[ntfsjournal](https://pypi.python.org/pypi/ntfsjournal)** module.


### The "proper" way for Windows:  

* ## [File system filter driver](http://msdn.microsoft.com/en-us/library/windows/hardware/ff548202%28v=vs.85%29.aspx)

 As descibed on the [MSDN page](http://msdn.microsoft.com/en-us/library/windows/hardware/ff557282(v=vs.85).aspx):
> A file system filter driver is an optional driver that adds value to
> or modifies the behavior of a file system. A file system filter driver
> is a kernel-mode component that runs as part of the Windows executive.
> A file system filter driver can filter I/O operations for one or more
> file systems or file system volumes. Depending on the nature of the
> driver, filter can mean log, observe, modify, or even prevent. Typical
> applications for file system filter drivers include antivirus
> utilities, encryption programs, and hierarchical storage management
> systems.

 It is not an easy task to implement a file system filter driver, but for someone who would like to give it a try, there is a good introduction tutorial on [CodeProject](http://www.codeproject.com/Articles/43586/File-System-Filter-Driver-Tutorial).

 P.S. Check  [@ixe013's answer](http://stackoverflow.com/a/22646476/2842884) for some additional info about this method.


# Multiplatform

* ## [Qt's QFileSystemWatcher](http://qt-project.org/doc/qt-4.8/qfilesystemwatcher.html)

    The `QFileSystemWatcher` class provides an interface for monitoring files and directories for modifications. This class was introduced in `Qt 4.2`.  
Unfortunately, its functionality is fairly limited, as it can only detect when a file has been modified, renamed or deleted, and when a new file was added to a directory.

 **Example usage:**

        import sys
        from PyQt4 import QtCore
    
        def directory_changed(path):
            print('Directory Changed: %s' % path)
        
        def file_changed(path):
            print('File Changed: %s' % path)
        
        app = QtCore.QCoreApplication(sys.argv)
        
        paths = ['/path/to/file']
        fs_watcher = QtCore.QFileSystemWatcher(paths)
        fs_watcher.directoryChanged.connect(directory_changed)
        fs_watcher.fileChanged.connect(file_changed)
        
        app.exec_()