Learning Path: Python GUI Projects
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
95 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path: Python GUI Projects to your Wishlist.

Add to Wishlist

Learning Path: Python GUI Projects

Create well-designed, powerful, and scalable applications by harnessing the power of Python.
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
95 students enrolled
Created by Packt Publishing
Last updated 2/2017
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
  • 7 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Create fully functional GUIs written in Python effortlessly
  • Implement several design patterns in Python
  • Create apps that can be scaled in size or complexity without breaking down the core
  • Create apps that leverage resources from the network
  • Understand the basics of 2D and 3D animation in GUI applications
  • Gain hands-on knowledge of the various angles of Python tasks through insightful projects
  • Build production ready projects using Python's eco system.
  • Conceptualize and build state-of-art GUI applications with Tkinter
View Curriculum
  • The only thing that are required before you begin this Learning Path are is the basic knowledge of Python.

One cannot ignore the benefits of a well-designed architecture and graphical user interface for applications. Let’s see how one of the most powerful language–Python–aids us in creating powerful enterprise-ready applications.

Packt’s Video Learning Paths are an amalgamation of multiple video courses that are logically tied together to provide you with a larger learning curve.

This Learning Path teaches important programming concepts of Python along with giving you the step-by-step approach of creating applications.

In the initial part of the Learning Path we will be focusing on creating applications. The latter part of the Learning Path focuses on a powerful GUI package—Tkinter—that comes with standard Python distributions. It delivers the bigger picture of GUI programming by building real-world, productive, and fun applications, such as a text editor, drum machine, game of chess, media player, drawing application, chat application, screen saver, and port scanner. In every project, you will build on the skills acquired in the previous project and gain more expertise.

After completing this Learning Path, you will have successfully created 14 high-end GUI applications, and will be capable of building many more powerful and scalable applications.

About the authors:

For this Learning Path, we have combined the best works of extremely esteemed authors: Burkhard A. Meier and Bhaskar Chaudhary.

Burkhard has more than 15 years of professional experience working in the software industry as a software tester and developer, specializing in software test automation development, execution, and analysis. He has a very strong background in SQL relational database administration, the development of stored procedures, and debugging code.

Bhaskar is a professional programmer and information architect. He has an experience of almost 9 years in consulting, contracting, and educating in the field of software development. He has worked with a large set of programming languages on various platforms over the years.

Who is the target audience?
  • This Learning path is ideal for web developers,statisticians, programmers, data scientists, Python consultants, and anyone who is working on multiple projects in Python.
  • With a project-based approach, the Learning Path focuses on building fun projects from scratch with easy-to-understand explanations and practical applications.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
79 Lectures
Python Projects
17 Lectures 02:19:09
This video will give you brief information about the course.
Preview 05:29

In this video we will set up our development environment.
Setting Up the Python Development Environment

In this video, we will get started writing programs in Python using the Eclipse IDE with the PyDev plugin. This will give us a foundation for all Python projects we are developing in this video series.
Preview 04:55

In this video, we will be setting breakpoints in order to step through and debug our code. Setting breakpoints is a great way to understand the flow of our code, especially when using object-oriented programming with Inheritance.
Setting Breakpoints

In this video, we will be enhancing our Python debugging skills by setting breakpoints and then using different available debugging tools within Eclipse. We will explore the callstack window; look at the Variables, Breakpoint, and Expression windows; set watches; and use the Outline window as well as bookmarks to navigate the code.
Using the Pydev Debugger

In this video, we will introduce the software classic "Design Patterns". We will then create the Maze labyrinth game from the Design Patterns book in Python using OOP. We will begin by not using any patterns so that we can see and understand the value of using patterns.

Preview 09:17

In this video, we will create the "Maze" game using the abstract factory design pattern. We will first build a regular Maze and then extend this Maze to an Enchanted Maze, and also to another Maze that can have bombs in it.
Creating the Maze in Python Using the Abstract Factory Design Pattern

In this video, we will create the "Maze" game using the Builder Design Pattern. We will explain this pattern by then creating a "Counting Maze".
Creating the Maze in Python Using the Builder Design Pattern

In this video, we will create the "Maze" game using the Prototype Design Pattern. We will explain this pattern by creating one Maze, saving it, and then cloning it a few times. We'll then modify the clones.
Creating the Maze in Python Using the Factory Prototype Design Pattern

In this video, we will introduce Python's built-in GUI framework, Tkinter. We will start with the fewest lines of code required to build a working GUI, and then we will change the GUI's default size and also fix its size.
Introducing Tkinter

In this video, we will enhance the GUI by adding several widgets. We will add a menu, add tabs and populate those tabs with LabelFrames, Labels, Comboboxes, and text entries using the Grid layout manager. We will also add spacing around the widgets to make the GUI look great.

In this video, we will extend our GUI by turning it into a Weather app. We will be using data from NOAA. First we will use previously saved data to populate our GUI, and in the end we will directly retrieve the weather data in real time from the website.

In this video, we will further enhance our Weather app GUI by using the OpenWeatherMap API. This will allow us to retrieve weather data from cities located all over the world. We will retrieve this data directly from the Web.

In this video, we will reuse some code from the previous section, in which we collected live weather data from the NOAA website. We will then save this data in HTML format.

In this video, we will use Gmail as our personal e-mailing server. First, we will setup a new Gmail account and configure required settings. Then we will e-mail our HTML weather data report using Gmail.

In this video, we will introduce Python's "schedule" module. We will explore the different scheduling options it provides, and then we will use this module to schedule our data collection, save as HTML, and e-mailing process.

Scheduling the Task

In this video, we will create a Windows Service written in Python. We will see one way to correctly install the required pywin32 module that works for Python 3.5, and how to successfully run the postinstall script. We will then run our scheduled task as a Windows Service.
Tkinter GUI Application Development Projects
62 Lectures 04:43:38
This video provides an overview of the entire course.
Preview 04:21

Install the Python Interpreter package from the official repository or build it directly from the source link.
Installing Python and Tkinter

Learn to describe the different styles of importing Tkinter modules.
Importing Tkinter

Ability to use the components of GUI programming.
GUI Programming – the Big Picture

Learn to draw board to capture your ideas. The drawing board that you will use is called the root window.
The Root Window – Your Drawing Board

Explore the ability to build blocks of GUI programs in the widgets.

Widgets – the Building Blocks of GUI Programs

Learn how to add widgets to a screen and position them where you want.
The Tkinter Geometry Manager

Make widgets functions to response events such as pressing of buttons, the pressing of keys on a keyboard, and mouse clicks.
Event and Callbacks – Adding Life to Programs

Learn to add a string variable to track what the user enters into the entry widget or text widget.
Handling Widgets – Specific Variables

Learn to provide the unbind option to undo the effect of an earlier binding.

Event Unbinding and Virtual Events

Learn to specify your own styling of widgets, such as their color, font size, border width, and relief.
Platform-Based Styling for Our Widgets

Discuss on some commonly used options for the root window.
Some Common Root Window Options

Gain the ability to implement the broad visual elements of the text editor.
Setting Up the Editor Skeleton

Learn to present a large number of choices to the user without cluttering the interface.
Adding a Menu and Menu Items

Drag down the majorities of the visual elements of the text editor.
Implementing the View Menu

Implement some common features in the text editor to handle common text-related functions.
Adding a Built-in Functionality

Achieve the ability to target each character or location of the text with precision.
Indexing and Tagging

Get the ability to apply the seltag to the entire text in the widget.

Implementing the Select All Feature

Learn to a search keyword and specifies whether the search needs to be case-sensitive. When the user clicks on the Find All button, all matches are highlighted.
Implementing the Find Text Feature

Introduce the indexing and tagging—two very powerful concepts associated with many Tkinter widgets. You will find yourself using these two concepts all the time in your projects.
Types of Top Level Windows

Implement the functionality of the File menu options of Open, Save, and Save As. We can implement these dialogs using the standard Tkinter widgets.
Working with Forms and Dialogs

Gain the ability to provide readymade message boxes to display a wide variety of messages in applications.

Working with Message Boxes

Learn to add shortcut icons to the toolbar.

The Icons Toolbar and View Menu Functions

Work towards showing the line numbers to the left of the Text widget. This will require us to tweak the code at various places.
Displaying the Line Number

Learn to add the cursor information bar, which is simply a small label at the bottom-right corner of the Text widget, which displays the current position of the cursor.
Adding the Cursor Information Bar

Define a color scheme dictionary containing the name and hexadecimal color codes as a key-value pair.
Adding Themes

Complete the editor in this final iteration by adding a contextual menu to the editor.

Creating the Context/Pop-Up Menu

Learn to add built-in libraries from the standard Python distribution, which includes Tkinter, os, math, threading, and pickle modules to verify that these modules do exist.

Module Requirements for Programmable Drum Machine

Achieve the ability to build our drum program using OOP to setup the GUI.
Setting Up the GUI in OOP

Build a good data structure and add a code which will naturally be more simple, elegant, and easy to maintain.
Finalizing the Data Structure

Generate a broader visual elements which will divide the program into four broad visual sections.
Creating Broader Visual Elements

Learn to play sound files, in the order of a beat pattern decided by the user.
Loading Drum Samples

Mechanism to load drum samples and a mechanism to define beat patterns in place.
Playing the Drum Machine

Gain the ability to handle the threading module of Python to play the pattern in a separate thread. This way, pygamewill not interfere with Tkinter's main loop.

Tkinter and Threading

Extend our drum machine to create more than one pattern in the same program which will provide us the ability to play different patterns simply by changing the pattern number.
Support for Multiple Beat Patterns

Achieve the ability to store values in some form of file storage and reload, play, and even edit the patterns. We need some form of object persistence.
Saving Beat Patterns

Gain the ability to work with the ttk-themed widgets.
Working with the ttk-themed Widgets

Learn to write programs in the Model-View-Controller (MVC) architecture.
Structuring Our Program

Ability to record the position of the chess pieces on the chessboard and define the locations to identify the chess pieces.
Modeling the Data Structures

Define classes for every individual piece as a subclass of this parent Piece class and then override all the attributes and methods in individual classes.
Creating a Piece Class

The objective of this iteration is to move the chess pieces with a click of the left mouse button. When a player clicks on a chess piece, the code should first check whether it is a legitimate turn for that chess piece.
Making the Game Functional

This video will show you how to manage User preferences smartly and enhances the User interactions.

Managing User Preferences

Learn to use cross-platform modules to write the code and to ensure that the player can play audio files on the Windows, Mac OS X, and Linux platforms.
External Library Requirements

Ability to build the broad modular structure for the program to keep the data structure, audio-related logic.
Program Structure and Broadview Skeleton

Learn to use the Play_list method to write the getter method for the playlist.
Deciding the Data Structure and Creating the Player class

Learn to write some code for a feature that allows us to add and remove items from a playlist.
Adding and Removing Items from a Playlist

Generate code for the play/stop, pause/unpause, next track, previous track, fast forward, rewind, volume change, and mute/unmute features.

Playing Audio and Adding Audio Controls

Learn to create our own Seekbar widget to add a seek bar to the audio player.
Creating a Seek Bar

Learn to generate the one time update information while playing the audio.
One-Time Updates during audio playback

Learn to update the position of the seek bar knob and the elapsed play duration.
Managing Continuous Updates

Gain the ability to add the feature that allows users to loop over tracks.
Looping Over Tracks

Achieve the ability to add a tooltip named the Balloon widget to all the buttons in our player.

Adding a Tooltip

Gain the ability to create a framework on your own that makes menu generation easy for us.

Creating a Tiny Framework

Learn to create a PaintApplicationclass to draw the menu using our framework and import the framework into our Framework class.
Setting Up a Broad GUI Structure

Learn to know where the mouse was first clicked and where it was released.
Dealing with Mouse Events

Achieve the ability to add 16 buttons to the left toolbar depending on which button is clicked, different options would show up in the top bar.

Adding Toolbar Buttons

Configure the items which you have added at the time of creating the object or later using the itemconfigmethod or the addtag_withtagmethod.
Drawing Items on the Canvas

Gain the ability to provide a color chooser, letting the user select two different colors: the foreground color and the background color.

Adding a Color Palette

Learn to display the options for the top bar dynamically.

Adding Top Bar Options for Draw Methods

Gain the ability to draw a variety of interesting shapes on the drawing canvas.
Drawing Irregular Lines and Super Shapes

Learn to add the functionalities to the remaining toolbar buttons into the canvas.

Adding Functionality to the Remaining Buttons

Learn to add the functionality to modify the empty methods to make them functional
Adding Functionality to Menu Items
About the Instructor
Packt Publishing
3.9 Average rating
7,264 Reviews
51,823 Students
616 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.