main.py:

import subone
import subtwo

subone.py:

a = 'abc'

subtwo.py:

print subone.a

Running python main.py throws a NameError: name 'subone' is not defined. I expected it to print 'abc'.

Refactoring it to use from import and classes doesn't help:

main.py:

from subone import *   # Only using from X import * for example purposes.
from subtwo import *

print 'from main.py:', a.out

subone.py:

class A:
    out = 'def'

a = A()

subtwo.py:

# This throws NameError: name 'a' is not defined
print a.out

# This throws NameError: name 'A' is not defined
b = A()
print b.out

BUT it will print 'from main.py: def'. (It works when using import too.)

Why does it work this way? It seems like once subone is imported, it should be available to subtwo.

Is it because it's bad programming to have imported modules depend on each other without going through their 'parent' module? Is there another, standard way to do this?

Update:

I now understand that the first example will not work because the line print subone.a doesn't recognize the name subone, it not being in subtwo's namespace (even though it's in main.py's), and it is being called from within the module subtwo. This can be fixed by using import subone at the top of subtwo.py -- it will not re-load the module but will add it to subtwo's namespace so subtwo can use it.

But what about this:

main.py:

from subone import Nugget
from subtwo import Wrap

wrap = Wrap()
print wrap.nugget.gold

subone.py:

class Nugget:
    gold = 'def'

subtwo.py:

class Wrap:
    nugget = Nugget()

I would think that since Wrap and Nugget are both loaded directly into main's namespace, that they would use main's namespace and be able to reference each other, but it throws a NameError: name 'Nugget' is not defined. IS IT because Wrap is evaluated/checked from within subtwo's namespace BEFORE being loaded into main's namespace开发者_如何学编程?

If you modified your subtwo.py this way then it will work

import subone
print subone.a

When you do subone.a in subtwo.py, you are trying to access the namespace subone in subtwo.py and in the namespace "subone", there should be a attribute "a".

When you do - import subone in subtwo.py, then subone is added to the namespace and subone namespace has attribute a. so subone.a will work.

I would also suggest that you play with dir() to see how namespaces are being added.

In subtwo.py, you can do the following:

print dir()
import subone
print dir()
print subone.a

Similarly, try adding "print dir()" before and after your import statements and the idea should become clear to you.

"import x" adds 'x' to the current modules namespace while "from x import * " will add all the module level attributes directly into current module namespace

So in your above first example of main.py, subone.py and subtwo.py, the namespace in main.py will contain 'subone' and 'subtwo' while subtwo.py will have an empty namespace and can not access subone.a.

[Edit: Some more explanations] Consider following files: main.py

print "Before importing subone : ", dir()
import subone
print "After importing subone and before importing subtwo: ",  dir()
import subtwo
print "After importing subone and subtwo: ", dir()

subone.py

a = 'abc'

subtwo.py

print dir()
import subone
print "module level print: ", subone.a
print dir()
def printX():
    print subone.a

And the output of running main.py:

Before importing subone :  ['__builtins__', '__doc__', '__file__', '__name__', '__package__']
After importing subone and before importing subtwo:  ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'subone']
['__builtins__', '__doc__', '__file__', '__name__', '__package__']
module level print:  abc
['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'subone']
After importing subone and subtwo:  ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'subone', 'subtwo']

Some Observations

You will notice that importing a module subtwo.py, the print statement is executed immediately.
So when subone and subtwo are imported in main.py, the namespace of main.py is augmented.
That does not mean that namespace of subtwo will be augmented. so "a" is available only in main.py via subone.a
When we do import subone in subtwo.py then the namespace of subtwo is augmented with subone and attribute a of module subone is available in subtow.py via subone.a

Can you explain why you feel like subone should be available to subtwo, when subone has been imported by main? As it is, subtwo.py can be compiled without knowing what main.py has imported.

Also, if a second program imports subtwo.py, should subtwo's knowledge of subone depend on which of two main programs is importing subtwo? This would reduce reusability of subtwo.

It seems like you're thinking of the compilation as a process with a defined order, accumulating state information: compile main.py, during which we compile/import subone.py, accumulating information from it, and then we compile/import subtwo.py, using the information we've already accumulated.

Instead, the compilation of each module is independent of others, unless dependencies are declared. This makes it much easier to reuse and maintain code: there are fewer hidden dependencies.

Is it because it's bad programming to have imported modules depend on each other without going through their 'parent' module?

Not as such... It's just bad programming to have module 2 depend on module 1 without saying so, i.e. without module 2 declaring "I depend on module 1".

The subtwo namespace will be totally empty unless you import subone into it.

As far as programming practices, subone and subtwo can depend on each other if so desired, you just need to explicitly link them (with an import)

Regarding your second example, "main.py" knows about Nugget but "subtwo.py" doesn't.

I think it would help to think of it this way. Every module (file) has to work as if the only other modules that exist are the ones that it imports. In this case "subtwo.py" would not be able to run by itself because it hasn't imported Nugget. Essentially "subtwo.py" doesn't know what "main.py" knows. It shouldn't, because it could be called from anywhere by anyone, and it can't rely on anyone else importing the stuff that it needs.

This is because the imported modules have its own separate namespaces. What you wrote is very much like:

def func1():
    a = 1

def func2():
    print a

func1()
func2()  # This will throw an error

a = 2

func2()  # Now this will print 2.

The modules have their namespaces locally, and when you use from subone import * you import the namespace ONLY to main.py namespace which cannot be accessed by subtwo.

Nevertheless - what you're trying to do is very bad practice. Avoid using global variables and import *, just because you will get more and more confused like now.

More on it: https://docs.python.org/3/reference/import.html

https://bytebaker.com/2008/07/30/python-namespaces/

http://www.diveintopython.net/html_processing/locals_and_globals.html

and maybe: http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html