Terapkan sentuhan menggunakan Python?

touchadalah utilitas Unix yang menetapkan waktu modifikasi dan akses file ke waktu saat ini. Jika file tidak ada, itu dibuat dengan izin default.

Bagaimana Anda mengimplementasikannya sebagai fungsi Python? Cobalah untuk menjadi lintas platform dan lengkap.

(Hasil Google saat ini untuk "file python touch" tidak terlalu bagus, tetapi arahkan ke os.utime .)

Sepertinya ini baru pada Python 3.4 - pathlib.

from pathlib import Path

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

Ini akan membuat file.txtdi jalan.

-

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

Buat file di jalur yang diberikan ini. Jika mode diberikan, itu dikombinasikan dengan nilai umask proses untuk menentukan mode file dan bendera akses. Jika file sudah ada, fungsi berhasil jika exist_ok benar (dan waktu modifikasinya diperbarui ke waktu saat ini), jika tidak FileExistsError dinaikkan.

Ini mencoba untuk menjadi sedikit lebih bebas dari solusi yang lain. (Kata withkunci tersebut baru dalam Python 2.5.)

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

Kira-kira setara dengan ini.

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

Sekarang, untuk benar-benar membuatnya bebas perlombaan, Anda perlu menggunakan futimesdan mengubah stempel waktu dari filehandle yang terbuka, alih-alih membuka file dan kemudian mengubah stempel waktu pada nama file (yang mungkin telah diubah namanya). Sayangnya, Python tampaknya tidak menyediakan cara untuk menelepon futimestanpa melalui ctypesatau serupa ...

EDIT

Seperti dicatat oleh Nate Parsons , Python 3.3 akan menambahkan menentukan deskriptor file (kapan os.supports_fd) ke fungsi seperti os.utime, yang akan menggunakan futimessyscall bukan utimessyscall di bawah tenda. Dengan kata lain:

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

Mengapa tidak mencoba ini ?:

import os

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

Saya percaya ini menghilangkan kondisi ras yang penting. Jika file tidak ada maka pengecualian akan dibuang.

Satu-satunya kondisi ras yang mungkin di sini adalah jika file dibuat sebelum open () dipanggil tetapi setelah os.utime (). Tetapi ini tidak masalah karena dalam hal ini waktu modifikasi akan seperti yang diharapkan karena pasti terjadi selama panggilan untuk menyentuh ().

Berikut ini beberapa kode yang menggunakan ctypes (hanya diuji di 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())

^{Jawaban ini kompatibel dengan semua versi sejak Python-2.5 ketika kata kunci withtelah dirilis.}

1. Buat file jika tidak ada + Atur waktu sekarang
(persis sama dengan perintah 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

Versi yang lebih kuat:

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. Cukup buat file jika tidak ada
(tidak memperbarui waktu)

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

3. Cukup perbarui akses file / waktu yang dimodifikasi
(tidak membuat file jika tidak ada)

import os

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

Penggunaan os.path.exists()tidak menyederhanakan kode:

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: Perbarui waktu semua file dalam direktori

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

Sederhana:

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

• The openmemastikan tidak ada file
• yang utimememastikan bahwa cap waktu diperbarui

Secara teoritis, ada kemungkinan seseorang akan menghapus file setelahnya open, menyebabkan utime memunculkan eksepsi. Tapi bisa dibilang itu tidak masalah, karena sesuatu yang buruk memang terjadi

Kompleks (mungkin bermasalah):

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)

Ini mencoba juga memungkinkan pengaturan waktu akses atau modifikasi, seperti sentuhan GNU.

Tampaknya logis untuk membuat string dengan variabel yang diinginkan, dan meneruskannya ke os.system:

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

Ini tidak memadai dalam beberapa cara (misalnya, tidak menangani spasi putih), jadi jangan lakukan itu.

Metode yang lebih kuat adalah dengan menggunakan subproses:

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

Meskipun ini jauh lebih baik daripada menggunakan subkulit (dengan osistem), itu masih hanya cocok untuk skrip cepat dan kotor; gunakan jawaban yang diterima untuk program lintas platform.

"open (file_name, 'a'). close ()" tidak bekerja untuk saya di Python 2.7 di Windows. "os.utime (file_name, None)" bekerja dengan baik.

Juga, saya memiliki kebutuhan untuk secara rekursif menyentuh semua file dalam direktori dengan tanggal yang lebih tua dari tanggal tertentu. Saya membuat hte berikut berdasarkan respon ephemient yang sangat membantu.

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)

Mengapa Anda tidak mencoba: newfile.py

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

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

python newfile.py foobar.txt

atau

gunakan subproses:

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

Berikut ini sudah cukup:

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

Jika Anda ingin mengatur waktu tertentu untuk disentuh, gunakan os.utime sebagai berikut:

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

Di sini, atime dan mtime keduanya harus int / float dan harus sama dengan waktu zaman dalam detik dengan waktu yang ingin Anda atur.

Jika Anda tidak keberatan dengan coba-kecuali ...

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

Satu hal yang perlu diperhatikan, jika ada file dengan nama yang sama maka tidak akan berfungsi dan akan gagal diam-diam.

write_text()dari pathlib.Pathbisa digunakan.

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