Import a Python package
As you have already seen, to make use of a Python module in the Python Standard Library you can use the syntax that you are already familiar with:
For example, if you want to use the
os module from the Python Standard Library to print the current working directory of a process, you could create a file called
script.py with the following contents:
You could then run
script.py from the terminal using
python script.py :
~ → python script.py /Users/george ~ →
In the script we import the entire
os module and make use of a piece of its functionality by calling
As an alternative to this, we can instead choose to
import selected functionality from the
os package as follows:
from os import getcwdprint(getcwd())
We import third-party Python packages into Python files in the same way as we import modules from the Python Standard Library into Python files. For example, we could make use of the
numpy package to round numbers up and down.
First, let’s install
numpy by running
pip install numpy from the command line terminal:
→ pip install numpy Collecting numpy Using cached https://files.pythonhosted.org/packages/5c/f5/0e5e57fa7683cf0e5036320f4676cd7e3dbd9ab8c17ada541c2bb5ebed5e/numpy-1.19.0-cp37-cp37m-macosx_10_9_x86_64.whl Installing collected packages: numpy Successfully installed numpy-1.19.0 ~ →
Now, we can
numpy in a Python script and use it to round some numbers up and down. Create a Python script called
number_rounding.py and put the following code into your script:
As you can see, we
import the third-party
numpy Python package in the same way as we would
import modules in the Python Standard Library such as
re . Running
number_rounding.py should generate the following output:
→ python number_rounding.py 2.0 2.0 1.0 ~ →
Import everything from a Python package
An alternative to using the
import <package> syntax is to instead
import everything from a package using
from <package> import * . This can be useful when you are using the Python shell, because it means you can type less.
For example, let’s start by opening the Python shell by typing
python in the command line terminal:
→ python Python 3.7.1 (default, Dec142018, 13:28:58) [Clang 4.0.1 (tags/RELEASE_401/final)] :: Anaconda, Inc. on darwin Type "help", "copyright", "credits" or "license" for more information. >>>
import everything from the
numpy package using
from numpy import * :
→ python Python 3.7.1 (default,Dec142018,13:28:58) [Clang 4.0.1 (tags/RELEASE_401/final)] :: Anaconda, Inc. on darwin Type "help", "copyright", "credits" or "license" for more information. >>> from numpy import * >>>
Now, we can use the
floor() methods without having to prefix them with
→ python Python 3.7.1 (default, Dec142018, 13:28:58) [Clang 4.0.1 (tags/RELEASE_401/final)] :: Anaconda, Inc. on darwin Type "help", "copyright", "credits" or "license" for more information. >>> from numpy import * >>> ceil(1.2) 2.0 >>> floor(1.2) 1.0
from <package> import * in the Python shell is fine, it generally isn’t considered good practice in application source code. If you use
from <package_a> import * and
from <package_b> import * and there is a name clash between functionality in
package_a and functionality in
package_b , then this might result in unintended consequences.
When importing packages you also have the option to
import them with an alias using the command
import <package> as <alias> . Strangely, this is industry standard for some packages, but would be considered unconventional for other packages.
For example, it is in fact industry standard to
import numpy as np . If we apply this style of
number_rounding.py , it would become:
import numpy as npprint(np.ceil(1.2))print(np.ceil(1.933))print(np.floor(1.2))
It’s functionality remains unchanged, so when we run it using Python the output is exactly the same:
→ python number_rounding.py 2.0 2.0 1.0 ~ →
np alias in this case means that for large applications with lots of source code, the code becomes slightly easier to read and understand, and thus more maintainable/extendable.
You can choose to use any alias you wish, but it is generally best to use something which could be considered shorthand for the package name. Using
import numpy as apples wouldn’t make much sense, for example!
For a bit more information around importing Python packages, check out this screencast:
Now that you have completed this chapter you should be confident with the following tasks:
importPython packages into Python files in the same way as importing modules from the Python Standard Library.
It is good practice to become familiar with, and accustomed to, a variety of methods for importing modules and packages and then choosing the most appropriate
importmethod for your particular use case.
Now that you are more confident with importing packages and modules into Python files, let’s take a look at why versioning of packages is so important in software development.