A **Python
module** is a file containing Python definitions, functions, classes, and
statements. It allows you to logically organize your Python code and reuse it
across multiple programs. Modules help keep code organized, manageable, and
maintainable, especially in larger projects.
### Key
Concepts:
1. **What is
a Module?**
2. **Using
Modules**
3.
**Importing Specific Items from a Module**
4. **Creating
Your Own Module**
5.
**Built-in Modules**
6.
**Exploring Module Contents**
7. **Module
Aliases**
8. **The
`__name__` variable**
9. **Using
the `dir()` function**
10.
**Packages (Organizing Multiple Modules)**
### 1.
**What is a Module?**
A module is
simply a Python file with a `.py` extension that contains Python code
(functions, classes, and variables). Modules can be used to structure your code
into smaller, reusable pieces.
#### Example
of a simple module (`mymodule.py`):
```python
# mymodule.py
def
greet(name):
return f"Hello, {name}!"
pi = 3.14159
```
### 2.
**Using Modules**
To use a
module, you can import it into your Python program using the `import`
statement. Once imported, you can access the functions, variables, and classes
defined in the module.
####
Example:
```python
# Import the
module
import
mymodule
# Use the
function and variable from the module
print(mymodule.greet("Alice")) # Output: Hello, Alice!
print(mymodule.pi) # Output: 3.14159
```
### 3.
**Importing Specific Items from a Module**
You can
import specific functions, variables, or classes from a module using the `from`
keyword. This allows you to avoid prefixing everything with the module name.
####
Example:
```python
# Import
only the greet function
from
mymodule import greet
# Now you
can use greet directly without the module name
print(greet("Bob")) # Output: Hello, Bob!
```
You can also
import multiple items:
```python
from
mymodule import greet, pi
print(greet("Bob")) # Output: Hello, Bob!
print(pi) # Output: 3.14159
```
### 4.
**Creating Your Own Module**
You can
create your own module by saving a Python file with functions, classes, and
variables in the same directory as your script or in the Python `sys.path` so it
can be imported.
####
Example:
1. Create a
file called `mathmodule.py`:
```python
# mathmodule.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
```
2. Use it in
another Python file:
```python
import mathmodule
print(mathmodule.add(5, 3)) # Output: 8
print(mathmodule.subtract(5, 3)) # Output: 2
```
### 5.
**Built-in Modules**
Python
includes many built-in modules that provide various functionalities, such as
handling files, system operations, math, and more. You can use these modules
without having to write any additional code.
#### Example
of using the `math` built-in module:
```python
import math
print(math.sqrt(16)) # Output: 4.0
print(math.factorial(5)) # Output: 120
```
Other
examples of built-in modules:
- `os`:
Operating system-related functionality
- `sys`:
System-specific parameters and functions
-
`datetime`: Working with dates and times
- `random`:
Generating random numbers
### 6.
**Exploring Module Contents**
To see the
functions and variables defined in a module, you can use the `dir()` function.
####
Example:
```python
import math
print(dir(math)) # Lists all functions and variables in the
math module
```
This will
return a list of all the names defined in the `math` module, including built-in
attributes and methods.
### 7.
**Module Aliases**
You can give
a module an alias using the `as` keyword to make it easier to reference, especially
for longer module names.
####
Example:
```python
import math
as m
print(m.sqrt(25)) # Output: 5.0
```
In this
case, `math` is imported as `m`, so you can refer to `math` functions with `m.`
instead of `math.`.
### 8. **The
`__name__` Variable**
Every Python
module has a special built-in variable called `__name__`. When a module is run
directly, the value of `__name__` is `"__main__"`. However, if the
module is imported, the `__name__` is set to the module's name.
This is
useful for writing test code in a module that only runs when the module is
executed directly, not when it's imported.
#### Example:
```python
#
mymodule.py
def
greet(name):
return f"Hello, {name}!"
if __name__
== "__main__":
print(greet("World")) # This runs only if the module is executed
directly
```
When
`mymodule.py` is run directly, the `greet("World")` will execute, but
when the module is imported, this block of code will not run.
### 9.
**Using the `dir()` Function**
You can use
the `dir()` function to list all the names defined in a module, including its
functions, variables, and classes.
####
Example:
```python
import math
print(dir(math)) # Lists all attributes of the math module
```
The `dir()`
function helps in exploring what is available inside the module.
### 10.
**Packages (Organizing Multiple Modules)**
A
**package** is a way of organizing related modules into a directory hierarchy.
A package is simply a directory that contains multiple modules and a special
`__init__.py` file (which can be empty).
#### Example
of Package Structure:
```
mypackage/
__init__.py
# Makes it a package
module1.py
module2.py
```
To use a
package, you import it as follows:
```python
from
mypackage import module1
```
#### Example
of using a package:
1.
**Directory structure**:
```
mypackage/
__init__.py
mathmodule.py
stringmodule.py
```
2.
**`mathmodule.py`**:
```python
def add(a, b):
return a + b
```
3.
**`stringmodule.py`**:
```python
def greet(name):
return f"Hello, {name}!"
```
4. **Using
the package**:
```python
from mypackage import mathmodule,
stringmodule
print(mathmodule.add(10, 5)) # Output: 15
print(stringmodule.greet("Alice")) # Output: Hello, Alice!
```
### Summary:
- A
**module** in Python is a file containing Python code (functions, classes, and
variables) that can be imported and reused.
- You can
**import modules** using the `import` statement and access their contents using
dot notation (`module_name.item`).
- Built-in
Python modules like `math`, `os`, and `sys` offer pre-defined functionality
that can be readily used.
- You can
create **custom modules** by writing Python files and importing them.
-
**Packages** are directories of modules, and they help organize code across
multiple files and folders.
- Use the
`__name__` variable to control when certain code should run, and the `dir()`
function to explore the contents of a module.
Python
modules help you build clean, reusable, and organized code that scales well for
larger applications.
