Master Python From Scratch With a Clear, Structured Curriculum

Introduction

How to Use This Course

Installing Python

Installing Powershell

Python Virtual Environments

Visual Studio Code

Hello World

The Shebang or Hashbang

Where to Find the Source Code

VS Code Tips

Variables

An Interactive Program

Builtin Functions

Numeric Variables

Numeric Expressions

Python Types

Peforming Calculations

Converting Temperatures

A Program Inspired By WarGames

Boolean Variables

The If Statement

If Else

Constants

If Else If

Comparison Operators

Fridge Exercise

Fridge Solution

Fridge Improvements

For Loops

Ranges

Indentation

Break

Continue

Password Exercise

Password Solution

Boolean Operators

Boolean Operators Exercise

Boolean Operators First Solution

Boolean Operators Second Solution

While Loops

Your First Function

Multiple Functions

Function Arguments

The Identity Function

Changing Parameters

Return Values

Multiple Arguments

Factorial Exercise

Factorial Solution

Default Arguments

Keyword Arguments

Variable Length Arguments

Variable Length Keyword Arguments

Arguments and Parameters Summary

Arguments Exercise Solution

Multiple Return Values

BMI Exercise Solution

Tuples

Packing and Unpacking Tuples

Tuple Slicing

Tuple Functions and Operators

Lists

Joining Lists

Modifying Lists

Extended Slicing

Inserting and Extending Lists

Removing List Items

List Comprehensions

List Comprehension Conditions

List Comprehension If Else

List Database Exercise

Database Exercise Tips

Database Exercise Functions

Completing the Database

About Data Validation

Sets

Adding To and Updating Sets

Removing Items from Sets

Set Union and Intersection

Difference Update

Set Exercise

Set Exercise Solution

Dictionaries

Adding Items to Dictionaries

Iterating Over Dictionaries

Dictionary Views

Deleting Dictionary Items

The Dictionary Get Method

Default Dictionaries

Dictionary Comprehensions

Dictionary Exercise

Dictionary Exercise Solution

Casefold and None

Enumerate and Zip

Improving the Dictionary Exercise Solution

Hashing Algorithms

Container Summary

Time Complexity

Lists of Lists

Iterating Over Lists of Lists

Dictionaries of Lists

Dictionaries of Sets Exercise

Dictionaries of Sets Solution Part 1

Dictionaries of Sets Solution Part 2

Global Variables

Random Items

Modular Arithmetic

Containers Exercise

Containers Solution Part 1

Container Solution Part 2

String Review

Formatting Strings

The Format Method

F Strings

Raw Strings

A Simple Regular Expression

Matching Multiple Characters

The Ternary Operator

Greedy Matching

Matching Numbers and Words

Capture Groups

Ranges in Regexes

Character Classes

Email Exercise Solution

Character Class Not

A Note On Escaping

Regular Expression Comments

Referring to Capture Groups

Capture and Non-Capture Groups

Matching Newlines

Matching Ends of Lines

Search

Findall

Matching Starts of Lines

Splitting

Substitution

Alternatives

Budget Exercise

Budget Solution Part 1

Budget Solution Part 2

Ignoring Case

Compiling Regular Expressions

Lookahead Assertions

Not Space or Digits or Text

Regular Expressions Summary

Tracebacks

Try Except

Catching Errors

Error Messages

Raising Exceptions

KeyboardInterrupt

Finally

Errors Exercise

Errors Solution

Calculating Pi Exercise

Pi Solution

Assertions

Classes

Constructors

Self

Properties

Converting to Strings

Encapsulation

An OO Word Game

Choosing Words

Guessing Letters

Displaying Letters

Completing the Word Game

Getters and Setters

Inheritance

Overriding Methods

Polymorphism

Super Constructors

Class Properties

Assigning IDs

Class Methods

Objects and Classes

OOP Exercise

OOP Solution Part 1

OOP Solution Part 2

OOP Solution Part 3

Class Hierarchies

Multiple Inheritance

The Diamond Problem

Mixins

The Property Class

Installing Tkinter

Conway Game of Life

A Basic GUI App

Frames

Refactoring Into Classes

Grids

A Canvas Class

Getting Widget Sizes

Drawing Cells

A Cell Class

Toggling Cell State

Handling Button Clicks

Selecting Neighbours

Wrapping

Game of Life Rules

Implementing the Rules

Clearing the Grid

Randomising

Modules Demo

Conditionally Running Main

Importing Parts of Modules

Packages

Games Package Solution

Functions in Dictionaries

Games Menu Solution

Package Initialisation

How Python Locates Modules

Inspecting Modules

Subpackages

Package Attributes

Referencing Parallel Packages

Installing Modules

Clock Exercise

Clock Solution

Implementing Add

Implementing Unary Operators

Flags

Bitwise Or

Bitwise Flags

Bitwise And

Flags Exercise

Flags Solution

Bitwise XOR and NOT

Bit Shift Operators

Hexadecimal Numbers

Hexadecimal Colors Solutions

Introducing Functional Programming

Recursion

Passing Functions to Functions

Iterators

Powers of Two Iterator

Mapping

Lambda Functions

Defining Functions in Loops

Lambda Exercise Solution

Sorting

Next and Iter

Generating Characters

Generators

Generators Exercise

Generators Solution

General Generator Syntax

Generators As Loops Solution

Game of Life Solution

Itertools

Function Generators

Powers of Two Generator Solution

Filtering

Reduce

A Functional Word Exercise

Functional Word Solution

Functional Parsing Exercise

Functional Parsing Solution

Mall Customers Database

Reading Files

Ensuring Files Get Closed

Examining With

Iterating Over Files

Writing Files

Files Exercise Solution

Appending to Files

Handling Binary Text

Binary Files

Serialization

Serializing Integers

Deserializing Integers

Saving and Loading Ints

Numbers Versus Bytes

Python Arrays

Saving Arrays

Pickling

JSON

File Dialogs

Game of Life Menus

Game of Life Load and Save

Testing Game of Life

The OS Module

Word Count Exercise

Splitting into Words

Counting Words

Numpy Arrays

Creating Numpy Arrays

Numpy Arithmetic

Numpy Slicing

2D Indexing

Views

Advanced Indexing

Numpy Matrices

Matrix Multiplication

Numpy Functions

Numpy Exercise

Numpy Solution Part 1

Numpy Solution Part 2

Tiling

Masks

Combining Boolean Arrays

Filtering Numpy Arrays

Variance and Standard Deviation

Variance Exercise

Bessel Correction

Scaling and Variance

Loading CSV in Numpy

Pyplot Basics

Styles

Configuration

More Configuration

Word Lengths Exercise

Word Length Plot Solution Part 1

Word Length Solution Part 2

Bar Charts

Pie Charts

Pie Chart Solution

Scatter Plots

Histograms

Multiple Graphs on One Chart

Subplots

Subplots Solution

3D Plots

Introduction

Referencing Cells

Loc and Iloc

Changing Values

Pandas Functions

Series

Pandas Charts

Sorting

Correlations

Grouping

Grouped Types

Group Aggregate Functions

Filtering

Multiple Groups

Plotting Groups

Binning

Groupby Exercise

Groupby Solution Part 1

Groupby Exercise Solution 2

Zipfs Law Exercise

Zipfs Law Solution

Introduction

Linear Regression Data

Configuring Labels

Equation of a Line

Linear Regression

Why Add Constant

R Squared

Calculating R Squared

Train Test

Predictions With Linear Regression

Linear Regression Exercise

Categorical Columns and Correlations

Plotting Grapes Solution

Predicting Grape Weights

Removing Outliers

Multiple Linear Regression

A Multiple Linear Regression Model

About Polynomial Regression

Polynomial Features

A Polynomial Regression Model

A Surprising Result

Loading Emails

Binomial Logistic Regression and Causation

Categorical Dummies

The Logistic Equation

Logistic Regression Model

Multiple Logistic Regression

Getting Predictions with Logistic Regression

Confusion Matrices

Scaling and Normalisation

Normalising Split Data

Using Standard Scaler

Confusion Matrix Exercise

Confusion Matrix Solution Part 1

Confusion Matrix Solution Part 2

Clustering

K-Means Clustering

Centroids and Inertia

The Elbow Method

KMeans Exercise Solution

Exercise Analysis

The Iris Flower Data Set

Loading the Iris Data

Seaborn Plots

KMeans Iris Exercise

KMeans Iris Solution

Permutations Exercise

Permutations Solution

Normalized Mutual Information

Dendrograms

The Linkage Table

Clustering Iris Data

Scikit Learn Agglomerative Clustering

Linkage and Affinity

Fit Predict Transform

Nearest Neighbours

Spherically Symmetric Data

DBSCAN

Determining Epsilon

Using DBSCAN

DBSCAN Moons Exercise

DBSCAN Moons Solution

Silhouette Scores

Nearest Neighbors Classification

Using KNeighbors Classifier

Bayes Theorem

Naive Bayes

Applying Naive Bayes to Classification

An Email Dataset

Loading Emails

Counting Words

Listing Common Words

The Predictor Matrix

Naive Bayes Classifiers

Naive Bayes Exercise

Naive Bayes Solution

Classifying Irises

Introduction

Gini Impurity

Calculating Gini Impurity

Gini Impurity Examples

Decision Tree Exercise

Decision Tree Solution

Seaborn Iris Plots

Plotting Decision Trees

Introduction

Data for PCA

How PCA Works

Transforming Data With PCA

Explained Variance Ratios

Iris Data PCA Analysis

PCA Components

Classifying Irises With PCA

PCA Tips

PCA Exercise

PCA Solution

The MNIST Dataset

Fetching from Openml

Loading MNIST With Keras

Character Recognition

Configuring Logistic Regression

Displaying Images

An Artificial Neuron

Activation Functions

Minimizing Loss

Preparing Iris Data

A Basic ANN

Dropout and Tweaking the Network

MNIST Exercise

MNIST Preparing the Data

MNIST ANN

Improving the MNIST ANN

Comparing Subarrays

Displaying Misclassified Images

Saving and Loading

Pipelines

Standalone Classifier

California Housing Dataset

Regression Neural Net

Improving Regression

Analysing Results

Detecting Overfitting

Conclusion