Snakes in the Grass – Learn From My Python Fails

As the January exams approach I have found myself becoming increasingly reflective about my teaching using Python. I have taught the OCR AS Level Computing course for two years now and when we first began the course Python was my immediate language of choice for its simplicity and ease of use. I did not have any experience with Python before I taught it, although obviously I had used many other procedural programming languages during my degree and I was easily able to pick it up. I enjoy using Python and I am glad I chose it, but this post intends to help teachers who are just starting out to avoid some of the pitfalls I have experienced.

Dude, where’s my construct?

The OCR AS syllabus requires students to be able to use select-case statements and do-while / repeat-until loops. Because Python is so compact and simple, it does not actually have these constructs! It is definitely possible to write the equivalent code in Python, but the key words are just not there, so you end up having to teach these concepts as pseudo code or in another language. This inevitably means that the students are less familiar with these constructs when they encounter them in the exam.

For info, here is how to do a select-case statement in Python:

# Select case pseudo code
number = input("Enter a number: ")
select( number ){
    case 0:
        print "You entered a zero"
        break
    case 1:
        print "You entered a one"
        break
    default:
        print "You did not enter a zero or a one"
        break
}

# The same effect in Python 
number = input("Enter a number: ")
if number == 0:
   print "You entered a zero"
elif number == 1:
   print "You entered a one"
else:
   print "You did not enter a zero or a one"

And here is how to achieve the same effect as a repeat-until loop:

# Pseudo code for a repeat until loop
counter = 0
repeat {
     print "Hello world"
     counter++
} until counter == 5;

# The same effect in Python
counter = 0
while( True ):
     print "Hello world"
     counter += 1
     if counter == 5:
          break

As you can see from the repeat-until example, Python also does not have the popular increment operator (++) either so if you wish to increment or decrement a variable you need to use += 1 as the shorthand way of doing it.

My advice: There is no “solution” to this problem – you either accept that you’ll have to teach these constructs as pseudo code, or you use another language to teach in.

Array issues

This one was a very silly decision indeed. I discovered that Python has a fantastic data structure called a list. You can do all sorts of useful things with a list – add items of data, iterate through the list, remove items of data, insert items of data, access them via their list index. Best of all, to create one the only thing you need is an identifier and some brackets – heaven! What idiot would want to go through all of the hassle of using the non-native proper Array construct where you have to faff with importing the library and putting in the type code (see this handy site) just to get one set up?

Well, as it turns out, a very sensible idiot.

You see, the key learning points about arrays in the exam are as follows:

• To set one up you need to know its identifier, how many data items are inside it, and the data type of those items
• Arrays can only hold data of one type (e.g. int, float etc.)
• Arrays are a static (fixed size) data structure

However, lists are somewhat different:

• To set up a list you need to know its identifier
• Lists can hold data of multiple types at once – [“a”, 1, 6.887, True] is a perfectly decent list
• Lists are a dynamic data structure and can be altered in size on the fly at any time

My advice: Whilst you can do absolutely everything you’d need to do with an array with a list as well, they have very different properties. In the exam, students will encounter questions based on the array learning points listed above which are more true for arrays in, say, Java. You try explaining to a class of students who already know how to do a list inside out that what they’ve learnt isn’t an array after all, and an array is slightly but very subtly different. Beware.

Y u so difficult?

The syllabus requires that you teach ‘record’ data structures, another thing which is native in languages such as Pascal but not in Python. (I keep mentioning native – I just mean that it’s part of the language without you having to do anything special to be able to use it.) It’s entirely possible to teach the same concept in Python using a structure called a “named tuple“, but it’s such a faff to set up and it doesn’t really feel as intuitive as the equivalent native type in Pascal (for instance). Add to this that I had no idea what one was until someone told me about it at the CAS working group meeting, so I’d imagine that many teachers new to programming will not quickly encounter this construct within their own learning either.

Edit: Adam McNicol (in the comments) says named tuples are no good for this. He recommends the following:

AQA use a class to simulate a record:

class student:
def __init__(self):
self.first_name = “”
self.last_name = “”

You could then use it:

new_student = student( )
new_student.first_name = “John”
new_student.last_name = “Bain”

My advice: Sitting on the fence here. Currently I’m teaching this as a concept using Pascal, but if I can get a simple explanation of named tuples going I will try to use that for more practical experience opportunities.

Version aversion

When I first started out, Python 2.7 was still rather widely used and so I created all of my resources including my full F452 student workbook using the syntax from 2.7. More recently, Python 3 has started to take over and this brings with it a number of headaches which are beautifully summed up in an appendix of the book “Invent your own Computer Games with Python“. The largest headaches are the fact that the print statement changes into a print function, i.e.

print "Hello world"

becomes…

print("Hello world")

… which sounds OK except that it gives a newline character at the end of the print by default, and whilst you used to be able to just put a comma afterwards to prevent that, you now have to provide an annoying second argument to the function – end=””. Also, the raw_input() function from Python 2.7 is now called input() in Python 3. Except that in Python 2.7 there was also a function called input() but that did something different. CONFUSED DOT COM! There are other syntax changes but these are the most annoying.

My advice: If you are just starting out, choose Python 3 and look for resources made in Python 3, it will save you work in the long run. I am going to be updating my booklet to Python 3 very soon.

Some are more equal than others

This is an extra bonus that I just thought of – the assignment and comparison operators. In Python you use = to assign a value to a variable and == to compare two values. However, in Pascal you use := to assign a value to a variable and = to compare two values. In the exam, pseudo code is used which could use EITHER WAY, because both Python and Pascal are accepted by OCR as teaching languages.

My advice: Continue to teach = and == but warn your students to look at the context clues in the question. They should be able to tell fairly easily from the code whether the = sign is being used as an assignment operator or a comparison operator. You may also need to warn them that && can denote “and” and || can denote “or” as well.