book

Python GUI Programming with Tkinter - Second Edition

Name: Python GUI Programming with Tkinter - Second Edition
Author: Alan D. Moore
ISBN: 9781801815925

by Alan D. Moore

October 2021

Intermediate to advanced

664 pages

16h 1m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touch
Introduction to Tkinter
Introducing Tkinter and TkChoosing TkinterInstalling TkinterInstalling Python 3.9 on WindowsInstalling Python 3 on macOSInstalling Python 3 and Tkinter on LinuxIntroducing IDLEUsing the shell mode of IDLEUsing the editor mode of IDLEIDLE as a Tkinter exampleCreating a Tkinter Hello WorldAn overview of basic TkinterBuilding a GUI with Tkinter widgetsArranging our widgets with geometry managersMaking the form actually do somethingHandling data with Tkinter control variablesUsing control variables in a callback functionThe importance of control variablesSummary
Designing GUI Applications
Analyzing a problem at ABQ AgriLabsAssessing the problemGathering information about the problemInterviewing the interested partiesAnalyzing what we've found outInformation from the data originatorsInformation from the users of the applicationInformation from technical supportInformation from the data consumerDocumenting specification requirementsContents of a simple specificationWriting the ABQ data entry program specificationDesigning the applicationDeciding on input widgetsGrouping our fieldsLaying out the formLaying out the applicationEvaluating technology optionsSummary
Creating Basic Forms with Tkinter and Ttk Widgets
The Ttk widget setThe Label widgetThe Entry widgetThe Spinbox widgetThe Checkbutton widgetThe Radiobutton widgetThe Combobox widgetThe Text widgetText widget indicesThe Button widgetThe LabelFrame widgetImplementing the applicationFirst stepsBuilding the data record formThe Record Information sectionThe Environment Data sectionThe Plant Data sectionFinishing the GUIWriting the callback functionsThe Reset functionThe Save callbackFinishing up and testingSummary
Organizing Our Code with Classes
A primer on Python classesThe advantages of using classesClasses are an integral part of PythonClasses make relationships between data and functions explicitClasses help create reusable codeSyntax of class creationAttributes and methodsMagic attributes and methodsPublic, private, and protected membersInheritance and subclassesUsing classes with TkinterImproving Tkinter classesCreating compound widgetsBuilding encapsulated componentsSubclassing TkRewriting our application using classesAdding a StringVar to the Text widgetPassing in a variableSynchronizing the widget to the variableSynchronizing the variable to the widgetCreating a more advanced LabelInput()Creating a form classCreating an application classSummary
Reducing User Error with Validation and Automation
Validating user inputStrategies to prevent data errorsValidation in TkinterThe validate argumentThe validatecommand argumentThe invalidcommand argumentCreating validated widget classesCreating a Date fieldImplementing validated widgets in our GUIIntroducing the power of multiple inheritanceBuilding a validating mixin classBuilding validating input widgets with ValidatedMixinRequiring dataCreating a Date widgetA better Combobox widgetA range-limited Spinbox widgetValidating Radiobutton widgetsUpdating our form with validated widgetsImplementing validation interaction between form widgetsDynamically updating the Spinbox rangeDynamic disabling of fieldsDisplaying errorsPreventing form submission on errorAutomating inputDate automationAutomating Plot, Lab, Time, and TechnicianSummary
Planning for the Expansion of Our Application
Separating concernsThe MVC patternWhat is a model?What is a view?What is a controller?Why complicate our design?Structuring our application directoryBasic directory structureThe abq_data_entry.py fileThe README.rst filePopulating the docs folderMaking a Python packageSplitting our application into multiple filesCreating the models moduleMoving the widgetsMoving the viewsRemoving redundancy in our view logicUsing custom events to remove tight couplingCreating the application fileRunning the applicationUsing version control softwareA super-quick guide to using GitInitializing and configuring a Git repositoryAdding and committing codeViewing and using our commitsSummary
Creating Menus with Menu and Tkinter Dialogs
Solving problems in our applicationPlanning solutions to the issuesImplementing Tkinter dialogsError dialogs with the Tkinter messageboxShowing error dialogs in ABQ Data EntryUsing filedialogUsing simpledialog and creating a custom dialogCreating a Login dialog using simpledialogIncorporating the LoginDialog in our classDesigning the application menuThe Tkinter Menu widgetUsing Checkbutton and Radiobutton itemsImplementing the ABQ application menuAdding a Help menuAdding a File menuAdding a settings menuFinishing the menuPersisting settingsBuilding a model for settings persistenceUsing the settings model in our applicationSummary
Navigating Records with Treeview and Notebook
Implementing read and update in the modelAdding read and update to the CSVModel classImplementing get_all_records()Implementing get_record()Adding update capability to save_record()The Ttk TreeviewAnatomy of a TreeviewBuilding a file browserCreating and configuring a TreeviewPopulating a Treeview with dataSorting Treeview recordsUsing Treeview virtual eventsImplementing a record list with TreeviewCreating the RecordList classConfiguring a Treeview widgetAdding a scrollbar for the TreeviewPopulating the TreeviewAdding the record list to the applicationModifying the record form for read and updateAdding a current record propertyAdding a label to show what is being editedAdding a load_record() methodUpdating the application layoutThe Ttk Notebook widgetAdding a notebook to our applicationAdding and updating application callbacksThe _show_recordlist() methodThe _populate_recordlist() methodThe _new_record() methodThe _open_record() methodThe _on_save() methodMain menu changesTesting our programSummary
Improving the Look with Styles and Themes
Working with images in TkinterTkinter PhotoImagePhotoImage and variable scopeUsing Pillow for extended image supportAdding the company logo to ABQ Data EntryDealing with the image path problemSetting a window iconAdding icons to buttons and menusUsing BitmapImageStyling Tkinter widgetsWidget color propertiesUsing widget properties on the MainMenuStyling widget content with tagsStyling our record list with tagsWorking with fonts in TkinterConfiguring Tkinter fontsConfiguring fonts with strings and tuplesThe font moduleGiving users font options in ABQ Data EntryStyling Ttk widgetsTTk styling breakdownExploring a Ttk widgetUsing themesAdding some color to ABQ Data EntryAdding styles to individual form widgetsFixing the error colorsStyling input widgets on errorSetting themesBuilding a theme selectorSummary

Maintaining Cross-Platform Compatibility
Writing cross-platform PythonFilenames and file paths across platformsPath separators and drivesCase sensitivitySymbolic linksPath variablesInconsistent library and feature supportPython's platform-limited librariesChecking low-level function compatibilityThe dangers of the subprocess moduleText file encodings and formatsGraphical and console modesWriting code that changes according to the platformWriting cross-platform TkinterTkinter version differences across platformsApplication menus across platformsMenu widget capabilitiesMenu guidelines and standardsMenus and accelerator keysCross-platform fontsCross-platform theme supportWindow zoomed stateImproving our application's cross-platform compatibilityStoring preferences correctlySpecifying an encoding for our CSV fileMaking platform-appropriate menusPreparing our MainMenu classAdding acceleratorsBuilding the Windows menuBuilding the Linux menuBuilding the macOS menuCreating and using our selector functionSummary
Creating Automated Tests with unittest
Automated testing basicsA simple unit testThe unittest moduleWriting a test caseTestCase assertion methodsFixturesUsing Mock and patchRunning multiple unit testsTesting Tkinter codeManaging asynchronous codeSimulating user actionsSpecifying an event sequenceManaging focus and grabGetting widget informationWriting tests for our applicationTesting the data modelTesting file reading in get_all_records()Testing file saving in save_record()More tests on the modelsTesting our Application objectTesting our widgetsUnit testing the ValidatedSpinbox widgetIntegration testing the ValidatedSpinbox widgetTesting our mixin classSummary
Improving Data Storage with SQL
PostgreSQLInstalling and configuring PostgreSQLConfiguring PostgreSQL using the GUI utilityConfiguring PostgreSQL using the command lineModeling relational dataPrimary keysUsing surrogate primary keysNormalizationFirst normal formSecond normal formThird normal formMore normalization formsEntity-relationship diagramsAssigning data typesCreating the ABQ databaseCreating our tablesCreating the lookup tablesThe lab_checks tableThe plot_checks tableCreating a viewPopulating the lookup tablesConnecting to PostgreSQL with psycopg2psycopg2 basicsParameterized queriesSpecial cursor classesIntegrating SQL into our applicationCreating a new modelSaving dataGetting the current seed sample for the plotAdjusting the Application class for the SQL backendImplementing SQL loginsUpdating the Application._on_save() methodRemoving file-based codeAdjusting the DataRecordForm for SQL dataReordering fieldsFixing the load_record() methodImproving auto-fillUpdating the RecordList for the SQLModelWe're done!Summary
Connecting to the Cloud
HTTP using urllibHTTP transaction fundamentalsHTTP status codesBasic downloading with urllib.requestGenerating POST requestsDownloading weather data to ABQ Data EntryCreating a weather data modelParsing the XML weather dataImplementing weather data storageAdding the GUI elements for weather downloadRESTful HTTP using requestsUnderstanding RESTful web servicesThe Python requests libraryInstalling and using requestsInteracting with authenticated sites using SessionThe requests.Response objectImplementing a REST backendThe authenticate() methodThe upload_file() methodThe check_file() methodThe get_file() methodIntegrating REST upload into the applicationCreating a CSV extractCreating the upload callbackFinishing upSFTP using paramikoSetting up SSH services for testingInstalling and using paramikoUsing paramikoInspecting our connectionUsing SFTPImplementing an SFTP modelUploading filesChecking a file's existenceUsing SFTPModel in our applicationFinishing upSummary
Asynchronous Programming with Thread and Queue
Tkinter's event queueEvent queue controlThe update() methodsThe after() methodsCommon uses of event queue controlSmoothing out display changesMitigating GUI freezesRunning code in the background with threadsThe threading moduleTkinter and thread safetyConverting our network functions to threaded executionUsing the threaded uploaderPassing messages using a queueThe Queue objectUsing queues to communicate between threadsAdding a communication queue to our threaded uploaderCreating a communications protocolSending messages from the uploaderHandling queue messagesUsing locks to protect shared resourcesUnderstanding the Lock objectUsing a Lock object to prevent concurrent uploadsThreading and the GILSummary
Visualizing Data Using the Canvas Widget
Drawing and animation with Tkinter's CanvasDrawing on the CanvasRectangles and squaresOvals, circles, and arcsLinesPolygonsTextImagesTkinter widgetsCanvas items and stateCanvas object methodsScrolling the CanvasAnimating Canvas objectsSetting up the playing fieldSetting our playersAnimating the racersRunning the game loop and detecting a win conditionCreating simple graphs using CanvasCreating the model methodCreating the chart viewUpdating the applicationAdvanced graphs using MatplotlibData model methodCreating the bubble chart viewUpdating the Application classSummary
Packaging with setuptools and cxFreeze
Creating distributable packages with setuptoolsPreparing our package for distributionCreating a requirements.txt fileCreating a pyproject.toml fileAdding a license fileMaking our package executableConfiguring a setup.py scriptBasic metadata argumentsPackages and dependenciesAdding extra filesDefining commandsTesting the configurationCreating and using source distributionsTesting our source distributionBuilding a wheel distributionCreating executables with cx_FreezeFirst steps with cx_FreezeThe build_exe optionsIncluding external filesBuilding executablesCleaning up the buildBuilding Windows executables with cx_FreezeBuilding a Windows installer fileBuilding macOS executables with cx_FreezeBuilding macOS application bundlesBuilding macOS .dmg filesSummary
Appendices
A: A Quick Primer on reStructuredText
The reStructuredText markup languageDocument structureListsCharacter stylesBlocks and quotesTablesConverting RST to other formatsOther ways to render RST
B: A Quick SQL Tutorial
SQL conceptsSyntax differences from PythonSQL operations and syntaxDefining tables and inserting dataRetrieving data from tablesUpdating rows, deleting rows, and more WHERE clausesSubqueriesJoining tablesManaging transactionsLearning more
Other Books You May Enjoy
Index

Overview

This book, "Python GUI Programming with Tkinter, 2nd edition", guides you through the process of creating graphical user interfaces using the Tkinter library. You'll explore its vast functionality to build scalable and efficient GUI applications for both desktop and cross-platform environments.

What this Book will help me do

Learn to develop robust GUI applications using Tkinter.
Apply object-oriented programming principles to design clean and maintainable code.
Utilize MVC patterns to structure applications for enhancement and scalability.
Incorporate testing and validation for reliable and error-free GUI functionality.
Integrate external libraries and optimize GUI applications for professional use.

Author(s)

None D. Moore is an experienced Python developer with extensive expertise in GUI application design and functional programming. They have a practical and hands-on approach to teaching, which helps learners acquire vital skills efficiently.

Who is it for?

This book is ideal for Python developers familiar with basic syntax but looking to advance their skills into GUI development. It is tailored to help professionals who aim to design sophisticated desktop applications. If you aspire to integrate user-oriented designs into your software, this is the book for you.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Beginning PyQt: A Hands-on Approach to GUI Programming with PyQt6

Publisher Resources

ISBN: 9781801815925

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills