Modular Programming with Python

Table of Contents

Modular Programming with Python

Credits

About the Author

About the Reviewer

www.PacktPub.com

eBooks, discount offers, and more

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Introducing Modular Programming

Introducing Python modules

Introducing Python packages

Using modules and packages to organize a program

Why use modular programming techniques?

Programming as a process

The Python Standard Library

Creating your first module

Caching

Writing a cache module

Using the cache

Summary

2. Writing Your First Modular Program

The inventory control system

Designing the inventory control system

The data storage module

The user interface module

The report generator module

The main program

Implementing the inventory control system

Implementing the data storage module

Implementing the user interface module

Implementing the report generator module

Implementing the main program

Summary

3. Using Modules and Packages

Modules and packages

Packages within packages

Initializing a module

Initialization functions

Initializing a package

How to import anything

What does the import statement actually do?

Using the import statement

Relative imports

Controlling what gets imported

Circular dependencies

Running modules from the command line

Summary

4. Using Modules for Real-World Programming

Introducing Charter

Designing Charter

Implementing Charter

Implementing the chart.py module

Implementing the generator.py module

The Pillow library

Renderers

Testing the code

Rendering the title

Rendering the x axis

The remaining renderers

Testing Charter

The fly in the ointment – changing requirements

Redesigning Charter

Refactoring the code

Implementing the PDF renderer modules

Testing the code

Lessons learned

Summary

5. Working with Module Patterns

Divide and conquer

Abstraction

Encapsulation

Wrappers

Extensible modules

Dynamic imports

Plugins

Hooks

Summary

6. Creating Reusable Modules

Using modules and packages to share your code

What makes a module reusable?

Functioning as a standalone unit

Using relative imports

Noting external dependencies

What makes a good reusable module?

Solving a general problem

Following standard conventions

Having clear documentation

Examples of reusable modules

requests

python-dateutil

lxml

Designing a reusable package

Implementing a reusable package

Testing our reusable package

Summary

7. Advanced Module Techniques

Optional imports

Local imports

Tweaking imports using sys.path

Import gotchas

Using an existing name for your module or package

Naming a Python script after a module or package

Adding package directories to sys.path

Executing and importing the same module

Using modules and packages with the Python interactive interpreter

Dealing with global variables

Package configuration

Package data

Summary

8. Testing and Deploying Modules

Testing modules and packages

Testing with the unittest Standard Library module

Designing your unit tests

Code coverage

Test-driven development

Mocking

Writing unit tests for your modules and packages

Preparing a module or package for publication

Uploading your work to GitHub

Submitting to the Python Package Index

Using pip to download and install modules and packages

Summary

9. Modular Programming as a Foundation for Good Programming Technique

The process of programming

The inevitable changes

Change management

Dealing with complexity

Being an effective programmer

Summary

Index

Modular Programming with Python

Modular Programming with Python

Copyright © 2016 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

First published: May 2016

Production reference: 1200516

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham B3 2PB, UK.

ISBN 978-1-78588-448-1

www.packtpub.com

Credits

Author

Erik Westra

Reviewer

Mike Driscoll

Commissioning Editor

Priya Singh

Acquisition Editor

Dharmesh Parmar

Content Development Editor

Arun Nadar

Technical Editor

Rupali Shrawane

Copy Editor

Sonia Cheema

Project Coordinator

Nikhil Nair

Proofreader

Safis Editing

Indexer

Hemangini Bari

Graphics

Disha Haria

Production Coordinator

Arvindkumar Gupta

Cover Work

Arvindkumar Gupta

About the Author

Erik Westra has been a professional software developer for over 25 years, and has worked almost exclusively in Python for the past decade. Erik's early interest in graphical user interface design led to the development of one of the most advanced urgent courier dispatch systems used by messenger and courier companies worldwide. In recent years, Erik has been involved in the design and implementation of systems matching seekers and providers of goods and services across a range of geographical areas, as well as real-time messaging and payments systems. This work has included the creation of real-time geocoders and map-based views of constantly changing data. Erik is based in New Zealand, and works for companies worldwide.

Erik is also the author of the Packt titles Python Geospatial Development, Python Geospatial Analysis, and Building Mapping Applications with QGIS.

I would like to thank Ruth for being so awesome, and my children for their patience. Without you, none of this would have been possible.

About the Reviewer

Mike Driscoll has been programming in Python since 2006. He enjoys writing about Python on his blog at http://www.blog.pythonlibrary.org/. He co-authored the Core Python Refcard for DZone. Mike has also been a technical reviewer for Python 3 Object Oriented Programming, Python 2.6 Graphics Cookbook, Tkinter GUI Application Development Hotshot, and several others. He recently wrote the book Python 101, and is working on his next book.

I would like to thank my beautiful wife, Evangeline, for always supporting me. I would also like to thank friends and family for all that they do to help me. And I would like to thank Jesus Christ for saving me.

www.PacktPub.com

eBooks, discount offers, and more

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.

https://www2.packtpub.com/books/subscription/packtlib

Do you need instant solutions to your IT questions? PacktLib is Packt's online digital book library. Here, you can search, access, and read Packt's entire library of books.

Why subscribe?

Fully searchable across every book published by Packt

Copy and paste, print, and bookmark content

On demand and accessible via a web browser

Preface

Modular programming is a way of organizing your program's source code. By organizing your code into modules (Python source files) and packages (collections of modules), and then importing those modules and packages into your program, you can keep your programs logically organized and keep potential problems to a minimum.

As your program grows and changes, you will often have to rewrite or expand certain parts of your code. Modular programming techniques help to manage these changes, minimizing side-effects, and keeping your code under control.

As you work with modular programming techniques, you will learn a number of common patterns for using modules and packages, including the divide and conquer approach to programming, the use of abstraction and encapsulation, and the idea of writing extensible modules.

Modular programming techniques are also a great way of sharing your code, either by making it available for other people to use or by reusing your code in another program. Using popular tools such as GitHub and the Python Package Index, you will learn how to publish your code, as well as use code written by other people.

Putting all these techniques together, you will learn how apply modular thinking to create better programs. You will see how modules can be used to deal with complexity and change in a large program and how modular programming really is the foundation of good programming technique.

By the end of the book, you will have an excellent understanding of how modules and packages work in Python and how to use them to create high-quality and robust software that can be shared with others.

What this book covers

Chapter 1, Introducing Modular Programming, looks at the ways you can use Python modules and packages to help organize your programs, why it is important to use modular techniques, and how modular programming helps you to deal with the ongoing process of programming.

Chapter 2, Writing Your First Modular Program, introduces the divide and conquer approach to programming and applies this technique to the process of building an inventory control system based on modular programming principles.

Chapter 3, Using Modules and Packages, covers the nuts and bolts of modular programming using Python, including nested packages, package and module initialization techniques, relative imports, choosing what gets imported, and how to deal with circular references.

Chapter 4, Using Modules for Real-World Programming, uses the implementation of a chart-generation library to show how modular techniques help to deal with changing requirements in the best possible way.

Chapter 5, Working with Module Patterns, looks at a number of standard patterns for working with modules and packages, including the divide and conquer technique, abstraction, encapsulation, wrappers, and how to write extensible modules using dynamic imports, plugins, and hooks.

Chapter 6, Creating Reusable Modules, shows how to design and create modules and packages that are intended to be shared with other people.

Chapter 7, Advanced Module Techniques, looks at some of the more distinctive aspects of modular programming in Python, including optional and local imports, tweaking the module search path, gotchas to be aware of, how to use modules and packages for rapid application development, working with package globals, package configuration, and package data files.

Chapter 8, Testing and Deploying Modules, examines the concept of unit testing, how to prepare your modules and packages for publication, how to upload and publish your work, and how to make use of modules and packages written by other people.

Chapter 9, Modular Programming as a Foundation for Good Programming Technique, shows how modular techniques help to deal with the ongoing process of programming by dealing with change and managing complexity, and how modular programming techniques help you to be a more effective programmer.

What you need for this book

All you need to follow through the examples in this book is a computer running any recent version of Python. While the examples all use Python 3, they can easily be adapted to work with Python 2 only a few changes.

Who this book is for

This book is aimed at the beginner to intermediate level Python programmer who wishes to use modular programming techniques to create high-quality and well organized programs. While the reader must know the basics of Python, no prior knowledge of modular programming is required.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: This one-line program would be saved in a file on disk, typically named something like hello.py

A block of code is set as follows:

def init():

    global _stats

    _stats = {}

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

[default]

exten => s,1,Dial(Zap/1|30)

exten => s,2,Voicemail(u100)

exten => s,102,Voicemail(b100)

exten => i,1,Voicemail(s0)

Any command-line input or output is written as follows:

# cp /usr/src/asterisk-addons/configs/cdr_mysql.conf.sample     /etc/asterisk/cdr_mysql.conf

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: Clicking the Next button moves you to the next screen.

Note

Warnings or important notes appear in a box like this.

Tip

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail <[email protected]>, and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

You can download the code files by following these steps:

Log in or register to our website using your e-mail address and password.

Hover the mouse pointer on the SUPPORT tab at the top.

Click on Code Downloads & Errata.

Enter the name of the book in the Search box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on Code Download.

You can also download the code files by clicking on the Code Files button on the book's webpage at the Packt Publishing website. This page can be accessed by entering the book's name in the Search box. Please note that you need to be logged in to your Packt account.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

WinRAR / 7-Zip for Windows

Zipeg / iZip / UnRarX for Mac

7-Zip / PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Modular-Programming-with-Python. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books—maybe a mistake in the text or the code—we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.

Piracy

Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at <[email protected]> with a link to the suspected pirated material.

We appreciate your help in protecting our authors and our ability to bring you valuable content.

Questions

If you have a problem with any aspect of this book, you can contact us at <[email protected]>, and we will do our best to address the problem.

Chapter 1. Introducing Modular Programming

Modular programming is an essential tool for the modern developer. Gone are the days when you could just throw something together and hope that it works. To build robust systems that last, you need to understand how to organize your programs so that they can grow and evolve over time. Spaghetti coding is not an option. Modular programming techniques, and in particular the use of Python modules and packages, will give you the tools you need to succeed as a professional in the fast changing programming landscape.

In this chapter, we will:

Look at the fundamental aspects of modular programming

See how Python modules and packages can be used to organize your code

Discover what happens when modular programming techniques are not used

Learn how modular programming helps you stay on top of the development process

Take a look at the Python standard library as an example of modular programming

Create a simple program, built using modular techniques, to see how it works in practice

Let's get started by learning about modules and how they work.

Introducing Python modules

For most beginner programmers, their first Python program is some version of the famous Hello World program. This program would look something like this:

print(Hello World!)

This one-line program would be saved in a file on disk, typically named something like hello.py, and it would be executed by typing the following command into a terminal or command-line window:

python hello.py

The Python interpreter would then dutifully print out the message you have asked it to:

Hello World!

This hello.py file is called a Python source file. When you are first starting out, putting all your program code into a single source file is a great way of organizing your program. You can define functions and classes, and put instructions at the bottom which start your program when you run it using the Python interpreter. Storing your program code inside a Python source file saves you from having to retype it each time you want to tell the Python interpreter what to do.

As your programs get more complicated, however, you'll find that it becomes harder and harder to keep track of all the various functions and classes that you define. You'll forget where you put a particular piece of code and find it increasingly difficult to remember how all the various pieces fit together.

Modular programming is a way of organizing programs as they become more complicated. You can create a Python module, a source file that contains Python source code to do something useful, and then import this module into your program so that you can use it. For example, your program might need to keep track of various statistics about events that take place while the program is running. At the end, you might want to know how many events of each type have occurred. To achieve this, you might create a Python source file named stats.py which contains the following Python code:

def init():

    global _stats

    _stats = {}

def event_occurred(event):

    global _stats

    try:

        _stats[event] = _stats[event] + 1

    except KeyError:

        _stats[event] = 1

def get_stats():

    global _stats

    return sorted(_stats.items())

The stats.py Python source file defines a module named stats—as you can see, the name of the module is simply the name of the source file without the .py suffix. Your main program can make use of this module by importing it and then calling the various functions that you have defined as they are needed. The following frivolous example shows how you might use the stats module to collect and display statistics about events:

import stats

stats.init()

stats.event_occurred(meal_eaten)

stats.event_occurred(snack_eaten)

stats.event_occurred(meal_eaten)

stats.event_occurred(snack_eaten)

stats.event_occurred(meal_eaten)

stats.event_occurred(diet_started)

stats.event_occurred(meal_eaten)

stats.event_occurred(meal_eaten)

stats.event_occurred(meal_eaten)

stats.event_occurred(diet_abandoned)

stats.event_occurred(snack_eaten)

for event,num_times in stats.get_stats():

    print({} occurred {} times.format(event, num_times))

We're not interested in recording meals and snacks, of course—this is just an example—but the important thing to notice here is how the stats module gets imported, and then how the various functions you defined within the stats.py file