For the module "AS91906: Use complex programming techniques to develop a computer program" this lesson meets the following requirements
By the end of this lesson, you will be able to:
Serialisation is the process of converting an object's state into a format that can be stored or transmitted and then reconstructed later. This is particularly useful for saving the state of an object to a file or sending it over a network. In Python, the pickle module is commonly used for serialisation and deserialisation of objects.
Compared to traditional text files, serialisation offers several advantages:
pickle module provides a simple interface for serialising and deserialising objects, making it easy to implement.In this lesson, you will learn how to use the pickle module to serialise and deserialise objects, and how to build a graphical user interface (GUI) using tkinter to interact with these objects.
In the last lesson we looked at how to set up a class so that it would contain both data about employees and functions/methods for processing that data. The problem with that example was that once we shut down the program, all of the data was lost.
One way to save the data is to write it to a file. However, writing and reading data to and from a file can be a complex process, especially if the data is complex. Serialisation is a way to save the data in a format that can be easily written to a file and read back into the program.
For this example, we will use the same class as in the last lesson, the external processing will be different- we shall be serialising the data.
import Validating
import pickle
class Employee:
CompanyName = "Python Enterprises"
EINNumber = "12345678"
minHrs = 5
maxHrs = 60
minRte = 25
maxRte = 100
def __init__(self,empN, empIRD, empHrs,empRte):
self.empName = empN
self.empIRD = empIRD
self.empHrs = empHrs
self.empRte = empRte
self.empGross = self.empHrs * self.empRte
self.empTax = self.empGross * 0.25
self.empNet = self.empGross - self.empTax
def toString(self):
return f"""
Employer:{Employee.CompanyName}
EIN Number:{Employee.EINNumber}
Name:{self.empName}
Hours worked: {self.empHrs}
Hourly Rate: ${self.empRte}
Gross Pay: ${self.empGross}
Tax Deducted: ${self.empTax}
Net Pay: ${self.empNet}
"""
The code above is the same as the code from the last lesson, apart lines 1 and 2. From previous experience line 1 should be familiar to you. It imports a module Validating.py which contains functions for validating user input data.
The second line imports a module named pickle. This has nothing to do with the solution vinegar and brine that you use to to pickle cucumber. However the methods and classes in the pickle library are all aimed at preserving computer data in the same way as cooks use brine or vinegar to preseve cumumbers and other vegetables, hence the name pickle.
Apart from this the rest of the code should be familiar to you.
def main():
Salaries = []
empName = input("Enter employee's name: ")
while len(empName)>0:
empIRD = input("Enter IRD number")
empHours = Validating.validateFloat(10, 60,"hours worked")
empRate = Validating.validateFloat(25, 80, "hourly rate")
worker = Employee(empName,empIRD, empHours, empRate)
Salaries.append(worker)
empName = input("Enter employee's name: ")
with open("Workers.pickle", 'ab') as file:
for worker in Salaries:
pickle.dump(worker, file)
In listing 1-2 the program gathers information from the users using a while loop to control the data entry. Once the values for the name, ird number hours and rate are entered line 38 creates an object of the class Employee. Line 39 then appends the newly created object to the list Salaries where it is stored until the system is ready to store it to a file.
Line 40 asks for the employee's name again and then control is passed up to line 34 where the value entered is tested for being blank. If it is blank control passes to line 42.
Once the loop has terminated line 42 starts the process of saving the data. First the file 'Workers.pickle' is opened in append mode. This identified by the parameter 'ab'. Here the letter 'a' stands for 'append.'
Line 43 then loops through the list Salaries and for each object in the list it is written to the file 'Workers.pickle' using the pickle method dump.
The dump method saves the data one object at a time and therefore the program iterates through lines 43 and 44 until all of the objects in the list have been serialised to the file.
Because of the width keyword at line 42 there is no need to close the file. This is automatically done by the system.
Salaries=[]
with open("Workers.pickle", 'rb') as file:
recordNumber = 0
while True:
try:
worker = pickle.load(file)
Salaries.append(worker)
recordNumber += 1
except EOFError:
break
print(f'{recordNumber} records have been loaded')
for worker in Salaries:
print(worker.toString())
if __name__ == "__main__":
main()
This block of code is the opposite to that in listing 1-2. Here Salaries is initialised as an empty list. Later it will hold the various objects as they are uploaded from the file.
At line 42 a few things need to be mentioned. The most obvious is that "Workers.pikle" is opened in read mode, i.e. we will be reading or extracting data from it. The other is the with statement. This statement is important here. It ensures that the file is automatically closed, even if errors occur within the block. This is a best practice for file handling
At line 48 the variable recordNumber is initialised to zero. As its name implies it will be used to count the number of objects loaded from the file.
Line 49 starts a while loop that will continue until the break statement at line 54 is executed
Line 50 is the first of the try block. Here the load method is used to extract an object from the file. This object is then appended to the list Salaries at line 52. The variable recordNumber is then incremented by one.
You may ask why the while loop is infinite? The reason is that we usually don't know how many records or pickled objects are stored in a file. How we handle this is to keep reading data from the file until we reach the end of the file. Once we try to read past this we get an "end of file error", or known to Python as EOFError. The EOFError is occurs at line 51 when the system tries to read past the end of the file. At this point control passes the except EOFError at line 54. Control then naturally passes to line 55 and the break statement. This will actually break out of the while loop. Behind the scenes then the the file 'Workers.pickle' is closed down and control passes to line 56 where the number of records extracted from the file is displayed.
Lines 57 and 58 then loop through the list Salaries and for each object in the list the toString method is called. This method returns a string that contains all of the data about the employee. This string is then printed to the screen.
Finally, the if __name__ == "__main__": statement at line 60 ensures that the main function is called when the program is run.
