Python Advanced

Learning Outcomes

By the end of this lesson you will be able to:

• Understand the process of serializing Python objects using a GUI.
• Use the tkinter library to create a GUI for data input.
• Apply the pickle module to serialize and deserialize Python objects.
• Implement a two-stage serialization process: storing data in a list and then serializing the list.
• Design a GUI that allows users to input data, store it, and save it to a file.
• Explain the importance of user feedback in GUI applications.
• Utilize Python classes in conjunction with GUI programming for data management.

Introduction

The document focuses on data serialization in Python using a Graphical User Interface (GUI). It explains how to save employee data (name, IRD number, hours worked, and hourly rate) using Python's tkinter library for the GUI and the pickle module for serialization. The process involves creating a GUI form for data input, temporarily storing the data as Employee class objects in a list, and then serializing that list into a file.

Complete Program

Form elements

                        import tkinter as tk
                        from tkinter import *
                        import employeeClass
                        import pickle
                        
                        def createPayroll():
                          root = Tk()
                          frame1 = Frame(root, width = 420, height = 240)
                          frame1.pack()
                        
                          varName=StringVar()
                          varIRD=StringVar()
                          varHours=DoubleVar()
                          varRate=DoubleVar()
                        
                          nameLabel=tk.Label(master=frame1,text='Full Name',width=15, anchor=E)
                          nameLabel.place(x = 40, y = 10)
                          irdLabel=tk.Label(master=frame1,text='IRD Number',width=15, anchor=E)
                          irdLabel.place(x = 40, y = 45)
                        
                          hoursLabel=tk.Label(master=frame1,text='Hours Worked',width=15, anchor=E)
                          hoursLabel.place(x = 40, y = 80)
                          rateLabel=tk.Label(master=frame1,text='Hourly Rate',width=15, anchor=E)
                          rateLabel.place(x = 40, y = 115)
                        
                          txtName=tk.Entry(master=frame1,relief=RAISED, textvariable=varName,width=15,bg="#ffffff", bd=1)
                          txtName.place(x = 180, y = 10)
                          txtIRD=tk.Entry(master=frame1,relief=RAISED, textvariable=varIRD,width=15,bg="#ffffff", bd=1)
                          txtIRD.place(x = 180, y = 45)
                        
                          txtHours=tk.Entry(master=frame1,relief=RAISED, textvariable=varHours,width=15,bg="#ffffff", bd=1)
                          txtHours.place(x = 180, y = 80)
                          txtRate=tk.Entry(master=frame1,relief=RAISED, textvariable=varRate,width=15,bg="#ffffff", bd=1)
                          txtRate.place(x = 180, y = 115)
                        
                          calculateButton=Button(master=frame1,text='Save to list', width = 20, command=lambda:saveToList(varName.get(), varIRD.get(), varHours.get(),varRate.get()))
                          calculateButton.place(x = 120, y= 150)
                        
                          calculateButton=Button(master=frame1,text='Save to File', width = 20, command=lambda:saveToFile())
                          calculateButton.place(x = 120, y= 180)
                    

The above block of code has been discussed in the previous lesson and, therefore, should be familiar to you. It is shown here only for completeness.

The three listings below are part of the GUI form that we only glanced at in the previous lesson. Here we shall look at it in more detail.

In this example data serialisation is in two stages. The first stage is temporarily storing the objects in a list until data input is complete. The second stage is serialising the contents of that list into a file. In listing 1-2 we shall begin with the first stage of the process.

Generating and saving data

                          Salaries = []
                          def saveToList(argName, argIRD, argHrs, argRt):
                              worker = employeeClass.Employee(argName,argIRD, argHrs, argRt)
                              Salaries.append(worker)
                              print(worker.toString())
                              varName.set("")
                              varIRD.set("")
                              varHours.set(0)
                              varRate.set(0)
                              txtName.focus()
                    

At line 42 the list Salaries[] is initialised. This is where the objects of the class Employee will be stored prior to being serialised.

At line 43 the function saveToList() is activated and the values for the name, ird number, hours and rate are passed to its four parameters.

Line 44 uses those four parameters to create an object of the class Employee This object is then appended to the list Salaries at line 45. This completes the essential part of saveToList() - the rest is tidying up

The contents of the Employee object is printed to the monitor at line 46. This is, strictly speaking, not necessary but it complies with the usability heuristic "visibility of system status".

Lines 47 - 51 initialise the values of the bridging classes.

Saving Data

                          def saveToFile():
                              with open('Workers.pickle', 'ab') as file:
                                  for worker in Salaries:
                                      pickle.dump(worker, file)
                              print("Data saved to file")
                    

Listing 1-3 is the second stage of the serialisation process. The function saveToFile() is activated when the button "Save to File" is clicked. The function opens the file Workers.pickle in append binary mode. The file is opened in append mode so that the data is not overwritten each time the function is called.

A for loop in lines in lines 55 - 56 controls serialising the contents of Salaries into the .pickle file. The loop simply iterates over the objects of the list and for each object uses the pickle.dump() method to serialise the current object.

Once all of the objects are serialised the file is closed and line 57 informs the user that saving the data is complete. This is another example of making the system status visible to the user.

Finishing the program

                          root.title("Payroll")
                          root.mainloop()
                        
                        if __name__ == "__main__":
                          createPayroll()
                    

Again there is no need to explain the finishing lines of the program.

Summary

The document describes a two-stage data serialization process: first, employee data is collected via a GUI and stored in a list; second, the contents of this list are serialized into a file. The saveToList() function handles data input and temporary storage, while the saveToFile() function performs the serialization using pickle.dump(). The importance of providing user feedback (e.g., confirming when data is saved) is also emphasized.

Revision

Multi choice

• What is the primary purpose of the `saveToList()` function?
  • To save data directly to a file.
  • To create a GUI.
  • To temporarily store objects in a list.
  • To print data to the console.
• Which data structure is used to temporarily store objects before serialization?
  • Dictionary
  • Tuple
  • List
  • Set
• What method is used to serialize objects into a file?
  • `write()`
  • `dump()`
  • `save()`
  • `serialize()`
• In which mode is the file opened for serializing data?
  • Read mode
  • Write mode
  • Append binary mode
  • Text mode
• What does the `pickle.dump()` method do?
  • Reads data from a file.
  • Writes data to a file.
  • Serializes an object.
  • Deserializes an object.
• What is the purpose of printing the `Employee` object's contents to the monitor?
  • To confuse the user.
  • To comply with the usability heuristic "visibility of system status."
  • To slow down the program.
  • To delete the object.
• Which GUI toolkit is used in the code?
  • Qt
  • wxPython
  • Tkinter
  • Kivy
• What is the name of the file used to store the serialized data?
  • Data.txt
  • Employees.txt
  • Workers.pickle
  • Salaries.dat
• What is the purpose of the `StringVar()` and `DoubleVar()`?
  • To store integer values
  • To create labels
  • To create buttons
  • To create bridging classes
• What is done at line 42?
  • A loop is initialised
  • A variable is initialised
  • A class is initialised
  • A list is initialised

Fill in the blanks

• The first stage of data serialization involves temporarily storing objects in a ______.
• The `______` function is used to add Employee objects to the Salaries list.
• The `Salaries` list stores objects of the `______` class.
• The second stage of serialization involves saving the contents of the list into a ______.
• The file is opened in `______` mode to prevent overwriting existing data.
• The `______` loop is used to iterate over the objects in the Salaries list.
• The `______` method is used to serialize each object into the file.
• The `saveToFile()` function is activated when the "______" button is clicked.
• Printing the Employee object's details complies with the usability heuristic "______".
• Lines 47-51 initialise the values of the ______

Assignment

1. Describe the two-stage process of data serialization as explained in the document.

2. Explain the purpose of the `Salaries` list and its role in the serialization process.

3. Outline the steps involved in the `saveToFile()` function, including file handling and data serialization.

4. Discuss the importance of providing feedback to the user during the serialization process and give examples.