问题
fp = open("a.txt")
#do many things with fp
c = fp.read()
if c is None:
print 'fp is at the eof'
Besides the above method, any other way to find out whether is fp is already at the eof?
回答1:
fp.read() reads up to the end of the file, so after it's successfully finished you know the file is at EOF; there's no need to check. If it cannot reach EOF it will raise an exception.
When reading a file in chunks rather than with read(), you know you've hit EOF when read returns less than the number of bytes you requested. In that case, the following read call will return the empty string (not None). The following loop reads a file in chunks; it will call read at most once too many.
assert n > 0
while True:
chunk = fp.read(n)
if chunk == '':
break
process(chunk)
Or, shorter:
for chunk in iter(lambda: fp.read(n), ''):
process(chunk)
回答2:
The "for-else" design is often overlooked. See: Python Docs "Control Flow in Loop":
Example
with open('foobar.file', 'rb') as f:
for line in f:
foo()
else:
# No more lines to be read from file
bar()
回答3:
I'd argue that reading from the file is the most reliable way to establish whether it contains more data. It could be a pipe, or another process might be appending data to the file etc.
If you know that's not an issue, you could use something like:
f.tell() == os.fstat(f.fileno()).st_size
回答4:
When doing binary I/O the following method is useful:
while f.read(1):
f.seek(-1,1)
# whatever
The advantage is that sometimes you are processing a binary stream and do not know in advance how much you will need to read.
回答5:
You can compare the returned value of fp.tell() before and after calling the read method. If they return the same value, fp is at eof.
Furthermore, I don't think your example code actually works. The read method to my knowledge never returns None, but it does return an empty string on eof.
回答6:
As python returns empty string on EOF, and not "EOF" itself, you can just check the code for it, written here
f1 = open("sample.txt")
while True:
line = f1.readline()
print line
if ("" == line):
print "file finished"
break;
回答7:
read returns an empty string when EOF is encountered. Docs are here.
回答8:
f=open(file_name)
for line in f:
print line
回答9:
If file is opened in non-block mode, returning less bytes than expected does not mean it's at eof, I'd say @NPE's answer is the most reliable way:
f.tell() == os.fstat(f.fileno()).st_size
回答10:
I really don't understand why python still doesn't have such a function. I also don't agree to use the following
f.tell() == os.fstat(f.fileno()).st_size
The main reason is f.tell() doesn't likely to work for some special conditions.
The method works for me is like the following. If you have some pseudocode like the following
while not EOF(f):
line = f.readline()
" do something with line"
You can replace it with:
lines = iter(f.readlines())
while True:
try:
line = next(lines)
" do something with line"
except StopIteration:
break
This method is simple and you don't need to change most of you code.
回答11:
The Python read functions will return an empty string if they reach EOF
回答12:
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>
You can use the file methods seek() and tell() to determine the position of the end of file. Once the position is found, seek back to the file beginning
回答13:
You can use tell() method after reaching EOF by calling readlines()
method, like this:
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
回答14:
Get the EOF position of the file:
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
and compare it with the current position: get_eof_position == file_handle.tell().
回答15:
Although I would personally use a with statement to handle opening and closing a file, in the case where you have to read from stdin and need to track an EOF exception, do something like this:
Use a try-catch with EOFError as the exception:
try:
input_lines = ''
for line in sys.stdin.readlines():
input_lines += line
except EOFError as e:
print e
回答16:
Reading a file in batches of BATCH_SIZE lines (the last batch can be shorter):
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
回答17:
Python doesn't have built-in eof detection function but that functionality is available in two ways: f.read(1) will return b'' if there are no more bytes to read. This works for text as well as binary files. The second way is to use f.tell() to see if current seek position is at the end. If you want EOF testing not to change the current file position then you need bit of extra code.
Below are both implementations.
Using tell() method
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
Using read() method
def is_eof(f):
s = f.read(1)
if s != b'': # restore position
f.seek(-1, os.SEEK_CUR)
return s == b''
How to use this
while not is_eof(my_file):
val = my_file.read(10)
Play with this code.
回答18:
I use this function:
# 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
回答19:
You can use below code snippet to read line by line, till end of file:
line = obj.readline()
while(line != ''):
# Do Something
line = obj.readline()
来源：https://stackoverflow.com/questions/10140281/how-to-find-out-whether-a-file-is-at-its-eof