CPX19Strings, Files, Validation and Authentication

A string is a sequence of characters. Like a list, each character has an index starting at 0.

• text[start:end] gives the characters from start up to but not including end. The slice has end - start characters.
• Slicing past the end is safe: "Li"[0:5] is just "Li". Indexing past the end, "Li"[5], is an IndexError.
• for letter in word: goes through the characters one at a time.
• You can’t change one character of a string in place (word[0] = "X" is a TypeError). Build a new string instead: word = "X" + word[1:len (word)].
• Compare whole strings with one relational operator: if (code == "AB"):. You don’t need to compare them letter by letter.
• Upper and lower case are different characters: "Leeds" == "leeds" is False. Convert both to one case first if case shouldn’t matter.

A slice includes the start index but stops before the end index

String

A sequence of characters. Python: str.

Slicing

Taking part of a string: text[start:end] gives indexes start to end − 1.

Concatenation

Joining strings end to end with +.

A method is called with a dot after the string: name.upper (). It returns a new value. The original string doesn’t change, so store the result: name = name.upper ().

• The is… methods return True or False, so they fit straight into a condition: if (pin.isdigit ()):.
• On an empty string, isalpha (), isdigit () and isalnum () all return False.
• "-5".isdigit () and "2.5".isdigit () are False: - and . aren’t digits.
• A space isn’t a letter or a digit, so "LS6 2QT".isalnum () is False.
• Use find when the text might be missing (test for -1), and index only when you know it is there.
• split always returns a list of strings. Convert number fields yourself.

fullName = input ("Full name: ")
space = fullName.find (" ")
surname = fullName[space + 1:len (fullName)]
print (surname.upper ())

Method

A subprogram called on a value with a dot, e.g. word.upper ().

Every character has a number. The first 128 Unicode codes are the same as ASCII.

• Letters run in order: if "A" is 65, "D" is 68. The next letter after c is chr (ord (c) + 1).
• Each lower-case letter’s code is 32 more than its capital: ord ("a") - ord ("A") is 32.
• A letter’s position in the alphabet is ord (letter) - 64 for capitals (A is 1).
• Digits: ord ("7") is 55, not 7. int ("7") gives the number 7. Read the question to see which one it wants.
• Comparisons between strings use these codes, which is why "Z" < "a" is True.

word = "CAB"
for letter in word:
    print (letter, ord (letter) - 64)

ord ()

Returns the integer code of a single character: ord ("A") is 65.

chr ()

Returns the character for an integer code: chr (65) is "A".

In Paper 2, data files are comma-separated value (CSV) text files: one record per line, fields separated by commas, every line ending in a line feed (\n).

• Open the file for reading: inFile = open ("Birds.txt", "r"). Use the file name constant if there is one.
• Loop through the lines: for line in inFile: reads one line each pass.
• Strip the line feed: line = line.strip ("\n"). Without this, the last field ends in \n and won’t match or convert properly.
• Split into fields: fields = line.split (","). Every field is a string: convert numbers with int () or float ().
• Use the fields straight away, or append them as a record to a two-dimensional list.
• Close the file when you’ve finished: inFile.close ().
• Also in the PLS: readline () returns the next line (an empty string at the end of the file), and readlines () returns a list of all the lines.
• Opening a file that isn’t there for reading crashes with a FileNotFoundError. Keep data files in the same folder as the program.

Strip, split, convert: the three steps for every line

Robin,14
Blue tit,22
Wren,6
Magpie,9

# -------------------------------------------------------------------
# Constants
# -------------------------------------------------------------------
IN_FILE = "Birds.txt"

# -------------------------------------------------------------------
# Global variables
# -------------------------------------------------------------------
inFile = ""
line = ""
fields = []
total = 0

# -------------------------------------------------------------------
# Main program
# -------------------------------------------------------------------
inFile = open (IN_FILE, "r")
for line in inFile:
    line = line.strip ("\n")
    fields = line.split (",")
    print (fields[0], fields[1])
    total = total + int (fields[1])
inFile.close ()

print ("Total birds:", total)

CSV file

A text file with one record per line and fields separated by commas.

Line feed

The control character \n that ends each line of a text file.

• Build each line first: convert each field to a string, join them with commas, add "\n" at the end. Then write the whole line: outFile.write (outLine).
• outLine = name + "," + str (score) + "\n". No spaces round the commas, and nothing after the last field except the line feed.
• writelines (list) writes a list of strings, one after another. It doesn’t add line feeds, so each string must end with "\n" already.
• Open a file for reading or writing, not both at once.
• Always close () the file. Data may not be saved properly if you don’t.
• Run file-writing programs twice and look at the file. With "w" it should be the same each time; with "a" it should grow.

Choose the mode carefully: "w" wipes the file first

stock = [["Wool", 50, 14], ["Cotton", 100, 3], ["Silk", 25, 21]]

OUT_FILE = "Yarn.txt"
stock = [["Wool", 50, 14], ["Cotton", 100, 3], ["Silk", 25, 21]]

outFile = open (OUT_FILE, "w")
for record in stock:
    outLine = record[0] + "," + str (record[1]) + "," + str (record[2]) + "\n"
    outFile.write (outLine)
outFile.close ()

Write mode ("w")

Opens a file for writing; any existing contents are destroyed.

Append mode ("a")

Opens a file so new data is added to the end of what is already there.

Validation checks that input is sensible and in the right form before the program uses it. It stops a program crashing or storing nonsense.

• Validation can’t make data correct. An age of 14 typed as 15 passes a range check. It only rejects data that can’t be right.
• Check the pattern before converting: test text.isdigit () before int (text), so letters don’t cause a ValueError.
• Use the constants given for limits: (len (code) >= MIN_LENGTH), not >= 6.
• Several checks on one item: put the presence check first. On an empty string, a later check such as text[0] would crash.
• Tell the user which check failed, so they know what to fix.
• Only validate what the question asks for. Extra checks earn nothing.

if ((len (code) == 5) and (code[0:2].isalpha ()) and
        (code[0:2].isupper ()) and (code[2:5].isdigit ())):
    print ("Valid")

Validation

Checking that input data is sensible, reasonable and in the right form before it is used.

Presence check

Checks that data has been entered.

Length check

Checks the number of characters.

Range check

Checks that a value lies between a lower and an upper limit.

Pattern check

Checks the type of characters and where they are, e.g. letters then digits.

Pearson’s advice: a while loop that only ends when the input is valid is an effective way to validate user input.

• Pattern 1: input once, then while (input is invalid): show a message and input again.
• Pattern 2: a Boolean flag. valid = False, then while (not valid): input, check, and set valid = True when every check passes.
• The flag pattern suits several checks with a different message for each.
• For a number, check the text with isdigit () first, then convert and range-check.
• If a question says to use relational and logical operators in an if (reject and stop), don’t add a loop. Do what the question says.

The program can’t continue until the check passes

MAX_TICKETS = 10
valid = False
tickets = 0

while (not valid):
    entry = input ("Number of raffle tickets (1 to 10): ")
    if (not entry.isdigit ()):
        print ("Please enter a whole number")
    else:
        tickets = int (entry)
        if ((tickets >= 1) and (tickets <= MAX_TICKETS)):
            valid = True
        else:
            print ("You can buy from 1 to", MAX_TICKETS, "tickets")

print ("Booking", tickets, "tickets")

Authentication confirms that a user is who they claim to be, usually by checking an ID and password against stored values, before letting them in.

• Store the users as a two-dimensional list of records, such as [["ID", "password"], …].
• Take the ID and password as input (presence-check them if asked).
• Look up the ID with a linear search: a while loop with a found flag that stops at a match or at the end of the list.
• Only compare the password with the password in the record you found, not with every password in the table.
• Give the result: ID not found, wrong password, or access allowed. Exam questions often ask for separate messages. Real systems usually say only ‘details not recognised’, so attackers can’t learn which IDs exist.
• Comparisons are case-sensitive. Convert the ID with upper () if case shouldn’t matter, but never the password.
• A limit on attempts (for example 3) slows down anyone guessing passwords.

members = [["Y104", "5521"], ["Y233", "0906"], ["Y317", "7340"]]
found = False
index = 0

memberID = input ("Member ID: ")
pin = input ("PIN: ")

while ((not found) and (index < len (members))):
    if (members[index][0] == memberID):
        found = True
    else:
        index = index + 1

if (not found):
    print ("ID not found")
elif (members[index][1] == pin):
    print ("Welcome")
else:
    print ("Wrong PIN")

Authentication

Checking a user’s identity, e.g. by matching an ID and password with stored values.

Paper 2’s longest questions often combine everything: read a file, check or process each record, and write the results to another file.

• Plan the sections first: constants for file names and limits, global variables, then the main program.
• Open the input file for reading and the output file(s) for writing before the loop. Close them all after it.
• Inside the loop: strip, split, convert, check or calculate, then build and write the output line.
• Go through the file once. Don’t read it all into a list first unless you need to use the data again later.
• Keep a count or total during the loop and show a summary after it.
• Run the program, open the output file to check it, then run it again to make sure the result is still right.

101,Noodles,4.20,2
102,Wrap,6.75,1
103,Bao bun,3.10,3

IN_FILE = "Orders.txt"
OUT_FILE = "Bills.txt"
dayTotal = 0.0

inFile = open (IN_FILE, "r")
outFile = open (OUT_FILE, "w")
for line in inFile:
    fields = line.strip ("\n").split (",")
    cost = float (fields[2]) * int (fields[3])
    dayTotal = dayTotal + cost
    outFile.write (fields[0] + "," + "{:.2f}".format (cost) + "\n")
inFile.close ()
outFile.close ()

print ("Day total: £" + "{:.2f}".format (dayTotal))