Wie kann ich sehen, eine Datei für die änderungen?

Haben Sie sah schon bei der Dokumentation auf http://timgolden.me.uk/python/win32_how_do_i/watch_directory_for_changes.html? Wenn Sie nur brauchen, es unter Windows funktioniert das 2. Beispiel zu sein scheint, genau das, was Sie wollen (wenn Sie den Austausch der Pfad zu dem Verzeichnis mit der Datei, die Sie wollen, zu sehen).

Ansonsten polling wird wahrscheinlich der einzige, der wirklich Plattform-unabhängige option.

Hinweis: ich habe nicht versucht, eine dieser Lösungen.

InformationsquelleAutor Horst Gutmann

Wenn polling ist gut genug für dich ist, würde ich nur sehen, wenn das "änderungsdatum" der Datei stat änderungen. Es Lesen:

os.stat(filename).st_mtime

(Beachten Sie auch, dass die nativen Windows-change-Ereignis-Lösung funktioniert nicht in allen Lebenslagen, z.B. auf Netzwerk-Laufwerke.)

import os

class Monkey(object):
    def __init__(self):
        self._cached_stamp = 0
        self.filename = '/path/to/file'

    def ook(self):
        stamp = os.stat(self.filename).st_mtime
        if stamp != self._cached_stamp:
            self._cached_stamp = stamp
            # File has changed, so do something...

InformationsquelleAutor Deestan

Sollte es unter windows nicht funktionieren (vielleicht mit cygwin ?), aber für unix-Benutzer sind, sollten Sie die "fcntl" system call. Hier ist ein Beispiel in Python. Es ist meist der gleiche code, wenn Sie brauchen, um es zu schreiben in C (gleiche Funktion Namen)

import time
import fcntl
import os
import signal

FNAME = "/HOME/TOTO/FILETOWATCH"

def handler(signum, frame):
    print "File %s modified" % (FNAME,)

signal.signal(signal.SIGIO, handler)
fd = os.open(FNAME,  os.O_RDONLY)
fcntl.fcntl(fd, fcntl.F_SETSIG, 0)
fcntl.fcntl(fd, fcntl.F_NOTIFY,
            fcntl.DN_MODIFY | fcntl.DN_CREATE | fcntl.DN_MULTISHOT)

while True:
    time.sleep(10000)

InformationsquelleAutor Maxime

Gut nach ein bisschen hacken von Tim Golden-Skript habe ich die folgende, die scheint ganz gut zu funktionieren:

import os

import win32file
import win32con

path_to_watch = "." # look at the current directory
file_to_watch = "test.txt" # look for changes to a file called test.txt

def ProcessNewData( newData ):
    print "Text added: %s"%newData

# Set up the bits we'll need for output
ACTIONS = {
  1 : "Created",
  2 : "Deleted",
  3 : "Updated",
  4 : "Renamed from something",
  5 : "Renamed to something"
}
FILE_LIST_DIRECTORY = 0x0001
hDir = win32file.CreateFile (
  path_to_watch,
  FILE_LIST_DIRECTORY,
  win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
  None,
  win32con.OPEN_EXISTING,
  win32con.FILE_FLAG_BACKUP_SEMANTICS,
  None
)

# Open the file we're interested in
a = open(file_to_watch, "r")

# Throw away any exising log data
a.read()

# Wait for new data and call ProcessNewData for each new chunk that's written
while 1:
  # Wait for a change to occur
  results = win32file.ReadDirectoryChangesW (
    hDir,
    1024,
    False,
    win32con.FILE_NOTIFY_CHANGE_LAST_WRITE,
    None,
    None
  )

  # For each change, check to see if it's updating the file we're interested in
  for action, file in results:
    full_filename = os.path.join (path_to_watch, file)
    #print file, ACTIONS.get (action, "Unknown")
    if file == file_to_watch:
        newText = a.read()
        if newText != "":
            ProcessNewData( newText )

Könnte es wahrscheinlich nicht mit einer Belastung mehr Fehler überprüfen, aber für einfach nur beobachten eine log-Datei und einige Verarbeitung auf, bevor Sie spucken es aus, um den Bildschirm, das funktioniert gut.

Danke an alle für Ihren input - great stuff!

InformationsquelleAutor

Überprüfen meine Antwort zu einem ähnliche Frage. Sie könnten versuchen, die gleiche Schleife in Python. Auf dieser Seite schlägt vor:

import time

while 1:
    where = file.tell()
    line = file.readline()
    if not line:
        time.sleep(1)
        file.seek(where)
    else:
        print line, # already has newline

Siehe auch die Frage tail() eine Datei mit Python.

InformationsquelleAutor Bruno De Fraine

Hier ist eine vereinfachte version des kenders code, der angezeigt wird, das gleiche zu tun, trick und nicht den import der gesamten Datei:

# Check file for new data.

import time

f = open(r'c:\temp\test.txt', 'r')

while True:

    line = f.readline()
    if not line:
        time.sleep(1)
        print 'Nothing New'
    else:
        print 'Call Function: ', line

InformationsquelleAutor AlaXul

Zum betrachten eine einzige Datei mit polling und minimale Abhängigkeiten, hier ist einer voll ausgestatteten-out-Beispiel, basierend auf der Antwort von Deestan (oben):

import os
import sys 
import time

class Watcher(object):
    running = True
    refresh_delay_secs = 1

    # Constructor
    def __init__(self, watch_file, call_func_on_change=None, *args, **kwargs):
        self._cached_stamp = 0
        self.filename = watch_file
        self.call_func_on_change = call_func_on_change
        self.args = args
        self.kwargs = kwargs

    # Look for changes
    def look(self):
        stamp = os.stat(self.filename).st_mtime
        if stamp != self._cached_stamp:
            self._cached_stamp = stamp
            # File has changed, so do something...
            print('File changed')
            if self.call_func_on_change is not None:
                self.call_func_on_change(*self.args, **self.kwargs)

    # Keep watching in a loop        
    def watch(self):
        while self.running: 
            try: 
                # Look for changes
                time.sleep(self.refresh_delay_secs) 
                self.look() 
            except KeyboardInterrupt: 
                print('\nDone') 
                break 
            except FileNotFoundError:
                # Action on file not found
                pass
            except: 
                print('Unhandled error: %s' % sys.exc_info()[0])

# Call this function each time a change happens
def custom_action(text):
    print(text)

watch_file = 'my_file.txt'

# watcher = Watcher(watch_file)  # simple
watcher = Watcher(watch_file, custom_action, text='yes, changed')  # also call custom action function
watcher.watch()  # start the watch going

InformationsquelleAutor 4Oh4

Dies ist ein Beispiel für die überprüfung einer Datei auf änderungen. Einer, der möglicherweise nicht der beste Weg, es zu tun, aber sicher ist es nur ein kurzer Weg.

Handliches Werkzeug für einen Neustart der Anwendung, wenn änderungen vorgenommen wurden, um die Quelle. Ich habe diese beim spielen mit pygame, damit ich sehen kann Effekte sofort nach dem die Datei zu speichern.

Beim Einsatz in pygame stellen Sie sicher, dass das Zeug in der 'while' - Schleife ist in Ihrem Spiel-Schleife aka update oder was auch immer. Ihr Antrag wird sonst stecken in einer Endlosschleife und Sie werden nicht sehen, Ihr Spiel zu aktualisieren.

file_size_stored = os.stat('neuron.py').st_size

  while True:
    try:
      file_size_current = os.stat('neuron.py').st_size
      if file_size_stored != file_size_current:
        restart_program()
    except: 
      pass

In den Fall, Sie wollten den restart-code, die ich im Internet gefunden habe. Hier ist es. (Nicht relevant für die Frage, aber es könnte nützlich)

def restart_program(): #restart application
    python = sys.executable
    os.execl(python, python, * sys.argv)

Haben Spaß dabei Elektronen tun, was Sie von Ihnen wollen.

InformationsquelleAutor Bassim Huis

Hier ist ein Beispiel ausgerichtet ist, die beobachtete input-Dateien, die nicht mehr schreiben als eine Zeile pro Sekunde, aber in der Regel viel weniger. Das Ziel ist die Letzte Zeile angefügt werden (die meisten aktuellen schreiben) an die angegebene Ausgabedatei. Habe ich kopiert aus einem meiner Projekte und nur gelöscht, alle nicht relevanten Zeilen. Sie haben zu füllen, oder ändern Sie die Symbole fehlen.

from PyQt5.QtCore import QFileSystemWatcher, QSettings, QThread
from ui_main_window import Ui_MainWindow   # Qt Creator gen'd 

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        QMainWindow.__init__(self, parent)
        Ui_MainWindow.__init__(self)
        self._fileWatcher = QFileSystemWatcher()
        self._fileWatcher.fileChanged.connect(self.fileChanged)

    def fileChanged(self, filepath):
        QThread.msleep(300)    # Reqd on some machines, give chance for write to complete
        # ^^ About to test this, may need more sophisticated solution
        with open(filepath) as file:
            lastLine = list(file)[-1]
        destPath = self._filemap[filepath]['dest file']
        with open(destPath, 'a') as out_file:               # a= append
            out_file.writelines([lastLine])

Natürlich die allumfassende QMainWindow Klasse ist nicht unbedingt erforderlich, dh. Sie können QFileSystemWatcher allein.

InformationsquelleAutor

Können Sie auch eine einfache Bibliothek namens repyt, hier ist ein Beispiel:

repyt ./app.py

InformationsquelleAutor Rafal Enden

Kenne ich keine Windows-spezifische Funktion. Sie könnten versuchen, immer den MD5-hash der Datei jede Sekunde/minute/Stunde (hängt davon ab, wie schnell Sie es brauchen) und vergleichen Sie es mit dem letzten hash. Wenn es sich unterscheidet, Sie wissen, die Datei wurde verändert und Lesen Sie die neuesten Linien.

InformationsquelleAutor daddz