Overview: Importing from Python Packages
In the previous tutorial, you learned how to create Python packages, organize related modules, and use the __init__.py file. Now it is time to learn how to import packages and their contents into your Python programs.
In this tutorial, you will learn Importing from Python Packages step by step. You will understand how to import an entire package, import modules from a package, import specific members, import multiple members, and use aliases to make your code easier to read.
By the end of this tutorial, you will be able to import packages and their contents confidently while keeping your Python programs organized and easy to maintain.
Quick Navigation
You can use the links below to jump directly to any topic covered in this tutorial.
- Introduction: Importing from Python Packages
- Importing an Entire Python Package
- Importing a Module from a Python Package
- Importing Specific Members from a Python Package
- Importing Multiple Members
- Using Aliases While Importing
- Example: Importing Members from a Python Package
- Common Mistakes When Importing from Python Packages
- Key Takeaways: Importing from Python Packages
Introduction: Importing from Python Packages
As Python projects grow, related modules are often grouped into packages to keep the project organized. After creating a package, the next step is learning how to import it and use its contents in other Python programs.
Python provides several ways to import from packages. You can import an entire package, import a specific module, import selected members such as functions or classes, or use aliases to make long import statements easier to work with.
Choosing the right import method makes code easier to read, reduces unnecessary typing, and helps organize larger projects more effectively.
Real-World Analogy
Imagine a library with different sections for science, history, and literature. You can visit an entire section, pick a particular shelf, or borrow only the book you need.
Importing from Python packages works in a similar way. You can import an entire package, access one of its modules, or import only the specific members your program requires.
Importing an Entire Python Package
The simplest way to use a package is to import the entire package using the import statement.
Suppose the project has the following structure.
project/
│
├── main.py
└── utilities/
├── __init__.py
├── calculator.py
└── validator.py
main.py
import utilities
print("Package imported successfully.")
# Output
Package imported successfully.
Code Explanation
The statement import utilities imports the utilities package. During the import process, Python executes the package’s __init__.py file before making the package available to the program.
Importing an entire package is useful when the package performs initialization tasks or when its exported members are accessed through the package.
Importing a Module from a Python Package
Instead of importing an entire package, you can import a specific module when you need functionality from only one part of the package.
Suppose the package contains a module named calculator.py.
Project Structure
project/
│
├── main.py
└── utilities/
├── __init__.py
├── calculator.py
└── validator.py
calculator.py
def add(a, b):
return a + b
main.py
from utilities import calculator
print(calculator.add(20, 10))
# Output
30
Code Explanation
The statement from utilities import calculator imports the calculator module from the utilities package.
The add() function is then called using calculator.add(), which returns 30.
Importing only the required module helps keep your program organized and avoids importing parts of the package that are not needed.
Importing Specific Members from a Python Package
Sometimes, you only need a particular function, class, or variable from a module inside a package instead of importing the entire module.
Suppose the calculator.py module contains the following function.
calculator.py
def add(a, b):
return a + b
main.py
from utilities.calculator import add
print(add(20, 10))
# Output
30
Code Explanation
The statement from utilities.calculator import add imports only the add() function from the calculator module inside the utilities package.
Since the function is imported directly, it can be called using add() without writing calculator.add().
Importing only the required members helps keep your code concise and avoids importing unnecessary objects.
Importing Multiple Members
If you need more than one member from the same module, you can import them together in a single statement.
calculator.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
main.py
from utilities.calculator import add, subtract
print(add(10, 5))
print(subtract(10, 5))
# Output
15
5
Code Explanation
The statement from utilities.calculator import add, subtract imports both functions from the calculator module.
After importing them, both functions can be called directly without using the module name.
Importing multiple members in one statement keeps the code shorter and improves readability when several members from the same module are required.
Using Aliases While Importing
Python allows you to assign an alternative name, called an alias, while importing a package, module, or member. Aliases are useful when names are long, difficult to type, or could conflict with other names in your program.
main.py
from utilities.calculator import add as addition
print(addition(20, 10))
# Output
30
Code Explanation
The keyword as assigns the name addition to the imported add() function.
The original function name remains unchanged inside the package, but within main.py it is accessed using the alias addition().
Aliases improve code readability and help avoid naming conflicts when different modules contain members with the same name.
Example: Importing Members from a Python Package
The following example brings together the different import techniques covered in this tutorial.
Project Structure
project/
│
├── main.py
└── utilities/
├── __init__.py
├── calculator.py
└── validator.py
calculator.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
validator.py
def is_positive(number):
return number > 0
main.py
from utilities.calculator import add, subtract
from utilities.validator import is_positive
print(add(20, 10))
print(subtract(20, 10))
print(is_positive(15))
# Output
30
10
True
Code Explanation
The program imports the add() and subtract() functions from the calculator module and the is_positive() function from the validator module.
Each function is called directly without using the module name because the required members were imported individually.
This approach keeps the code clean and makes it easy to use only the members needed by the program.
Common Mistakes When Importing from Python Packages
Importing from Python packages is straightforward, but beginners often make a few common mistakes. Understanding these mistakes will help you avoid import errors and keep your programs organized.
- Using an incorrect package or module name in the import statement.
- Importing from the wrong module inside a package.
- Omitting the package name when importing a module from a package.
- Using the same alias for different imports, causing confusion.
- Importing unnecessary modules or members that are never used.
Writing clear import statements and organizing packages properly makes Python programs easier to read and maintain.
Key Takeaways: Importing from Python Packages
Here are the key points to remember:
- Python packages help organize related modules into a structured project.
- You can import an entire package or only the modules you need.
- You can import specific functions, classes, or variables from modules in a package.
- Multiple members can be imported using a single import statement.
- Aliases make import statements shorter and help avoid naming conflicts.
- Choosing the appropriate import method keeps code organized and easier to maintain.
You now know how to import packages, modules, and individual members in Python. In the next tutorial, you will learn how Python searches for modules and packages during the import process using the module search path.