Behalve de bovenstaande methode, is er nog een andere manier om erachter te komen of fp al aan het einde is?
Antwoord 1, autoriteit 100%
fp.read()leest tot aan het einde van het bestand, dus nadat het succesvol is voltooid, weet u dat het bestand zich op EOF bevindt; het is niet nodig om te controleren. Als het EOF niet kan bereiken, wordt er een uitzondering gemaakt.
Als je een bestand in stukjes leest in plaats van met read(), weet je dat je op EOF hebt geklikt wanneer readminder oplevert dan het aantal bytes dat je hebt aangevraagd. In dat geval zal de volgende readaanroep de lege string teruggeven (niet None). De volgende lus leest een bestand in stukjes; het zal hoogstens een keer te veel readnoemen.
assert n > 0
while True:
chunk = fp.read(n)
if chunk == '':
break
process(chunk)
Of, korter:
for chunk in iter(lambda: fp.read(n), ''):
process(chunk)
Antwoord 2, autoriteit 77%
Het ‘voor-anders’-ontwerp wordt vaak over het hoofd gezien. Zie: Python Docs “Control Flow in Loop”:
Voorbeeld
with open('foobar.file', 'rb') as f:
for line in f:
foo()
else:
# No more lines to be read from file
bar()
Antwoord 3, autoriteit 45%
Ik zou zeggen dat het lezen van het bestand de meest betrouwbare manier is om vast te stellen of het meer gegevens bevat. Het kan een pijp zijn, of een ander proces kan gegevens aan het bestand toevoegen, enz.
Als u weetdat dit geen probleem is, kunt u zoiets gebruiken als:
f.tell() == os.fstat(f.fileno()).st_size
Antwoord 4, autoriteit 25%
Aangezien python een lege string retourneert op EOF, en niet “EOF” zelf, kun je de code ervoor controleren, hier geschreven
f1 = open("sample.txt")
while True:
line = f1.readline()
print line
if ("" == line):
print "file finished"
break;
Antwoord 5, autoriteit 19%
Bij binaire I/O is de volgende methode handig:
while f.read(1):
f.seek(-1,1)
# whatever
Het voordeel is dat je soms een binaire stream aan het verwerken bent en niet van tevoren weet hoeveel je moet lezen.
Antwoord 6, autoriteit 12%
Je kunt de geretourneerde waarde van fp.tell()vergelijken voor en na het aanroepen van de readmethode. Als ze dezelfde waarde retourneren, is fp op eof.
Bovendien denk ik niet dat uw voorbeeldcode echt werkt. De readmethode retourneert voor zover ik weet nooit None, maar retourneert wel een lege string op eof.
Antwoord 7, autoriteit 10%
read retourneert een lege string wanneer EOF wordt aangetroffen. Documenten zijn hier.
Antwoord 8, autoriteit 10%
f=open(file_name)
for line in f:
print line
Antwoord 9, autoriteit 10%
Ik begrijp echt niet waarom python nog steeds niet zo’n functie heeft. Ik ga ook niet akkoord met het gebruik van het volgende
f.tell() == os.fstat(f.fileno()).st_size
De belangrijkste reden is dat f.tell()waarschijnlijk niet werkt onder bepaalde speciale omstandigheden.
De methode die voor mij werkt, is als volgt. Als je een pseudocode hebt, zoals de volgende
while not EOF(f):
line = f.readline()
" do something with line"
Je kunt het vervangen door:
lines = iter(f.readlines())
while True:
try:
line = next(lines)
" do something with line"
except StopIteration:
break
Deze methode is eenvoudig en u hoeft de meeste code niet te wijzigen.
Antwoord 10, autoriteit 5%
Als het bestand wordt geopend in de niet-blokkerende modus, betekent het retourneren van minder bytes dan verwacht niet dat het op zijn einde is, ik zou zeggen dat het antwoord van @NPE de meest betrouwbare manier is:
f.tell() == os.fstat(f.fileno()).st_size
Antwoord 11, autoriteit 4%
Hier is een manier om dit te doen met de Walrus Operator (nieuw in Python 3.8)
f = open("a.txt", "r")
while (c := f.read(n)):
process(c)
f.close()
Handige Python-documenten (3.8):
Walrus-operator: https://docs.python.org/ 3/whatsnew/3.8.html#assignment-expressions
Methoden van bestandsobjecten: https:// docs.python.org/3/tutorial/inputoutput.html#methods-of-file-objects
Antwoord 12, autoriteit 3%
De Python-leesfuncties retourneren een lege string als ze EOF bereiken
Antwoord 13, autoriteit 3%
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>
U kunt de bestandsmethodenseek()en tell()om de positie van het einde van het bestand te bepalen. Zodra de positie is gevonden, zoekt u terug naar het bestand dat begint
Antwoord 14, autoriteit 3%
Python heeft geen ingebouwde eof-detectiefunctie, maar die functionaliteit is op twee manieren beschikbaar: f.read(1)retourneert b''als er zijn geen bytes meer om te lezen. Dit werkt voor zowel tekst als binaire bestanden. De tweede manier is om f.tell()te gebruiken om te zien of de huidige zoekpositie aan het einde is. Als je wilt dat EOF-testen de huidige bestandspositie niet veranderen, dan heb je wat extra code nodig.
Hieronder staan beide implementaties.
De tell()-methode gebruiken
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
De methode read() gebruiken
def is_eof(f):
s = f.read(1)
if s != b'': # restore position
f.seek(-1, os.SEEK_CUR)
return s == b''
Hoe dit te gebruiken
while not is_eof(my_file):
val = my_file.read(10)
Antwoord 15
U kunt de methode tell()gebruiken nadat u EOFhebt bereikt door readlines()aan te roepen
methode, zoals deze:
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
Antwoord 16
De EOF-positie van het bestand ophalen:
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
en vergelijk het met de huidige positie: get_eof_position == file_handle.tell().
Antwoord 17
Hoewel ik persoonlijk een with-instructie zou gebruiken om het openen en sluiten van een bestand af te handelen, in het geval dat je moet lezen van stdin en een EOF-uitzondering moet volgen, doe dan zoiets als dit:
Gebruik een try-catch met EOFErrorals uitzondering:
try:
input_lines = ''
for line in sys.stdin.readlines():
input_lines += line
except EOFError as e:
print e
Antwoord 18
Ik gebruik deze functie:
# Returns True if End-Of-File is reached
def EOF(f):
current_pos = f.tell()
file_size = os.fstat(f.fileno()).st_size
return current_pos >= file_size
Antwoord 19
Een bestand lezen in batches van BATCH_SIZEregels (de laatste batch kan korter zijn):
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
Antwoord 20
Deze code werkt voor python 3 en hoger
file=open("filename.txt")
f=file.readlines() #reads all lines from the file
EOF=-1 #represents end of file
temp=0
for k in range(len(f)-1,-1,-1):
if temp==0:
if f[k]=="\n":
EOF=k
else:
temp+=1
print("Given file has",EOF,"lines")
file.close()
Antwoord 21
U kunt onderstaand codefragment gebruiken om regel voor regel te lezen, tot het einde van het bestand:
line = obj.readline()
while(line != ''):
# Do Something
line = obj.readline()