Chapter 11. Namespaces, Scopes, and Modules

In this chapter, we will cover Python modules. Modules are files containing functions and class definitions. The concept of a namespace and the scope of variables across functions and modules is also explained in this chapter.

Namespace

Names of Python objects, such as names of variables, classes, functions, and modules, are collected in namespaces. Modules and classes have their own named namespaces with the same name as these objects. These namespaces are created when a module is imported or a class is instantiated. The lifetime of a namespace of a module is as long as the current Python session. The lifetime of a namespace of a class instance is until the instance is deleted.

Functions create a local namespace when they are executed (invoked). It is deleted when the function stops the execution by a regular return or an exception. Local namespaces are unnamed.

The concept of namespaces puts a variable name in its context. For example, there are several functions with the name sin and they are distinguished by the namespace they belong to, as shown in the following code:

import math
import scipy
math.sin
scipy.sin

They are indeed different, as scipy.sin is a universal function accepting lists or arrays...

Scope of a variable

A variable defined in one part of a program needs not to be known in other parts. All program units to which it a certain variable is known are called the scope of that variable. We first give an example; let's consider the two nested functions:

e = 3
def my_function(in1):
    a = 2 * e
    b = 3
    in1 = 5
    def other_function():
       c = a
       d = e
       return dir()
    print("""
          my_function's namespace: {} 
          other_function's namespace: {}
          """.format(dir(),other_function()))
    return a

Execution of my_function(3) results in:

my_function's namespace: ['a', 'b', 'in1', 'other_function'] 
other_function's namespace: ['a', 'c', 'd']

The variable e  is in the namespace of the program unit that encloses the function my_function . The variable a  is in the namespace of this function, which itself encloses the innermost function other_function. For the two functions,...

Modules

In Python, a module is simply a file containing classes and functions. By importing the file in your session or script, the functions and classes become usable.

Introduction

Python comes with many different libraries by default. You may also want to install more of those for specific purposes, such as optimization, plotting, reading/writing file formats, image handling, and so on. NumPy and SciPy are two important examples of such libraries, matplotlib for plotting is another one. At the end of this chapter, we will list some useful libraries.

To use a library, you may either:

• Load only certain objects from a library, for example from NumPy:

          from numpy import array, vander

• Or load the entire library:

          from numpy import *

• Or give access to an entire library by creating a namespace with the library name:

          import numpy
          ...
          numpy.array(...)

  Prefixing a function from the library with the namespace gives access to this function and distinguishes...

Summary

We started the book by telling you that you had to import SciPy and other useful modules. Now you fully understand what importing means. We introduced namespaces and discussed the difference between import and from ... import *. The scope of a variable was already introduced in an earlier Chapter 7, Functions, but now you have a more complete picture of the importance of that concept.