Jak sprawić, by tworzenie plików stało się operacją atomową?

Prosty fragment implementujący atomic writing przy użyciu Pythona tempfile.

with open_atomic('test.txt', 'w') as f:
    f.write("huzza")

Lub nawet odczyt i zapis do i z tego samego pliku:

with open('test.txt', 'r') as src:
    with open_atomic('test.txt', 'w') as dst:
        for line in src:
            dst.write(line)

Używanie dwóch prostych menedżerów kontekstu

import os
import tempfile as tmp
from contextlib import contextmanager

@contextmanager
def tempfile(suffix='', dir=None):
    """ Context for temporary file.

    Will find a free temporary filename upon entering
    and will try to delete the file on leaving, even in case of an exception.

    Parameters
    ----------
    suffix : string
        optional file suffix
    dir : string
        optional directory to save temporary file in
    """

    tf = tmp.NamedTemporaryFile(delete=False, suffix=suffix, dir=dir)
    tf.file.close()
    try:
        yield tf.name
    finally:
        try:
            os.remove(tf.name)
        except OSError as e:
            if e.errno == 2:
                pass
            else:
                raise

@contextmanager
def open_atomic(filepath, *args, **kwargs):
    """ Open temporary file object that atomically moves to destination upon
    exiting.

    Allows reading and writing to and from the same filename.

    The file will not be moved to destination in case of an exception.

    Parameters
    ----------
    filepath : string
        the file path to be opened
    fsync : bool
        whether to force write the file to disk
    *args : mixed
        Any valid arguments for :code:`open`
    **kwargs : mixed
        Any valid keyword arguments for :code:`open`
    """
    fsync = kwargs.get('fsync', False)

    with tempfile(dir=os.path.dirname(os.path.abspath(filepath))) as tmppath:
        with open(tmppath, *args, **kwargs) as file:
            try:
                yield file
            finally:
                if fsync:
                    file.flush()
                    os.fsync(file.fileno())
        os.rename(tmppath, filepath)

Ponieważ bardzo łatwo jest namieszać w szczegółach, zalecam użycie do tego małej biblioteki. Zaletą biblioteki jest to, że zajmuje się ona wszystkimi szczegółami i jest weryfikowana i ulepszana przez społeczność.

Jedną z takich bibliotek jest python-atomicwrites by untitaker , która ma nawet odpowiednie okna wsparcie:

• https://github.com/untitaker/python-atomicwrites
• https://pypi.org/project/atomicwrites/

Z README:

from atomicwrites import atomic_write

with atomic_write('foo.txt', overwrite=True) as f:
    f.write('Hello world.')
    # "foo.txt" doesn't exist yet.

# Now it does.

Instalacja przez PIP:

pip install atomicwrites

Używam tego kodu do atomicznego zastąpienia / zapisu pliku:

import os
from contextlib import contextmanager

@contextmanager
def atomic_write(filepath, binary=False, fsync=False):
    """ Writeable file object that atomically updates a file (using a temporary file).

    :param filepath: the file path to be opened
    :param binary: whether to open the file in a binary mode instead of textual
    :param fsync: whether to force write the file to disk
    """

    tmppath = filepath + '~'
    while os.path.isfile(tmppath):
        tmppath += '~'
    try:
        with open(tmppath, 'wb' if binary else 'w') as file:
            yield file
            if fsync:
                file.flush()
                os.fsync(file.fileno())
        os.rename(tmppath, filepath)
    finally:
        try:
            os.remove(tmppath)
        except (IOError, OSError):
            pass

Użycie:

with atomic_write('path/to/file') as f:
    f.write("allons-y!\n")

Jest oparty na ten przepis .

Odpowiedzi na tej stronie są dość stare, są teraz biblioteki, które robią to za Ciebie.

W szczególności safer jest biblioteką zaprojektowaną w celu zapobiegania błędom programisty przed uszkodzeniem plików, połączeń gniazd lub uogólnionych strumieni. Jest dość elastyczny i między innymi ma możliwość korzystania z pamięci lub plików tymczasowych, możesz nawet zachować pliki tymczasowe w przypadku awarii.

Ich przykład jest właśnie tym, czego chcesz:

# dangerous
with open(filename, 'w') as fp:
    json.dump(data, fp)
    # If an exception is raised, the file is empty or partly written

# safer
with safer.open(filename, 'w') as fp:
    json.dump(data, fp)
    # If an exception is raised, the file is unchanged.

Jest w PyPI, po prostu go zainstaluj używając pip install --user safer lub Pobierz najnowszą wersję na https://github.com/rec/safer

Rozwiązanie atomowe dla systemu Windows do zapętlania folderu i zmiany nazw plików. Przetestowany, atomowy w celu automatyzacji, możesz zwiększyć prawdopodobieństwo, aby zminimalizować ryzyko, że nie wystąpi taka sama nazwa pliku. Losowa biblioteka dla kombinacji symboli literowych używa losowych.metoda wyboru, dla cyfry str(random.przypadkowe.zasięg (50,999999999,2). Możesz zmieniać zakres cyfr, jak chcesz.

import os import random

path = "C:\\Users\\ANTRAS\\Desktop\\NUOTRAUKA\\"

def renamefiles():
    files = os.listdir(path)
    i = 1
    for file in files:
        os.rename(os.path.join(path, file), os.path.join(path, 
                  random.choice('ABCDEFGHIJKL') + str(i) + str(random.randrange(31,9999999,2)) + '.jpg'))
        i = i+1

for x in range(30):
    renamefiles()