Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > Can someone explain this behavior to me?

Reply
Thread Tools

Can someone explain this behavior to me?

 
 
Jesse Aldridge
Guest
Posts: n/a
 
      02-26-2009
I have one module called foo.py
---------------------
class Foo:
foo = None

def get_foo():
return Foo.foo

if __name__ == "__main__":
import bar
Foo.foo = "foo"
bar.go()
---------------------
And another one called bar.py
---------------------
import foo

def go():
assert foo.get_foo() == "foo"
----------------------
When I run foo.py, the assertion in bar.py fails. Why?
 
Reply With Quote
 
 
 
 
Chris Rebert
Guest
Posts: n/a
 
      02-26-2009
On Thu, Feb 26, 2009 at 1:48 PM, Jesse Aldridge <(E-Mail Removed)> wrote:
> I have one module called foo.py
> ---------------------
> class Foo:
> * *foo = None
>
> def get_foo():
> * *return Foo.foo
>
> if __name__ == "__main__":
> * *import bar
> * *Foo.foo = "foo"
> * *bar.go()
> ---------------------
> And another one called bar.py
> ---------------------
> import foo
>
> def go():
> * *assert foo.get_foo() == "foo"
> ----------------------
> When I run foo.py, the assertion in bar.py fails. *Why?


Not sure, but circular imports are *evil* anyway, so I'd suggest you
just rewrite the code to avoid doing any circular imports in the first
place.

Cheers,
Chris

--
Follow the path of the Iguana...
http://rebertia.com
 
Reply With Quote
 
 
 
 
John Machin
Guest
Posts: n/a
 
      02-26-2009
On Feb 27, 8:48*am, Jesse Aldridge <(E-Mail Removed)> wrote:
> I have one module called foo.py
> ---------------------
> class Foo:
> * * foo = None
>
> def get_foo():
> * * return Foo.foo
>
> if __name__ == "__main__":
> * * import bar
> * * Foo.foo = "foo"
> * * bar.go()
> ---------------------
> And another one called bar.py
> ---------------------
> import foo
>
> def go():
> * * assert foo.get_foo() == "foo"
> ----------------------
> When I run foo.py, the assertion in bar.py fails. *Why?


AFAICT from that convoluted mess, because there are two rabbit holes,
__main__.Foo.foo and foo.Foo.foo, and you poked "foo" down the wrong
one. In any case the other one is not the right one -- as you have
already been advised, circular imports are evil.
 
Reply With Quote
 
Albert Hopkins
Guest
Posts: n/a
 
      02-26-2009
On Thu, 2009-02-26 at 13:48 -0800, Jesse Aldridge wrote:
> I have one module called foo.py
> ---------------------
> class Foo:
> foo = None
>
> def get_foo():
> return Foo.foo
>
> if __name__ == "__main__":
> import bar
> Foo.foo = "foo"
> bar.go()
> ---------------------
> And another one called bar.py
> ---------------------
> import foo
>
> def go():
> assert foo.get_foo() == "foo"
> ----------------------
> When I run foo.py, the assertion in bar.py fails. Why?


AFAICT you have 2 different "foo" modules here. The first foo is when
foo.py is called as a script, but it's not called "foo" it's called
"__main__" because it's called as a script. When "bar" is imported, it
imports "foo", but this is different. Technically this is the first time
you are *importing* foo. It's actually loaded a second time with the
name "foo".

A more simplified version of it is this:

$ cat foo.py
cat = 6
import bar
print '%s: %s.cat = %s' % (__file__, __name__, cat)

$ cat bar.py
import foo
foo.cat = 7
print '%s: %s.cat = %s' % (__file__, foo.__name__, foo.cat)

$ python foo.py
/home/marduk/test/foo.py: foo.cat = 6
/home/marduk/test/bar.py: foo.cat = 7
foo.py: __main__.cat = 6


OTOH:
$ python -c "import foo"
bar.py: foo.cat = 7
foo.py: foo.cat = 7

But, as others have said, this is confusing and should be avoided.

-a


 
Reply With Quote
 
Steve Holden
Guest
Posts: n/a
 
      02-27-2009
Jesse Aldridge wrote:
> I have one module called foo.py
> ---------------------
> class Foo:
> foo = None
>
> def get_foo():
> return Foo.foo
>
> if __name__ == "__main__":
> import bar
> Foo.foo = "foo"
> bar.go()
> ---------------------
> And another one called bar.py
> ---------------------
> import foo
>
> def go():
> assert foo.get_foo() == "foo"
> ----------------------
> When I run foo.py, the assertion in bar.py fails. Why?


There are actually two get_foo()s, since foo.py is run (giving it the
name "__main__") and imported (giving it the name "foo"). You will
probably find that __main__.get_foo() == "foo".

regards
Steve

--
Steve Holden +1 571 484 6266 +1 800 494 3119
Holden Web LLC http://www.holdenweb.com/

 
Reply With Quote
 
Jesse Aldridge
Guest
Posts: n/a
 
      02-27-2009
Ah, I get it.
Thanks for clearing that up, guys.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Can someone explain this behavior ? broli C Programming 5 03-16-2008 06:13 AM
Can someone explain this unexpected raw_input behavior? Mike Kent Python 9 01-24-2008 11:18 PM
Can someone explain this weakref behavior? Michael Kent Python 4 06-14-2004 11:25 PM
RE: Can someone explain this weakref behavior? Tim Peters Python 2 06-14-2004 03:55 PM
Can someone explain this IE/Opera behavior to me? delerious@no.spam.com HTML 1 12-03-2003 04:35 AM



Advertisments