Path: csiph.com!v102.xanadu-bbs.net!xanadu-bbs.net!feeder.erje.net!eu.feeder.erje.net!newsfeed.fsmpi.rwth-aachen.de!newsfeed0.kamp.net!newsfeed.kamp.net!feeder1.cambriumusenet.nl!feed.tweaknews.nl!194.109.133.83.MISMATCH!newsfeed.xs4all.nl!newsfeed4a.news.xs4all.nl!xs4all!newsgate.cistron.nl!newsgate.news.xs4all.nl!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
In-Reply-To: <53C4589A.9040109@jpl.nasa.gov>
References: <53C4589A.9040109@jpl.nasa.gov>
From: Chris Kaynor <ckaynor@zindagigames.com>
Date: Mon, 14 Jul 2014 16:21:27 -0700
Subject: Re: initializing "parameters" class in Python only once?
To: Catherine M Moroney <Catherine.M.Moroney@jpl.nasa.gov>
Content-Type: multipart/alternative; boundary=f46d04426a601332ab04fe2f8e97
Cc: "python-list@python.org" <python-list@python.org>
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.11811.1405380114.18130.python-list@python.org>
Lines: 200
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:74444

--f46d04426a601332ab04fe2f8e97
Content-Type: text/plain; charset=UTF-8

On Mon, Jul 14, 2014 at 3:24 PM, Catherine M Moroney <
Catherine.M.Moroney@jpl.nasa.gov> wrote:

> Hello,
>
> Pardon me for not using the proper Python language terms, but I hope that
> people can still understand the question:
>
> The problem:  I'm writing a large Python program and I have a bunch of
> parameters (whose values are static) that I want to make available to
> the rest of the code with minimum overhead and duplicate processing.
>
> I think that the simplest way would be to create a file called "Params.py"
> and then simply have statements like a = 1, b = 2, etc.
> in there (no classes, no methods, just a bunch of declarations).  But,
> some of these static parameters have to be calculated rather than simply
> hard-coded.
>

Within a module (such as "Params.py"), you can put any statements or code
you want, without needing classes or functions. Depending on the complexity
of the calculations, you may want to put some of the functionality into
functions, which could then be run on import (just put the function call at
the bottom of the module file).

The interpreter will take care to only import one copy, with the exception
of if the Params.py file is accessible from multiple paths in sys.path
(generally not an issue).

For example, the following is a valid module (untested):
# Params.py
a = 1
b = 5
c = a * b + 42
d = c - b
# End Params.Py

You could also go farther and read external configuration files at the root
scope. The main thing to remember is that all intermediate variables will
be visible outside, and thus should be prefixed with an underscore
(Python's standard for private).

I thought of creating a class called Params and having a bunch of
> methods (decorated with @classmethod) that set/calculate the value of
> all the parameters.  Easy enough, but then I have to create a Params
> object in every source file that uses these parameters, and that seems
> wasteful.
>

If all the methods of a class as decorated with @classmethod or
@staticmethod, and all variables are declared on the class, and not inside
of any non-class/static methods (include __init__), you would not need to
create instances of the object.

For example, if you have a class like follows (untested):

class Params():
    myVar = 0
    @classmethod
    def myMethod(cls):
        cls.myVar += 1
        return cls.myVar

you can access them without an instance, by using Params.myVar or
Params.myMethod().


> The actual scope of the problem is very small, so memory/cpu time is not
> an issue.  I'm just looking for the most pythonic/elegant way of doing
> this.
>

For most configuration, I would recommend using a combination of the above.
Create the module and place some configuration variables inside the module
directly. Use classes (which shouldn't be instantiated) for namespacing. If
you start to get a LOT of parameters, you may also want to consider making
the entire params a package (folder/directory) with multiple modules and
possibly classes, however that is likely overkill.

Note that, in any case, I would recommend treating the parameters as
constants, meaning do not change their values, except during the
initialization of the parameters module. This is mostly to ensure
thread-safety and prevent difficult to track bugs.


>
> What is the recommended way of passing a bunch of static (hard-coded and
> calculated) parameters to various parts of the code?
>
> Thank you for any advice,
>
> Catherine
> --
> https://mail.python.org/mailman/listinfo/python-list
>

--f46d04426a601332ab04fe2f8e97
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div class=3D"gmail_extra"><div class=3D"gmail_quote">On M=
on, Jul 14, 2014 at 3:24 PM, Catherine M Moroney <span dir=3D"ltr">&lt;<a h=
ref=3D"mailto:Catherine.M.Moroney@jpl.nasa.gov" target=3D"_blank">Catherine=
.M.Moroney@jpl.nasa.gov</a>&gt;</span> wrote:<br>

<blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-=
left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;p=
adding-left:1ex">Hello,<br>
<br>
Pardon me for not using the proper Python language terms, but I hope that p=
eople can still understand the question:<br>
<br>
The problem: =C2=A0I&#39;m writing a large Python program and I have a bunc=
h of<br>
parameters (whose values are static) that I want to make available to<br>
the rest of the code with minimum overhead and duplicate processing.<br>
<br>
I think that the simplest way would be to create a file called &quot;Params=
.py&quot; and then simply have statements like a =3D 1, b =3D 2, etc.<br>
in there (no classes, no methods, just a bunch of declarations). =C2=A0But,=
 some of these static parameters have to be calculated rather than simply h=
ard-coded.<br></blockquote><div><br></div><div>Within a module (such as &qu=
ot;Params.py&quot;), you can put any statements or code you want, without n=
eeding classes or functions. Depending on the complexity of the calculation=
s, you may want to put some of the functionality into functions, which coul=
d then be run on import (just put the function call at the bottom of the mo=
dule file).</div>

<div><br></div><div>The interpreter will take care to only import one copy,=
 with the exception of if the Params.py file is accessible from multiple pa=
ths in sys.path (generally not an issue).</div><div><br></div><div>For exam=
ple, the following is a valid module (untested):</div>

<div># Params.py</div><div>a =3D 1</div><div>b =3D 5</div><div>c =3D a * b =
+ 42</div><div>d =3D c - b</div><div># End Params.Py</div><div><br></div><d=
iv>You could also go farther and read external configuration files at the r=
oot scope. The main thing to remember is that all intermediate variables wi=
ll be visible outside, and thus should be prefixed with an underscore (Pyth=
on&#39;s standard for private).</div>

<div><br></div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0p=
x 0.8ex;border-left-width:1px;border-left-color:rgb(204,204,204);border-lef=
t-style:solid;padding-left:1ex">
I thought of creating a class called Params and having a bunch of<br>
methods (decorated with @classmethod) that set/calculate the value of<br>
all the parameters. =C2=A0Easy enough, but then I have to create a Params<b=
r>
object in every source file that uses these parameters, and that seems<br>
wasteful.<br></blockquote><div><br></div><div>If all the methods of a class=
 as decorated with @classmethod or @staticmethod, and all variables are dec=
lared on the class, and not inside of any non-class/static methods (include=
 __init__), you would not need to create instances of the object.</div>

<div><br></div><div>For example, if you have a class like follows (untested=
):</div><div><br></div><div>class Params():</div><div>=C2=A0 =C2=A0 myVar =
=3D 0</div><div>=C2=A0 =C2=A0 @classmethod</div><div>=C2=A0 =C2=A0 def myMe=
thod(cls):</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 cls.myVar +=3D 1</div>

<div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 return cls.myVar</div><div><br></div><div>=
you can access them without an instance, by using Params.myVar or Params.my=
Method().</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"=
margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-color:rgb(204,20=
4,204);border-left-style:solid;padding-left:1ex">


The actual scope of the problem is very small, so memory/cpu time is not<br=
>
an issue. =C2=A0I&#39;m just looking for the most pythonic/elegant way of d=
oing this.<br></blockquote><div><br></div><div>For most configuration, I wo=
uld recommend using a combination of the above. Create the module and place=
 some configuration variables inside the module directly. Use classes (whic=
h shouldn&#39;t be instantiated) for namespacing. If you start to get a LOT=
 of parameters, you may also want to consider making the entire params a pa=
ckage (folder/directory) with multiple modules and possibly classes, howeve=
r that is likely overkill.</div>

<div><br></div><div>Note that, in any case, I would recommend treating the =
parameters as constants, meaning do not change their values, except during =
the initialization of the parameters module. This is mostly to ensure threa=
d-safety and prevent difficult to track bugs.</div>

<div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px =
0px 0.8ex;border-left-width:1px;border-left-color:rgb(204,204,204);border-l=
eft-style:solid;padding-left:1ex">
<br>
What is the recommended way of passing a bunch of static (hard-coded and ca=
lculated) parameters to various parts of the code?<br>
<br>
Thank you for any advice,<br>
<br>
Catherine<span class=3D""><font color=3D"#888888"><br>
-- <br>
<a href=3D"https://mail.python.org/mailman/listinfo/python-list" target=3D"=
_blank">https://mail.python.org/<u></u>mailman/listinfo/python-list</a><br>
</font></span></blockquote></div><br></div></div>

--f46d04426a601332ab04fe2f8e97--