code structure advise for a model

Martin De Kauwe mdekauwe at gmail.com
Sat Feb 5 15:37:48 CET 2011


On Feb 4, 8:41 pm, Marco Nawijn <naw... at gmail.com> wrote:
> On Feb 4, 3:43 am, Martin De Kauwe <mdeka... at gmail.com> wrote:
>
>
>
>
>
> > Hi,
>
> > I am translating some c++ code to python and just wanted to ask some
> > advise on structure. The original has everything declared globally and
> > nothing passed via function (I assume, but don't know, that this isn't
> > just standard c++ practice!). So given this, I have a pretty much
> > clean slate as I can't quite just copy the functions over. I was
> > thinking something like this
>
> > class Params:
>
> >     def __init__(self, fname):
> >         self.set_inital_condtions()
> >         self.read_input_file(fname)
>
> >     def set_inital_conditons(self):
> >         self.some_parm = 0.0
>
> >     def read_input_file(fname):
>
> >         #read file, change initial params if specified
>
> > then I thought I could pass this as an object to the model class
>
> > class Model(Params):
>
> >     def __init__(self):
> >         # blah
>
> >     def some_func(self):
> >          if (Params.some_param == something):
> >              foo
>
> > OR this just a very bad way to structure it?
>
> > The other thing I can't decide on is how to pass the parameters and
> > variables through the class. So because of the way the original is
> > written (everything is global), I could just inherit things, but it
> > does means there is a lot of self. syntax. So I wondered if it might
> > be better to pass things as function arguments? Any thoughts? I am
> > also half considering other users from non-python backgrounds and what
> > might seem very alien (syntax) to them.
>
> > thanks in advance
>
> > (ps. I am cross posting this on comp.lang.python as I am not sure
> > where is more appropriate).
>
> I would structure it in three classes/functions:
> 1. A parser class/function that reads an input file and returns a
> Parameters object
> 2. A Parameters class
> 3. A Model class that uses the Parameters
>
> You would end up with something like the following:
>
> class MyParser(object):
>
>     def __init__(self, filename=None):
>         self.filename = filename
>
>     def parse(self, filename):
>
>         params = Parameters()
>
>         ...read info from filename and update parameters
>
>         return params
>
> class Parameters(object):
>
>     def __init__(self):
>          self.myAttribute1 = 0
>          self.myAttribute2 = "A string"
>
> class MyModel(object):
>
>    def __init__(self, parameters):
>        self.parameters = parameters
>
>    def solve(self):
>         ...solve the problem
>
> The driver program would look something like this:
>
> parser = MyParser()
>
> params = parser.parse('inputfile')
>
> model = MyModel(params)
> model.solve()
>
> I hope this is helpfull for you.
>
> Regards,
>
> Marco

thanks for that. I decided to read the params straight into a set of
dictionaries and then pass these dictionaries around the various model
methods.



More information about the Python-list mailing list