Read from end of file python

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?

asked Apr 13, 2012 at 11:52

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)

answered Apr 13, 2012 at 11:55

Fred FooFred Foo

347k72 gold badges724 silver badges824 bronze badges

9

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()

BigMan73

1,04413 silver badges13 bronze badges

answered Jul 14, 2014 at 14:18

BeepBoopBeepBoop

1,21410 silver badges12 bronze badges

2

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

answered Apr 13, 2012 at 11:54

NPENPE

471k104 gold badges922 silver badges997 bronze badges

3

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;

joanis

8,23112 gold badges26 silver badges36 bronze badges

answered Jun 16, 2016 at 9:51

tingtongtingtong

2552 silver badges2 bronze badges

5

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.

answered Aug 1, 2014 at 1:39

user545424user545424

15.3k11 gold badges53 silver badges69 bronze badges

11

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.

answered Apr 13, 2012 at 11:54

1

read returns an empty string when EOF is encountered. Docs are here.

answered Apr 13, 2012 at 11:55

0110011001100110

2,2363 gold badges22 silver badges32 bronze badges

f=open(file_name)
for line in f:
   print line

NorthCat

9,17716 gold badges45 silver badges49 bronze badges

answered Dec 9, 2014 at 7:08

sambasamba

6693 gold badges10 silver badges19 bronze badges

2

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.

answered Feb 8, 2018 at 7:20

Han LuoHan Luo

1883 silver badges4 bronze badges

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

answered Sep 10, 2013 at 4:37

ymattwymattw

1,09910 silver badges7 bronze badges

The Python read functions will return an empty string if they reach EOF

answered Apr 13, 2012 at 11:55

mensimensi

9,4102 gold badges33 silver badges43 bronze badges

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

answered Jul 31, 2017 at 8:57

1

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.

answered May 1, 2019 at 0:47

Shital ShahShital Shah

58.1k12 gold badges224 silver badges180 bronze badges

1

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

progmatico

4,3341 gold badge14 silver badges25 bronze badges

answered Jan 27, 2018 at 21:47

wambawamba

111 bronze badge

1

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

answered Feb 25, 2018 at 22:33

boechat107boechat107

1,52413 silver badges23 bronze badges

1

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().

answered Jul 22, 2018 at 19:11

Константин ВанКонстантин Ван

10.8k7 gold badges54 silver badges65 bronze badges

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

answered Jan 12, 2016 at 4:19

Blairg23Blairg23

10.5k6 gold badges70 silver badges70 bronze badges

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

answered Jul 31, 2016 at 22:39

1

This code will work for python 3 and above

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()

answered Aug 4, 2020 at 6:17

You can try this code:

import sys
sys.stdin = open('input.txt', 'r') # set std input to 'input.txt'

count_lines = 0
while True:
    try: 
        v = input() # if EOF, it will raise an error
        count_lines += 1
    except EOFError:
        print('EOF', count_lines) # print numbers of lines in file
        break

answered Jan 8 at 1:44

1

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()

Assem

11k5 gold badges53 silver badges92 bronze badges

answered Oct 27, 2014 at 12:11

A RA R

2,5673 gold badges19 silver badges37 bronze badges

What does readline return at end of file Python?

How do I read a file from the bottom?

Can we use EOF in Python?

How do you read until the end of a line in Python?