Soll ich Dateinamen zum Öffnen übergeben oder Dateien öffnen?

Angenommen, ich habe eine Funktion, die Dinge mit einer Textdatei ausführt - zum Beispiel liest sie aus und entfernt das Wort 'a'. Ich könnte ihm entweder einen Dateinamen übergeben und das Öffnen / Schließen in der Funktion handhaben, oder ich könnte ihm die geöffnete Datei übergeben und erwarten, dass jeder, der sie aufruft, damit umgehen würde, sie zu schließen.

Der erste Weg scheint ein besserer Weg zu sein, um sicherzustellen, dass keine Dateien offen bleiben, hindert mich jedoch daran, Dinge wie StringIO-Objekte zu verwenden

Der zweite Weg könnte ein wenig gefährlich sein - keine Möglichkeit zu wissen, ob die Datei geschlossen wird oder nicht, aber ich könnte dateiähnliche Objekte verwenden

def ver_1(filename):
    with open(filename, 'r') as f:
        return do_stuff(f)

def ver_2(open_file):
    return do_stuff(open_file)

print ver_1('my_file.txt')

with open('my_file.txt', 'r') as f:
    print ver_2(f)

Ist eine davon generell bevorzugt? Wird allgemein erwartet, dass sich eine Funktion auf eine dieser beiden Arten verhält? Oder sollte es nur so gut dokumentiert sein, dass der Programmierer die Funktion entsprechend nutzen kann?

Praktische Benutzeroberflächen sind nett und manchmal der richtige Weg. In den meisten Fällen ist jedoch eine gute Kompositionsfähigkeit wichtiger als Bequemlichkeit , da eine kompositionsfähige Abstraktion es uns ermöglicht, andere Funktionen (einschließlich Convenience-Wrapper) darüber zu implementieren.

Die allgemeinste Möglichkeit für Ihre Funktion, Dateien zu verwenden, besteht darin, ein geöffnetes Dateihandle als Parameter zu verwenden, da dies die Verwendung von Dateihandles ermöglicht, die nicht zum Dateisystem gehören (z. B. Pipes, Sockets usw.):

def your_function(open_file):
    return do_stuff(open_file)

Wenn with open(filename, 'r') as f: result = your_function(f)Ihre Benutzer zu viele Fragen zur Rechtschreibung haben , können Sie eine der folgenden Lösungen wählen:

• your_functionNimmt eine geöffnete Datei oder einen Dateinamen als Parameter. Wenn es sich um einen Dateinamen handelt, wird die Datei geöffnet und geschlossen, und Ausnahmen werden weitergegeben. Es gibt hier ein kleines Problem mit Mehrdeutigkeiten, das mit benannten Argumenten umgangen werden könnte.

• Bieten Sie einen einfachen Wrapper an, der das Öffnen der Datei übernimmt, z

  def your_function_filename(file):
      with open(file, 'r') as f:
          return your_function(f)

  Ich nehme solche Funktionen im Allgemeinen als "API bloat" wahr, aber wenn sie häufig verwendete Funktionen bereitstellen, ist der gewonnene Komfort ein hinreichend starkes Argument.

• Wickeln Sie die with openFunktionalität in eine andere zusammensetzbare Funktion ein:

  def with_file(filename, callback):
      with open(filename, 'r') as f:
          return callback(f)

  verwendet als with_file(name, your_function)oder in komplizierteren Fällenwith_file(name, lambda f: some_function(1, 2, f, named=4))

Die eigentliche Frage ist die Vollständigkeit. Handelt es sich bei Ihrer Dateiverarbeitungsfunktion um die vollständige Verarbeitung der Datei, oder handelt es sich nur um ein Teil einer Reihe von Verarbeitungsschritten? Wenn es vollständig ist, können Sie den gesamten Dateizugriff in einer Funktion einschließen.

def ver(filepath):
    with open(filepath, "r") as f:
        # do processing steps on f
        return result

Dies hat die sehr schöne Eigenschaft, die Ressource am Ende der withAnweisung zu finalisieren (die Datei zu schließen) .

Wenn es jedoch möglicherweise erforderlich ist, eine bereits geöffnete Datei zu verarbeiten, ist die Unterscheidung von ver_1und ver_2sinnvoller. Zum Beispiel:

def _ver_file(f):
    # do processing steps on f
    return result

def ver(fileobj):
    if isinstance(fileobj, str):
        with open(fileobj, 'r') as f:
            return _ver_file(f)
    else:
        return _ver_file(fileobj)

Diese Art der expliziten Typprüfung wird häufig verpönt , insbesondere in Sprachen wie Java, Julia und Go, in denen typ- oder schnittstellenbasiertes Dispatching direkt unterstützt wird. In Python gibt es jedoch keine Sprachunterstützung für typbasiertes Dispatching. Es kann gelegentlich vorkommen, dass Sie in Python Kritik an direkten Typprüfungen üben, in der Praxis ist dies jedoch äußerst verbreitet und recht effektiv. Es ermöglicht einer Funktion ein hohes Maß an Allgemeingültigkeit, wobei alle Datentypen behandelt werden, die wahrscheinlich ihren Weg finden, auch bekannt als "Duck Typing". Beachten Sie den führenden Unterstrich an _ver_file; Dies ist eine herkömmliche Art, eine "private" Funktion (oder Methode) zu bezeichnen. Sie kann zwar technisch direkt aufgerufen werden, weist jedoch darauf hin, dass die Funktion nicht für den direkten externen Verbrauch vorgesehen ist.

Update 2019: Angesichts der jüngsten Aktualisierungen in Python 3, zum Beispiel, dass Pfade jetzt möglicherweise pathlib.Pathnicht nur als Objekte stroder bytes(3.4+) gespeichert werden und dieser Hinweis vom Esoterischen zum Mainstream übergegangen ist (ca. 3.6+, obwohl er sich immer noch aktiv weiterentwickelt), hier aktualisierter Code, der diese Fortschritte berücksichtigt:

from pathlib import Path
from typing import IO, Any, AnyStr, Union

Pathish = Union[AnyStr, Path]  # in lieu of yet-unimplemented PEP 519
FileSpec = Union[IO, Pathish]

def _ver_file(f: IO) -> Any:
    "Process file f"
    ...
    return result

def ver(fileobj: FileSpec) -> Any:
    "Process file (or file path) f"
    if isinstance(fileobj, (str, bytes, Path)):
        with open(fileobj, 'r') as f:
            return _ver_file(f)
    else:
        return _ver_file(fileobj)

Wenn Sie den Dateinamen anstelle des Datei-Handles weitergeben, kann nicht garantiert werden, dass die zweite Datei dieselbe Datei ist wie die erste, wenn sie geöffnet wird. Dies kann zu Korrektheitsproblemen und Sicherheitslücken führen.

Hier geht es um das Eigentum und die Verantwortung, die Datei zu schließen. Sie können auf einem Stream oder Datei - Handle übergeben oder was auch immer Dingen , das geschlossen werden soll / an einem gewissen Punkt zu einem anderen Verfahren angeordnet ist , solange Sie sicherstellen , dass es klar ist , wer es besitzt und sicher , es wird vom Eigentümer geschlossen werden , wenn Sie fertig sind , . Dies beinhaltet typischerweise ein Endversuchskonstrukt oder das Wegwerfmuster.

Wenn Sie geöffnete Dateien übergeben möchten, können Sie etwas wie das folgende tun, ABER Sie haben keinen Zugriff auf den Dateinamen in der Funktion, die in die Datei schreibt.

Ich würde dies tun, wenn ich eine Klasse haben möchte, die zu 100% für Datei- / Stream-Vorgänge verantwortlich ist, und andere Klassen oder Funktionen, die naiv wären und die Dateien / Streams nicht öffnen oder schließen sollen.

Denken Sie daran, dass Kontextmanager wie eine finally-Klausel funktionieren. Wenn also eine Ausnahme in der Writer-Funktion ausgelöst wird, wird die Datei geschlossen, egal was passiert.

import contextlib

class FileOpener:

    def __init__(self, path_to_file):
        self.path_to_file = path_to_file

    @contextlib.contextmanager
    def open_write(self):
        # ...
        # Here you can add code to create the directory that will accept the file.
        # ...
        # And you can add code that will check that the file does not exist 
        # already and maybe raise FileExistsError
        # ...
        try:            
            with open(self.path_to_file, "w") as file:
                print(f"open_write: has opened the file with id:{id(file)}")            
                yield file                
        except IOError:
            raise
        finally:
            # The try/catch/finally is not mandatory (except if you want to manage Exceptions in an other way, as file objects have predefined cleanup actions 
            # and when used with a 'with' ie. a context manager (not the decorator in this example) 
            # are closed even if an error occurs. Finally here is just used to demonstrate that the 
            # file was really closed.
            print(f"open_write: has closed the file with id:{id(file)} - {file.closed}")        


def writer(file_open, data, raise_exc):
    with file_open() as file:
        print("writer: started writing data.")
        file.write(data)
        if raise_exc:
            raise IOError("I am a broken data cable in your server!")
        print("writer: wrote data.")
    print("writer: finished.")

if __name__ == "__main__":
    fo = FileOpener('./my_test_file.txt')    
    data = "Hello!"  
    raise_exc = False  # change me to True and see that the file is closed even if an Exception is raised.
    writer(fo.open_write, data, raise_exc)