OOP vs. Procedural Programming

• Graphical User Interfaces (GUI) revolutionized the software industry

Introduction to Python GUI

• User interaction drives program execution in GUIs.
• Xerox Palo Alto Research Center developed the first GUI in 1979
• Steve Jobs picked up the GUI idea
• Apple software engineers release first GUI-based Mac in 1984
• GUI programs use widgets e.g. labels, entry boxes, and buttons, placed on a window canvas for user interaction.
• UX/UI designers create visual designs for optimal experience
• Developers code designs using tools like Python

Event-Driven Programming

• Event-driven programming is used in GUI programs
• GUI programs run an infinite loop until terminated
• Widgets are constantly monitored
• Associated events are checked e.g. a button click
• Python code in "callback" functions associated with events.
• User decides the order of execution in event-driven programs

Tkinter Module

• Tkinter comes standard installations and is easy to get started with
• Tkinter doesn't have an easy-to-use designer tool and requires "design-with-code."
• The program structure can be found in Lect13_Payment_Calc.py.
• The code is contained in a single class, e.g. PmtCalcGUI()
• An object like Pmt_calc of the class is instantiated in the main() function, which calls the __init__ constructor.

Main Window

• The main window is also known as the root widget
• The PmtCalcGUI() class’s __init__ constructor acts as a main switchboard
• It creates the main application window (root widget)
• Basic parameters such as window title and size are set
• All widgets are placed inside this window
• User-defined functions are called to create the user interface and implement functionality
• Static and output labels, input entry boxes, frames, radio buttons, list boxes, and command buttons are created

Exact Placement

• Geometry Manager manages the exact placement of widgets
• The place(x, y) method is used for exact placement
• x,y represent the number of pixels from the left/top edge of the main window
• Label widgets are used for static text display using the place(x, y) method
• Mostly uses an add-hoc trial-and-error approac
• Labels display static text.

Input Entry Widget

• Input Entry Widget are generic input box where content entered is interpreted as text.
• There is no control over the kind of the information entered
• The width of the Entry widget is NOT in pixels but in "text units" with 5 holding '00000'
• Use get() to retrieve the content of Entry widgets.
• .focus() sets the input entry active

Frame and Radiobutton

• Frames are can be use to contain other widgets for organization
• Radiobutton are able to only selecte on radio button within a frame
• Selecting another button within a frame deselects the previous one
• IntVar class assigns unique values to radio buttons.
• Frames group widgets
• Radiobuttons allow only one selection within their frame
• IntVar() tracks the selected radio button's value
• Two-way communication between code and buttons use
  • Object variable of IntVar class to set() turns on a button
  • Object variable to get() is how to take action

Listbox Widget

• Listbox display a list of items for user selection
  • Height is number of list items
  • Width is number of text units
• The options for Listboxe are
  • SINGLE: which allow user to select only a single item from the list
  • MULTIPLE: which allow user can select multiple items, items already selected gets deselected
• Vertical scrolling with mouse wheel, scrollbar is a separate, non-covered, widget
• Items are accessed with .get(index)

Command Button Widgets

• Command Button are used to execute program tasks via appropriate functions
• Callback functions will do the task. Attaches to the command attribute and predefine function
• User-defined callback functions gather imputs from widgets, performs needed tasks/stores results
• The function attaches to the Calculate command button for example.
• Perdefined callback function is the destory method is the main function for root widgets
• Typically its attaches to the Quit command button

Output Label

• Output labels are initialized with an empty non-visible text
• StringVar class is used to dynamically display output and uses object variable of StrVar class
• Its a one way of communication. Uses texvariable property of Label widget
• As soon as the variable of StrVar class is updated, change appears on label
• Variable typically updated in callback function of a command button
• Labels are linked with textvariable=StringVar()
• The value is updated with .set()

Qt Designer

• PyQt can be installed by pip install pyqt5
• Qt Designer can be installed by pip install pyqt5-tools
• When using Windows find designer.exe
• Note using Qt creator would eat up space on the hard drive
• Visual GUI is built, then exported to Python with: pyuic5 my_ui.ui -o my_ui.py
• It Ideal for complex interfaces and logic

Payment Calculator with Qt Designer

• It is possible to Run Qt Designer and Create UI visually.
• Use similar object names
• After it is completed the results are saved is Pmt_Calc.ui file
• Convert the filetype to Pmt_Calc.py file with following command pyuic5 Pmt_Calc.ui > Pmt_Calc.py
  • Then conver UTF-16 to UTF-8 Encoding
• Lect13_Pmt_Calc.pyis the main program. Set the UI setting withPmtCalcApp(QDialog) class set is to PmtCalc class
• The QApplication object manages the overall process

Summary

• Event-driven programming is define
• Create GUI through widgets
  • Write the code for buttons etc
  • Test Interface and functionality
• Structure of Python's GUI -
  • Import tkinter module (Mention the alternative also)
  • Entire program in a single class, construct as a switchboard
  • Create the widget and perform desired task
  • Cover widgets: Label, Entry, Frame, Rediobuttton, Listbox, Button
• Examine visual GUI with qt Designer
  • Compare and contrast python and tkinter libraries

Intro to Object-Oriented Programming (OOP)

Procedural (Functional) Programming

• The focus is on Functions that solve specific tasks
• Pros:
  • Modular design (top-down)
  • Simple for sequential problems
    • Fast execution
• Cons:
  • Not ideal for user-driven or non-linear problems
  • Poor code reuse (copy/paste)
  • Hard to manage as code complexity grows

Object-Oriented Programming (OOP)

• Focus: Objects = data + functions (methods)
• Pros:
  • Data hidden (encapsulation)
  • Methods interact with data consistently
  • Reusable, reliable, extensible
  • Easier to maintain large systems
• Cons:
  • Slower execution
    • Harder to learn, more complex

Classes and Objects

• Class: A blueprint for creating objects
  • Attributes: Data (e.g., color, size)
  • Methods: Behavior (e.g., drive, turn)
• Object: An instance of a class
• Example: car1 = Car()

Loan Class Example

• Attributes: Interest rate, term, amount, loan type, period
• Methods:
  • calc_mth_pmt() calculates the monthly payment
  • calc_remain_balance(per) calculates remaining balance
  • calc_interest_savings(per) calculates the total savings

Defining a Class

• __init__: Constructor; runs when an object is created
• self: Refers to current object
• Private attributes start with __ (e.g., __rate)
• Encapsulation hides data

Accessors (Getters)

• Ex:

 def get_rate(self):
  return self.__rate

Mutators (Setters)

• Ex:

 def set_rate(self, rate):
  if rate > 0:
   self.__rate = rate

Using the Class

• Example:

loan1 = Loan(0.045, 30, 400000)
payment = loan1.calc_mth_pmt()

UML Diagram for Loan Class

• Class Name: Loan
• Attributes: __int_rate, __term
• Methods: calc_mth_pmt(), accessors/setters

Summary of OOP

• OOP builds programs using classes and objects
• Procedural programming is step-by-step and better for simple tasks
• OOP is better for user-driven, complex, and scalable systems
• Classes are templates for making objects
• Encapsulation keeps data safe using getters/setters
• UML is helpful for designing and visualizing code

Visual Design with Qt Designer

• Part of PyQt5 (install via pip install pyqt5-tools)
• GUI built visually, then exported to Python with: pyuic5 my_ui.ui -o my_ui.py
• Ideal for more complex interfaces
• Can still add logic with Python after UI is generated

Databases

• Databases are used in airlines, hospitals, banks, etc.
• A database is a collection of related tables.
• Tables consist of fields (columns) and records (rows).
• A Primary Key is a unique identifier for records (e.g., custID in Customer table).
• A Foreign Key is a field in one table referring to the primary key in another (e.g., custID in Loans table).
• Relationships between tables are defined by primary and foreign keys
• Joining tables combines data from multiple sources using common fields

Basic SQL Queries

• SELECT * FROM Customer;
• SELECT firstName, lastName FROM Customer WHERE city='Santa Fe';
• SELECT COUNT(*) FROM Loan GROUP BY loanType;

Database Management Systems (DBMS)

• DBMS software manages relational databases like Oracle, SQL Server, MySQL, SQLite, etc.
• SQLite is a simple, file-based database system

Python and SQLite

• Import the library sqlite3 to implement
• Example:

db_conn = sqlite3.connect('Loans.db')
db_cursor = db_conn.cursor()
db_cursor.execute('SELECT * FROM Customer')
results = db_cursor.fetchall()
db_conn.close()

Database Application Development

• Utilize GUI Components (Tkinter)
  • Listbox for customer selection
    • Treeview table for displaying loan details
    • Radiobuttons for filtering data (e.g., by loan type or city)
    • Events (<>) trigger functions to update displays

Advanced Queries and Summary Functions

Querying multiple tables

• Example:

SELECT firstName, lastName, amount, mthPmt
FROM Customer INNER JOIN Loan
ON Customer.custID = Loan.custID
WHERE city = 'Santa Fe' AND loanType = 'Mortg';

Summary Queries

• Count loans by type:

SELECT loanType, COUNT(*) AS NumLoans
FROM Loan
GROUP BY loanType;

• Calculate average mortgage payment per city:

SELECT city, ROUND(AVG(mthPmt),2) AS avgMthPmt
FROM Customer INNER JOIN Loan
ON Customer.custID = Loan.custID
WHERE loanType = 'Mortg'
GROUP BY city;

Database Notes Summary

• Relational Databases involve tables, records, fields, and relationships.
• SQLite is an easy-to-use relational database.
• Python with SQLite allows querying and managing data.
• GUI Applications use Tkinter components like Listbox, Treeview, and Radiobuttons.
• SQL Queries are used for retrieving, filtering, joining, and summarizing data.