Help on object scope?

[bmaron2]

Hello everybody,

I have a (hopefully) simple question about scoping in python. I have a
program written as a package, with two files of interest. The two
files are /p.py and /lib/q.py

My file p.py looks like this:

---

from lib import q

def main():
global r
r = q.object1()
s = q.object2()

if __name__ == "__main__":
main()

---

My file q.py in the subdirectory lib looks like this:

class object1:
t = 3

class object2:
print r.t

---

Python gives me an error, saying it can't recognize global name r.
However I define r as global in the top-level main definition! Can
anyone suggest how I can get around this, if I want to define and bind
global names inside of main() which are valid in all sub-modules?

Thanks very much for your help!

[hg]

bm*****@hotmail.com wrote:

Hello everybody,

I have a (hopefully) simple question about scoping in python. I have a
program written as a package, with two files of interest. The two
files are /p.py and /lib/q.py

My file p.py looks like this:

---

from lib import q

def main():
global r
r = q.object1()
s = q.object2()

if __name__ == "__main__":
main()

---

My file q.py in the subdirectory lib looks like this:

class object1:
t = 3

class object2:
print r.t

---

Python gives me an error, saying it can't recognize global name r.
However I define r as global in the top-level main definition! Can
anyone suggest how I can get around this, if I want to define and bind
global names inside of main() which are valid in all sub-modules?

Thanks very much for your help!

Might be wrong, but globals can only be global to the module they're
declared in.

I suggest you find another way such as passing your object as a parameter

hg

[bmaron2]

On Feb 25, 9:37 am, hg <[e-mail]:

[e-mail] wrote:

Hello everybody,

I have a (hopefully) simple question about scoping in python. I have a
program written as a package, with two files of interest. The two
files are /p.py and /lib/q.py

My file p.py looks like this:

---

from lib import q

def main():
global r
r = q.object1()
s = q.object2()

if __name__ == "__main__":
main()

---

My file q.py in the subdirectory lib looks like this:

class object1:
t = 3

class object2:
print r.t

---

Python gives me an error, saying it can't recognize global name r.
However I define r as global in the top-level main definition! Can
anyone suggest how I can get around this, if I want to define and bind
global names inside of main() which are valid in all sub-modules?

Thanks very much for your help!

Might be wrong, but globals can only be global to the module they're
declared in.

I suggest you find another way such as passing your object as a parameter

hg

Dear hg,

Thank you for the advice, but that seems a bit unwieldy. My code will
have about 10 of these global objects, all of which interact with
eachother. It seems silly to have to pass 10 parameters around to each
instance I work with. I hope there is a smarter way to do it, or
perhaps someone can suggest a smarter way to code it.

Am I stuck with just having to put all the code in one file? That is
what I wanted to avoid, because the file will get incredibly long. It
seems like the only reason my code above failed is because there were
two separate modules. Perhaps I just need to import /lib/q.py in a
different way?

Many thanks.

[Diez B. Roggisch]

>

Thank you for the advice, but that seems a bit unwieldy. My code will
have about 10 of these global objects, all of which interact with
eachother. It seems silly to have to pass 10 parameters around to each
instance I work with. I hope there is a smarter way to do it, or
perhaps someone can suggest a smarter way to code it.

Am I stuck with just having to put all the code in one file? That is
what I wanted to avoid, because the file will get incredibly long. It
seems like the only reason my code above failed is because there were
two separate modules. Perhaps I just need to import /lib/q.py in a
different way?

You can interact just fine, just qualify the objects with the module
names. So in q, you need to use p.r instead of just r.

It's another question if this design is really good - relying on so many
globals. It would certainly be better to have e.g. a class that looks
like this:
import p
import q
class GlueThingy(object):
def __init__(self):
self.p1 = p.SomeObject(self)
self.q1 = q.SomeOtherObject(self)
Then in SomeObject you can use the passed GlueThingy reference to access
other instances:

class SomeObject(object):

def __init__(self, glue):
self.glue = glue

def do_something(self):
self.glue.q1.foobar()
Diez

[Ben Finney]

bm*****@hotmail.com writes:

My code will have about 10 of these global objects, all of which
interact with eachother. It seems silly to have to pass 10
parameters around to each instance I work with.

Yes. A better solution would be to put them inside a module, and
import that module. Then the objects are available at any level as
attributes of the imported module.

===== foo.py =====
def spam():
return max(eggs, ham)

eggs = 17
ham = 12
=====

===== bar.py =====
import foo

def main():
spork = do_something_with(foo.eggs)
foo.spam(spork)
=====

--
\ "Know what I hate most? Rhetorical questions." -- Henry N. Camp |
`\ |
_o__) |
Ben Finney

[Hendrik van Rooyen]

"hg" <[e-mail]:

bm*****@hotmail.com wrote:

Hello everybody,

I have a (hopefully) simple question about scoping in python. I have a
program written as a package, with two files of interest. The two
files are /p.py and /lib/q.py

Make a third file for all the system wide globals, say param.py:

global r
r = 42

My file p.py looks like this:

---

from lib import q

def main():

from param import *

global r
r = q.object1()
s = q.object2()

if __name__ == "__main__":
main()

---

My file q.py in the subdirectory lib looks like this:

from param import *

class object1:
t = 3

class object2:
print r.t

---

Python gives me an error, saying it can't recognize global name r.
However I define r as global in the top-level main definition! Can
anyone suggest how I can get around this, if I want to define and bind
global names inside of main() which are valid in all sub-modules?

Thanks very much for your help!

Might be wrong, but globals can only be global to the module they're
declared in.

Correct.

>
I suggest you find another way such as passing your object as a parameter

or make the third file and import it everywhere you need them...

- Hendrik

[Duncan Booth]

"Diez B. Roggisch" <de***@nospam.web.dewrote:

You can interact just fine, just qualify the objects with the module
names. So in q, you need to use p.r instead of just r.

No. When p.py is being run as a script, the module you need to access is
__main__.

Much better to put the globals into a separate module created specifically
to hold the global variables rather than having them in something which
might or might not be the main script.

[bmaron2]

On Feb 26, 1:16 pm, Dennis Lee Bieber <[e-mail]:

On Mon, 26 Feb 2007 07:54:12 +0200, "Hendrik van Rooyen"
<[e-mail] the following in comp.lang.python:

from param import *

"from <import *" (or any "from <import ..." variant) is NOT the
best thing to use.

Any rebinding to an imported name breaks the linkage to the import
module.

--
Wulfraed Dennis Lee Bieber KD6MOG
[e-mail] [e-mail]
HTTP://wlfraed.home.netcom.com/
(Bestiaria Support Staff: [e-mail])
HTTP://www.bestiaria.com/

Thank you all for the advice.

The suggestion Dennis made about using a 3rd, "common" module to hold
global names seemed to be the best idea. The only problem is now I
have to type common.r.t instead of just r.t. If I put common in the /
lib directory, it is even worse and I have to type lib.common.r.t. I
like that it is explicit and perhaps this is the Python way, but it is
annoying and produces ugly code to see all those fully-qualified names
when all I'd really like to use is r.t throughout the program.

Is there a way to import lib.common but then re-bind its attributes to
the local space without breaking the linkage?

[Jussi Salmela]

bm*****@hotmail.com kirjoitti:

<snip>

global names seemed to be the best idea. The only problem is now I
have to type common.r.t instead of just r.t. If I put common in the /
lib directory, it is even worse and I have to type lib.common.r.t. I
like that it is explicit and perhaps this is the Python way, but it is
annoying and produces ugly code to see all those fully-qualified names
when all I'd really like to use is r.t throughout the program.

Is there a way to import lib.common but then re-bind its attributes to
the local space without breaking the linkage?

See section "6.12 The import statement" in the "Python Reference
Manual". (Hint the part "as name" is what you want)

HTH,
Jussi

[Bart Ogryczak]

On Feb 25, 10:25 pm, [e-mail] wrote:

Hello everybody,

I have a (hopefully) simple question about scoping in python. I have a
program written as a package, with two files of interest. The two
files are /p.py and /lib/q.py

My file p.py looks like this:

---

from lib import q

def main():
global r
r = q.object1()
s = q.object2()

if __name__ == "__main__":
main()

---

My file q.py in the subdirectory lib looks like this:

class object1:
t = 3

class object2:
print r.t

"Globals" are only global within the module they are defined in.
Change "global r" to "import __main__; __main__.r = r", and in q.py
add "from __main__ import r".