looking for way to include many times some .py code from anotherpython code

[Martin MOKREJ©]

Hi,
I'm looking for some easy way to do something like include in c or PHP.
Imagine I would like to have:
cat somefile.py
a = 222
b = 111
c = 9
cat somefile2.py
self.xxx = a
self.zzz = b
self.c = c
self.d = d
cat anotherfile.py

def a():
include somefile
postprocess(a)

def b():
include somefile
postprocess(a, b, c)

class klass():
def __init__(self, a, b, c, d):
include somefile2

I know about module imports and reloads, but am not sure if this is the right
way to go. Mainly, I want to assign to multiple object instances some self bound
variables. Their values will be different, so I can't use global variables.

Martin

[Scott David Daniels]

Martin MOKREJ© wrote:

Hi,
I'm looking for some easy way to do something like include in c or PHP.
Imagine I would like to have: ....

I know about module imports and reloads, but am not sure if this is the
right way to go. Mainly, I want to assign to multiple object instances
some self bound variables. Their values will be different, so I can't
use global variables.

Someone will, no doubt, find a way to code this. I suggest you are
fighting the language here -- learn to use it instead. Decide what
you really want to do, not how you want to do it. Then try to figure
out how to accomplish your real goal in the normal flow of the language.
-Scott David Daniels
Sc***********@A cm.Org

[Kent Johnson]

Martin MOKREJ© wrote:

Hi,
I'm looking for some easy way to do something like include in c or PHP.
Imagine I would like to have:
cat somefile.py
a = 222
b = 111
c = 9
cat somefile2.py
self.xxx = a
self.zzz = b
self.c = c
self.d = d
cat anotherfile.py

def a():
include somefile
postprocess(a)

def b():
include somefile
postprocess(a, b, c)

class klass():
def __init__(self, a, b, c, d):
include somefile2
You can do this with module-level variables and a base class for klass:

cat somefile.py
a = 222
b = 111
c = 9
cat somefile2.py
class base:
def __init__(self, a, b, c, d):
self.xxx = a
self.zzz = b
self.c = c
self.d = d
cat anotherfile.py
import somefile, somefile2

def a():
postprocess(som efile.a)

def b():
postprocess(som efile.a, somefile.b, somefile.c)

class klass(somefile2 .base):
def __init__(self, a, b, c, d):
somefile2.base. __init__(self, a, b, c, d)

Kent


I know about module imports and reloads, but am not sure if this is the
right
way to go. Mainly, I want to assign to multiple object instances some
self bound
variables. Their values will be different, so I can't use global variables.

Martin

[Martin MOKREJ©]

Scott David Daniels wrote:

Martin MOKREJ© wrote:

Hi,
I'm looking for some easy way to do something like include in c or PHP.
Imagine I would like to have: ....

I know about module imports and reloads, but am not sure if this is
the right way to go. Mainly, I want to assign to multiple object
instances some self bound variables. Their values will be different,
so I can't

> use global variables.

Someone will, no doubt, find a way to code this. I suggest you are
fighting the language here -- learn to use it instead. Decide what
you really want to do, not how you want to do it. Then try to figure
out how to accomplish your real goal in the normal flow of the language.

See my post on Mar 2 about "automating assignment of class variables".
I got no answers, maybe I wasn't clear enough ... :(

I need to define lots of variables. The variable names are often identical.
The problem is that if I put such a code into a function ... no, I'm not going
to pass anything to a function to get it returned back. I just want to get
lots of variables assigned, that all. If I put them into module, it get's
exectued only once unless I do reload. And I'd have to use:
"from some import *", because mainly I'm interrested in assigning to self:
self.x = "blah"
self.y = "uhm"

I'm newbie, sure.

M.

[Diez B. Roggisch]

> See my post on Mar 2 about "automating assignment of class variables".

I got no answers, maybe I wasn't clear enough ... :(
Seems so - I for example didn't understand it.

I need to define lots of variables. The variable names are often
identical. The problem is that if I put such a code into a function ...
no, I'm not going to pass anything to a function to get it returned back.
I just want to get lots of variables assigned, that all. If I put them
into module, it get's exectued only once unless I do reload. And I'd have
to use: "from some import *", because mainly I'm interrested in assigning
to self: self.x = "blah"
self.y = "uhm"

Okay, I try and guess: From your two posts I infer that you want to set
variables in instances. But you've got lots of these and you don't want to
write code like this:

class Foo:
def __init__(self, a, b, .....):
self.a = a
self.b = b
....
If that is what you want, then this might help you: Put all the values in a
dictionary - like this:

my_vals = {"a": 1, "b" : 2, ....}

There are plenty of other ways to create such a dictionary, but I won't
digress on that here.

Now in your class, you pass than dict to your constructor and then simply
update the instance's __dict__ so that the keys-value-pairs in my_vals
become attributes:

class Foo:

def __init__(self, my_vals):
self.__dict__.u pdate(my_vals)

foo = Foo(my_vals)

print foo.a

-> 1

Hope this helps,
--
Regards,

Diez B. Roggisch

[Martin MOKREJ©]

Kent Johnson wrote:

Martin MOKREJ© wrote:

Hi,
I'm looking for some easy way to do something like include in c or PHP.
Imagine I would like to have:
cat somefile.py
a = 222
b = 111
c = 9
cat somefile2.py
self.xxx = a
self.zzz = b
self.c = c
self.d = d
cat anotherfile.py

def a():
include somefile
postprocess(a)

def b():
include somefile
postprocess(a, b, c)

class klass():
def __init__(self, a, b, c, d):
include somefile2

You can do this with module-level variables and a base class for klass:

cat somefile.py
a = 222
b = 111
c = 9
cat somefile2.py
class base:
def __init__(self, a, b, c, d):
self.xxx = a
self.zzz = b
self.c = c
self.d = d
cat anotherfile.py
import somefile, somefile2

def a():
postprocess(som efile.a)

def b():
postprocess(som efile.a, somefile.b, somefile.c)

class klass(somefile2 .base):
def __init__(self, a, b, c, d):
somefile2.base. __init__(self, a, b, c, d)

Oh, I've picked up not the best example. I wanted to set the variables
not under __init__, but under some other method. So this is actually
what I really wanted.

class klass(somefile2 .base):
def __init__():
pass

def set_them(self, a, b, c, d):
somefile2.base. __init__(self, a, b, c, d)

Thanks!
Martin

[Martin MOKREJŠ]

Diez B. Roggisch wrote:

See my post on Mar 2 about "automating assignment of class variables".
I got no answers, maybe I wasn't clear enough ... :(

Seems so - I for example didn't understand it.

I need to define lots of variables. The variable names are often
identical. The problem is that if I put such a code into a function ...
no, I'm not going to pass anything to a function to get it returned back.
I just want to get lots of variables assigned, that all. If I put them
into module, it get's exectued only once unless I do reload. And I'd have
to use: "from some import *", because mainly I'm interrested in assigning
to self: self.x = "blah"
self.y = "uhm"

Okay, I try and guess: From your two posts I infer that you want to set
variables in instances. But you've got lots of these and you don't want to
write code like this:

class Foo:
def __init__(self, a, b, .....):
self.a = a
self.b = b
....
If that is what you want, then this might help you: Put all the values in a

Good guess! ;)
dictionary - like this:

my_vals = {"a": 1, "b" : 2, ....}

There are plenty of other ways to create such a dictionary, but I won't
digress on that here.

Now in your class, you pass than dict to your constructor and then simply
update the instance's __dict__ so that the keys-value-pairs in my_vals
become attributes:

class Foo:

def __init__(self, my_vals):
self.__dict__.u pdate(my_vals)

foo = Foo(my_vals)

print foo.a

-> 1

Hope this helps,

Sure. Thanks! Would you prefer exactly for this method over the method posted by Kent Johnson
few minutes ago?

Am I so deperately fighting the language? No-one here on the list needs to set hundreds
variables at once somewhere in their code? I still don't get why:

"include somefile.py" would be that non-pythonic so that it's not available, but
I have already two choices how to proceed anyway. Thanks. ;)

Now have to figure out how to assign them easily into the XML tree.

martin

[Kent Johnson]

Martin MOKREJ© wrote:

Oh, I've picked up not the best example. I wanted to set the variables
not under __init__, but under some other method. So this is actually
what I really wanted.

class klass(somefile2 .base):
def __init__():
pass

def set_them(self, a, b, c, d):
somefile2.base. __init__(self, a, b, c, d)

In that case you can define set_them() directly in the base class and omit set_them from klass:

class base:
def set_them(self, a, b, c, d):
self.a = a
# etc

I'm guessing here, but if a, b, c, d are the same variables defined in your original somefile.py,
and the intent is to make them attributes of the klass instance, you could do something like this
and avoid listing all the arguments to klass.set_them( ):

## somefile.py
a = 222
b = 111
c = 9

def set_them(obj):
obj.a = a
obj.b = b
obj.c = c

## anotherfile.py

import somefile
class klass:
def set_them(self):
somefile.set_th em(self)

Kent

[Duncan Booth]

Martin MOKREJŠ wrote:

Am I so deperately fighting the language? No-one here on the list
needs to set hundreds variables at once somewhere in their code? I
still don't get why:

I've certainly never needed to set hundreds of variables at once in my
code. I might have hundreds of values, but if so they go into a list or a
dictionary or some other suitable data structure.

There isn't any point setting hundreds of variables unless you also
have hundreds of different expressions accessing hundreds of variables. If
they are all accessed in a similar way then this indicates they shouldn't
be separate variables. If they are all accessed differently then you have
some very complex code and hard to maintain code which can probably be
simplified.

Can you give a use case where you think 'hundreds of variables' would be
needed?

[Steve Holden]

Martin MOKREJŠ wrote:

Diez B. Roggisch wrote:

See my post on Mar 2 about "automating assignment of class variables".
I got no answers, maybe I wasn't clear enough ... :(
Seems so - I for example didn't understand it.

I need to define lots of variables. The variable names are often
identical. The problem is that if I put such a code into a function ...
no, I'm not going to pass anything to a function to get it returned
back.
I just want to get lots of variables assigned, that all. If I put them
into module, it get's exectued only once unless I do reload. And I'd
have
to use: "from some import *", because mainly I'm interrested in
assigning
to self: self.x = "blah"
self.y = "uhm"

Okay, I try and guess: From your two posts I infer that you want to set
variables in instances. But you've got lots of these and you don't
want to
write code like this:

class Foo:
def __init__(self, a, b, .....):
self.a = a
self.b = b
....
If that is what you want, then this might help you: Put all the values
in a

Good guess! ;)

dictionary - like this:

my_vals = {"a": 1, "b" : 2, ....}

There are plenty of other ways to create such a dictionary, but I won't
digress on that here.

Now in your class, you pass than dict to your constructor and then simply
update the instance's __dict__ so that the keys-value-pairs in my_vals
become attributes:

class Foo:

def __init__(self, my_vals):
self.__dict__.u pdate(my_vals)

foo = Foo(my_vals)

print foo.a

-> 1

Hope this helps,

Sure. Thanks! Would you prefer exactly for this method over the method
posted by Kent Johnson
few minutes ago?

Am I so deperately fighting the language? No-one here on the list needs
to set hundreds
variables at once somewhere in their code? I still don't get why:

Well, consider that you haven't actually made any kind of a case for
using variables!

If the names of these things are dynamic then why would you want to put
them in an object's namespace, when you could just as easily include

self.insDict = {}

in your __init__() method and then simply update self.insDict whenever
you want.

If you "set hundreds variables", and their names aren't predictable,
then presumably you will have to go through similar contortions to
access them.

So it is generally simpler just to use a dictionary to hold the values
whose names aren't known in advance. Techniques for inserting names into
namespaces are known (as you have discovered), but when a beginner wants
to know about them it's usually considered a sign of "fighting the
language".

So, think about this a while and then tell us exactly *why* it's so
important that these values are stored in variables.

"include somefile.py" would be that non-pythonic so that it's not
available, but
I have already two choices how to proceed anyway. Thanks. ;)

Now have to figure out how to assign them easily into the XML tree.

martin

You do know there are lots of Python libraries that support XML, right?

regards
Steve