Wie kann man herausfinden, ob sich eine Datei in ihrem "eof" befindet?
fp = open("a.txt")
#do many things with fp
c = fp.read()
if c is None:
print 'fp is at the eof'
Abgesehen von der oben genannten Methode gibt es keine andere Möglichkeit, um herauszufinden, ob fp bereits am eof ist.
fp.read() liest bis zum Ende der Datei. Nach erfolgreichem Abschluss wissen Sie, dass sich die Datei im EOF befindet. es besteht keine Notwendigkeit zu überprüfen. Wenn EOF nicht erreicht wird, wird eine Ausnahme ausgelöst.
Wenn Sie eine Datei in Blöcken anstatt mit read() lesen, wissen Sie, dass Sie EOF gedrückt haben, wenn read weniger als die angeforderte Anzahl von Bytes zurückgibt. In diesem Fall gibt der folgende Aufruf read die leere Zeichenfolge zurück (nicht None). Die folgende Schleife liest eine Datei in Stücken. Es wird read höchstens einmal zu viele aufrufen.
assert n > 0
while True:
chunk = fp.read(n)
if chunk == '':
break
process(chunk)
Oder kürzer:
for chunk in iter(lambda: fp.read(n), ''):
process(chunk)
Das "for-else" -Design wird oft übersehen. Siehe: Python Docs "Kontrollfluss in Schleife" :
Beispiel
with open('foobar.file', 'rb') as f:
for line in f:
foo()
else:
# No more lines to be read from file
bar()
Ich würde argumentieren, dass das Lesen der Datei die zuverlässigste Methode ist, um festzustellen, ob sie mehr Daten enthält. Es kann sich um eine Pipe handeln, oder ein anderer Prozess hängt möglicherweise Daten an die Datei usw. an.
Wenn Sie wissen das ist kein Problem, könnten Sie etwas verwenden wie:
f.tell() == os.fstat(f.fileno()).st_size
Bei der binären E/A ist die folgende Methode hilfreich:
while f.read(1):
f.seek(-1,1)
# whatever
Der Vorteil ist, dass Sie manchmal einen binären Stream verarbeiten und nicht im Voraus wissen, wie viel Sie lesen müssen.
Sie können den zurückgegebenen Wert von fp.tell() vor und nach dem Aufruf der read-Methode vergleichen. Wenn sie denselben Wert zurückgeben, ist fp bei eof.
Außerdem glaube ich nicht, dass Ihr Beispielcode tatsächlich funktioniert. Die read -Methode gibt meines Wissens niemals None zurück, aber sie liefert eine leere Zeichenfolge bei eof.
read gibt eine leere Zeichenfolge zurück, wenn EOF gefunden wird. Dokumente sind hier .
Da Python eine leere Zeichenfolge in EOF und nicht "EOF" selbst zurückgibt, können Sie einfach den hier beschriebenen Code überprüfen
f1 = open("sample.txt")
while True:
line = f1.readline()
print line
if ("" == line):
print "file finished"
break;
f=open(file_name)
for line in f:
print line
Wenn die Datei im Nicht-Block-Modus geöffnet wird, bedeutet die Rückgabe von weniger Bytes als erwartet nicht, dass sie bei eof liegt. Ich würde sagen, die Antwort von @ NPE ist die zuverlässigste Methode:
f.tell () == os.fstat (f.fileno ()). st_size
Ich verstehe wirklich nicht, warum Python noch keine solche Funktion hat. Ich stimme auch nicht der folgenden Verwendung zu
f.tell() == os.fstat(f.fileno()).st_size
Der Hauptgrund ist, dass f.tell() wahrscheinlich nicht für bestimmte Bedingungen geeignet ist.
Die Methode funktioniert für mich wie folgt. Wenn Sie einen Pseudocode wie den folgenden haben
while not EOF(f):
line = f.readline()
" do something with line"
Sie können es ersetzen durch:
lines = iter(f.readlines())
while True:
try:
line = next(lines)
" do something with line"
except StopIteration:
break
Diese Methode ist einfach und Sie müssen die meisten Code nicht ändern.
Die Python-Lesefunktionen geben einen leeren String zurück, wenn sie EOF erreichen
f = open(filename,'r')
f.seek(-1,2) # go to the file end.
eof = f.tell() # get the end of file location
f.seek(0,0) # go back to file beginning
while(f.tell() != eof):
<body>
Sie können die Methoden fileseek () und tell () verwenden, um die Position des Dateiendes zu bestimmen. Sobald die Position gefunden wurde, kehren Sie zum Anfang der Datei zurück
Sie können die tell()-Methode nach dem Erreichen der EOF verwenden, indem Sie die readlines() -Methode aufrufen:
fp=open('file_name','r')
lines=fp.readlines()
eof=fp.tell() # here we store the pointer
# indicating the end of the file in eof
fp.seek(0) # we bring the cursor at the begining of the file
if eof != fp.tell(): # we check if the cursor
do_something() # reaches the end of the file
Rufen Sie die EOF - Position der Datei ab:
def get_eof_position(file_handle):
original_position = file_handle.tell()
eof_position = file_handle.seek(0, 2)
file_handle.seek(original_position)
return eof_position
und vergleichen Sie es mit der aktuellen Position: get_eof_position == file_handle.tell().
Lesen einer Datei in Stapeln von BATCH_SIZE Zeilen (der letzte Stapel kann kürzer sein):
BATCH_SIZE = 1000 # lines
with open('/path/to/a/file') as fin:
eof = False
while eof is False:
# We use an iterator to check later if it was fully realized. This
# is a way to know if we reached the EOF.
# NOTE: file.tell() can't be used with iterators.
batch_range = iter(range(BATCH_SIZE))
acc = [line for (_, line) in Zip(batch_range, fin)]
# DO SOMETHING WITH "acc"
# If we still have something to iterate, we have read the whole
# file.
if any(batch_range):
eof = True
Python verfügt nicht über eine eingebaute Funktion zur EOF-Erkennung, diese Funktionalität ist jedoch auf zwei Arten verfügbar: f.read(1) gibt b'' zurück, wenn keine weiteren zu lesenden Bytes vorhanden sind. Dies funktioniert sowohl für Text- als auch für Binärdateien. Die zweite Möglichkeit besteht darin, mit f.tell() zu prüfen, ob die aktuelle Suchposition am Ende ist. Wenn Sie möchten, dass EOF die aktuelle Dateiposition nicht ändert, benötigen Sie etwas zusätzlichen Code.
Nachfolgend sind beide Implementierungen aufgeführt.
Verwenden der tell () Methode
import os
def is_eof(f):
cur = f.tell() # save current position
f.seek(0, os.SEEK_END)
end = f.tell() # find the size of file
f.seek(cur, os.SEEK_SET)
return cur == end
Mit read () Methode
def is_eof(f):
s = f.read(1)
if s != b'': # restore position
f.seek(-1, os.SEEK_CUR)
return s == b''
Wie man das benutzt
while not is_eof(my_file):
val = my_file.read(10)
Obwohl ich persönlich eine with-Anweisung verwenden würde, um das Öffnen und Schließen einer Datei zu behandeln, müssen Sie in dem Fall, in dem Sie von stdin lesen und eine EOF -Ausnahme verfolgen müssen, Folgendes tun:
Verwenden Sie einen try-catch mit EOFError als Ausnahme:
try:
input_lines = ''
for line in sys.stdin.readlines():
input_lines += line
except EOFError as e:
print e