What’s the difference between a Python module and a Python package?
See also: What's the difference between "package" and "module" (for other languages)
A module is a single file (or files) that are imported under one import and used.
A package is a collection of modules in directories that give a package hierarchy.
from my_package.timing.danger.internets import function_of_love
Any Python file is a module, its name being the file’s base name without the
.py extension. A package is a collection of Python modules: while a module is a single Python file, a package is a directory of Python modules containing an additional
__init__.py file, to distinguish a package from a directory that just happens to contain a bunch of Python scripts. Packages can be nested to any depth, provided that the corresponding directories contain their own
The distinction between module and package seems to hold just at the file system level. When you import a module or a package, the corresponding object created by Python is always of type
module. Note, however, when you import a package, only variables/functions/classes in the
__init__.py file of that package are directly visible, not sub-packages or modules. As an example, consider the
xml package in the Python standard library: its
xml directory contains an
__init__.py file and four sub-directories; the sub-directory
etree contains an
__init__.py file and, among others, an
ElementTree.py file. See what happens when you try to interactively import package/modules:
>>> import xml >>> type(xml) <type 'module'> >>> xml.etree.ElementTree Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'module' object has no attribute 'etree' >>> import xml.etree >>> type(xml.etree) <type 'module'> >>> xml.etree.ElementTree Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'module' object has no attribute 'ElementTree' >>> import xml.etree.ElementTree >>> type(xml.etree.ElementTree) <type 'module'> >>> xml.etree.ElementTree.parse <function parse at 0x00B135B0>
In Python there also are built-in modules, such as
sys, that are written in C, but I don’t think you meant to consider those in your question.
From the Python glossary:
It’s important to keep in mind that all packages are modules, but not all modules are packages. Or put another way, packages are just a special kind of module. Specifically, any module that contains a
__path__attribute is considered a package.
Python files with a dash in the name, like
my-file.py, cannot be imported with a simple
import statement. Code-wise,
import my-file is the same as
import my - file which will raise an exception. Such files are better characterized as scripts whereas importable files are modules.
A late answer, yet another definition:
A package is represented by an imported top-entity which could either
be a self-contained module, or the
__init__.pyspecial module as the
top-entity from a set of modules within a sub directory structure.
So physically a package is a distribution unit, which provides one or more modules.
First, keep in mind that, in its precise definition, a module is an object in the memory of a Python interpreter, often created by reading one or more files from disk. While we may informally call a disk file such as
a/b/c.py a “module,” it doesn’t actually become one until it’s combined with information from several other sources (such as
sys.path) to create the module object.
(Note, for example, that two modules with different names can be loaded from the same file, depending on
sys.path and other settings. This is exactly what happens with
python -m my.module followed by an
import my.module in the interpreter; there will be two module objects,
my.module, both created from the same file on disk,
A package is a module that may have submodules (including subpackages). Not all modules can do this. As an example, create a small module hierarchy:
$ mkdir -p a/b $ touch a/b/c.py
Ensure that there are no other files under
a. Start a Python 3.4 or later interpreter (e.g., with
python3 -i) and examine the results of the following statements:
import a a ⇒ <module 'a' (namespace)> a.b ⇒ AttributeError: module 'a' has no attribute 'b' import a.b.c a.b ⇒ <module 'a.b' (namespace)> a.b.c ⇒ <module 'a.b.c' from '/home/cjs/a/b/c.py'>
a.b are packages (in fact, a certain kind of package called a “namespace package,” though we wont’ worry about that here). However, module
a.b.c is not a package. We can demonstrate this by adding another file,
a/b.py to the directory structure above and starting a fresh interpreter:
import a.b.c ⇒ ImportError: No module named 'a.b.c'; 'a.b' is not a package import a.b a ⇒ <module 'a' (namespace)> a.__path__ ⇒ _NamespacePath(['/.../a']) a.b ⇒ <module 'a.b' from '/home/cjs/tmp/a/b.py'> a.b.__path__ ⇒ AttributeError: 'module' object has no attribute '__path__'
Python ensures that all parent modules are loaded before a child module is loaded. Above it finds that
a/ is a directory, and so creates a namespace package
a, and that
a/b.py is a Python source file which it loads and uses to create a (non-package) module
a.b. At this point you cannot have a module
a.b is not a package, and thus cannot have submodules.
You can also see here that the package module
a has a
__path__ attribute (packages must have this) but the non-package module
a.b does not.
I read the different answers given to this question. The issue is fully covered. But it seems to me that making an extra point may not be a bad idea. If we examine the value of __package__ for different modules, we reach the following result. All of them are module types but for some of them the package is not defined. Check __package__ for "random" and "math".
import cv2 import math import random import tkinter as tk print('cv2:',type(cv2)) # <class 'module'> print('cv2:',cv2) # <module 'cv2.cv2' from 'PATH'> print('cv2:',cv2.__package__) # cv2 print('random:',type(random)) # <class 'module'> print('random:',random) # <module 'random' from 'PATH'> print('random:',random.__package__) # [EMPTY] print('tk:',type(tk)) # <class 'module'> print('tk:',tk) # <module 'tkinter' from 'PATH'> print('tk:',tk.__package__) # tkinter print('math:',type(math)) # <class 'module'> print('math:',math) # <module 'math' (built-in)> print('math:',math.__package__) # [EMPTY]
So if we define a folder as follows:
This is how we can see the __package__ output:
import myfolder import myfolder.script1 as s1 import myfolder.script2 as s2 import myfolder.mySubfolder.script3 as s3 print(type(s1)) # <class 'module'> print(type(s2)) # <class 'module'> print(type(s3)) # <class 'module'> print(s1.__package__) # myfolder print(s2.__package__) # myfolder print(s3.__package__) # myfolder.mySubfolder print(myfolder) # <module 'myfolder' (namespace)> print(myfolder.mySubfolder) # <module 'myfolder.mySubfolder' (namespace)> print(myfolder.mySubfolder.script3) # <module 'myfolder.mySubfolder.script3' from 'PATH'> print(myfolder.__package__) # myfolder print(myfolder.mySubfolder.__package__) # myfolder.mySubfolder print(myfolder.mySubfolder.script3.__package__) # myfolder.mySubfolder
The other answers here may still be a bit vague, so I’m posting a hopefully clearer answer. It’s important to note that the title of the question is also a bit misleading in the first place, and a better title in my opinion would be: "What is special about package modules compared to regular modules?".
Packages are modules too, they are however, a special type of them. Special in the sense that 1. they are "directories" and 2. they may contain special files such as
The point is, packages are a special type of modules, so we need to understand modules in general first, and then what’s special about the package modules will make sense too. (Notice: I’ll sometimes refer to "package modules" in this answer as just "packages", and vice versa)
So let’s talk about modules in general first, as it would be less vague / easier to understand. There are basically two things that we do with modules, we either import them in other modules, or execute them directly by Python.
Importing a module has a single obvious goal, accessing what that module has inside.
Executing a module however, usually pursues one of these two goals:
Let’s make more sense of all these through some examples:
# bar.py def talk(): print("bar")
# foo.py import bar # <-- importing module "bar" bar.talk() # <-- prints "bar"
Let’s assume that the
foo.py module in the example above, is a main module that starts our program. We can run it by typing this command in the terminal:
python3 foo.py # <-- executing a main module and then it will start our program.
Let’s assume that we want to try the function
talk in the
bar.py module in the example above, without running our whole program, i.e., without calling the module
foo.py. For that, we’ll have to slightly change the
# bar.py def talk(): print("bar") if __name__ == '__main__': talk()
Now run this command in the terminal:
python3 bar.py # <-- trying functionalities of a module in isolation and then it will print
Now that we know what we can do with modules in general, let’s return to the main question:
__init__.pyfile in its directory, and if you want to "execute" a package module, you’ll have to put the execution code of it in a
__main__.pyfile in its directory.
And here’s the final example for the explanation above:
# hierarchy of files and folders: . ├── bar_pack/ │ ├── __init__.py │ ├── __main__.py │ foo.py
# bar_pack/__init__.py def talk(): print("bar")
# bar_pack/__main__.py import __init__ __init__.talk()
# foo.py import bar_pack # <-- importing package module "bar_pack" bar_pack.talk() # <-- prints "bar"
# Run this command in the terminal: python3 bar_pack # <-- executing the package module "bar_pack", prints "bar"
I know, it’s too late, but a simple answer which would be sufficient for some is:
a module is a file,
a package is a folder.
Module: A module is a simple Python file with a (
.py) extension that contains collections of functions and global variables. It is an executable file, and the notion of Package in Python is used to arrange all of the modules.
For an Example: Save the code in a file called demo (
def myModule1(name): print("My Module name is: "+ name)
Import the demo module module and use the myModule1 function within it.
import demo_module demo_module.myModule1("Math")
My Module name is: Math
Package: A package is a basic directory that contains a collection of modules. This directory contains Python modules as well as a (
__init .py__) file that the interpreter uses to recognize it as a Package. The package is nothing more than a namespace. Within the package, there are sub-packages.
For an Example:
A package is a set of modules organized into directories to form a package directory.
from Student import details, collegeDetails, demo_module