Learning Path: Expert Python Projects

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