Objective

In this unit, we will explore how to organize Python code using modules, packages, and libraries. We'll learn how to create, use, and import these components to enhance code reusability and maintainability. By the end of this unit, you'll be able to split your code into separate modules and packages, and leverage existing libraries to build more complex programs.

Modules

A module in Python is a file containing Python definitions and statements. It allows you to logically organize your code, making it more readable and maintainable.

Creating and Using Modules

You can create a module by saving your code in a file with a .py extension.

Here's an example of a module named shapes.py:

# shapes.py
def draw_square():
    print("Drawing a square")

You can import this module into another Python file using the import statement:

# main.py
import shapes

shapes.draw_square()  # Output: Drawing a square

Packages

A package in Python is a directory that contains multiple module files and a special __init__.py file. It's a way to organize related modules into a hierarchical structure.

Creating and Using Packages

You can create a package by organizing related modules into a directory and including an __init__.py file.

Here's a drawing package containing shapes.py:

drawing/
├── __init__.py
└── shapes.py

You can import modules from the package:

from drawing import shapes

shapes.draw_square()  # Output: Drawing a square

Libraries

A library is a collection of modules and packages that provide functionalities for various tasks. Python has a rich set of libraries, including the Python Standard Library, which comes with Python, and external libraries that can be installed.

External libraries are collections of modules and packages developed by the community to extend Python's functionality. These libraries can cover a wide range of functionalities, from web development and data analysis to machine learning and game development.

PyPI: The Python Package Index

PyPI is the central repository for Python packages. It hosts thousands of third-party libraries that can be easily installed and used in Python projects. PyPI ensures that the community has access to a vast array of tools and frameworks, promoting collaboration and code reusability.

You can browse PyPI at pypi.org to discover packages, read documentation, and see user ratings and download statistics.

Understanding the if __name__ == "__main__": Construct

When you're working with modules and packages in Python, you may come across a line of code that looks like this:

if __name__ == "__main__":
    # code to be executed

This construct is used to determine whether the Python file is being run directly or being imported as a module into another script.

To understand why this matter, it's important to be aware that importing a module actually runs all the code in that module. This can lead to unexpected behavior if the module contains code that you don't want to be executed when it's imported.

How Importing a Module Works

When you import a module in Python, the interpreter reads the module file and executes all the code in it. Any functions or classes defined in the module become available for use, but any code outside of functions or classes is also executed at the time of import.

This can be useful, but it can also lead to problems if the module contains code that you don't want to run when it's imported. For example, if the module includes code to connect to a database or perform some other action, that code will be run every time the module is imported.

The __name__ Variable

In Python, the special variable __name__ is used to determine if a Python file is the main program or if it is being used by another file as a module. When a Python script is executed, __name__ is set to "__main__" in that script. If the script is being imported into another script, __name__ is set to the name of the script/module.

Using if __name__ == "__main__":

By wrapping code inside an if __name__ == "__main__": block, you can ensure that it only gets executed when the script is run directly, not when it's imported as a module.

Example 1: Running the Script Directly

Consider a file named mymodule.py with the following code:

# mymodule.py

def my_function():
    print("This is my function.")

if __name__ == "__main__":
    print("This script is being run directly.")
    my_function()

If you run this script directly, the output will be:

This script is being run directly.
This is my function.

Example 2: Importing the Script as a Module

Now, consider another script called mymain.py that imports mymodule.py:

# mymain.py

import mymodule

mymodule.my_function()

When you run this script, the output will be:

This is my function.

Notice that the line "This script is being run directly." is not printed. That's because the code inside the if __name__ == "__main__": block is not executed when the mymodule.py script is imported as a module.

Why This Matters

Using if __name__ == "__main__": allows you to create modules that can be both used as standalone scripts and imported into other scripts without executing unwanted code. This promotes code reusability and helps you organize your code effectively.

By understanding how importing a module actually runs the code in that module, and by using the if __name__ == "__main__": construct to control what gets executed, you can write more modular and maintainable Python code.

Project: Split Your Turtle Drawing Code into Separate Modules and Import Them to Create a Cohesive Drawing

In this project, you'll take the turtle drawing code from previous units and split it into separate modules.

Step 1: Create Modules for Different Shapes

Create a new project directory called turtle_project.

• Inside this directory, create a folder named shapes.
• Inside the shapes folder, create two Python files: square.py and triangle.py.

square.py

import turtle

def draw_square(side_length):
    for _ in range(4):
        turtle.forward(side_length)
        turtle.right(90)

triangle.py

import turtle

def draw_triangle(side_length):
    for _ in range(3):
        turtle.forward(side_length)
        turtle.right(120)

Step 2: Create the Main Drawing File

Create a file named main.py inside the turtle_project directory. This file will import the shape modules and use them to draw a pattern.

main.py

from shapes.square import draw_square
from shapes.triangle import draw_triangle
import turtle

def draw_pattern():
    for _ in range(36):
        draw_square(100)
        turtle.right(10)
        draw_triangle(100)
        turtle.right(10)

turtle.speed(0)
draw_pattern()
turtle.done()

Step 3: Run the Project

Make sure you're in the turtle_project directory, and run the main.py file:

python main.py

You should see a pattern of squares and triangles drawn on the turtle screen.

This modular approach is a foundational concept in software development, and it's applicable to projects of all sizes. It promotes code reusability, collaboration, and maintainability, and it's a stepping stone to building more complex and robust applications.

In the next unit, we'll explore some of the most commonly used modules in the Python Standard Library and provide practical examples of how to use them.