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
English
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 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
Requirements
  • The only thing that are required before you begin this Learning Path are is the basic knowledge of Python.
Description

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
07:02:47
+
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
09:31

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
04:38

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
07:02

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
05:47

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
08:42

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
12:51

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
05:32

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.
Simple_GUI
10:22

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.
NOAA_Weather_Data
15:12

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.
OpenWeatherMap
15:19

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.
GettingDataHtml
05:30

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.
EmailingViaGmail
05:40

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
03:58

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.
TaskSchedulerSvc
09:24
+
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
04:04

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

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

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
02:27

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

Widgets – the Building Blocks of GUI Programs
08:46

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

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
10:01

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

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

Event Unbinding and Virtual Events
01:32

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

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

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

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

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

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

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

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

Implementing the Select All Feature
01:31

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
05:45

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
02:01

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
07:48

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

Working with Message Boxes
03:17

Learn to add shortcut icons to the toolbar.

The Icons Toolbar and View Menu Functions
02:36

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
06:14

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
01:31

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

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

Creating the Context/Pop-Up Menu
02:36

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
03:34

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

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

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

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

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

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
05:10

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
02:21

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
06:04

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

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

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
04:25

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
13:54

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
07:25

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

Managing User Preferences
05:19

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
03:49

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

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

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
03:58

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
04:21

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

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

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

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

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

Adding a Tooltip
03:45

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

Creating a Tiny Framework
07:19

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
01:44

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

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
03:44

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
Processing..

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
02:50

Learn to display the options for the top bar dynamically.

Adding Top Bar Options for Draw Methods
04:02

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

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

Adding Functionality to the Remaining Buttons
05:59

Learn to add the functionality to modify the empty methods to make them functional
Adding Functionality to Menu Items
03:24
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.