You are on page 1of 2

A Beginner's Python Tutorial/Importing Modules

A Beginner's Python Tutorial


Introduction[edit]
Last lesson we covered the killer topic of Classes. As you can remember, classes
are neat combinations of variables and functions in a nice, neat package. Progr
amming lingo calls this feature encapsulation, but regardless of what it is call
ed, it's a really cool feature for keeping things together so the code can be us
ed in many instances in lots of places. Of course, you've got to ask, "how do I
get my classes to many places, in many programs?". The answer is to put them int
o a module, to be imported into other programs.
Module? What's a Module?[edit]
A module is a Python file that (generally) has only definitions of variables, fu
nctions, and classes. For example, a module might look like this:
Code Example 1 - moduletest.py
### EXAMPLE PYTHON MODULE
# Define some variables:
numberone = 1
ageofqueen = 78
# define some functions
def printhello():
print "hello"
def timesfour(input):
print input * 4
# define a class
class Piano:
def __init__(self):
self.type = raw_input("What type of piano? ")
self.height = raw_input("What height (in feet)? ")
self.price = raw_input("How much did it cost? ")
self.age = raw_input("How old is it (in years)? ")
def printdetails(self):
print "This piano is a/an " + self.height + " foot",
print self.type, "piano, " + self.age, "years old and costing\
" + self.price + " dollars."
As you see, a module looks pretty much like your normal Python program.
So what do we do with a module? We import bits of it (or all of it) into other p
rograms.
To import all the variables, functions and classes from moduletest.py into anoth
er program you are writing, we use the import operator. For example, to import m
oduletest.py into your main program, you would have this:
Code Example 2 - mainprogram.py
### mainprogam.py
### IMPORTS ANOTHER MODULE
import moduletest
This assumes that the module is in the same directory as mainprogram.py, or is a
default module that comes with python. You leave out the '.py' at the end of th
e file - it is ignored. You normally put all import statements at the beginning
of the python file, but technically they can be anywhere. In order to use the it
ems in the module in your main program, you use the following:
Code Example 3 - mainprogram.py continued

### USING AN IMPORTED MODULE


# Use the form modulename.itemname
# Examples:
print moduletest.ageofqueen
cfcpiano = moduletest.Piano()
cfcpiano.printdetails()
As you see, the modules that you import act very much like the classes we looked
at last lesson - anything inside them must be preceeded with modulename. for it
to work.
More Module Thingamajigs (for lack of a better title)[edit]
Wish you could get rid of the modulename. part that you have to put before every
item you use from a module? No? Never? Well, I'll teach it you anyway.
One way to avoid this hassle is to import only the wanted objects from the modul
e. To do this, you use the from operator. You use it in the form of from modulen
ame import itemname. Here is an example:
Code Example 4 - importing individual objects
### IMPORT ITEMS DIRECTLY INTO YOUR PROGRAM
# import them
from moduletest import ageofqueen
from moduletest import printhello
# now try using them
print ageofqueen
printhello()
What is the point of this? Well, maybe you could use it to make your code a litt
le more readable. If we get into heaps of modules inside modules, it could also
remove that extra layer of crypticness.
If you wanted to, you could import everything from a module in this way by using
from modulename import *. Of course, this can be troublesome if there are objec
ts in your program with the same name as some items in the module. With large mo
dules, this can easily happen, and can cause many a headache. A better way to do
this would be to import a module in the normal way (without the from operator)
and then assign items to a local name:
Code Example 5 - mainprogram.py continued
### ASSIGNING ITEMS TO A LOCAL NAME
# Assigning to a local name
timesfour = moduletest.timesfour
# Using the local name
print timesfour(565)