Implementare il tocco usando Python?

touchè un'utilità Unix che imposta i tempi di modifica e accesso dei file sull'ora corrente del giorno. Se il file non esiste, viene creato con autorizzazioni predefinite.

Come lo implementeresti come una funzione Python? Cerca di essere multipiattaforma e completo.

(I risultati attuali di Google per "file touch Python" non sono così grandi, ma puntano a os.utime .)

Sembra che questo sia nuovo a partire da Python 3.4 - pathlib.

from pathlib import Path

Path('path/to/file.txt').touch()

Questo creerà un file.txtpercorso.

-

Path.touch (mode = 0o777, exist_ok = True)

Crea un file in questo percorso specificato. Se viene fornita la modalità, viene combinata con il valore umask del processo per determinare la modalità file e i flag di accesso. Se il file esiste già, la funzione ha esito positivo se exist_ok è true (e l'ora di modifica viene aggiornata all'ora corrente), altrimenti viene generato FileExistsError.

Questo cerca di essere un po 'più libero da gara rispetto alle altre soluzioni. (La withparola chiave è nuova in Python 2.5.)

import os
def touch(fname, times=None):
    with open(fname, 'a'):
        os.utime(fname, times)

Praticamente equivalente a questo.

import os
def touch(fname, times=None):
    fhandle = open(fname, 'a')
    try:
        os.utime(fname, times)
    finally:
        fhandle.close()

Ora, per renderlo davvero privo di razza, è necessario utilizzare futimese modificare il timestamp del filehandle aperto, invece di aprire il file e quindi modificare il timestamp sul nome del file (che potrebbe essere stato rinominato). Sfortunatamente, Python non sembra fornire un modo per chiamare futimessenza passare attraverso ctypeso simili ...

MODIFICARE

Come notato da Nate Parsons , Python 3.3 aggiungerà specificando un descrittore di file (quando os.supports_fd) a funzioni come os.utime, che utilizzerà la futimessyscall invece della utimessyscall sotto il cofano. In altre parole:

import os
def touch(fname, mode=0o666, dir_fd=None, **kwargs):
    flags = os.O_CREAT | os.O_APPEND
    with os.fdopen(os.open(fname, flags=flags, mode=mode, dir_fd=dir_fd)) as f:
        os.utime(f.fileno() if os.utime in os.supports_fd else fname,
            dir_fd=None if os.supports_fd else dir_fd, **kwargs)

def touch(fname):
    if os.path.exists(fname):
        os.utime(fname, None)
    else:
        open(fname, 'a').close()

Perché non provarlo ?:

import os

def touch(fname):
    try:
        os.utime(fname, None)
    except OSError:
        open(fname, 'a').close()

Credo che questo elimini tutte le condizioni di gara che contano. Se il file non esiste, verrà generata un'eccezione.

L'unica possibile condizione di competizione qui è se il file viene creato prima che venga chiamato open () ma dopo os.utime (). Ma questo non importa perché in questo caso il tempo di modifica sarà come previsto poiché deve essere accaduto durante la chiamata a touch ().

Ecco un po 'di codice che utilizza i tipi (testato solo su Linux):

from ctypes import *
libc = CDLL("libc.so.6")

#  struct timespec {
#             time_t tv_sec;        /* seconds */
#             long   tv_nsec;       /* nanoseconds */
#         };
# int futimens(int fd, const struct timespec times[2]);

class c_timespec(Structure):
    _fields_ = [('tv_sec', c_long), ('tv_nsec', c_long)]

class c_utimbuf(Structure):
    _fields_ = [('atime', c_timespec), ('mtime', c_timespec)]

utimens = CFUNCTYPE(c_int, c_char_p, POINTER(c_utimbuf))
futimens = CFUNCTYPE(c_int, c_char_p, POINTER(c_utimbuf)) 

# from /usr/include/i386-linux-gnu/bits/stat.h
UTIME_NOW  = ((1l << 30) - 1l)
UTIME_OMIT = ((1l << 30) - 2l)
now  = c_timespec(0,UTIME_NOW)
omit = c_timespec(0,UTIME_OMIT)

# wrappers
def update_atime(fileno):
        assert(isinstance(fileno, int))
        libc.futimens(fileno, byref(c_utimbuf(now, omit)))
def update_mtime(fileno):
        assert(isinstance(fileno, int))
        libc.futimens(fileno, byref(c_utimbuf(omit, now)))

# usage example:
#
# f = open("/tmp/test")
# update_mtime(f.fileno())

^{Questa risposta è compatibile con tutte le versioni da Python-2.5 quando la parola chiave withè stata rilasciata.}

1. Crea il file se non esiste + Imposta l'ora corrente
(esattamente come il comando touch)

import os

fname = 'directory/filename.txt'
with open(fname, 'a'):     # Create file if does not exist
    os.utime(fname, None)  # Set access/modified times to now
                           # May raise OSError if file does not exist

Una versione più robusta:

import os

with open(fname, 'a'):
  try:                     # Whatever if file was already existing
    os.utime(fname, None)  # => Set current time anyway
  except OSError:
    pass  # File deleted between open() and os.utime() calls

2. Basta creare il file se non esiste
(non aggiorna l'ora)

with open(fname, 'a'):  # Create file if does not exist
    pass

3. Aggiorna semplicemente l'accesso al file / i tempi modificati
(non crea il file se non esistente)

import os

try:
    os.utime(fname, None)  # Set access/modified times to now
except OSError:
    pass  # File does not exist (or no permission)

L'uso os.path.exists()non semplifica il codice:

from __future__ import (absolute_import, division, print_function)
import os

if os.path.exists(fname):
  try:
    os.utime(fname, None)  # Set access/modified times to now
  except OSError:
    pass  # File deleted between exists() and utime() calls
          # (or no permission)

Bonus: tempo di aggiornamento di tutti i file in una directory

from __future__ import (absolute_import, division, print_function)
import os

number_of_files = 0

#   Current directory which is "walked through"
#   |     Directories in root
#   |     |  Files in root       Working directory
#   |     |  |                     |
for root, _, filenames in os.walk('.'):
  for fname in filenames:
    pathname = os.path.join(root, fname)
    try:
      os.utime(pathname, None)  # Set access/modified times to now
      number_of_files += 1
    except OSError as why:
      print('Cannot change time of %r because %r', pathname, why)

print('Changed time of %i files', number_of_files)

with open(file_name,'a') as f: 
    pass

Semplicistico:

def touch(fname):
    open(fname, 'a').close()
    os.utime(fname, None)

• Le opengarantisce che non v'è un file lì
• le utimeassicura che i timestamp vengono aggiornate

Teoricamente, è possibile che qualcuno elimini il file dopo il open, causando utime per sollevare un'eccezione. Ma probabilmente va bene, dal momento che è successo qualcosa di brutto.

Complesso (possibilmente buggy):

def utime(fname, atime=None, mtime=None)
    if type(atime) is tuple:
        atime, mtime = atime

    if atime is None or mtime is None:
        statinfo = os.stat(fname)
        if atime is None:
            atime = statinfo.st_atime
        if mtime is None:
            mtime = statinfo.st_mtime

    os.utime(fname, (atime, mtime))


def touch(fname, atime=None, mtime=None):
    if type(atime) is tuple:
        atime, mtime = atime

    open(fname, 'a').close()
    utime(fname, atime, mtime)

Questo tenta di consentire anche l'impostazione del tempo di accesso o modifica, come GNU touch.

Potrebbe sembrare logico creare una stringa con le variabili desiderate e passarla a os.system:

touch = 'touch ' + dir + '/' + fileName
os.system(touch)

Questo è inadeguato in diversi modi (ad esempio, non gestisce gli spazi bianchi), quindi non farlo.

Un metodo più efficace consiste nell'utilizzare il sottoprocesso:

subprocess.call(['touch', os.path.join(dirname, fileName)])

Sebbene sia molto meglio dell'uso di una subshell (con os.system), è comunque adatto solo per gli script quick-and-dirty; utilizzare la risposta accettata per i programmi multipiattaforma.

"open (file_name, 'a'). close ()" non ha funzionato per me in Python 2.7 su Windows. "os.utime (file_name, None)" ha funzionato bene.

Inoltre, avevo la necessità di toccare ricorsivamente tutti i file in una directory con una data più vecchia di una data. Ho creato il seguente follower basato sulla risposta molto utile di effemerente.

def touch(file_name):
    # Update the modified timestamp of a file to now.
    if not os.path.exists(file_name):
        return
    try:
        os.utime(file_name, None)
    except Exception:
        open(file_name, 'a').close()

def midas_touch(root_path, older_than=dt.now(), pattern='**', recursive=False):
    '''
    midas_touch updates the modified timestamp of a file or files in a 
                directory (folder)

    Arguements:
        root_path (str): file name or folder name of file-like object to touch
        older_than (datetime): only touch files with datetime older than this 
                   datetime
        pattern (str): filter files with this pattern (ignored if root_path is
                a single file)
        recursive (boolean): search sub-diretories (ignored if root_path is a 
                  single file)
    '''
    # if root_path NOT exist, exit
    if not os.path.exists(root_path):
        return
    # if root_path DOES exist, continue.
    else:
        # if root_path is a directory, touch all files in root_path
        if os.path.isdir(root_path):
            # get a directory list (list of files in directory)
            dir_list=find_files(root_path, pattern='**', recursive=False)
            # loop through list of files
            for f in dir_list:
                # if the file modified date is older thatn older_than, touch the file
                if dt.fromtimestamp(os.path.getmtime(f)) < older_than:
                    touch(f)
                    print "Touched ", f
        # if root_path is a file, touch the file
        else:
            # if the file modified date is older thatn older_than, touch the file
            if dt.fromtimestamp(os.path.getmtime(f)) < older_than:
                touch(root_path)

Perché non provi: newfile.py

#!/usr/bin/env python
import sys
inputfile = sys.argv[1]

with open(inputfile, 'w') as file:
    pass

python newfile.py foobar.txt

o

usa sottoprocesso:

import subprocess
subprocess.call(["touch", "barfoo.txt"])

È sufficiente:

import os
def func(filename):
    if os.path.exists(filename):
        os.utime(filename)
    else:
        with open(filename,'a') as f:
            pass

Se si desidera impostare un orario specifico per il tocco, utilizzare os.utime come segue:

os.utime(filename,(atime,mtime))

Qui, atime e mtime dovrebbero essere entrambi int / float e dovrebbero essere uguali al tempo di epoca in secondi al tempo che si desidera impostare.

Se non ti dispiace provare, tranne ...

def touch_dir(folder_path):
    try:
        os.mkdir(folder_path)
    except FileExistsError:
        pass

Una cosa da notare, tuttavia, se esiste un file con lo stesso nome, allora non funzionerà e fallirà silenziosamente.

write_text()da pathlib.Pathpuò essere utilizzato.

>>> from pathlib import Path
>>> Path('aa.txt').write_text("")
0