Why does Python's __import__ require fromlist?
In fact, the behaviour of __import__()
is entirely because of the implementation of the import
statement, which calls __import__()
. There's basically five slightly different ways __import__()
can be called by import
(with two main categories):
import pkg
import pkg.mod
from pkg import mod, mod2
from pkg.mod import func, func2
from pkg.mod import submod
In the first and the second case, the import
statement should assign the "left-most" module object to the "left-most" name: pkg
. After import pkg.mod
you can do pkg.mod.func()
because the import
statement introduced the local name pkg
, which is a module object that has a mod
attribute. So, the __import__()
function has to return the "left-most" module object so it can be assigned to pkg
. Those two import statements thus translate into:
pkg = __import__('pkg')
pkg = __import__('pkg.mod')
In the third, fourth and fifth case, the import
statement has to do more work: it has to assign to (potentially) multiple names, which it has to get from the module object. The __import__()
function can only return one object, and there's no real reason to make it retrieve each of those names from the module object (and it would make the implementation a lot more complicated.) So the simple approach would be something like (for the third case):
tmp = __import__('pkg')
mod = tmp.mod
mod2 = tmp.mod2
However, that won't work if pkg
is a package and mod
or mod2
are modules in that package that are not already imported, as they are in the third and fifth case. The __import__()
function needs to know that mod
and mod2
are names that the import
statement will want to have accessible, so that it can see if they are modules and try to import them too. So the call is closer to:
tmp = __import__('pkg', fromlist=['mod', 'mod2'])
mod = tmp.mod
mod2 = tmp.mod2
which causes __import__()
to try and load pkg.mod
and pkg.mod2
as well as pkg
(but if mod
or mod2
don't exist, it's not an error in the __import__()
call; producing an error is left to the import
statement.) But that still isn't the right thing for the fourth and fifth example, because if the call were so:
tmp = __import__('pkg.mod', fromlist=['submod'])
submod = tmp.submod
then tmp
would end up being pkg
, as before, and not the pkg.mod
module you want to get the submod
attribute from. The implementation could have decided to make it so the import
statement does extra work, splitting the package name on .
like the __import__()
function already does and traversing the names, but this would have meant duplicating some of the effort. So, instead, the implementation made __import__()
return the right-most module instead of the left-most one if and only if fromlist is passed and not empty.
(The import pkg as p
and from pkg import mod as m
syntax doesn't change anything about this story except which local names get assigned to -- the __import__()
function sees nothing different when as
is used, it all remains in the import
statement implementation.)
What does __all__ mean in Python?
It's a list of public objects of that module, as interpreted by import *
. It overrides the default of hiding everything that begins with an underscore.
Why is Python running my module when I import it, and how do I stop it?
Because this is just how Python works - keywords such as class
and def
are not declarations. Instead, they are real live statements which are executed. If they were not executed your module would be empty.
The idiomatic approach is:
# stuff to run always here such as class/def
def main():
pass
if __name__ == "__main__":
# stuff only to run when not called via 'import' here
main()
It does require source control over the module being imported, however.
How to use the __import__ function to import a name from a submodule?
The __import__
function will return the top level module of a package, unless you pass a nonempty fromlist
argument:
_temp = __import__('foo.bar', fromlist=['object'])
object = _temp.object
See the Python docs on the __import__
function.
What exactly does import * import?
The "advantage" of from xyz import *
as opposed to other forms of import is that it imports everything (well, almost... [see (a) below] everything) from the designated module under the current module. This allows using the various objects (variables, classes, methods...) from the imported module without prefixing them with the module's name. For example
>>> from math import *
>>>pi
3.141592653589793
>>>sin(pi/2)
>>>1.0
This practice (of importing * into the current namespace) is however discouraged because it
- provides the opportunity for namespace collisions (say if you had a variable name pi prior to the import)
- may be inefficient, if the number of objects imported is big
- doesn't explicitly document the origin of the variable/method/class (it is nice to have this "self documentation" of the program for future visit into the code)
Typically we therefore limit this import * practice to ad-hoc tests and the like. As pointed out by @Denilson-Sá-Maia, some libraries such as (e.g. pygame) have a sub-module where all the most commonly used constants and functions are defined and such sub-modules are effectively designed to be imported with import *
. Other than with these special sub-modules, it is otherwise preferable to ...:
explicitly import a few objects only
>>>from math import pi
>>>pi
>>>3.141592653589793
>>> sin(pi/2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'sin' is not defined
or import the module under its own namespace (or an alias thereof, in particular if this is a long name, and the program references its objects many times)
>>>import math
>>>math.pi
>>>3.141592653589793
etc..
>>>import math as m #bad example math being so short and standard...
>>>m.pi
>>>3.141592653589793
etc..
See the Python documentation on this topic
(a) Specifically, what gets imported with from xyz import *
?
if xyz module defines an __all__
variable, it will import all the names defined in this sequence, otherwise it will import all names, except these which start with an underscore.
Note Many libraries have sub-modules. For example the standard library urllib
includes sub-modules like urllib.request
, urllib.errors
, urllib.response
etc. A common point of confusion is that
from urllib import *
would import all these sub-modules. That is NOT the case: one needs to explicitly imports these separately with, say, from urllib.request import *
etc. This incidentally is not specific to import *
, plain import
will not import sub-modules either (but of course, the *
which is often a shorthand for "everything" may mislead people in thinking that all sub-modules and everything else would be imported).
How to load all modules in a folder?
List all python (.py
) files in the current folder and put them as __all__
variable in __init__.py
from os.path import dirname, basename, isfile, join
import glob
modules = glob.glob(join(dirname(__file__), "*.py"))
__all__ = [ basename(f)[:-3] for f in modules if isfile(f) and not f.endswith('__init__.py')]
What is __init__.py for?
It used to be a required part of a package (old, pre-3.3 "regular package", not newer 3.3+ "namespace package").
Here's the documentation.
Python defines two types of packages, regular packages and namespace packages. Regular packages are traditional packages as they existed in Python 3.2 and earlier. A regular package is typically implemented as a directory containing an
__init__.py
file. When a regular package is imported, this__init__.py
file is implicitly executed, and the objects it defines are bound to names in the package’s namespace. The__init__.py
file can contain the same Python code that any other module can contain, and Python will add some additional attributes to the module when it is imported.
But just click the link, it contains an example, more information, and an explanation of namespace packages, the kind of packages without __init__.py
.
Python - why can I import modules without __init__.py at all?
I think this is a good 'answer' for what I didn't understand.
myMath/
__init__.py
adv/
__init__.py
sqrt.py
fib.py
add.py
subtract.py
multiply.py
divide.py
myMath/__init__.py
from add import add
from divide import division
from multiply import multiply
from subtract import subtract
from adv.fib import fibonacci
from adv.sqrt import squareroot
index.py
import sys
sys.path.append('C:\Users\mdriscoll\Documents')
import mymath
print mymath.add(4,5)
print mymath.division(4, 2)
print mymath.multiply(10, 5)
print mymath.fibonacci(8)
print mymath.squareroot(48)
python __import__ all files in folder not working
Your are not defining test_samp
you are defining modules['test_samp']
. Plus if it's in scripts you need to import scripts.test_samp
in yor case use a package.Add an empty (or not) __init__.py
(with 2 underscores). and use import scripts
. Access your function with scripts.test_samp.function("test")
. And you could use reload(scripts)
to reload all of the package.
Python How To Import And Use Module With One Line
You always need the import, however you can still use semi-colons to separate statements, but why would you do that?
from urllib.request import urlopen; print(int(str(urllib.request.urlopen("http://ir.eia.gov/ngs/wngsr.txt").read()).split("\\n")[4].split(" ")[2]))
# note the semi-colon ^
Related Topics
How to Find Out Whether a File Is at Its 'Eof'
Delete File from Zipfile with the Zipfile Module
How to Stop Numpy from Multithreading
Python - How to Check List Monotonicity
Saving the State of a Program to Allow It to Be Resumed
How to Make Custom Legend in Matplotlib
How Could I Use Batch Normalization in Tensorflow
Datetime Timezone Conversion Using Pytz
Why Do Attribute References Act Like This with Python Inheritance
How to Create an Incrementing Filename in Python
Is There Any Built-In Way to Get the Length of an Iterable in Python
String Formatting: Columns in Line
Saving Upload in Flask Only Saves to Project Root
How to Access a File's Properties on Windows
How Does Keras Calculate the Accuracy
Target Wsgi Script Cannot Be Loaded as Python Module
Why Can't I Use the Method _Cmp_ in Python 3 as for Python 2