Modules are a great way to keep your code well organized, as they allow you to reuse your code across multiple files. You can also make use of the many useful modules included in Python's extensive standard library.
A module is simply a file containing Python definitions and statements, and it has a file extension of
.py. You can import modules into other modules in order to make use of the code that the imported modules contain.
Python also comes with a library of standard modules. Some modules are built into the Python interpreter, which means that you can use them immediately.
Here's an example, where we import the
random module in order to generate a random number:
We import the
random module because it contains code that we require. Specifically, it contains the
randint() function that generates the random number.
If we didn't use
import random we would've ended up with NameError: name 'randint' is not defined being returned instead of the random number.
Also notice that we prepend the function name with its module name, separated by a dot (
random.randint()). This is required due to the fact that we only specified
random when importing the module. We didn't specify the functions within that module, so we need to qualify our function call with the module name.
There are a couple of other ways of doing this though.
Assign a Local Name
If you don't like prefixing functions with the module name, you can assign it a local name. This allows you to call that function without the prefix.
Here's how to do that:
Variation of the
There's a variation of the
import statement that allows you to name the functions to import from the module. When you do this, you can call the functions without having to qualify them with the module name.
It goes like this:
You can import multiple functions by separating them with a comma:
Create a Module
Let's take the two functions that we created previously and put them into a new module called
So here's what
calculations.py looks like:
Now we can call that module and its functions from within another file. Note that you don't need to specify the
.py when importing the module.
Here's an example of importing our new module and then calling its functions.
800591878564 1312 320775 0.3292806484295846 -662
The above code example assumes that the module is in the current folder or the module search path.
You can put your modules into folders so that they're well organized. You could create one folder for all modules, or you could create multiple folders, each for a different group of modules. Either way, the process for accessing them is the same.
To access modules within a folder, you can use dot (
For example, if we move the above
calculations.py file to a folder called
mypackage, we can access the module using
mypackage.calculations. So we would change the first line of the above example to this:
You can nest packages inside each other. If you do this, simply use dot notation for the full path. So if your module path was inside a second level package, you'd use something like this
There's an important thing to remember when creating packages. Each package must contain a file called
This file is required before Python treats it as a package. This can be an empty file, but it can also execute initialization code for the package or set the
So the first thing to do when creating a package is to create an empty
__init__.py file. Of course, you can add code to it if you need to, but if you have no code to add, just leave it empty.
So your package structure might look something like this:
mypackage/ __init__.py package1/ __init__.py module1.py module2.py package2/ __init__.py module1.py module2.py
Try to give your packages and modules concise but descriptive names. Don't call them
module1 etc like I've done here. I've only done that to demonstrate the concept of packages.
Other ways to Import Packages
There's more than one way to import a package (or a module inside a package). The method you use will determine whether or not you need to prefix your function names with the module and/or package name.
Here are the variations:
Module Search Path
When you (try to) import a module, the interpreter goes through a process to look for it. The interpreter first searches for a built-in module of that name. If not found, it then searches for a file of that name in a list of directories given by the
sys.path variable. The
sys.path variable is initialized from these locations:
- The directory containing the input script (or the current directory when no file is specified).
PYTHONPATH(a list of directory names, with the same syntax as the shell variable
- The installation-dependent default.