Python GUI Programming with Tkinter电子书

Title Page

Copyright and Credits

Python GUI Programming with Tkinter

Dedication

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

Introduction to Tkinter

Introducing Tkinter and Tk

Choosing Tkinter

Installing Tkinter

Installing Python 3 on Windows

Installing Python 3 on macOS

Installing Python 3 and Tkinter on Linux

Introducing IDLE

Using the shell mode of IDLE

Using the editor mode of IDLE

IDLE as a Tkinter example

Creating a Tkinter Hello World

Creating a better Hello World Tkinter

Summary

Designing GUI Applications with Tkinter

A problem at ABQ AgriLabs

Assessing the problem

Gathering information about the problem

What you found out

Information about the data being collected

Information about the users of the application

Documenting specification requirements

Contents of a simple specification

Writing the ABQ data entry program specification

Designing the application

Exploring Tkinter input widgets

Grouping our fields

Laying out the form

Laying out the application

Summary

Creating Basic Forms with Tkinter and ttk Widgets

Evaluating our technology choices

Choosing a technology

Exploring Tkinter widgets

The Entry widget

The Spinbox widget

The Combobox widget

The Checkbutton widget

The Text widget

The Button widget

The LabelFrame widget

Implementing the application

Saving some time with a LabelInput class

Building the form

Adding LabelFrame and other widgets

Retrieving data from our form

Resetting our form

Building our application class

Saving to CSV

Finishing and testing

Summary

Reducing User Error with Validation and Automation

Validating user input

Strategies to prevent data errors

Validation in Tkinter

Creating a DateEntry widget

Implementing validated widgets in our form

Exploiting the power of multiple inheritance

A validating mixin class

Building our widgets

Requiring data

A Date widget

A better Combobox widget

A range-limited Spinbox widget

Dynamically adjusting the Spinbox range

Updating our form

Displaying errors

Preventing form submission on error

Automating input

Inserting a date

Automating Lab, Time, and Technician

Summary

Planning for the Expansion of Our Application

Separating concerns

The MVC pattern

What is a model?

What is a view?

What is a controller?

Why complicate our design?

Structuring our application directory

Basic directory structure

The abq_data_entry.py file

The README.rst file

ReStructuredText

Populating the docs folder

Making a Python package

Splitting our application into multiple files

Creating the models module

Moving the widgets

Moving the views

Removing redundancy in our view logic

Creating the application file

Running the application

Using version control software

A super-quick guide to using Git

Initializing and configuring a Git repository

Adding and committing code

Viewing and using our commits

Summary

Creating Menus with Menu and Tkinter Dialogs

Solving problems in our application

Deciding how to address these problems

Implementing simple Tkinter dialogs

Tkinter messagebox

Showing the error dialogs

Designing our menu

Creating menus in Tkinter

Implementing our application menu

Showing an About dialog

Adding the menu functionality in the controller

Handling file selection

Making our settings work

Persisting settings

Building a model for settings persistence

Using the settings model in our application

Summary

Navigating Records with Treeview

Implementing read and update in the model

Adding read and update to our model

Implementing get_all_records()

Implementing get_record()

Adding update to save_record()

Implementing a record list view

The ttk Treeview

Implementing our record list with Treeview

Configuring a Treeview widget

Adding a scrollbar

Populating the Treeview

Responding to record selection

Modifying the record form for read and update

Updating __init__()

Adding a load_record() method

Updating the rest of the application

Main menu changes

Connecting the pieces in Application

Adding the RecordList view

Moving the model

Populating the record list

Adding the new callbacks

Cleaning up

Testing our program

Summary

Improving the Look with Styles and Themes

Working with images in Tkinter

Tkinter PhotoImage

Adding the company logo

Setting our Window icon

Styling Tkinter widgets

Widget color properties

Using widget properties on our form

Using tags

Styling our record list with tags

Tkinter fonts

Giving users font options

Styling Ttk widgets

Exploring a Ttk widget

Styling our form labels

Styling input widgets on error

Making our Spinbox a Ttk widget

Updating ValidatedMixin

Setting themes

Building a theme selector

Summary

Maintaining Cross-Platform Compatibility

Writing cross-platform Python

Filenames and filepaths across platforms

Path separators and drives

Path separator translation

The os.path module

The pathlib module

Case-sensitivity

Symbolic links

Path variables

Inconsistent library and feature support

Python's platform-limited libraries

Checking low-level function compatibility

The dangers of the subprocess module

Text file encodings and formats

Graphical and console modes

Writing code that changes according to the platform

Writing cross-platform Tkinter

Tkinter version differences across platforms

Application menus across platforms

Menu widget capabilities

Menu guidelines and standards

Windows user experience interaction guidelines

Apple's human interface guidelines

Linux and BSD human interface guidelines

Accelerator keys

Fonts

Theme support

Window zoomed state

Improving our application's cross-platform compatibility

Storing preferences correctly

Specifying an encoding for our CSV file

Making platform-appropriate menus

Preparing our MainMenu class

Building the Windows menu

Building the Linux menu

Building the macOS menu

Creating and using our selector function

Summary

Creating Automated Tests with unittest

Automated testing basics

A simple unit test

The unittest module

Writing a test case

TestCase assertion methods

Fixtures

Using Mock and patch

Running multiple unit tests

Testing Tkinter code

Managing asynchronous code

Simulating user actions

Specifying an event sequence

Managing focus and grab

Getting widget information

Writing tests for our application

Testing our model

Testing file reading in get_all_records()

Testing file saving in save_record()

More tests

Testing our application

Testing our widgets

Unit testing the ValidatedSpinbox widget

Integration testing the ValidatedSpinbox widget

Testing our mixin class

Summary

Improving Data Storage with SQL

PostgreSQL

Installing and configuring PostgreSQL

Connecting with psycopg2

SQL and relational database basics

Basic SQL operations

Syntax differences from Python

Defining tables and inserting data

Retrieving data from tables

Updating rows, deleting rows, and more WHERE clauses

Subqueries

Joining tables

Learning more

Modeling relational data

Normalization

The entity-relationship diagrams

Assigning data types

Creating the ABQ database

Creating our tables

Creating the lookup tables

The lab_checks table

The plot_checks table

Creating a view

Integrating SQL into our application

Creating a new model

Adjusting the Application class for the SQL backend

Building a login window

Using the login window

Fixing some model incompatibilities

DataRecordForm creation

Fixing the open_record() method

Fixing the on_save() method

Creating new callbacks

Updating our views for the SQL backend

The data record form

The record list

Last changes

Summary

Connecting to the Cloud

HTTP using urllib

Basic downloading with urllib.request

Creating a download function

Parsing XML weather data

Implementing weather data storage

Creating the SQL table

Implementing the SQLModel.add_weather_data() method

Updating the SettingsModel class

Adding the GUI elements for weather download

HTTP using requests

Installing and using requests

The requests.session() fucntion

The response objects

Implementing API upload

Creating a test HTTP service

Creating our network function

Updating application

Updating the models.py file

Finishing up

FTP using ftplib

Basic concepts of FTP

Creating a test FTP service

Implementing the FTP upload function

Listing files

Retrieving files

Deleting or renaming files

Adding FTP upload to the GUI

Summary

Asynchronous Programming with Thread and Queue

Tkinter's event queue

The after() and after_idle() methods

The update() and update_idletasks () methods

Eliminating freezes with after() and update_idletasks ()

Running code in the background with threading

The threading module

Converting our network functions to threads

Simulating a slow server

Demonstrating the threaded versus non-threaded uploader

Passing messages using a queue

The Queue object

Using queues to communicate between threads

Adding a communication queue to our threaded uploader

Creating a communications protocol

Sending messages from the uploader

Handling queue messages

Summary

Visualizing Data Using the Canvas Widget

Drawing and animation with Tkinter's Canvas

Animating Canvas objects

Creating our objects

Animating the racers

Detecting and handling a win condition

Creating simple graphs on the canvas

Creating the model method

Creating the graph view

Updating the application

Advanced graphs using Matplotlib and Tkinter

Data model method

Creating the bubble chart view

Application method

Summary

Packaging with setuptools and cx_Freeze

Using setuptools

Configuring a setup.py script

Basic metadata arguments

Packages and dependencies

Adding extra files

Defining commands

Creating and using source distributions

Testing our source distribution

Building a wheel distribution

Using cx_Freeze

First steps with cx_Freeze

The build_exe options

Including external files

Building executables

Cleaning up the build

Building Windows executables with cx_Freeze

Building a Windows installer file

Building macOS executables with cx_Freeze

Building macOS application bundles

Building macOS .dmg files

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think