when is a != foo.a?

[Chaz Ginger]

I am somewhat new to Python (last year). As such I encounter little
"gotchas" all the time. I am wondering is someone can explain this to me:

If have three simple files:

a.py ---------------------

foo = None
def a(b):
global foo
foo = b

b.py ----------------------

from a import foo
def b(): print foo

c.py ----------------------

import a
from b import b

print 'per a.a() ',a.foo
a.a(245)
print 'expect 245 ', a.foo
b()
If I run 'python c.py' I get the following printed out:
per a.a() None
expect 245 245
None
That surprised me. If I change b.py to

import a
def b(): print a.foo

I get the following (which is what I expected originally):
per a.a() None
expect 245 245
245
Can someone explain what is really going on here?

TIA,
Chaz

[Duncan Booth]

Chaz Ginger wrote:

Can someone explain what is really going on here?

Think of 'from x import y' as an assignment. Roughly equivalent to:

y = sys.modules['x'].y

(except of course you don't have to have imported sys, and it will load the
module 'x' if it hasn't already been imported.)

b.py ----------------------

from a import foo

In other words:

foo = a.foo

foo in module b is initialised from a.foo, but it is a separate variable.
So when a.foo is rebound that doesn't affect b.foo.

def b(): print foo

c.py ----------------------

import a
from b import b

and here:
b = b.b

>
print 'per a.a() ',a.foo
a.a(245)
print 'expect 245 ', a.foo
b()

[Chaz Ginger]

Duncan Booth wrote:

Chaz Ginger wrote:

>Can someone explain what is really going on here?

Think of 'from x import y' as an assignment. Roughly equivalent to:

y = sys.modules['x'].y

(except of course you don't have to have imported sys, and it will load the
module 'x' if it hasn't already been imported.)

>b.py ----------------------

from a import foo

In other words:

foo = a.foo

foo in module b is initialised from a.foo, but it is a separate variable.
So when a.foo is rebound that doesn't affect b.foo.

>def b(): print foo

c.py ----------------------

import a
from b import b

and here:
b = b.b

>print 'per a.a() ',a.foo
a.a(245)
print 'expect 245 ', a.foo
b()

Thanks, Duncan. It now makes sense.

[John Machin]

Chaz Ginger wrote:

I am somewhat new to Python (last year). As such I encounter little
"gotchas" all the time. I am wondering is someone can explain this to me:

If have three simple files:

a.py ---------------------

foo = None
def a(b):
global foo
foo = b

b.py ----------------------

from a import foo
def b(): print foo

c.py ----------------------

import a
from b import b

print 'per a.a() ',a.foo
a.a(245)
print 'expect 245 ', a.foo
b()
If I run 'python c.py' I get the following printed out:
per a.a() None
expect 245 245
None
That surprised me. If I change b.py to

import a
def b(): print a.foo

I get the following (which is what I expected originally):
per a.a() None
expect 245 245
245
Can someone explain what is really going on here?

You are, in a very roundabout fashion, effectively executing the
following bindings:

a.foo = None # done when a is first imported
b.foo = a.foo # done in module b by "from a import foo"
a.foo = 245

So b.foo is bound to None, and a.foo is bound to 245.

Cheers,
John

[Chaz Ginger]

John Machin wrote:

Chaz Ginger wrote:

>I am somewhat new to Python (last year). As such I encounter little
"gotchas" all the time. I am wondering is someone can explain this to me:

If have three simple files:

a.py ---------------------

foo = None
def a(b):
global foo
foo = b

b.py ----------------------

from a import foo
def b(): print foo

c.py ----------------------

import a
from b import b

print 'per a.a() ',a.foo
a.a(245)
print 'expect 245 ', a.foo
b()
If I run 'python c.py' I get the following printed out:
per a.a() None
expect 245 245
None
That surprised me. If I change b.py to

import a
def b(): print a.foo

I get the following (which is what I expected originally):
per a.a() None
expect 245 245
245
Can someone explain what is really going on here?

You are, in a very roundabout fashion, effectively executing the
following bindings:

a.foo = None # done when a is first imported
b.foo = a.foo # done in module b by "from a import foo"
a.foo = 245

So b.foo is bound to None, and a.foo is bound to 245.

Cheers,
John

Thanks John. It is a lot different from the C and C++ world where you
can hold a reference to something and use it. That is how I thought
about what I was doing and learned it wasn't quite right! lol.

Thanks again.