phoebe> I have a big text file with size more than 2GB. It turned out
    phoebe> memory error when reading in this file. Here is my python
    phoebe> script, the error occurred at line -- self.fh.readlines().

    phoebe> import math
    phoebe> import time

    phoebe> class textfile:
    phoebe>   def __init__(self,fname):
    phoebe>      self.name=fname
    phoebe>      self.fh=open(fname)
    phoebe>      self.fh.readline()
    phoebe>      self.lines=self.fh.readlines()

Don't do that.  The problem is that you are trying to read the entire file
into memory.  Learn to operate a line (or a few lines) at a time.  Try
something like:

    a = open("/home/sservice/nfbc/GenoData/CompareCalls3.diff")
    for line in a:
        do your per-line work here

Anyway, loading the whole file into a list is seldom the best answer,
except for files under a meg or so.  It's usually better to process the
file in sequence.  It looks like you're also making slices of that data,
so they could potentially be pretty big as well.

If you can be assured that you only need the current line and the
previous two (for example), then you can use a list of just those three,
and delete the oldest one, and add a new one to that list each time
through the loop.

Or, you can add some methods to that 'textfile' class that fetch a line
by index.  Brute force, you could pre-scan the file, and record all the
file offsets for the lines you find, rather than storing the actual
line.  So you still have just as big a list, but it's a list of
integers.  Then when somebody calls your method, he passes an integer,
and you return the particular line.  A little caching for performance,
and you're good to go.

Anyway, if you organize it that way, you can code the rest of the module
to not care whether the whole file is really in memory or not.

uses the old object model.

    class Foo(object):

uses the new object model.

See http://docs.python.org/reference/datamodel.html (specifically
section 3.3) for details of the differences.

(1) Properties don't work correctly:

In general, anything that uses the descriptor protocol, not just
property, will fail to work correctly with old-style classes.

(2) Classes using multiple inheritance with diamond-shaped inheritance
will be broken.

(3) __slots__ is just an attribute.

(4) super() doesn't work.

And, depending on whether you consider this a disadvantage or an
advantage:

(5) Special methods like __len__ can be over-ridden on the instance, not
just the class:

In their favour:

(1) Less typing.

(2) If you're not using descriptors, including property(), or multiple
inheritance with diamond diagrams, they work fine.

(3) They're (apparently) a tiny bit faster.