I have two specific situations where I don't understand how importing works in Python:
1st specific situation:
When I import the same module in two different Python scripts, the module isn't imported twice, right? The first time Python encounters it, it is imported, and second time, does it check if the module has been imported, or does it make a copy?
2nd specific situation:
Consider the following module, called
a = 10
from bla import *
def Stuff ():
from foo import *
Stuff() #This should return 10
a = 5
The module is only loaded once, so there is no performance loss by importing it again. If you actually wanted it to be loaded/parsed again, you'd have to
reload() the module.
The first place checked is
sys.modules, the cache of all modules that have been imported previously. [source]
from foo import * imports
a to the local scope. When assigning a value to
a, it is replaced with the new value - but the original
foo.a variable is not touched.
So unless you
import foo and modify
foo.a, both calls will return the same value.
For a mutable type such as a list or dict it would be different, modifying it would indeed affect the original variable - but assigning a new value to it would still not modify
If you want some more detailed information, have a look at http://docs.python.org/reference/executionmodel.html:
The following constructs bind names: formal parameters to functions, import statements, class and function definitions (these bind the class or function name in the defining block), and targets that are identifiers if occurring in an assignment, for loop header, in the second position of an except clause header or after as in a with statement.
The two bold sections are the relevant ones for you: First the name
a is bound to the value of
foo.a during the import. Then, when doing
a = 5, the name
a is bound to
5. Since modifying a list/dict does not cause any binding, those operations would modify the original one (
foo.b are bound to the same object on which you operate). Assigning a new object to
b would be a binding operation again and thus separate
It is also worth noting what exactly the
import statement does:
import foobinds the module name to the module object in the current scope, so if you modify
foo.whatever, you will work with the name in that module - any modifications/assignments will affect the variable in the module.
from foo import barbinds the given name(s) only (i.e.
foowill remain unbound) to the element with the same name in
foo- so operations on
barbehave like explained earlier.
from foo import *behaves like the previous one, but it imports all global names which are not prefixed with an underscore. If the module defines
__all__only names inside this sequence are imported.
Part 3 (which doesn't even exist in your question :p)
The python documentation is extremely good and usually verbose - you find answer on almost every possible language-related question in there. Here are some useful links: