GUI Programming for Python Developers

Beginning Python
1. The Course Overview and Installing Python
2. Setting Up a Programming Environment
3. Variables
4. Introduction to Types
5. Basic Operators
6. Introduction to Strings
7. String Functions
8. Advanced String Manipulation
9. String Formatting
10. User Input
11. Introduction to Lists
12. List Methods
13. Advanced List Methods
14. Built-in List Functions
15. 2D Arrays and Array References
16. List Slicing
17. Control Flow
18. Comparison Operators
19. Else and Elif
20. and, or, and not
21. Conditional Examples
22. Mini Program
23. For Loop
24. While Loop
25. Iterables
26. Loops and Conditionals
27. Prime Number Checker
28. Function Basics
29. Parameters and Arguments
30. Return versus Void Functions
31. Working with Examples
32. Advanced Examples
33. Recursion
34. Recursion Examples
35. Import, as, and from
36. Python API and Modules
37. Creating Modules
38. Modules and Testing
39. Installing PIL-Pillow
40. Basics of Using PIL-Pillow
41. Picture Manipulations
42. Custom Picture Manipulation
43. Wrapping Up

Python Projects
44. Setting Up the Python Development Environment
45. Getting Started with Python
46. Setting Breakpoints
47. Using the Pydev Debugger
48. Creational Design patterns – The “Maze” Labyrinth Game in Python
49. Creating the Maze in Python Using the Abstract Factory Design Pattern
50. Creating the Maze in Python Using the Builder Design Pattern
51. Creating the Maze in Python Using the Factory Prototype Design Pattern
52. Introducing Tkinter
53. Simple_GUI
54. NOAA_Weather_Data
55. OpenWeatherMap
56. GettingDataHtml
57. EmailingViaGmail
58. Scheduling the Task
59. TaskSchedulerSvc

Python GUI Programming Solutions
60. Introduction to Python GUI
61. Adding a Label to the GUI Form
62. Creating Buttons and Text Box Widgets
63. Exploring Widgets
64. Adding Extra Features
65. Adding Several Widgets in a Loop
66. Arranging Several Labels within a Label Frame
67. Using Padding to Add Space Around Widgets
68. Expanding the GUI Dynamically Using Widgets
69. Aligning the GUI Widgets by Embedding Frames within Frames
70. Creating Menu Bars
71. Creating Tabbed Widgets
72. Using the Grid Layout Manager
73. Creating Message Boxes
74. Creating Independent Message Boxes
75. Creating the Title and Icon of the Main Root Window
76. Using a Spinbox Control
77. Creating Tooltips and Using the Canvas Widget
78. Using the StringVar() Type
79. Using Module-Level Global Variables
80. Improving the GUI by Coding in Classes
81. Creating Reusable GUI Components
82. Creating Beautiful Charts Using Matplotlib
83. Downloading Modules for Matplotlib
84. Creating Our First Chart
85. Placing Labels on Charts
86. Giving the Chart a Legend
87. Scaling Charts
88. Adjusting the Scale Dynamically
89. Creating Multiple Threads
90. Starting a Thread
91. Stopping a Thread
92. Using Queues
93. Passing Queues among Different Modules
94. Using Dialog Widgets to Copy Files to Your Network
95. Using TCP-IP to Communicate via Networks
96. Using URLOpen to Read Data from Websites
97. Connecting to a MySQL Database from Python
98. Configuring the MySQL Connection
99. Designing the Python GUI Database
100. Using the SQL INSERT Command
101. Using the SQL UPDATE Command
102. Using the SQL DELETE Command
103. Displaying Widget Text in Different Languages
104. Changing the Entire GUI Language All at Once
105. Localizing the GUI
106. Preparing the GUI for Internationalization
107. Designing a GUI in an Agile Fashion
108. Do We Need to Test the GUI Code
109. Setting Debug Watches
110. Configuring Different Debug Output Levels
111. Creating Self-Testing Code Using Python-s __main__ Section
112. Creating Robust GUIs Using Unit Tests
113. Writing Unit Tests Using the Eclipse PyDev IDE
114. Installing the wxPython Library
115. Creating Our GUI
116. Adding Controls
117. Embedding the tkinter and wxPython GUIs into Each Other
119. Communicating Between the Two Connected GUIs
120. PyOpenGL Transforms Our GUI
121. Our GUI in 3D
122. Pyglet Transforms Our GUI More Easily Than PyOpenGL
123. Creating a Slideshow Using tkinter
124. Avoiding Spaghetti Code
125. Using __init__ to Connect Modules
126. Mixing Fall-Down and OOP Coding
127. When Not to Use OOP
128. Using Design Patterns Successfully
129. Avoiding Complexity

Mastering Python – Second Edition
130. The Course Overview
131. Python Basic Syntax and Block Structure
132. Built-in Data Structures and Comprehensions
133. First-Class Functions and Classes
134. Extensive Standard Library
135. New in Python 3.5
136. Downloading and Installing Python
137. Using the Command-Line and the Interactive Shell
138. Installing Packages with pip
139. Finding Packages in the Python Package Index
140. Creating an Empty Package
141. Adding Modules to the Package
142. Importing One of the Package-s Modules from Another
143. Adding Static Data Files to the Package
144. PEP 8 and Writing Readable Code
145. Using Version Control
146. Using venv to Create a Stable and Isolated Work Area
147. Getting the Most Out of docstrings 1- PEP 257 and docutils
148. Getting the Most Out of docstrings 2- doctest
149. Making a Package Executable via python -m
150. Handling Command-Line Arguments with argparse
151. Interacting with the User
152. Executing Other Programs with Subprocess
153. Using Shell Scripts or Batch Files to Run Our Programs
154. Using concurrent.futures
155. Using Multiprocessing
156. Understanding Why This Isn-t Like Parallel Processing
157. Using the asyncio Event Loop and Coroutine Scheduler
158. Waiting for Data to Become Available
159. Synchronizing Multiple Tasks
160. Communicating Across the Network
161. Using Function Decorators
162. Function Annotations
163. Class Decorators
164. Metaclasses
165. Context Managers
166. Descriptors
167. Understanding the Principles of Unit Testing
168. Using the unittest Package
169. Using unittest.mock
170. Using unittest-s Test Discovery
171. Using Nose for Unified Test Discover and Reporting
172. What Does Reactive Programming Mean
173. Building a Simple Reactive Programming Framework
174. Using the Reactive Extensions for Python (RxPY)
175. Microservices and the Advantages of Process Isolation
176. Building a High-Level Microservice with Flask
177. Building a Low-Level Microservice with nameko
178. Advantages and Disadvantages of Compiled Code
179. Accessing a Dynamic Library Using ctypes
180. Interfacing with C Code Using Cython