To begin with: what are these magical creatures? Well, a module is essentially just a file with some Python code in it. You can import this file into another Python script using the `import` statement. For example:
# my_module.py
# This is a module that contains a function to print "Hello!"
def say_hello():
print("Hello!")
# main.py
# This is the main script that will import the my_module module and use its function to print "Hello!"
import my_module # Importing the my_module module
my_module.say_hello() # Calling the say_hello() function from the my_module module
This is a basic example, but you can also import specific functions or classes from the module using `from … import …`.
Now, packages. A package is just a directory with some Python code in it (and possibly other directories and files). You can install this package into your system-wide library by running:
# This script installs a package called "my_package" using the pip command.
# Pip is a package management system used to install and manage software packages written in Python.
# The following command uses the "install" option to install the "my_package" package.
# This will download and install the package from the Python Package Index (PyPI) repository.
pip install my_package
# After the package is installed, it can be imported and used in Python scripts.
# This allows access to the functions and classes within the package.
# Importing specific functions or classes can be done using the "from ... import ..." syntax.
# This allows for more efficient use of the package by only importing what is needed.
# For example, "from my_package import function_name" would import only the specified function.
# This is useful when working with large packages that contain many functions and classes.
# It also helps to avoid naming conflicts with other packages or modules.
# Packages are essentially directories with Python code in them, and can contain other directories and files.
# They can be installed into the system-wide library by running the "pip install" command.
# This makes the package accessible to all Python scripts on the system.
# However, packages can also be installed locally within a specific project or virtual environment.
# This allows for better organization and management of packages for different projects.
# To install a package locally, the "pip install" command can be used with the "-t" option, followed by the desired installation directory.
# For example, "pip install -t /path/to/project/directory my_package" would install the package into the specified project directory.
# This is useful when working on multiple projects that require different versions of the same package.
# It also allows for easier sharing and collaboration on projects.
# Overall, packages are an important aspect of Python development and are essential for building complex and efficient applications.
Or you can create a virtual environment to keep things organized and avoid conflicts. To do that, run:
# This script creates a virtual environment, installs necessary packages, and deactivates the environment afterwards.
# Create a virtual environment named "env" using the python3 module "venv"
python3 -m venv env
# Activate the virtual environment by sourcing the "activate" script in the "bin" directory of the "env" folder
source env/bin/activate
# Upgrade pip, setuptools, and wheel to the latest versions
pip install --upgrade pip setuptools wheel
# Install the package "my_package" using pip
pip install my_package
# Deactivate the virtual environment
deactivate
This will create a new environment called `env`, activate it (so you can use the package without having to prefix every command with `(env)`), and then upgrade your pip, setuptools, and wheel packages. After that, you can install any other packages you need for this project using `pip`.
Now how to create a package. First, create a new directory called `my_package` (or whatever name you want). Inside of it, create a file called `__init__.py`, which is required for Python to recognize the directory as a package:
# Creating a package in Python
# First, we need to import the necessary module to create a directory and file
import os
# Next, we define a function to create a new directory for our package
def create_package(name):
# We use the os module to create a new directory with the given name
os.mkdir(name)
# We then change the current working directory to the newly created one
os.chdir(name)
# We create a new file called __init__.py, which is required for Python to recognize the directory as a package
open("__init__.py", "w+")
# We print a message to confirm that the package has been created
print("Package created successfully!")
# Now we can call our function and pass in the desired name for our package
create_package("my_package")
# Finally, we define a function to print a simple greeting
def say_hello():
# We use the print() function to display the message "Hello!"
print("Hello!")
# We can now import our package and call the say_hello() function
import my_package
my_package.say_hello()
# Output: Hello!
Now let’s add some more files and directories inside of `my_package`. For example, you could create a new file called `utils.py`, which contains some utility functions:
# my_package/utils.py
# This script is used to create a new file called `utils.py` inside the `my_package` directory, which contains utility functions.
# Importing the datetime module to use its functions
import datetime
# Defining a function called `get_current_time` which takes no parameters
def get_current_time():
# Using the `now()` function from the datetime module to get the current date and time
current_time = datetime.datetime.now()
# Using the `strftime()` function to format the current time in the specified format
formatted_time = current_time.strftime("%Y-%m-%d %H:%M:%S")
# Returning the formatted time as a string
return formatted_time
And you could create a new directory called `submodule`, which contains some more code:
# This script creates a new directory called `submodule` within the `my_package` directory.
# It then creates two new files within the `submodule` directory.
# Create the `submodule` directory within `my_package`.
mkdir my_package/submodule
# Create an empty `__init__.py` file within the `submodule` directory.
touch my_package/submodule/__init__.py
# Create an empty `some_function.py` file within the `submodule` directory.
touch my_package/submodule/some_function.py
Inside of the `submodule/__init__.py` file, you can add some code to initialize your submodule:
# my_package/submodule/__init__.py
# This is the initialization file for the submodule within the my_package package.
# This function prints "Goodbye!" when called.
def say_goodbye():
print("Goodbye!") # This line prints the string "Goodbye!" to the console.
And inside of the `some_function.py` file, you could add a new function called `do_something()`:
# my_package/submodule/some_function.py
# This script is used to define a new function called do_something() within the some_function.py file in the my_package/submodule directory.
# Function definition for do_something()
def do_something():
# This function prints the string "Doing something..." when called.
print("Doing something...")
Now how to use your package in another Python script. First, make sure that you have installed it using `pip`. Then, import the module and call its functions:
# main.py
# Importing the my_package module
import my_package
# Calling the say_hello function from the my_package module
my_package.say_hello()
# Printing the current time using the get_current_time function from the utils submodule within the my_package module
print(my_package.utils.get_current_time())
# Calling the do_something function from the submodule within the my_package module
my_package.submodule.do_something()
# Calling the say_goodbye function from the submodule within the my_package module
my_package.submodule.say_goodbye()
# The purpose of this script is to demonstrate how to use the functions within the my_package module in another Python script.
# First, the module is imported and then its functions are called using the dot notation.
# The utils and submodule within the my_package module are also accessed using dot notation to call their respective functions.
And that’s it! You now have a package with multiple modules and submodules, which you can use in your other Python scripts.