Learning Path: Expert Python Projects

Video description

Python is one of the most powerful, flexible, and popular programming languages in the world. Become an expert with a plethora of projects with this Learning Path.This Learning Path follows a project-based approach to help you learn all the advanced concepts of Python. We will focus on GUI projects with Tkinter, look at data visualization in deep, and then move on to machine learning. This Learning Path aims to get you well-versed with every concept of Python by teaching a broad range of topics.This Learning Path aims to equip you with a mastery of Python like no other!

What You Will Learn

  • Become proficient at creating tools and utility programs in Python
  • Create apps that can be scaled in size or complexity without breaking down the core
  • Understand the basics of 2D and 3D animation in GUI applications
  • Make 3D visualizations mainly using mplot3d
  • Understand the most appropriate charts to describe your data
  • Use predictive modeling and apply it to real-world problems
  • Work with image data and build systems for image recognition and biometric face recognition


Requires beginner-level knowledge of Python and cursory information about Tkinter, data visualization, and machine learning.

Publisher resources

Download Example Code

Table of contents

  1. Chapter 1 : Mastering Python - Second Edition
    1. The Course Overview
    2. Python Basic Syntax and Block Structure
    3. Built-in Data Structures and Comprehensions
    4. First-Class Functions and Classes
    5. Extensive Standard Library
    6. New in Python 3.5
    7. Downloading and Installing Python
    8. Using the Command-Line and the Interactive Shell
    9. Installing Packages with pip
    10. Finding Packages in the Python Package Index
    11. Creating an Empty Package
    12. Adding Modules to the Package
    13. Importing One of the Package's Modules from Another
    14. Adding Static Data Files to the Package
    15. PEP 8 and Writing Readable Code
    16. Using Version Control
    17. Using venv to Create a Stable and Isolated Work Area
    18. Getting the Most Out of docstrings 1: PEP 257 and docutils
    19. Getting the Most Out of docstrings 2: doctest
    20. Making a Package Executable via python -m
    21. Handling Command-Line Arguments with argparse
    22. Interacting with the User
    23. Executing Other Programs with Subprocess
    24. Using Shell Scripts or Batch Files to Run Our Programs
    25. Using concurrent.futures
    26. Using Multiprocessing
    27. Understanding Why This Isn't Like Parallel Processing
    28. Using the asyncio Event Loop and Coroutine Scheduler
    29. Waiting for Data to Become Available
    30. Synchronizing Multiple Tasks
    31. Communicating Across the Network
    32. Using Function Decorators
    33. Function Annotations
    34. Class Decorators
    35. Metaclasses
    36. Context Managers
    37. Descriptors
    38. Understanding the Principles of Unit Testing
    39. Using the unittest Package
    40. Using unittest.mock
    41. Using unittest's Test Discovery
    42. Using Nose for Unified Test Discover and Reporting
    43. What Does Reactive Programming Mean?
    44. Building a Simple Reactive Programming Framework
    45. Using the Reactive Extensions for Python (RxPY)
    46. Microservices and the Advantages of Process Isolation
    47. Building a High-Level Microservice with Flask
    48. Building a Low-Level Microservice with nameko
    49. Advantages and Disadvantages of Compiled Code
    50. Accessing a Dynamic Library Using ctypes
    51. Interfacing with C Code Using Cython
  2. Chapter 2 : Tkinter GUI Application Development Projects
    1. The Course Overview
    2. Installing Python and Tkinter
    3. Importing Tkinter
    4. GUI Programming – the Big Picture
    5. The Root Window – Your Drawing Board
    6. Widgets – the Building Blocks of GUI Programs
    7. The Tkinter Geometry Manager
    8. Event and Callbacks – Adding Life to Programs
    9. Handling Widgets – Specific Variables
    10. Event Unbinding and Virtual Events
    11. Platform-Based Styling for Our Widgets
    12. Some Common Root Window Options
    13. Setting Up the Editor Skeleton
    14. Adding a Menu and Menu Items
    15. Implementing the View Menu
    16. Adding a Built-in Functionality
    17. Indexing and Tagging
    18. Implementing the Select All Feature
    19. Implementing the Find Text Feature
    20. Types of Top Level Windows
    21. Working with Forms and Dialogs
    22. Working with Message Boxes
    23. The Icons Toolbar and View Menu Functions
    24. Displaying the Line Number
    25. Adding the Cursor Information Bar
    26. Adding Themes
    27. Creating the Context/Pop-Up Menu
    28. Module Requirements for Programmable Drum Machine
    29. Setting Up the GUI in OOP
    30. Finalizing the Data Structure
    31. Creating Broader Visual Elements
    32. Loading Drum Samples
    33. Playing the Drum Machine
    34. Tkinter and Threading
    35. Support for Multiple Beat Patterns
    36. Setting Up the GUI in OOP
    37. Working with the ttk-themed Widgets
    38. Structuring Our Program
    39. Modeling the Data Structures
    40. Creating a Piece Class
    41. Making the Game Functional
    42. Managing User Preferences
    43. External Library Requirements
    44. Program Structure and Broadview Skeleton
    45. Deciding the Data Structure and Creating the Player class
    46. Adding and Removing Items from a Playlist
    47. Playing Audio and Adding Audio Controls
    48. Creating a Seek Bar
    49. One-Time Updates during audio playback
    50. Managing Continuous Updates
    51. Looping Over Tracks
    52. Adding a Tooltip
    53. `Creating a Tiny Framework
    54. Setting Up a Broad GUI Structure
    55. Dealing with Mouse Events
    56. Adding Toolbar Buttons
    57. Drawing Items on the Canvas
    58. Adding a Color Palette
    59. Adding Top Bar Options for Draw Methods
    60. Drawing Irregular Lines and Super Shapes
    61. Adding Functionality to the Remaining Buttons
    62. Adding Functionality to Menu Items
  3. Chapter 3 : Python Data Visualization Solutions
    1. The Course Overview
    2. Importing Data from CSV
    3. Importing Data from Microsoft Excel Files
    4. Importing Data from Fix-Width Files
    5. Importing Data from Tab Delimited Files
    6. Importing Data from a JSON Resource
    7. Importing Data from a Database
    8. Cleaning Up Data from Outliers
    9. Importing Image Data into NumPy Arrays
    10. Generating Controlled Random Datasets
    11. Smoothing Noise in Real-World Data
    12. Defining Plot Types and Drawing Sine and Cosine Plots
    13. Defining Axis Lengths and Limits
    14. Defining Plot Line Styles, Properties, and Format Strings
    15. Setting Ticks, Labels, and Grids
    16. Adding Legends and Annotations
    17. Moving Spines to Center
    18. Making Histograms
    19. Making Bar Charts with Error Bars
    20. Making Pie Charts Count
    21. Plotting with Filled Areas
    22. Drawing Scatter Plots with Colored Markers
    23. Displaying Images with Other Plots in the Figure
    24. Plotting Data on a Map Using Basemap
    25. Generating CAPTCHA
    26. Understanding Logarithmic Plots
    27. Creating a Stem Plot
    28. Drawing Streamlines of Vector Flow
    29. Using Colormaps
    30. Using Scatter Plots and Histograms
    31. Plotting the Cross Correlation Between Two Variables
    32. The Importance of Autocorrelation
    33. Drawing Barbs
    34. Making a Box-and-Whisker Plot
    35. Adding a Shadow to the Chart Line
    36. Adding a Data Table to the Figure
    37. Using Subplots
    38. Customizing Grids
    39. Creating Contour Plots
    40. Filling an Under-Plot Area
    41. Drawing Polar Plots
    42. Visualizing the filesystem Tree Using a Polar Bar
    43. Creating 3D Bars
    44. Creating 3D Histograms
    45. Animating with OpenGL
    46. Plotting with Images
    47. Making Gantt Charts
    48. Making Error Bars
    49. Making Use of Text and Font Properties
    50. Understanding the Difference between pyplot and OO API
  4. Chapter 4 : Python Machine Learning Solutions
    1. Preprocessing Data Using Different Techniques
    2. Label Encoding
    3. Building a Linear Regressor
    4. Regression Accuracy and Model Persistence
    5. Building a Ridge Regressor
    6. Building a Polynomial Regressor
    7. Estimating housing prices
    8. Computing relative importance of features
    9. Estimating bicycle demand distribution
    10. Building a Simple Classifier
    11. Building a Logistic Regression Classifier
    12. Building a Naive Bayes’ Classifier
    13. Splitting the Dataset for Training and Testing
    14. Evaluating the Accuracy Using Cross-Validation
    15. Visualizing the Confusion Matrix and Extracting the Performance Report
    16. Evaluating Cars based on Their Characteristics
    17. Extracting Validation Curves
    18. Extracting Learning Curves
    19. Extracting the Income Bracket
    20. Building a Linear Classifier Using Support Vector Machine
    21. Building Nonlinear Classifier Using SVMs
    22. Tackling Class Imbalance
    23. Extracting Confidence Measurements
    24. Finding Optimal Hyper-Parameters
    25. Building an Event Predictor
    26. Estimating Traffic
    27. Clustering Data Using the k-means Algorithm
    28. Compressing an Image Using Vector Quantization
    29. Building a Mean Shift Clustering
    30. Grouping Data Using Agglomerative Clustering
    31. Evaluating the Performance of Clustering Algorithms
    32. Automatically Estimating the Number of Clusters Using DBSCAN
    33. Finding Patterns in Stock Market Data
    34. Building a Customer Segmentation Model
    35. Building Function Composition for Data Processing
    36. Building Machine Learning Pipelines
    37. Finding the Nearest Neighbors
    38. Constructing a k-nearest Neighbors Classifier
    39. Constructing a k-nearest Neighbors Regressor
    40. Computing the Euclidean Distance Score
    41. Computing the Pearson Correlation Score
    42. Finding Similar Users in a Dataset
    43. Generating Movie Recommendations
    44. Preprocessing Data Using Tokenization
    45. Stemming Text Data
    46. Converting Text to Its Base Form Using Lemmatization
    47. Dividing Text Using Chunking
    48. Building a Bag-of-Words Model
    49. Building a Text Classifier
    50. Identifying the Gender
    51. Analyzing the Sentiment of a Sentence
    52. Identifying Patterns in Text Using Topic Modelling
    53. Reading and Plotting Audio Data
    54. Transforming Audio Signals into the Frequency Domain
    55. Generating Audio Signals with Custom Parameters
    56. Synthesizing Music
    57. Extracting Frequency Domain Features
    58. Building Hidden Markov Models
    59. Building a Speech Recognizer
    60. Transforming Data into the Time Series Format
    61. Slicing Time Series Data
    62. Operating on Time Series Data
    63. Extracting Statistics from Time Series
    64. Building Hidden Markov Models for Sequential Data
    65. Building Conditional Random Fields for Sequential Text Data
    66. Analyzing Stock Market Data with Hidden Markov Models
    67. Operating on Images Using OpenCV-Python
    68. Detecting Edges
    69. Histogram Equalization
    70. Detecting Corners and SIFT Feature Points
    71. Building a Star Feature Detector
    72. Creating Features Using Visual Codebook and Vector Quantization
    73. Training an Image Classifier Using Extremely Random Forests
    74. Building an object recognizer
    75. Capturing and Processing Video from a Webcam
    76. Building a Face Detector using Haar Cascades
    77. Building Eye and Nose Detectors
    78. Performing Principal Component Analysis
    79. Performing Kernel Principal Component Analysis
    80. Performing Blind Source Separation
    81. Building a Face Recognizer Using a Local Binary Patterns Histogram
    82. Building a Perceptron
    83. Building a Single-Layer Neural Network
    84. Building a deep neural network
    85. Creating a Vector Quantizer
    86. Building a Recurrent Neural Network for Sequential Data Analysis
    87. Visualizing the Characters in an Optical Character Recognition Database
    88. Building an Optical Character Recognizer Using Neural Networks
    89. Plotting 3D Scatter plots
    90. Plotting Bubble Plots
    91. Animating Bubble Plots
    92. Drawing Pie Charts
    93. Plotting Date-Formatted Time Series Data
    94. Plotting Histograms
    95. Visualizing Heat Maps
    96. Animating Dynamic Signals

Product information

  • Title: Learning Path: Expert Python Projects
  • Author(s): Taabish Khan - Curator
  • Release date: January 2017
  • Publisher(s): Packt Publishing
  • ISBN: 9781787123564