how to avoid repeated calls to init when passing a subclass to inherit in python

Question

consider class

class Grid():
    def __init__(self,r,z,t):
        self.rgrid = r
        self.zgrid = z
        self.tgrid = t
        self.otherstuff = long_computation(r,t,z)

class Solution(Grid):
    def __init__(self,r,g):
        self.zones = r
        Grid.__init__(self,g.r,g.z,g.t)

g = Grid(my_r,my_z,my_t)
sol = Solution(r,g)

This creates what I want, except the "long_computation" is done twice. What would be a clean way to structure the classes that would work whether I called just Grid, or whether I also did the Solution step?

Thanks, J.

Why does Solution inherit from Grid, and why does it take an existing Grid as an argument instead of r, z, and t? — user2357112
– user2357112, Commented May 24, 2017 at 23:47
what's the difference between r in Grid.__init__ and in Solution.__init__? it seems like last one should be named zones — Azat Ibrakov
– Azat Ibrakov, Commented May 25, 2017 at 3:35
You can have a class variable done_long_computation which you'd set the first time __init__ is executed, and __init__ checks if done_long_computation is set. — boardrider
– boardrider, Commented May 25, 2017 at 20:21

Harwee · Accepted Answer · 2017-05-25 01:23:16Z

1

You can have a method to perform calculation in parent class. Using this you can call the method and compute the stuff which takes long time when you want to calculate it.

class Grid():
    def __init__(self,r,z,t):
        self.rgrid = r
        self.zgrid = z
        self.tgrid = t

    def start_long_computation(self):
        self.otherstuff = long_computation(self.rgrid,self.tgrid,self.zgrid)

call the start_long_computation in Solution instance

class Solution(Grid):
    def __init__(self,r,my_r ,my_z ,my_t):
        self.zones = r
        Grid.__init__(self, my_r ,my_z ,my_t)
        Grid.start_long_computation(self)

You can now access otherstuff using self.otherstuff in Solution instance

or

class Grid():
    def __init__(self,r,z,t):
        self.rgrid = r
        self.zgrid = z
        self.tgrid = t

    def start_long_computation(self):
        return long_computation(self.rgrid,self.tgrid,self.zgrid)

class Solution():
    def __init__(self,r,g):
        self.zones = r
        self.otherstuff = g.start_long_computation()

g = Grid(my_r,my_z,my_t)
sol = Solution(r,g)

edited May 25, 2017 at 1:23

answered May 24, 2017 at 23:57

Harwee

1,6502 gold badges22 silver badges35 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Tunneller Over a year ago

Hi, is there a way to for Solution to know if otherstuff has been created already? Sometimes I will want to use Grid and have it run the long-computation without calling it as part of Solution. Sometimes I will want to call Grid without calling Solution. Maybe subclass() ... hm. I just saw dict.keys()

Harwee Over a year ago

You can use self.__dict__ to see if the attribute exists for the class and calculate if necessary.

Azat Ibrakov · Accepted Answer · 2017-05-25 15:03:07Z

1

IMO you should avoid any computations inside of __init__ and only do attributes assigning, so if you wanna do long_computation once and use its result you can do it outside of __init__ and pass as argument.
If you are not using Python 3 you probably should inherit you base class Grid from object type (in Python 3 all classes are inherited from object by default). And there is function named super and you probably should use it like super(Solution, self).__init__ (or just super().__init__ in Python 3) instead of writing Grid.__init__.
Passing Grid instance to initialize Solution object looks ugly, why not passing required Grid attributes? Also your example will not work since Grid objects doesn't have r, z, t fields, but rgrid, zgrid, tgrid. If you need to construct Solution instance from Grid you can write custom constructor (e.g. there are many of them in datetime.datetime type).

Considering all this remarks

class Grid(object):
    def __init__(self, r, t, z, otherstuff):
        self.rgrid = r
        self.tgrid = t
        self.zgrid = z
        self.otherstuff = otherstuff


class Solution(Grid):
    def __init__(self, zones, r, t, z, otherstuff):
        self.zones = zones
        super(Solution, self).__init__(r, t, z, otherstuff)

    @classmethod
    def from_grid(cls, zones, grid):
        return cls(zones, grid.rgrid, grid.tgrid, grid.zgrid, grid.otherstuff)


otherstuff = long_computation(my_r, my_t, my_z)
g = Grid(my_r, my_t, my_z, otherstuff)
sol = Solution.from_grid(r, g)

edited May 25, 2017 at 15:03

answered May 25, 2017 at 3:52

Azat Ibrakov

11.1k9 gold badges43 silver badges58 bronze badges

1 Comment

Tunneller Over a year ago

Thanks, for pointing me to super() ... and then discovering mysteries of old-style classes vs new. The classmethod device is also new to me and will be useful. In some more detail, my "otherstuff" is more like two dozen values: grid.o1, grid.o2, grid.o3, grid.o4, grid.o5,..... etc. I don't want to have to type all of those in the main code each time. But I can use the classmethod to keep the main code clean. Appreciate the update.

Prune · Accepted Answer · 2017-05-24 23:37:14Z

The quick, dirty way would be to add a "new" parameter to the initialization:

def long_computation(r, t, z):
    print "Oh, the despair of wasted time!", r, t, z

class Grid():
    def __init__(self,r,z,t, new_grid=True):
        self.rgrid = r
        self.zgrid = z
        self.tgrid = t
        if new_grid:
            self.otherstuff = long_computation(r,t,z)

class Solution(Grid):
    def __init__(self,r,g):
        self.zones = r
        Grid.__init__(self, g.rgrid, g.zgrid, g.tgrid, False)
        # Inherit long computation from parent.
        self.otherstuff = g.otherstuff

my_r = 77
my_z = 18
my_t = 6.2
r = 0.333

g = Grid(my_r,my_z,my_t)
sol = Solution(r,g)

Another possibility is to memoize longcomputation.

Does that help at all? I know it's not aesthetically satisfying, but it gets the job done.

Tunneller · Accepted Answer · 2017-05-25 16:08:42Z

0

Hm, this looks pretty ugly but builds on the above:

class Grid(object):
    def __init__(self,r,z,t):    
        self.rgrid = r
        self.zgrid = z
        self.tgrid = t       

        if "otherstuff" not  in self.__dict__.keys(): 
            self.otherstuff = self.long_computation(r,t,z)
        else:
            print "No Need to Call"

    def long_computation(ggg,r, t, z):
        return 123456

class Solution(Grid):
    def __init__(self,r,g):
        self.zones = r

    if "otherstuff" in g.__dict__.keys(): 
       self.otherstuff = g.otherstuff

    super(Solution, self).__init__(g.rgrid,g.zgrid,g.tgrid)

edited May 25, 2017 at 16:08

answered May 25, 2017 at 2:44

Tunneller

6195 silver badges20 bronze badges

Collectives™ on Stack Overflow

how to avoid repeated calls to init when passing a subclass to inherit in python

4 Answers 4

2 Comments

1 Comment

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related