Python import modules in another file

Question

I'm currently re-factoring a project (formerly big one file) into several seperate python files, each of which runs a specific part of my application. Eg, GUIthread.py runs the GUI, Computethread.py does some maths, etc etc.

Each thread includes the use of functions from imported modules like math, time, numpy, etc etc.

I already have a file globalClasses.py containing class definitions for my datatypes etc, which each .py file imports at the start, as per recomendation here: http://effbot.org/pyfaq/how-do-i-share-global-variables-across-modules.htm . This is working well.

What I would like to do is have all my 3rdparty module imports in the globals file as well, so that I can write, for example, import math once but have all of my project files able to use math functions.

Questions:

1. Is this possible?

2. Is it a good idea/is it good Python practice?

My current solution is just to put

import math 
import time
import numpy
...

(plus imports for all the other modules I'm using as well)

at the top of every file in my project... But that doesn't seem very tidy, and it's easy to forget to move a dependency's import statement when moving code-chunks from file to file...

Answer 1

Yeah I guess there is a more elegant way of doing this which will save redundant line of code. Suppose you want to import some modules math, time, numpy(say), then you can create a file importing_modules(say) and import the various modules as from module_name import *, So the importing_modules.py may look something like this:

importing_modules.py

from math import *
from numpy import *
from time import *

main.py

from importing_modules import *
#Now you can call the methods of that module directly
print sqrt(25) #Now we can call sqrt() directly in place of math.sqrt() or importing_modules.math.sqrt().

Answer 2

The other answer shows how what you want is (sort of) possible, but didn't address your second question about good practice.

Using import * is almost invariably considered bad practice. See "Why is import * bad?" and "Importing * from a package" from the docs.

Remember from PEP 20 that explicit is better than implicit. With explicit, specific imports (e.g. from math import sqrt) in every module, there is never confusion about from where a name came, your module's namespace includes only what it needs, and bugs are prevented.

The downside of having to write a couple import statements per module does not outweigh the potential problems introduced by trying to get around writing them.