Python imports load reusable code from modules and packages. Start with the core import syntax, then install third‑party libraries when needed, control the search path for local code, and apply a few best practices from the Python documentation.

Option: Basic Import Syntax

These patterns cover most day‑to‑day imports.

Import a module.

import math

Access members with dot notation.

area = math.pi * (2 ** 2)

Import specific names when you frequently use a few items.

from math import sqrt, factorial
r = sqrt(49)

Use an alias for long names or established conventions.

import numpy as np
arr = np.array([1, 2, 3])

Avoid wildcard imports.

Using from module import * pollutes the namespace and makes code harder to read and debug.

Approach: Install Third‑Party Libraries

When a module isn’t part of the standard library, install it with pip in an isolated environment. The full workflow is outlined in the PyPA tutorial.

Create a virtual environment.

# Unix/macOS
python3 -m venv .venv

# Windows
py -m venv .venv

Activate the environment.

# Unix/macOS
source .venv/bin/activate

# Windows
.\.venv\Scripts\activate

Install the package with pip.

python -m pip install requests

Verify the import.

import requests
print(requests.__version__)

Method: Control the Module Search Path

Python looks for modules in directories listed in sys.path.

Inspect the current search path.

import sys, pprint
pprint.pprint(sys.path)

Add a local directory at runtime only when necessary.

import sys
sys.path.append("/path/to/my_modules")  # temporary during this process

Prefer a package structure for your code.

# my_app/
# ├── my_app/
# │   ├── __init__.py
# │   ├── helpers.py
# │   └── mathutils.py
# └── main.py

# In main.py
from my_app.mathutils import hypotenuse

Way: Import from Packages

Use dotted names to reach submodules and items inside packages.

Import a submodule with its full path.

import package.subpackage.module as mod
mod.run()

Import a symbol directly from a submodule.

from package.subpackage.module import run
run()

Keep imports at the top level of files for clarity.

Top‑level imports make dependencies obvious and avoid circular import traps in most cases.

Path: Reload a Module During a Session

In interactive sessions, reload a changed module with importlib.reload().

Import the module once.

import mymodule

Edit and save mymodule.py in your editor.

Edits don’t apply automatically to already imported modules.

Reload the module to pick up changes.

import importlib
importlib.reload(mymodule)

Troubleshooting Import Errors

Resolve ModuleNotFoundError by installing the package or activating the correct environment.

# Activate the right venv, then:
python -m pip install <package>

Fix ImportError: cannot import name ... by checking the symbol and its location.

Confirm the item exists in that module, check for typos and case, and import from the correct submodule.

Avoid module shadowing by renaming files that collide with library names.

A local file like math.py will hide the standard library math module.

Restart the interpreter when imports behave unexpectedly.

Python imports a module once per process; a restart resets state cleanly.

Best practices

Keep imports at the top of the file in three groups: standard library, third‑party, then local modules.
Prefer import module with dot notation for readability.
Use aliases only when they are conventional (for example, numpy as np).
Avoid from module import * in production code.
Use virtual environments to isolate dependencies per project.

With these patterns, you can import built‑ins, pull in third‑party libraries, and structure local code so imports stay fast and predictable.