Creating a class that inherits from dict using a txtfile - python

Question

I have a file as such:

1 23
2 21
5 23
561 2
73 19781

And with this function:

def readx(x):
    return {int(line.split()[0]):int(line.split()[1]) for line in x.split('\n')}

I can get this:

{1: 23, 2: 21, 5: 23, 73: 19781, 561: 2}

But I need to put it into some sort of class object, so I tried this:

z = """1 23
2 21
5 23
561 2
73 19781"""

def readx(x):
    return {int(line.split()[0]):int(line.split()[1]) for line in x.split('\n')}


class Foo(dict):
    def __init__(self, x):
        self = readx(x)

f = Foo(z)
print f

But it returns a None instead of the dictionary.

1. Is there a more pythonic way to do readx()? It a little ugly as it is now.
2. How do i get the class object to work and make foo a dict with keys and values?

Answer 1

Use super:

class Foo(dict):
    def __init__(self, x):
        super(Foo, self).__init__(readx(x))

This will call the dict constructor on the data, copying it into the object.

Note that this works on Python 3 as well.

Answer 2

An alternative without super is:

class Foo(dict):
    def __init__(self, x):
        for k, v in readx(x).items():
            self[k] = v

Answer 3

To the first question, yes, this comprehension is a bit unreadable, a simple loop might work better:

def read_dict(fp):
   d = {}
   for line in fp:
        k, v = line.strip().split();
        d[int(k)] = int(v)
   return d

where fp is any iterable, e.g. a file object.

To the second question, if your __init__ doesn't do any useful job, just get rid of it, and pass the result of read as an argument to the constructor, which will then transparently invoke the parent dict.__init__:

class Foo(dict):
    # stuff

with open(path) as fp:
   foo = Foo(read_dict(fp))

Alternatively, instantiate Foo right in read and return it:

 def read_foo(fp):
   d = Foo()
   for line in fp:
       # etc, just as above

and then simply

with open(path) as fp:
   foo = read_foo(fp)

You can also make read a class method in Foo to structure your code better:

class Foo(dict):

   @classmethod
   def read(cls, fp):
       d = cls()
       for line in fp:
          #etc

and then:

with open(path) as fp:
   foo = Foo.read(fp)

Finally, if you want to initialize Foo directly from the fp object, you do need __init__:

class Foo(dict):
    def __init__(self, fp):
        for line in fp:
            k, v = line.strip().split()
            self[int(k)] = int(v)

and then

x = Foo(fp)

This code should be used with care though, since it violates the Liskov substitution principle, and that is generally not a good thing.