Programming python quick intro for schools

Editor's Notes

• #5: The very first programmers actually had to enter the binary codes themselves, this is known as machine code programming and is incredibly difficult. The next stage was to create a translator that simply converted English equivalents of the binary codes into binary so that instead of having to remember that the code 001273 05 04 meant add 5 to 4 programmers could now write ADD 5 4. This very simple improvement made life much simpler and these systems of codes were really the first programming languages, one for each type of computer. They were known as assembler languages and Assembler programming is still used for a few specialized programming tasks today. Even this was very primitive and still told the computer what to do at the hardware level - move bytes from this memory location to that memory location, add this byte to that byte etc. It was still very difficult and took a lot of programming effort to achieve even simple tasks. Gradually computer scientists developed higher level computer languages to make the job easier. This was just as well because at the same time users were inventing ever more complex jobs for computers to solve! This competition between the computer scientists and the users is still going on and new languages keep on appearing. This makes programming interesting but also makes it important that as a programmer you understand the concepts of programming as well as the pragmatics of doing it in one particular language.
• #11: Basically there are three types of error you will encounter. The first of these is a syntax error which basically means that Python didn't recognise what you typed as a valid program, it's like missing out punctuation in an English sentence or spelling a word wrongly. The next category of errors is a runtime error which is where the program looks valid but for some reason cannot be executed, you have tried to perform an illegal, or unavailable operation. Trying to read a file that did not exist would be an example. The final type of error is a semantic error which is where the program appears to have worked in that there are no error messaages but it produces the wrong output. For example if you wrote a word counter program that reported that this file only contained 5 words, it would obviously be wrong, so the program has a semantic error. Most of the errors you will come across initially will be syntax errors or runtime errors, later, as you start to design your own programs, you will make semantic errors and need to fix them. This process is called debugging and the errors so found are called bugs for historic reasons - one of the first computer faults was due to a real insect-type bug getting stuck inside the machine!
• #12: A simple sequence of instructions is the most basic program you can write. The simplest sequence is one containing a single command. We will try out some of these now. The heading will describe what you should type at the '>>> ' Python prompt, the following paragraph will explain what happens. >>> print 'Hello there!'The first thing to notice is that you don't need to type the space between the >>> and the 'print' - Python puts that there for you. Secondly Python cares about details like whether or not you use upper or lower case. If you typed Print instead of print you would get an error because Python considers the two words to be different. (JavaScript is also fussy about case whereas VBScript is much more forgiving, but it's best to just get used to being very careful about case when programming.) The print command is the way to get Python to display its results to you. In this case it is printing the sequence of characters H,e,l,l,o, ,t,h,e,r,e,!. Such a sequence of characters is known in programming circles as a string of characters or a character string or just a plain string. You signify a string by surrounding it in quotes. In Python you can use either single quotes (as above) or double quotes: "a string". This allows you to include one type of quote within a string which is surrounded by the other type - useful for apostrophes:>>> print "Monty Python's Flying Circus has a ' within it..." JavaScript and VBScript are both a bit more fussy about which types of quotes you can use and where. In both of those languages I recommend sticking to double quotes where possible.
• #13: BIDMASNotice the way parentheses is used to group the numbers together. What happens if you type the same sequence without the parentheses? This is because Python will evaluate the multiplication and division before the addition and subtraction. This is usually what you would expect mathematically speaking but it may not be what you expect as a programmer! All programming languages have rules to determine the sequence of evaluation of operations and this is known as operator precedence.
• #14: This is because Python sees that the numbers are whole numbers and assumes you want to keep them that way. If you want decimal fractions as a result simply write one number as a decimal:
• #16: In this command the format string contains '%' markers within it. The letter 'd' after the % tells Python that a 'decimal number' should be placed there. The values to fill in the markers are obtained from the values inside the bracketed expression following the % sign on its own. There are other letters that can be placed after the % markers. Some of these include: %s - for string %x - for hexadecimal number %0.2f - for a real number with a maximum of 2 decimal places %04d - pad the number out to 4 digits with 0's
• #17: Now this is a strange one. If you've tried it you'll see that it apparently does nothing. But that's not really true. To understand what happened we need to look at the architecture of Python (for non Python programmers, bear with me there will be a similar mechanism available to you too!) When you start Python there are a bunch of commands available to you called built-ins, because they are built in to the Python core. However Python can extend the list of commands available by incorporating extension modules. - It's a bit like buying a new tool in your favourite DIY shop and adding it to your toolbox. The tool is the sys part and the import operation puts it into the toolbox. In fact what this command does is makes available a whole bunch of new 'tools' in the shape of Python commands which are defined in a file called 'sys.py'. This is how Python is extended to do all sorts of clever things that are not built in to the basic system. You can even create your own modules and import and use them, just like the modules provided with Python when you installed it. So how do we use these new tools? >>>sys.exit()Whoops! What happened there? Simply that we executed the exit command defined in the sys module. That command causes Python to exit.(Note 1: Normally you exit Python by typing the End Of File(EOF) character at the >>> prompt - CTRL-Z on DOS or CTRL-D on Unix. In a development tool you exit using the File->Exit menu etc as usual.)(Note 2: If you try this inside a development tool like IDLE the tool will probably catch the attempt to exit and display a message saying something about SystemExit. Don't worry that means the program is working and the tool is just saving you the bother of restarting from scratch.) Notice that exit had 2 brackets after it. That's because exit is a function defined in sys and when we call a Python function we need to supply the parentheses even if there's nothing inside them! Try typing sys.exit without the brackets. Python responds by telling you that exit is a function rather than by executing it! One final thing to notice is that the last two commands are actually only useful in combination. That is, to exit from Python other than by typing EOF you need to type: import sys sys.exit() This is a sequence of two commands! Now we're getting closer to real programming....
• #26: We can even hold one list inside another, thus if we append our second list to the first:>>> aList.append(another) >>> print aList [42, [1, 2, 7]] Notice how the result is a list of two elements but the second element is itself a list (as shown by the []’s around it). We can now access the element 7 by using a double index: >>> print aList[1][2] 7 The first index, 1, extracts the second element which is in turn a list. The second index, 2, extracts the third element of the sublist.This nesting of lists one inside the other is extremely useful since it effectively allows us to build tables of data, like this: >>> row1 = [1,2,3] >>> row2 = ['a','b','c'] >>> table = [row1, row2] >>> print table [ [1,2,3], ['a','b','c'] ] >>> element2 = table[0][1] We could use this to create an address book where each entry was a list of name and address details. For example, here is such an address book with two entries: >>> addressBook = [ ... ['Fred', '9 Some St',' Anytown', '0123456789'], ... ['Rose', '11 Nother St', 'SomePlace', '0987654321'] ... ] >>>
• #34: If we know the number of iterations
• #35: Let's walk through what's happening. First we initialize j to 1, initializing the control variable of a while loop is a very important first step, and a frequent cause of errors when missed out. Next we execute the while statement itself, which evaluates a boolean expressionIf the result is True it proceeds to execute the indented block which follows. In our example j is less than 12 so we enter the block. We execute the print statement to output the first line of our table. The next line of the block increments the control variable, j. In this case it's the last indented line, signifying the end of the while block. We go back up to the while statement and repeat steps 4-6 with our new value of j. We keep on repeating this sequence of actions until j reaches 13. At that point the while test will return False and we skip past the indented block to the next line with the same indentation as the while statement. In this case there are no other lines so the program stops.
• #39: Notice that we use the string formatting operator to display the value stored in the variable resp and that value is the one captured from the user by raw_input. raw_input() has a cousin called input(). The difference is that raw_input() collects the characters the user types and presents them as a string, whereas input() collects them and tries to evaluate them as some kind of data. For example if the user types '1','2','3' then input will read those 3 characters and convert them into the number 123. Let's use input to decide which multiplication table to print:
• #44: VBscript<script type="text/vbscript"> MsgBox "Starting Here" DIM J J = 5 If J > 10 Then MsgBox "This is never printed" Else MsgBox "End of Program" End If </script> Java Script<script type="text/javascript"> var j; j = 5; if (j > 10){ document.write("This is never printed"); } else { document.write("End of program"); } </script>
• #46: Note 1:we used == (that's a double = sign) to test for equality in the first if statement, whereas we use = to assign values to variables. Using = when you mean to use == is one of the more common mistakes in programming Python, fortunately Python warns you that it's a syntax error, but you might need to look closely to spot the problem. Note 2:A subtle point to notice is that we perform the greater-than tests from the highest value down to the lowest. If we did it the other way round the first test, which would be price > 200 would always be true and we would never progress to the > 500 test. Similarly if using a sequence of less-than tests you must start at the lowest value and work up. This is another very easy trap to fall into. <script type="text/vbscript"> DIM Price price = InputBox("What's the price?") price = CInt(price) If price = 100 Then MsgBox "I'll take it!" Else: if price > 500 Then MsgBox "No way Jose!" else: if price > 200 Then MsgBox "How about throwing in a free mouse mat too?" else: MsgBox "price is an unexpected value!" End If End If End If </script>
• #47: Note the use of elif and the fact that the indentation (all important in Python) does not change (unlike the nested if statement example). It's also worth pointing out that both this technique and the earlier nested if/else example are equally valid, the elif technique is just a little easier to read if there are many tests. The final condition is an else which catches anything not caught by the previous tests, just like the default in JavaScript and Case Else in VBScript. VBScript also provides a slightly more cumbersome version of this technique with ElseIf...Then which is used in exactly the same way as the Python elif but is rarely seen since Select Case is easier to use.
• #54: If the program runs quickly and you cannot see the end of the program then try thisraw_input("Hit ENTER to quit")