## Simple Sequences

What will we cover?
Single commands, the use of Python as a calculator, using brackets to get the correct result and using format strings to combine text and numbers. Finally we see how to quit Python from within a program.

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 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. 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..."
```

It's not just strings that can be printed:

#### >>>print 6 + 5

Here we have printed the result of an arithmetic operation - we added six and five. Python recognized the numbers as such and the plus sign and did the sum for us. It then printed the result.

So straight away you have a use for Python: its a handy 'pocket calculator'! Try a few more sums. Use some other arithmetic operators:

• subtract (-)
• multiply (*)
• divide (/)

Combine multiple expressions like:

```>>> print ((8 * 4) + (7 - 3)) / (2 + 4)
```

Notice the way I used brackets to group the numbers together. What happens if you type the same sequence without the brackets? 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. You will need to look at the reference documentation for each language to see how it works. With Python it's usually what logic and intuition would suggest, but occasionally it won't be...

As a general rule its safest to include the brackets to make sure you get what you want when dealing with long series of sums like this.

One other thing to note:

```>>> print 5/2
```

results in a whole number (integer) result (i.e. 2). 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:

```>>> print 5/2.0
2.5
```
Python sees the 2.0 and realizes that we are happy dealing with fractions (referred to as real numbers or floating point in computing parlance), so it responds with a fractional result. If you want to keep with whole numbers you can find the remainder by using the % sign like a division operator. Python will print the remainder:
```>>> print 7/2
3
>>> print 7%2
1
>>> print 7%4
3
```

% is known as the modulus or mod operator and in other languages is often seen as MOD or similar.

Experiment and you will soon get the idea.

#### >>>print 'The total is: ', 23+45

You've seen that we can print strings and numbers. Now we combine the two in one print statement, separating them with a comma. We can extend this feature by combining it with a useful Python trick for outputting data called a format string:

```>>> print "The sum of %d and %d is: %d" % (7,18,7+18)
```

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

The Python documentation will give lots more...

In fact you can print any Python object with the print command. Sometimes the result will not be what you hoped for (perhaps just a description of what kind of object it is) but you can always print it.

#### >>>import sys

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: Normally you exit Python by typing the End Of File(EOF) character at the >>> prompt - CTRL-Z on DOS or CTRL-D on Unix)

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....

### Using Tcl

We can also type simple commands like this into Tcl too. The Tcl interpreter is started by typing tclsh80 (assuming you have Tcl v8.0)at a DOS prompt. The command prompt is a '%' sign. Try the following examples:

```% put "Hello world"
Hello world
% put [expr 4 + 6]
10
```

Note that in the last example the section in square brackets is evaluated first and the result passed to the put command. Unlike Python you can't assume the put will attempt to interpret what you mean, it expects a character string and it's up to you to ensure it gets one.

To exit from tclsh80 just type exit at the prompt

### And BASIC too...

To start BASIC type QBASIC at the DOS prompt. In this case a whole programming environment will start. Get rid of the welcome dialog etc and in the edit window you can type commands and then run whatever is in the window using the Run menu. This has the advantage that the environment allows you to edit the commands, and even does some checks on the text as you enter it.

Enter the following set of commands and then Run them:

```PRINT "Hello world"
PRINT 4+6
```

You exit as usual via the File|Exit menu option.

That's our first look at programming, it wasn't too painful was it? Before we continue tho' we need to take a look at the raw materials of programming, data and what we can do with it.

Points to remember
• Even a single command is a program
• Python does math almost the way you'd expect
• To get a fractional result you must use a fractional number
• You can combine text and numbers using the % format operator
• Quit with import sys; sys.exit()

If you have any questions or feedback on this page send me mail at: alan.gauld@btinternet.com