Tengo un archivo de registro que está siendo escrito por otro proceso que quiero ver para ver los cambios. Cada vez que se produce un cambio que me gustaría leer los nuevos datos en hacer algún tipo de procesamiento en él.

¿Cuál es la mejor manera de hacer esto? Yo tenía la esperanza de que habría algún tipo de gancho de la PyWin32 de la biblioteca. He encontrado el win32file.FindNextChangeNotification función, pero no tienen idea de cómo hacer para ver un archivo específico.

Si alguien hace algo como esto yo estaría muy agradecido de escuchar cómo…

[Editar] debería haber mencionado que yo buscaba una solución que no requiere de la votación.

[Editar] Maldiciones! Parece que esto no funciona en una unidad de red asignada. Supongo que windows no se » oye » todas las actualizaciones del archivo de la forma que lo hace en un disco local.

  • en Linux se puede usar el strace monitoreo write llamadas para este
  • @simao de la respuesta utiliza python-watchdog. Python-Watchdog tiene una gran documentación –> aquí hay un enlace a la [«QuickStart»] documentación que proporciona un mínimo ejemplo de código que mira el directorio de trabajo actual.
InformationsquelleAutor Jon Cage | 2008-10-08

23 Comentarios

  1. 73

    Ya has mirado la documentación disponible en http://timgolden.me.uk/python/win32_how_do_i/watch_directory_for_changes.html? Si sólo lo necesitas para trabajar bajo Windows el 2º ejemplo parece ser exactamente lo que usted desea (si cambio la ruta de acceso del directorio con el de uno de los archivos que desea ver).

    De lo contrario, la votación será probablemente el único realmente independiente de la plataforma opción.

    Nota: no he probado ninguna de estas soluciones.

    • Esta respuesta es específica de Windows, pero parece que algunos de la cruz-plataforma de soluciones a este problema se han publicado aquí.
    • Hay un punto de referencia, si este proceso es más lento, a continuación, su implementación en un lenguaje nativo como c++ ?
    • Es mejor insertar el contenido relevante de fuentes citadas como pueden llegar a ser obsoletos.
    • (1.) al final de esta respuesta es un fuerte descargo de responsabilidad… «yo no he probado ninguna de estas soluciones». (2.) esta respuesta es más o menos un «enlace sólo» respuesta (3.) la respuesta menciona la «votación», pero no proporciona agregar algo útil después de que … donde como @Deestan la respuesta proporciona buena información sobre la votación
  2. 267

    Hizo probar con Watchdog?

    Python API de la biblioteca y utilidades de shell para el archivo de monitor de eventos del sistema.

    Directorio de monitoreo fácil con

    • Una cruz-plataforma de la API.
    • Un shell herramienta para ejecutar comandos en respuesta a los cambios en el directorio.

    Empezar a trabajar rápidamente con un ejemplo sencillo en el Inicio rápido

    • Instalable con easy_install? De verificación. Licencia libre? Buscar. Resuelve el problema en las grandes plataformas? Buscar. Estoy de acuerdo con esta respuesta. Nota: el ejemplo en su página de proyecto no funciona fuera de la caja. El uso de el uno en su github en su lugar.
    • Utilizamos watchdog. Podemos cambiar a QFileSystemWatcher. Sólo una advertencia justa – watchdog es buena, pero lejos de ser perfecto en todas las plataformas (en este momento). Cada sistema operativo tiene su idiosincrasia. Así que, a menos que usted se dedica a lo que es perfecto va a estar tirando de los pelos. Si usted sólo está buscando a ver 10 archivos o así, me gustaría encuesta. OS almacenamiento en caché de disco es muy maduro y vigilancia implica sondear las Api de todos modos. Es principalmente para la observación de enormes estructuras de carpetas en mi humilde opinión.
    • Mi única queja con el watchdog es, que tiene muchas dependencias. Menos de PyQt, por supuesto, pero no funciona y se siente como el mínimo, mejores prácticas, hace-un-trabajo-y-hace-que-la solución de la derecha.
    • Es @denfromufa correcto aquí? ¿Watchdog realmente bloqueo de archivos, por lo que no pueden ser editados simultáneamente vigilar a verlos? Casi no puedo creer que eso, sería completamente inútil.
    • Acabo de comprobar en este ejemplo (ver enlace abajo) y funciona! no estoy seguro de lo que estaba mal antes, pero esta respuesta no ofrece ningún ejemplo. stackoverflow.com/a/18599427/2230844
    • Gracias! Así que, ¿que revisar su opinión sobre watchdog, se utiliza en sus proyectos si usted realmente no necesita absolutamente para ver los cambios de los archivos? Para mis propósitos (gran cantidad de lecturas que deben ser rápidos, no muchos se escribe) me he encontrado con el siguiente esquema: 1) encuesta de directorio de fecha de modificación en cada solicitud –> me dice si los archivos se han añadido, eliminado o cambiado de nombre. 2) en caso de cambios en (1), refrescar en la memoria de archivo de índice. 3) encuesta de la fecha de modificación del archivo para el conjunto de archivos que me interesa (por ejemplo, los primeros 10 archivos a la hora de ordenar en orden descendente). 4) lea los archivos modificados
    • quiero que no cuenta el uso de watchdog en mis proyectos, parece bastante de la cruz-plataforma así

  3. 84

    Si el sondeo es lo suficientemente buena para ti, solo quisiera ver si la «modificación» archivo stat cambios. Leer:

    os.stat(filename).st_mtime

    (También tenga en cuenta que el nativo de Windows evento de cambio de solución no funciona en todas las circunstancias, por ejemplo, en unidades de red.)

    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...
    • ¿Cómo se puede hacer esto en un intervalo?
    • Aquí es cómo usted puede hacer esto en un intervalo de ` import sys import time pub = Mono() while True: tratar: el tiempo.sleep(1) pub.reloj() excepto KeyboardInterrupt: print(‘\nDone’) break, excepto: print(f’Unhandled de error: {sys.exc_info()[0]}’) `
    • Totalmente expandidas ejemplo de código: stackoverflow.com/a/49007649/5859283
  4. 49

    Si quieres una solución multiplataforma, a continuación, compruebe QFileSystemWatcher.
    Aquí un ejemplo de código (no sanitized):

    from PyQt4 import QtCore
    
    @QtCore.pyqtSlot(str)
    def directory_changed(path):
        print('Directory Changed!!!')
    
    @QtCore.pyqtSlot(str)
    def file_changed(path):
        print('File Changed!!!')
    
    fs_watcher = QtCore.QFileSystemWatcher(['/path/to/files_1', '/path/to/files_2', '/path/to/files_3'])
    
    fs_watcher.connect(fs_watcher, QtCore.SIGNAL('directoryChanged(QString)'), directory_changed)
    fs_watcher.connect(fs_watcher, QtCore.SIGNAL('fileChanged(QString)'), file_changed)
    • Creo que esta es, posiblemente, la mejor respuesta del grupo, dado que a) se basan en Win32 del objeto FileSystemwatcher y no puede ser transferido o b) encuesta para el archivo (lo cual es malo para el rendimiento y no a escala). Es una lástima que Python no tiene este centro, construido en PyQt es una enorme dependencia de si todo lo que estamos utilizando es el QFileSystemWatcher clase.
    • Me gusta esta solución. Yo quería señalar que necesitarás una QApplication instancia para que funcione, he añadido «app = QtGui.QApplication(sys.argv)» justo debajo de las importaciones y, a continuación, «de la aplicación.exec_()» después de la señal de las conexiones.
    • Sólo prueba esta en un cuadro de Linux, estoy viendo que el directory_changed método se llama, pero no file_changed.
    • si no te gusta el pyQt dependencia, el watchdog paquete es la respuesta correcta
    • ¿por qué no utilizar PySide para que en lugar de PyQt para tan poco uso.
    • Sólo quería añadir que esto funciona en Windows ubicaciones de red con las letras de unidad asignada o la ruta completa de acceso UNC.

  5. 27

    No debería funcionar en windows (tal vez con cygwin ?), pero para el usuario de unix, debe utilizar el «fcntl» llamada al sistema. Aquí está un ejemplo en Python. Es todo el mismo código si necesitas escribir en C (la misma función de los nombres de

    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)
    • Solo de paso, no funciona en OS X.
    • Funciona como un encanto con el núcleo de Linux 2.6.31 en un sistema de archivos ext4 (en Ubuntu 10.04), aunque sólo para los directorios – se plantea una excepción IOError «no es un directorio» si yo lo uso con un archivo.
    • GENIAL!!! Igual para mí, las obras para el directorio sólo y ver los archivos en este directorio. Pero no funciona con los archivos modificados en subdirectorios, así que parece que usted necesita para caminar a través de los subdirectorios y ver todas. (o es que hay una manera mejor de hacer esto?)
  6. 21

    Retirar pyinotify.

    inotify reemplaza dnotify (a partir de una anterior respuesta) en las nuevas linuxes y permite a nivel de archivo en lugar de directorio a nivel de supervisión.

    • No para poner un freno a esta respuesta, pero después de leer este artículo, me atrevería a decir que puede no ser tan glamoroso, una solución como se pensaba. serpentine.com/blog/2008/01/04/why-you-should-not-use-pyinotify
    • pyinotify tiene un montón de inconvenientes a partir de muy unpythonic base de código para el consumo de memoria. Mejor buscar otras opciones..
  7. 13

    Bien después de un poco de hacking de Tim Golden script, tengo el siguiente, que parece que funciona bastante bien:

    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 )

    Probablemente se podría hacer con una carga más la comprobación de errores, pero simplemente para ver un archivo de registro y hacer un poco de procesamiento de la misma antes de escupir a la pantalla, esta funciona bien.

    Gracias a todos por su entrada – grandes cosas!

  8. 7

    Solución más sencilla para mí es el uso de vigilancia de la herramienta watchmedo

    De https://pypi.python.org/pypi/watchdog ahora tengo un proceso que busca el sql archivos en un directorio y ejecuta si es necesario.

    watchmedo shell-command \
    --patterns="*.sql" \
    --recursive \
    --command='~/Desktop/load_files_into_mysql_database.sh' \
    .
  9. 6

    De verificación mi respuesta a un pregunta similar. Usted podría tratar de la misma bucle en Python. Esta página sugiere:

    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

    Ver también la pregunta cola() un archivo con Python.

    • Usted puede sys.stdout.escribir(línea). El código no funciona si el archivo se trunca. Python tiene incorporada la función file().
    • He publicado una versión modificada de su código. Usted puede incorporar en su respuesta, si funciona para usted.
  10. 6

    Bueno, ya que están usando Python, usted sólo puede abrir un archivo y mantener la lectura de las líneas de ello.

    f = open('file.log')

    Si la línea de lectura es no vacío, que se procesa.

    line = f.readline()
    if line:
        // Do what you want with the line

    Usted puede ser que falta que es aceptar a seguir llamando readline en la EF. Se acaba de mantener devolver una cadena vacía en este caso. Y cuando algo se adjunta el archivo de registro, la lectura continuará desde donde se detuvo, como usted necesita.

    Si usted está buscando una solución que utiliza los eventos, o a una biblioteca en particular, por favor especifíquelo en su pregunta. De lo contrario, creo que esta solución es bien.

  11. 6

    Aquí es una versión simplificada del Kender el código que aparece para hacer el mismo truco y no importar el archivo completo:

    # 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
  12. 6

    Para ver un archivo único con el sondeo, y un mínimo de dependencias, aquí es totalmente de pulpa de salida ejemplo, basado en la respuesta de Deestan (arriba):

    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
    • Hace este trabajo para la observación de multples archivos demasiado ?
    • Usted podría hacer watch_file y _cached_stamp en las listas, y recorrer a través de ellos en un bucle for. Realmente no escala bien a un gran número de archivos
    • No esta desencadenar la acción cada vez que se ejecute? _cached_stamp se establece a 0 y, a continuación, en comparación a os.stat(auto.nombre de archivo).st_mtime. _cached_stamp se debe establecer a os.stat(auto.nombre de archivo).st_mtime en el constructor, no?
    • call_func_on_change() se activará en la primera ejecución de look(), pero luego _cached_stamp se actualiza, por lo que no se activa de nuevo hasta que el valor de os.stat(self.filename).st_mtime. _cached_stamp cambios.
    • Puede establecer el valor de _cached_stamp en el constructor si no desea que los call_func_on_change() a ser llamado en la primera ejecución
  13. 4

    Como se puede ver en Tim Golden artículo, señaló por Horst Gutmann, WIN32 es relativamente complejo y relojes de directorios, no de un solo archivo.

    Me gustaría sugiero que busque en IronPython, que es un .NET implementación de python.
    Con IronPython usted puede utilizar todos los .NET funcionalidad – incluyendo

    System.IO.FileSystemWatcher

    Que se encarga de archivos único, con un simple Evento interfaz.

    • porque entonces usted tiene que tener Hierro Python disponibles en vez de un básico de instalación de Python.
  14. 4

    Esta es otra modificación de Tim Goldan de la secuencia de comandos que se ejecuta en linux y añade un simple observador de la modificación de archivos mediante el uso de un diccionario (archivo=>tiempo).

    uso: whateverName.py path_to_dir_to_watch

    #!/usr/bin/env python
    
    import os, sys, time
    
    def files_to_timestamp(path):
        files = [os.path.join(path, f) for f in os.listdir(path)]
        return dict ([(f, os.path.getmtime(f)) for f in files])
    
    if __name__ == "__main__":
    
        path_to_watch = sys.argv[1]
        print "Watching ", path_to_watch
    
        before = files_to_timestamp(path_to_watch)
    
        while 1:
            time.sleep (2)
            after = files_to_timestamp(path_to_watch)
    
            added = [f for f in after.keys() if not f in before.keys()]
            removed = [f for f in before.keys() if not f in after.keys()]
            modified = []
    
            for f in before.keys():
                if not f in removed:
                    if os.path.getmtime(f) != before.get(f):
                        modified.append(f)
    
            if added: print "Added: ", ", ".join(added)
            if removed: print "Removed: ", ", ".join(removed)
            if modified: print "Modified ", ", ".join(modified)
    
            before = after
  15. 1

    Este es un ejemplo de comprobación de un archivo para que los cambios. Uno que puede no ser la mejor manera de hacerlo, pero seguro que es un camino corto.

    Herramienta útil para reiniciar la aplicación cuando se han realizado cambios a la fuente. Hice esto cuando se juega con pygame para que yo pueda ver los efectos de tener lugar inmediatamente después de guardar archivo.

    Cuando se utiliza en pygame asegúrese de que el material en el ‘tiempo’ bucle se coloca en el bucle de juego aka actualización o lo que sea. De lo contrario, su aplicación se queda atascado en un bucle infinito y no ver su juego de actualización.

    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

    En caso de que usted quisiera reiniciar el código que he encontrado en la web. Aquí está. (No es pertinente a la cuestión, aunque podría ser útil)

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

    Tener diversión el hacer de los electrones hacer lo que usted quiere que ellos hagan.

    • Parece que el uso de .st_mtime en lugar de .st_size sería más fiable y un igualmente corto manera de hacer esto, aunque el OP ha indicado que él no quería hacerlo a través de la votación.
  16. 1
    ACTIONS = {
      1 : "Created",
      2 : "Deleted",
      3 : "Updated",
      4 : "Renamed from something",
      5 : "Renamed to something"
    }
    FILE_LIST_DIRECTORY = 0x0001
    
    class myThread (threading.Thread):
        def __init__(self, threadID, fileName, directory, origin):
            threading.Thread.__init__(self)
            self.threadID = threadID
            self.fileName = fileName
            self.daemon = True
            self.dir = directory
            self.originalFile = origin
        def run(self):
            startMonitor(self.fileName, self.dir, self.originalFile)
    
    def startMonitor(fileMonitoring,dirPath,originalFile):
        hDir = win32file.CreateFile (
            dirPath,
            FILE_LIST_DIRECTORY,
            win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
            None,
            win32con.OPEN_EXISTING,
            win32con.FILE_FLAG_BACKUP_SEMANTICS,
            None
        )
        # 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_M in results:
                full_filename = os.path.join (dirPath, file_M)
                #print file, ACTIONS.get (action, "Unknown")
                if len(full_filename) == len(fileMonitoring) and action == 3:
                    #copy to main file
                    ...
  17. 1

    He aquí un ejemplo orientado hacia la observación de los archivos de entrada que no escribir más de una línea por segundo, pero por lo general mucho menos. El objetivo es anexar la última línea (la más reciente escritura) para el archivo de salida especificado. He copiado esto de uno de mis proyectos y acaba de eliminar todos los irrelevante líneas. Tendrás que rellenar o cambiar los símbolos perdidos.

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

    De curso, el que abarca QMainWindow clase, no es estrictamente necesario, es decir,. usted puede utilizar QFileSystemWatcher solo.

  18. 0

    Parece que nadie ha publicado fswatch. Es una cruz-plataforma archivo system watcher. Basta con instalarlo, ejecutarlo y seguir las instrucciones.

    Lo he utilizado con python y golang programas y simplemente funciona.

  19. 0

    relacionadas con @4Oh4 solución de un cambio suave para obtener una lista de archivos para ver;

    import os
    import sys
    import time
    class Watcher(object):
    running = True
    refresh_delay_secs = 1
    # Constructor
    def __init__(self, watch_files, call_func_on_change=None, *args, **kwargs):
    self._cached_stamp = 0
    self._cached_stamp_files = {}
    self.filenames = watch_files
    self.call_func_on_change = call_func_on_change
    self.args = args
    self.kwargs = kwargs
    # Look for changes
    def look(self):
    for file in self.filenames:
    stamp = os.stat(file).st_mtime
    if not file in self._cached_stamp_files:
    self._cached_stamp_files[file] = 0
    if stamp != self._cached_stamp_files[file]:
    self._cached_stamp_files[file] = stamp
    # File has changed, so do something...
    file_to_read = open(file, 'r')
    value = file_to_read.read()
    print("value from file", value)
    file_to_read.seek(0)
    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 Exception as e:
    print(e)
    print('Unhandled error: %s' % sys.exc_info()[0])
    # Call this function each time a change happens
    def custom_action(text):
    print(text)
    # pass
    watch_files = ['/Users/mexekanez/my_file.txt', '/Users/mexekanez/my_file1.txt']
    # watcher = Watcher(watch_file)  # simple
    if __name__ == "__main__":
    watcher = Watcher(watch_files, custom_action, text='yes, changed')  # also call custom action function
    watcher.watch()  # start the watch going
  20. -2

    Yo no conozco a ninguna de Windows función específica. Usted podría tratar de obtener el hash MD5 del archivo de cada segundo/minuto/hora (depende de lo rápido que se necesita) y compararlo con el último hash. Cuando se diferencia usted sabe que el archivo ha sido cambiado y leer la más reciente de las líneas.

  21. -6

    Me gustaría probar algo como esto.

        try:
    f = open(filePath)
    except IOError:
    print "No such file: %s" % filePath
    raw_input("Press Enter to close window")
    try:
    lines = f.readlines()
    while True:
    line = f.readline()
    try:
    if not line:
    time.sleep(1)
    else:
    functionThatAnalisesTheLine(line)
    except Exception, e:
    # handle the exception somehow (for example, log the trace) and raise the same exception again
    raw_input("Press Enter to close window")
    raise e
    finally:
    f.close()

    El bucle comprueba si hay una nueva línea(s) desde la última vez que el archivo se lee – si la hay, que se lee y se pasa a la functionThatAnalisesTheLine función. Si no, el script espera 1 segundo y vuelve a intentarlo el proceso.

    • -1: Abrir el archivo y la lectura de las líneas no es una gran idea cuando los archivos pueden ser de 100 MB grandes. Tendrías que ejecutar para cada archivo también que sería malo cuando usted desea ver los 1000 de los archivos.
    • De verdad? Abrir el archivo para que los cambios?

Dejar respuesta

Please enter your comment!
Please enter your name here