When you do : f.readlines() you already read all the file so f.tell() will show you that you are in the end of the file, and doing f.next() will result in a StopIteration error.

Alternative of what you want to do is:

filne = "D:/testtube/testdkanimfilternode.txt"

with open(filne, 'r+') as f:
    for line in f:
        if line.startswith("anim "):
            print f.next() 
            # Or use next(f, '') to return <empty string> instead of raising a  
            # StopIteration if the last line is also a match.
            break

your code is handling each line as a term, in the code below f is an iterator so you can use next to move it to the next element:

with open('test.txt') as f:
    for line in f:
        nextLine = next(f)
        if 'A' == line.strip():
            print nextLine

Once you found the tag, just break from the loop and start reading names, it will continue reading from the position where you interrupted:

for line in file:
    if '[FOR_EACH_NAME]' in line:
        break
else:
    raise Exception('Did not find names')  # could not resist using for-else

for _ in range(5):
    line = file.readline()
    if 'Name' in line:
        print(line)

Just loop over the open file:

infile = open(input,"r")
for line in infile:
    line = doSomething(line, next(infile))

Because you now use the file as an iterator, you can call the next() function on the infile variable at any time to retrieve an extra line.

Two extra tips:

1. Don't call your variable file; it masks the built-in file type object in python. I named it infile instead.

2. You can use the open file as a context manager with the with statement. It'll close the file for you automatically when done:

   with open(input,"r") as infile:
       for line in infile:
           line = doSomething(line, next(infile))
   

Here's what you are trying to do, and probably could have gotten there with a little debugging.

temp_keywords = ''
mykeywords = ''
with open(input_file, encoding="utf8") as fo:    
    for line in fo:
        if line[:2].isupper():    
            if line[:2] == 'GJ':
                temp_line = line[2:].strip()
                next_line = next(fo)
                temp_line += next_line.strip()
                print (temp_line.split(';'))

The problem here is that calling next(fo) yourself, instead of letting the for loop do its job, means you have to handle all of the for loop's job. So whatever you read into next_line will NOT be processed on the next loop. You will completely miss some lines of the file.

Instead, you always want to let the for loop handle its job.

But what you have here is two different methods of breaking a file up. It's easier to write a record parser which finds full records, and let it read lines from the file as needed. Here is an adaptation of my other answer linked in comments:

def is_new_record(line):
    return line[:2].isupper()

def helper(text):
    data = []
    for line in text.readlines():
        if is_new_record(line):
            if (data):
                yield ''.join(data)
            data = [line.strip()]
        else:
            data.append(line.strip())
    if (data):
        yield ''.join(data)

# the helper is a generator for multiline records, as one line
input_file = 'data.txt'
with open(input_file) as f:
    for record in helper(f):
        print (record)

LA English
DT Article
GJ asthma; susceptible genes; natural language processing analysis; networkcentrality analysis
ID LITERATURE-BASED DISCOVERY; CO-WORD ANALYSIS; UNDISCOVERED PUBLICKNOWLEDGE; INFORMATION-RETRIEVAL; FISH-OIL; SCIENTIFIC COLLABORATION;INSULIN-RESISTANCE; COMPLEX NETWORKS; METFORMIN; OBESITY
GJ natural language processing; network analysis
GJ data mining; text mining; learning analytics; deep learning;network centrality analysis

You can use iter to convert your object into an iterable which supports next.

irofile = iter(rofile)
for line in irofile:
    print line
    if(line == 'foo'):
        line = next(irofile)  #BEWARE, This could raise StopIteration!
        print line

As pointed out in the comments, if your object is already an iterator, then you don't need to worry about iter (this is the case with file objects). However, I leave it here as it works for the case of any arbitrary iterable (e.g. lists).

Just use the index.

def openFood():
    with open("FoodList.txt")  as f:
        lines = f.readlines()
        for i in range(len(lines)-1):
            if 'Food' in lines[i]:
                print(lines[i+1])
openFood()

You don't need to call next(). You are already iterating over the lines of the file, so, don't do anything, and the next line will come at the next iteration.

elif clientid not in line:
    pass

Unrelated to file reading: You if-elseif-else doesn't make sense. clientid in line is either true or false, so it doesn't make sense to have 3 conditions. Just remove the middle elif altogether`

next(f) consumes the next line, each line can only be read once, so you need to reorder how you read lines. This should work

with open(filename) as f:
    previous = None
    current = next(f).strip()
    for line in f:
        line=line.strip()
        print(previous, current, line)
        previous = current
        current = line

Output:

None line1 line2
line1 line2 line3
line2 line3 line4

you can use xml.dom.minidom

Assuming your xml data is in a file

from xml.dom.minidom import parse

xmldata = open("abc.txt", "r")

domdata = parse(xmldata)

def getDescriptionData(title):
    titledata = [x.toxml().lstrip('<title>').rstrip('</title>') for x in domdata.getElementsByTagName('title')]
    descriptiondata = [x.toxml().lstrip('<description>').rstrip('</description>') for x in domdata.getElementsByTagName('description')]

    l =  [v for (x, v) in zip(titledata, descriptiondata) if x == title]
    if l:
        return l[0]
    return None

print getDescriptionData('Lake Louis')

Output:

Open  / Past 48 Hours: 2cm / Primary:  / Base Depth: 162cm

You can also look into SAX XML parsing

If you just want to skip over lines not starting with #, there's a much easier way to do this:

file_handler = open(fname, 'r')
    for line in file_handler:
       if line[0] != '#':
           continue
       # now do the regular logic
       print line

Obviously this kind of simplistic logic won't work in all possible cases. When it doesn't, you have to do exactly what the error implies: either use iteration consistently, or use read methods consistently. This is going to be more tedious and error-prone, but it's not that bad.

For example, with readline:

while True:
    line = file_handler.readline()
    if not line:
        break
    if line[0] == '#':
        print line
    else:
        line2 = file_handler.readline()
        print line2

Or, with iteration:

lines = file_handler
for line in file_handler:
    if line[0] == '#':
        print line
    else:
        print line
        print next(file_handler)

However, that last version is sort of "cheating". You're relying on the fact that the iterator in the for loop is the same thing as the iterable it was created from. This happens to be true for files, but not for, say, lists. So really, you should do the same kind of while True loop here, unless you want to add an explicit iter call (or at least a comment explaining why you don't need one).

And a better solution might be to write a generator function that transforms one iterator into another based on your rule, and then print out each value iterated by that generator:

def doublifier(iterable):
    it = iter(iterable)
    while True:
        line = next(it)
        if line.startswith('#'):
            yield line, next(it)
        else:
            yield (line,)