Lisi wrote:
By "envelope" I meant container, because I was afraid of misusing the correct
technical terms. I am still very confused by the terminology. Having been
told that modules, functions and methods are just different names for the
same thing, that commands are really also the same thing and having had them
called yet a fifth thing in order "not to confuse you" (ouch!!) I am in a
right muddle.
Ayyeee!!!! You have my sympathy!
Okay, let's start with the basics. Here's a small piece of simple Python
code, to count down from ten:
for i in range(10, 0, -1):
print(i)
print("Lift off!")
If you type that in the interactive interpreter, and hit Enter, Python
will execute that code and print 10 9 8 ... 2 1 Lift off!
Suppose you want to do a count-down again. In the interpreter, you would
have to type out the whole thing again. This is annoying and frustrating
-- imagine if you wanted to run it a thousand times. So instead, we can
make a re-usable, named, piece of code: a function.
def countdown():
for i in range(10, 0, -1):
print(i)
print("Lift off!")
If you type that in, once, it defines a reusable piece of code called
"countdown". Now you can run that code as many times as you like, by typing:
countdown()
and then hitting Enter. Much simpler, with much less chance of error.
Note that the parentheses are required. Without the round brackets, the
code inside the function won't be run.
(Methods are very similar to functions. At the most basic level, we can
pretend that a method is just a function that comes stuck to something
else. Don't worry about methods for now.)
But the problem here is that the countdown function is not permanent. If
you exit the interpreter, and start again, it will be lost for good. The
solution is to save the function in a .py file -- a module.
So in your text editor, type
def countdown():
for i in range(10, 0, -1):
print(i)
print("Lift off!")
in the file, save the file as "example.py". This becomes a module. A
module can contain any Python code you like: one line or a thousand, one
function or a hundred functions, or anything else.
Then, later, you can restart the Python interpreter, give the command:
from example import countdown
and use countdown as if you had just typed it in by hand.
Sometimes people will use "function" and "command" interchangeably. I
don't like this. Commands (also known as statements) are always built-in
to Python and operate as *instructions* to the interpreter. There are
only a few:
import ...
from ... import ...
def
class
del
print (Python 2 only, in Python 3 it becomes a function)
are the main ones. (There may be a few more I have missed.) Such
commands generally don't use parentheses, except for grouping items.
Functions always require parentheses. They may be built-in, such as len,
or you can write your own, using the def command.
Functions also always return a result, so you can do this:
x = some_function(a, b, c)
Commands don't. You can't say:
x = del a, b, c
because del doesn't return anything. Since it doesn't return anything,
you can't save the result in x.
(Aside: you can create functions that mimic commands by returning the
special value None. That's used for functions which are intended to not
return a value, but since Python requires functions to return something,
they return the special value None to mean "ignore this, it's nothing".
But they're still functions, and they still return something: the
special value None.)
So, summary:
* Commands are built-in Python instructions;
* Sometimes also known as "statements".
* They take actions, but don't return a result.
* "Command" is not an official Python term, so some people may
disagree with me!
* Functions may be built-in, or defined by the user.
* Functions always return something.
* Functions can mimic commands by returning None. I call these
"procedures", copying the language Pascal.
* Methods are related to functions.
* A module is a container that holds functions and any other values
you like.
* Modules are NOT functions, although they can hold functions.
* Modules usually are loaded from .py files on your disk.
* When you import the module, Python runs the code inside the file,
builds a module, and makes the module appear in the interpreter.
* Some special modules are built-in to the Python compiler, and
don't exist in a .py file.
* Other modules come from DLLs or .so files, and are written in C.
So now, can anyone suggest an example of a module to look at? (Preferably
with some subroutines inside).It is clearly NOT just another name for
function or method. I imagine that there are some on the Internet?
The Python standard library consists of 200 or so Python files, all of
which can be opened in a text editor and read or printed for study.
(Be careful not to make modifications to the files, since you risk
breaking them and preventing Python from working correctly.)
Are you using Windows or Linux or Mac?
On my Linux system, I can look inside:
/usr/lib/python2.5/
and see the Python modules.
--
Steven
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
http://mail.python.org/mailman/listinfo/tutor
