Variables

It is difficult to think of a useful computer program that does not need to store data in some way. The program may ask the user to input some information, or read a value from a sensor - this will then need to be stored before further processing is done and the computer can react.

This data will be stored in the main memory of the computer, which leads us to this important definition:

Constants

As well as storing data that changes over time, computer programs often need to store data that will not change when the program is executing. The data will be stored in exactly the same way as a variable, although this is sometimes slightly different in order to make access to the data faster. Examples of data that may be stored in a constant are the value of Pi, the current VAT rate etc.

Input and Output

A program will usually need some data to start with, and will output the data when it has been processed.

We will need to store any values that have been input, and the most logical way to do this is by storing the value in a variable. in Python, we use a statement similar to this:

name = input("What is your name?")

This will display the prompt "What is your name?" and then program execution will then pause until the user has types something and pressed the enter key. Whatever the user typed will then be stored in the variable name.

It is important to note that the Python input function accepts only string values. If you need the user to enter a numerical value, then you must cast it to either a floating point or integer value:

# This will ask the user for their age, and then convert what they type in from a string value, into an integer value:

age = int(input("How old are you?"))

# This will do a similar thing, but this time the input will be converted to a floating point value:

height = float(input("How tall are you?"))

Python also allows the program to output data using the print() function. Everything inside the brackets will be printed. It is possible to print longer groups of characters by using a "," symbol (this will add a space directly between the two items), or using a "+" character (this will not add a space). Python has some formatting methods as well, so multiple lines of data can be displayed in a tabular form, or a set number of decimal places are used.

# The following will display "Hello John" because the , will add a space:

name = "John"

print("Hello",name)

# This line will display "alltogther" without a space, because the + symbol concatenates the two words:

print("all" + "together")

String Techniques

There are many different ways of manipulating strings. As a very bare minimum, you should be able to find the length of a string, break it up into shorter sections and change the capitalisation of a string.

File Access Modes.

As mentioned earlier, it is also possible to specify a mode when you open a file.

filehandle = open('filename', 'w') will open an existing file and enable write mode. You can save data to the file, but you cannot read data from the file.

filehandle = open('filename', 'r') will open an existing file and enable data to be read from the file. The file must already exist (or you will get an error), and you cannot write data to the file.

filehandle = open('filename', 'a') will open a file for appending, creates the file if it does not exist. You cannot read data from the file.

filehandle = open('filename', 'x') will create the file, and will give an error if the file already exists.

In addition you can specify if the file should be handled as binary or text mode

filehandle = open('filename', 't') - Text - Default value. Text mode, if you do not specify text or binary, then text mode is used.

filehandle = open('filename', 'b') - Binary - Binary mode (e.g. images)

The final two options are always used with one of the first four (so the complete set of options are wt, wb, rt,rb,at and ab

When using file handling in Python, it is usually best to read an entire file into an array, then perform any operations, and finally reopen the file in w mode and saving all the data.

We will often want the results from the query to be sorted into order, either alphabetically or numerically. We can do this by adding ORDER BY to the end of our SQL statement.

SELECT * FROM students WHERE form="9Mauritius" AND gender="M" ORDER BY surname will sort the results of the query into alphabetical order of surname.

Adding, Updating and Deleting records

If the table above, which is called "world", we can add a new record using the SQL:

INSERT INTO world VALUES('United Kingdom', 'Europe', '242900', '64105700', '2471600000000', 'London')

When you use this command, it is important that you add the correct number of fields, and surround each item in speech marks, otherwise you will get an error message.

UPDATE world SET area=242890 WHERE name='United Kingdom'

This SQL will alter one or more fields. You have to specify where the data is that you want to change (the world database), what specifically it is that you want to change, and to what (area=242890) and lastly add a criteria clause so that only one record is altered. If the criteria clause was missed off in this example, then every single record in the database would be updated.

DELETE FROM world WHERE name='United Kingdom'

The delete statement should be used cautiously as you could potentially delete the whole database if you make a mistake! The actual statement is easy to understand, we are deleting a whole record from the world table that matches the criteria of having a name of 'United Kingdom'

Arrays in Python (Lists)

Two Dimensional Lists

It is a quite common requirement when we are writing a program that uses lists to store items that are connected in some way. We need to store firstnames and surnames, and possibly students addresses and scores for their exams.

We can do this using a two dimensional list. Instead of just one index, we can have two - think of them as being the row and column numbers:

students[0][0] = "John"

students[0][1] = "Wayne"

students[0][2] = "10 Poplar Avenue"

students[0][3] = 12.5

If this example, we can see that all of the data in row [0] is linked together.

The code is valid Python, but it is more normal to add a full one dimensional list to another like this:

students = []

students.append(["John", "Wayne", "10 Poplar Avenue", 12.5]) # Add a list to our students list

students.append(["Billy", "Elliot", "15 High Street", 14.2]) # ...and add another.

There are two ways that we can iterate through this two dimensional list. The first method uses a control variable which will take the value of each row on each successive loop, so child will be ["John", "Wayne", "10 Poplar Avenue", 12.5] in the first iteration and then ["Billy", "Elliot", "15 High Street", 14.2] in the second. We use a second for loop to iterate through the loop, in this case the variable item. Item will be "John", and then "Wayne", and the "10 Poplar Drive" etc.

for child in students:

    for item in child:

        print(item)

The second method uses two for loops, and we can use the len() function to determine how many items are in the rows and columns. This code produces exactly the same result:

for x in range(len(students)):

    for y in range(len(students[x])):

        print(students[x][y])

Arrays are great ways of storing data but cannot cope with large volumes of data very well, particularly when we need to search and filter the data. To do this, we need to use a database.

A database is an organised collection of data. Data is stored in tables, and the tables can have any number of fields. Each item added to the table is referred to as a record. The data is stored is a fairly standard format, which can be accessed using a database browser program.

Python 3 uses functions a lot and most of the reserved words that it uses are actually functions. Let's examine an example:

print('This is a function', 'that can take multiple arguments')

This is the print function which takes values inside the brackets and displays them on the screen. To do this, Python uses a large section of code that can vary from one operating system to another. The programmer will never know this, as all they see is the print function.

We can easily make new functions:

def sayhello(name):

print('Hello', name)

This will give us a new reserved word, that we can use anywhere in our program. Whenever we type sayhello('John') then the message 'Hello John' will be printed to the monitor.

Difference Between a Function and a Procedure

A function is able to return a value, so for example:

total_payable = calculate_VAT(sale_price)

This line uses a function called calculate_VAT() which is passed the parameter sale_price and returns a value which is stored in a variable called total_payable.

On the other hand, a procedure does not return a value. An example of a procedure may be a subroutine that displays a game board on the screen.

Functions and procedures, also known as subroutines, make program code much easier to understand. By using a modular approach (sometimes called black box programming and more formally known as object orientated programming), then larger problems can be broken down into smaller sections. In the above example, we could easily change the function to output 'Hello John, how are you?' and by changing just the function, every part of the program that called the function would be updated.

The variable (or variables) inside the brackets are known as parameters. When the function is called, whatever is inside the brackets will be passed to the function and the function will set the variables in the brackets to those values.

Functions can also return values. Values can be passed to a function by including them inside the brackets, but you can also use them like this:

def includeVAT(price):

    VATrate = 0.2

    return price + price * VATrate

This will make a new function that will add VAT (20% or 0.2) onto any value that is passed to it. We can use the function like this:

price = 4.20

totalPrice = includeVAT(price)

print(totalPrice)

Variable Scope

When you use Thonny, you will notice that it display some of the variable names in italics. That is because the variables inside a function are known as local variables and thier scope is said to be local. in the above example, we created a new variable called VATrate inside the includeVAT function, and set it to the value 0.2. If you try and refer to this value outside of the function, then you get an error. Variables outside of the functions are said to have a global scope.

We can illustrate this with the following example:

Arithmetic and Comparison Operators.