In this chapter I attempt to explain the fundamentals of Python. Here I have the same difficulty as Bertie Wooster faces when he tries to keep us abreast of the developments in Much Obliged, Jeeves. If I start too early, and begin at the very beginning, telling you all about how a computer doesn't understand plain English, I'm likely to irritate the coves who already know all about that, and just want a quick update on the high-level datastructures of Python and the current state of iterators and generators. However, that would leave the birds who are just starting out wondering whether it was such a good idea, after all, to pick up this book, and start learning how to program.
The fact is, writing an introduction to a complete programming language — or the concept of programming in itself — in just one chapter is the deuce of a task. It can't really be done, I'm afraid to say. If you already know a few programming languages, the on-line Python tutorial that is included with BlackAdder (or with Python itself) will probably suffice. If you haven't programmed all that much before, I highly advise you to buy Marc Lutz' excellent book, Learning Python, which is more like an introduction to programming, with a focus on Python.
Still with me? Then we had better take a quick tour through Python — which is really one of the easiest programming languages to master. Like ancient Gaul, and like this book, I have divided this chapter into three sections. The first tries to gently introduce the concept of programming to people who need to be primed with the most basic concepts. This is difficult for me to do, because I have been programming since I was twelve years old, so bear with me. The second is about Rules. Every programming language needs rules, and these are the rules that you need to keep in mind while programming Python. The final part gives an overview of the various constructions that Python contains for your satisfaction and pleasure.
Please don't think that I can teach you programming in just the space of this section — you need to read some good books for that, such as Steve McConnel's Code Complete. What I can do is show you what the fuss is all about.
Computers do not do anything of their own volition: ultimately, someone has always told the machine what to do. Even crashing, down to the ultimate Blue Screen of Death, is caused by a computer blindly following instructions given by a human being.
Instructions can take the form of mouseclicks on fancy icons or buttons, or of bits of text the computer can understand. While there is still no computer that can understand plain English, there are many sub-dialects of English that a computer can understand. Python is one of these — a mix between pidgin English and mathematical notation. It is close to both the way computers work, and the way people think.
Unless you have a speech-to-text interface for your computer, you will have to type out all the pidgin-English, and then tell the computer to read what you've written, and do what you told it to. In a sense, you have to write a kind of manual for the computer to read, on how to perform a certain task.
Let's start with a simple example: fire up BlackAdder, and open the Python Interpreter window. If you start typing at the >>>, nothing will happen — only by pressing the Enter key will Python realize that it has been spoken to. Go ahead and type something — you can't hurt the computer or your system, except if, by a fluke, you type import os, followed by Enter and os.system("deltree c:") — which would radically clean out your C drive. So don't do this! On the other hand, asking Python about the captain's age or the contents of a bathtub that's being filled by two taps is all right.
Chances are very small that you will have hit upon something Python understands by accident, for you are strictly limited to the few keywords Python actually knows about. Most of these keywords are concerned with creating blocks of instructions, called functions. Functions are used to construct more complex systems. Other keywords are used for creating another kind of block, called classes, which are combinations of information and instructions.
Let's construct a class that knows the value of something (though not the price), and has a function that does something to that value. Remember to press enter at the end of each line, and don't type the three > signs or the three dots — Python does this for you.
Python 2.1.1 (#1, Aug 11 2001, 20:14:53) [GCC 2.95.2 19991024
(release)] on linux2 Type "copyright", "credits" or "license"
for more information.
>>> class FirstClass:
... def __init__(self, value):
... self.item=value
... def printValue(self):
... print self.item
...
>>> firstObject=FirstClass(value="BlackAdder goes forth")
>>> firstObject.printValue
<method FirstClass.printValue of FirstClass instance at 0x80db1f4>
>>> firstObject.printValue()
BlackAdder goes forth
>>>
If you type neatly and without mistakes, the contents of the Python interpreter window might look like this. Let's look at what happens: we have defined a ‘class' — that's a combination of information and complex actions that work on the contained information. The class has a name: FirstClass. (It is customary to capitalize the first letter of each word in a classname).
A class in itself is only the ‘template', so to speak, while an object is the ‘document' — just as you can make documents out of templates in a wordprocessor, you can make objects from classes.
Furthermore, the class has two ‘functions' — defined with the def statement.
The first function, __init__, is called when you want to create an object. The function has two ‘parameters' — that is, two names associated with a value (which we call a ‘variable' because the value can change, though the name remains the same). The first parameter refers to the object — it's always called self in Python (though it is called this in Java or C++). The second parameter is the value we want the object to manage for us.
You can use a dot ‘.' to associate variables with each other. The line ‘self.item = value' means that from now on the object we refer to with self (but also, in another context, with firstObject) knows that the name item is associated with the value represented by the parameter value.
Cleverly, Python doesn't forget this, so when you create an object with the name firstObject and the string value (that is to say, some text, as opposed to a number) ‘BlackAdder goes forth', you can later call the printValue() function, which will be able to do something with that value.
In order to call—that is, ask Python to execute— a function, you must add brackets after the function name; the parameters always go between the brackets. You don't have to put self between brackets, for Python does this for you. If you don't add the brackets, you are referring to the function, not asking Python to execute it. Python then answers you with the revealing sentence:
>>> firstObject.printValue
<method FirstClass.printValue of FirstClass instance at 0x80db1f4>
This tells you what kind of an object a function is. Calling the function will ‘print' the value of item in your window:
>>> firstObject.printValue()
BlackAdder goes forth
>>>
As I said, the self is supplied by Python, because you call the function from the object. That is, by prefixing the variable that points to the object to the function name, with a dot in between. This is the same as typing the following code (that is, calling the function with the object as its first parameter). As such, the following two expressions are equivalent:
>>>firstObject.printValue()
BlackAdder goes forth
>>>FirstClass.printValue(firstObject)
BlackAdder goes forth
Of course, typing in all these instructions correctly every time you want the computer to print ‘BlackAdder goes forth' is quite a chore. To get around this, you can write a small text document (this is not the same as a Word document!) using BlackAdder's text editor, and then ask Python to execute it.
To sum up: composition of complex wholes from smaller parts using a debased variant of English, and calling things names, is what programming is all about. The rest is made up of rules —rules intended to make it easier for computer the compute to determine what it should do, and more difficult for you to explain yourself to the machine.
| Warning |
Please be warned that if you execute your programs (or scripts) from BlackAdder, all the output of ‘print' will disappear into the void. The output will only be shown if you start your scripts using the debugger, and have the Python Interpreter window open. If you merely type in stuff in the Interpreter window you will see all output. |
If this section went over your head with the airspeed of an unladen African swallow, don't worry. There is much more to programming — more than I can explain in a third of a chapter. Please read the Python tutorial that is included with Python and with BlackAdder. It is well-written and a little less hasty. Another good source is the free Livewires Python course, which you can find in PDF format at: http://www.livewires.org.uk/python/. I heartily recommend it as the best introduction to the general idea of programming I've ever read.