with open(filename) as f:
    while True:
        c = f.read(1)
        if not c:
            print("End of file")
            break
        print("Read a character:", c)

Another option is to use itertools.chain.from_iterable():

import itertools

with open("test.txt") as f:
    for c in itertools.chain.from_iterable(f):
        print(c)

chain.from_iterable makes an iterable that returns elements from the first iterable in the given iterable until it is exhausted, then proceeds to the next iterable, until all of the iterables are exhausted. Normally this is used to flatten out lists of lists, but in this case, it allows you to ignore the lines.

Whether this is really any better than nested loops is another matter (it'll be a little faster, but that's unlikely to matter), but worth mentioning.

Here is a technique to make a one-character-at-a-time file iterator:

from functools import partial

with open("file.data") as f:
    for char in iter(partial(f.read, 1), ''):
        # now do something interesting with the characters
        ...

• The with-statement opens the file and unconditionally closes it when you're finished.
• The usual way to read one character is f.read(1).
• The partial creates a function of zero arguments by always calling f.read with an argument of 1.
• The two argument form of iter() creates an iterator that loops until you see the empty-string end-of-file marker.

Here's a link to the ActiveState Recipes site that says how you can read a single character in Windows, Linux and OSX:

    getch()-like unbuffered character reading from stdin on both Windows and Unix

class _Getch:
    """Gets a single character from standard input.  Does not echo to the
screen."""
    def __init__(self):
        try:
            self.impl = _GetchWindows()
        except ImportError:
            self.impl = _GetchUnix()

    def __call__(self): return self.impl()


class _GetchUnix:
    def __init__(self):
        import tty, sys

    def __call__(self):
        import sys, tty, termios
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch


class _GetchWindows:
    def __init__(self):
        import msvcrt

    def __call__(self):
        import msvcrt
        return msvcrt.getch()


getch = _Getch()

Your syntax is a bit off, your assignment inside the while statement is invalid syntax:

f = open('test.dat', 'r')
while True:
    ch=f.read(1)
    if not ch: break
    print ch

This will start the while loop, and break it when there are no characters left to read! Give it a try.

I'd approach this differently, and make a function that takes in a filename that returns a generator:

def reader(filename):
    with open(filename) as f:
        while True:
            # read next character
            char = f.read(1)
            # if not EOF, then at least 1 character was read, and 
            # this is not empty
            if char:
                yield char
            else:
                return

Then you need to give the filename only once

r = reader('filename')

And the file is kept opened for much faster operation. To fetch next character, use the next built-in function

print(next(r))  # 0
print(next(r))  # 1
...

You can also use itertools, such as islice on this object slice characters, or use that in a for loop:

# skip characters until newline
for c in r:
    if r == '\n':
        break