The Import Statement - Page 4

There are three different forms of the import statement. The most basic,

import modulename

You can import a module, and refer to things in the module via the module name.

simply searches for a Python module of the given name, parses its contents, and makes it available. The importing code can make use of the contents of the module, but any references by that code to names within the module must still be prepended with the module name. If the named module is not found, an error will be generated. Exactly where Python looks for modules will be discussed shortly.

The second form permits specific names from a module to be explicitly imported into the code:

from modulename import name1, name2, name3,. . .

Each of name1, name2, and so forth, from within modulename are made available to the importing code; code after the import statement can make use of any of name1, name2, name3, . . ., without prepending the module name.

Finally, there's a general form of the from . . . import . . . statement:

from modulename import *

You can explicitly import objects (names) from a module, and then refer to those objects directly. You can explicitly import all names from a module, and refer to them directly.

The '* ' stands for all of the names in modulename. This imports almost all names from modulename, and makes them available to the importing code, without the necessity of prepending the module name.

This particular form of importing should be used with some care. If two modules both define a name, and you import both modules using this form of importing, you'll end up with a name clash. It also makes it more difficult for readers of your code to determine where names you are using originate. When using either of the two previous forms of the import statement you give your reader explicit information about where they are from.

However, some modules (such as Tkinter and types, which will be covered later) name their functions such as to make it obvious where they originate, and to make it quite unlikely there will be name clashes. It is standard practice to use this form to import them.

The Module Search Path

Exactly where Python looks for modules is defined in a variable called path, which is accessible to the programmer through a module called sys. Do the following:

>>>import sys
>>> sys. path
_list of directories in the search path_

Python searches the list of directories given in sys. path, when looking for requested modules.

The value shown in place of where I've said …list of directories in the search path… will depend on the configuration of your system. Regardless of the details, the string indicates a list of directories that are searched by Python (in order), when attempting to execute an import statement. The first module found which satisfies the import request is used. If there is no satisfactory module in the module search path, an ImportError exception is raised.

If you are using IDLE, you can graphically look at the search path and the modules on it using the Path Browser window, which you can start from File menu of the Python Shell window.

sys. path can be initialized from an environment variable, or from a default value defined by Python.

The sys.path variable is initialized from the value of the environment (operating system) variable PYTHONPATH, if it exists, or from a default value which is dependent on your installation. In addition, whenever a Python script is run, the sys.path variable for that script will have the directory containing the script inserted as its first element—this provides a convenient way of determining where the executing Python program is located. In an interactive session such as the one just above, the first element of sys.path will be set to the empty string, which Python takes as meaning that it should first look for modules in the current directory.

A First Module - Page 3
The Quick Python Book
Where To Place Your Own Modules - Page 5