Shipsar Tutorials

whenever life put's you in a tough situtation, never say why me! but, try me!

Understanding Python Modules

In this module, we will explore Python's module system, which allows for code reusability and logical organization. You will learn what modules are, how to import and use built-in modules, how to create your own custom modules, and how Python searches for these modules during runtime.

Subtopic 1: What are Modules?

A module is simply a file containing Python definitions and statements. This file can define functions, classes, and variables, and include runnable code. When you write a Python file, you are essentially creating a module. The name of the module is the name of the Python file, with the .py extension removed.

Example of a Basic Module:

Let's say you have a file named math_operations.py:

# math_operations.py

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

Here, math_operations.py is a module that defines two functions: add() and subtract(). This file can now be imported and used in other Python programs.

Subtopic 2: Importing and Using Built-in Modules

Python comes with many built-in modules that you can use without needing to install anything. To use a module, you simply import it into your code.

Syntax for Importing Modules:
import module_name
Example 1: Importing and Using the math Module
import math

result = math.sqrt(16)  # Using the sqrt() function from the math module
print(result)  # Output: 4.0
Explanation:
  • The math module provides access to mathematical functions. Here, math.sqrt(16) calculates the square root of 16.
Example 2: Importing Specific Functions from a Module
from math import pi, sqrt

print(pi)  # Output: 3.141592653589793
print(sqrt(25))  # Output: 5.0
Explanation:
  • By using the from ... import ... syntax, you can import specific functions or variables from a module, reducing the amount of code needed.
Example 3: Using Aliases for Modules
import numpy as np

arr = np.array([1, 2, 3])
print(arr)  # Output: [1 2 3]
Explanation:
  • You can give a module an alias using the as keyword. This is useful for modules with long names or to avoid naming conflicts.

Subtopic 3: Creating and Using Custom Modules

In addition to using built-in modules, you can create your own custom modules. This is useful for organizing and reusing your code in multiple programs.

Steps to Create and Use a Custom Module:
  1. Create a Python file that contains functions or classes you want to reuse. For example, let's create a module named string_utils.py:
# string_utils.py

def reverse_string(s):
    return s[::-1]

def capitalize_words(s):
    return ' '.join(word.capitalize() for word in s.split())
  1. To use this module in another file, you can import it:
# main.py
import string_utils

print(string_utils.reverse_string("hello"))  # Output: "olleh"
print(string_utils.capitalize_words("hello world"))  # Output: "Hello World"
Explanation:
  • The string_utils.py file defines two functions, reverse_string() and capitalize_words().
  • We import string_utils in main.py and use the functions as string_utils.reverse_string() and string_utils.capitalize_words().

Subtopic 4: Understanding the Python Module Search Path

When you import a module, Python searches for it in specific directories. This search is done in the following order:

  1. Current directory: Python first checks if the module exists in the current directory (i.e., the directory where the script is being run).
  2. Standard library directories: If the module is not found locally, Python will search the directories where built-in modules are stored (standard library).
  3. Third-party packages: Python also searches in the directories where third-party packages are installed (e.g., those installed using pip).
  4. Environment variables: The search path can be modified using the PYTHONPATH environment variable, which can include additional directories to search.

You can view the module search path in Python by importing the sys module and printing sys.path.

Example: Viewing Module Search Path
import sys

print(sys.path)

Output:

['/path/to/current/directory', '/usr/lib/python3.8', '/usr/local/lib/python3.8', ...]
Explanation:
  • sys.path is a list that contains all the directories where Python will search for modules. The first entry is the current directory, followed by directories for Python's standard library, and directories for third-party packages.

You can also add directories to the search path manually:

import sys
sys.path.append('/path/to/my/modules')

This would allow Python to search for modules in the specified directory as well.

Tasks

  1. Task 1: Create and Use a Custom Module

    • Create a module that contains a function multiply(a, b) that returns the product of a and b. Then, import this module and use the function in another file.
    # create a file math_ops.py
def multiply(a, b):
    return a * b

  2. Task 2: Use Built-in Module

    • Use the random module to generate a random integer between 1 and 100 and print the result.
    import random
print(random.randint(1, 100))

  3. Task 3: Use Aliases for Modules

    • Import the datetime module with an alias dt and print the current date and time using the alias.
    import datetime as dt
print(dt.datetime.now())

  4. Task 4: Modify Python Module Search Path

    • Add a new directory to the Python module search path and import a module from that directory.
    import sys
sys.path.append('/path/to/your/modules')
import your_module

  5. Task 5: Using math Module

    • Use the math module to calculate the area of a circle with a radius of 5 using the formula area = π * r^2.
    import math
radius = 5
area = math.pi * (radius ** 2)
print(area)

  6. Task 6: Create and Import a Custom String Module

    • Create a module string_utils.py that has a function count_vowels(s) which counts the number of vowels in a given string s. Import and use this function in another script.
    # string_utils.py
def count_vowels(s):
    return sum(1 for char in s if char in 'aeiouAEIOU')

# main.py
import string_utils
print(string_utils.count_vowels("hello"))  # Output: 2