By the end of this lesson you should be able to:
currentRecord and highestIndex variablesloadData() function in deserialisationDeserialising is the process of converting a byte stream back into an object. In the previous lesson we looked at serialising objects into a file. In this lesson we shall look at how to deserialise objects from a file and display them in a GUI form.
Once the program starts to run, the data in the file will be serialised into list, each element of the list containing a deserialised object. Those objects, of course, will be objects of the class Employee that we have met in previous lessons.
Once all of the objects are loaded into the list we can start browsing them. This will involve having buttons that will take us to:
Each of the buttons will have a corresponding function that will be called when the button is clicked. The function will display the record in the text widget.
Go to top
import tkinter as tk
from tkinter import *
#import employeeClass
import pickle
These are the libraries we have been using so far. We only need to comment on line 3.
We won't be using the Employee class in this program because there is no need for it. When we deserialise our 'Workers.pickle' file each object is fully recreated and all of its functionalities are available to us. We would only need to import the Employee class if we were to create more objects of it, which we are not doing in this case.
Here we shall create the form that will display the records. The form will have a text widget that will display the records and four buttons that will be used to navigate through the records.
def createForm
global currentRecord
currentRecord = 0
root = Tk()
frame1 = Frame(root, width = 500, height = 300, bg = 'lightgrey')
frame1.pack()
The code block above should be familiar apart from lines 7 and 8. At line 7 we declare a variable currentRecord and we initialise it to zero at line 8.
In our current application we shall be moving through a list, either backwards or forwards and currentRecord will keep track of our position in the list.
text_widget = tk.Text(master= frame1, borderwidth=4, width=35, height=16, font=("Helvetica", 14, "bold"), bg="white")
text_widget.pack(padx=1, pady=1)
text_widget.place(x = 30, y = 10)
#text_widget.insert("0.0", "Added text at the end\n")
Here we are meeting a new form control: the Text widget. It is more versatile than the Entry element and it can accommodate multiple lines of text. It's code is at line 14. As it is a very long line we shall reproduce it here:text_widget = tk.Text(master= frame1, borderwidth=4, width=35, height=16, font=("Helvetica", 14, "bold"), bg="white")
From the above we can see that it is part of frame1, that it has a width of 35 character spaces and the height of 16 character space. Its font is set at Helvetics, 14 points.
firstButton = Button(master=frame1, text='First Record', width=10, command=lambda: firstRecord())
firstButton.place(x = 350, y= 10)
lastButton = Button(master=frame1, text='Last Record', width=10, command=lambda: lastRecord())
lastButton.place(x = 350, y= 100)
nextButton = Button(master=frame1, text='Next Record', width=10, command=lambda: nextRecord())
nextButton.place(x = 350, y= 40)
previousButton = Button(master=frame1, text='Previous Record', width=10, command=lambda: previousRecord())
previousButton.place(x = 350, y= 70)
Here we have four buttons that will be used to navigate through the list of records. Each button has a corresponding function that will be called when the button is clicked. The functions are firstRecord(), lastRecord(), nextRecord() and previousRecord(). We shall be looking at those four functions shortly.
Salaries = []
def loadData():
with open('Workers.pickle', 'rb') as file:
while True:
try:
Salaries.append(pickle.load(file))
except EOFError:
break
loadData()
At line 27 we declare a list Salaries that will hold the deserialised objects. The function loadData() is called at line 31 and it reads the file Workers.pickle and deserialises the objects into the list Salaries.
At line 29 we have a while loop that will keep reading the file until the end of the file is reached. The try block at line 30 will keep reading the file and appending the objects to the list Salaries until the end of the file is reached. At that point an EOFError will be raised and the except block at line 32 will be executed.
global highestIndex
highestIndex = len(Salaries) - 1
def firstRecord():
global currentRecord
if Salaries: # Check if the list has any values.
currentRecord = 0
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, Salaries[currentRecord].toString())
else:
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, "No records available.")
At line 40 we declare a variable highestIndex and we initialise it to the length of the list Salaries minus one. This will be used to check if we have reached the end of the list.
The function firstRecord() starts at line 43. At line 44 the global variable currentRecord is initialised again. This means that the global variable declared at line 7 is accessible inside firstRecord().
The rest of the function is an if..else construct.
At line 45 the list Selection is checked for content. If there is at least one element in it then a value of true is returned and the code at lines 46 - 48 is executed. This involves:
currentRecord to zeroIf the list is empty then the code at lines 49 - 51 is executed
def lastRecord():
global currentRecord
if Salaries:
currentRecord = highestIndex
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, Salaries[currentRecord].toString())
else:
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, "No records available.")
The function lastRecord() is similar to firstRecord() but it sets the currentRecord to the highest index in the list.
def nextRecord():
global currentRecord, highestIndex
if Salaries:
currentRecord += 1
if currentRecord > highestIndex:
currentRecord = 0
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, Salaries[currentRecord].toString())
else:
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, "No records available.")
Here we only need to explain lines 66 - 68.
At line 66 the value of currentRecord is incremented by 1. Line 67 tests the new value for being higher than highestIndex. If this is true then currentRecord is set to zero. The outcome of this is that once currentRecord is incremented, the system must check if it is gone past the last element on the list. If this is the case then currentRecord is set to zero so that the first element in the list is accessed.
def previousRecord():
global currentRecord, highestIndex
if Salaries:
currentRecord -= 1
if currentRecord < 0:
currentRecord = highestIndex
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, Salaries[currentRecord].toString())
else:
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, "No records available.")
root.title('Deserialising Employee Records')
root.mainloop()
Here we have the function previousRecord(). The code at lines 78 - 80 is similar to that of nextRecord() but the difference is that the value of currentRecord is decremented by 1. Line 81 tests if the value of currentRecord is less than zero. If this is true then currentRecord is set to the highest index in the list, i.e. it is set to the value of the last element.
if __name__ == "__main__":
createForm()
Again the above code should be familiar to you.
Above is a short video demonstration of the program running.
This lesson describes the process of deserializing objects from a file and displaying them in a GUI using Python. It explains how a byte stream is converted back into objects, specifically Employee class objects in this context. The deserialized objects are loaded into a list, and the document details how to navigate through this list using GUI buttons and corresponding functions. It also explains the use of the Text widget for displaying the deserialized data and the logic behind functions like firstRecord(), lastRecord(), nextRecord(), and previousRecord() for browsing through the records. The document further clarifies the roles of variables like currentRecord and highestIndex in managing the navigation.
Go to top1. Explain the process of deserialization as described in the text. What is its purpose, and how does it relate to the `Employee` class mentioned in the document?
2. Describe the functionality of the `firstRecord()`, `lastRecord()`, `nextRecord()`, and `previousRecord()` functions. How do they enable navigation through the deserialized objects?
3. Explain the role of the `currentRecord` and `highestIndex` variables in the code. How are they used to manage the navigation and display of records in the GUI?
4. Describe how the `loadData()` function works. What is the purpose of the `try-except` block within this function, and why is it necessary?
5. Explain the purpose and functionality of the Text widget in the GUI. How does it differ from the Entry element, and why is it more suitable for this application?
Go to top