Python 3: Project-based Python, Algorithms, Data Structures

1. Introduction

This video introduces the course.

2. Course structure and content overview

An in-depth look at the structure of the course and an overview of the content of every section

1. Section intro and overview

A look at development environments, some options and what we'll use in the course

2. Download and install Python

Explore various options available and download Python 3

3. Setup Atom as text editor (setup used in this course)

Download and customize the Atom text editor. This is the editor used in this course throughout

4. Exploring Jupyter Notebooks interface (optional)

A detailed look at using Jupyter Notebooks for developing Python code

1. Section intro and overview

Introduction to material covered in the section and the who it's intended for

2. Command line/Terminal basics

A quick look at using the command line/terminal window to navigate file directories

3. Strings, variables, top down execution flow

Working with strings and variables to handle text

4. Strings: concatenation, indexing, slicing, python console

Detailed look at string concatenation, indexing and slicing

5. String methods, functions and import statements

Wrap up our look at strings with some functions and methods available to string objects. Also investigate import statements and how they work

6. Print formatting and special characters

A look at how to format print statements and use special characters within strings

7. Numbers, math, type casting and input

Working with numbers and computation along with type casting and getting input from user

8. Introduction to branching (if, elif, else) and conditionals

An introductory look at branching and how it works including real code examples from projects built in the course in later sections

9. Building if, elif, else blocks incrementally

An in-depth look at building if elif and else blocks using conditional tests and boolean values

10. Lists, dicts, sets and tuples - Intro to compound data types in Python

An introductory look at collections in Python

11. Lists - an in-depth look 1

Working with lists and exploring functions and methods

12. Lists - an in-depth look 2

Working with sublists, slicing, indexing and basic iteration

13. Dictionaries, sets and tuples

Working with dictionaries, sets and tuples

14. Iterators, for loops, generators, list comprehension

An in-depth look at using for loops in combination with iterables and generators along with list comprehension

15. While loops, enumerate, zip

Conclude our look at iterators, generators and popular functions associated with them with while loops and enumerate and zip functions

16. Functions - an introductory look

A look at functions, their structure, properties and examples

17. Functions - implementation step by step

Take a program and build a function step by step

18. Functions - execution context, frames, mutable vs. immutable arguments in-depth

An in-depth look at the execution context (with global and function frames) of python programs, along with the differences between mutable and immutable data types passed in as parameters

19. Classes and objects - an introductory look

An introductory look at objects with example classes built in the course

20. Building a custom Student class and intro to special methods

Learning the basics of building a class from scratch and special __init__ method

21. Add some methods to the class

Add the add and remove_course methods to the class

22. Special methods and what they are

Explore some special methods like __init__ and __repr__

23. Reading from and writing to files

Working with files and performing read and write operations using context managers and permissions

24. Add read functionality and utilize special and static methods

Add previously built read functionality to the student class using static and regular methods, along with another special method __eq__ to test for equality based on custom definition

25. Inheritance, subclasses and complete example class

Complete Student class and look at inheritance and subclasses

26. Lambda expressions and map function

Explore lambda expressions and use them in conjunction with other functions like map

27. Generators - under the hood

You have already seen generator objects in use, let's take a deeper look at what they are and how they work.

28. Build your own generators using yield

Create custom generators using yield

1. Introduction to section 4 and overview of the material covered in it

Intro to part 2 of this course with section 4 and sorting algorithms, performance analysis and recursion

2. Bubble sort demonstration and complexity analysis

Visual presentation and complexity analysis of the bubble sort algorithm

3. Bubble sort implementation

Implement the bubble sort algorithm step by step

4. Selection sort demonstration and complexity analysis

Visual presentation and complexity analysis of the selection sort algorithm

5. Selection sort implementation

Implement the selection sort algorithm step by step

6. Insertion sort demonstration and assignment handoff

Complete visualization of the insertion sort algorithm and assignment handoff for implementation

7. Insertion sort programmatic execution step by step

Programmatic visual of execution steps performed by the insertion sort algorithm as it sorts a list of 5 elements

8. Performance measures - deep dive with a programmatic view

Look at best, worst and average cases for complexity in more detail

9. O(nlog(n)) performance and algorithm prerequisites

Discuss algorithms that achieve O(nlog(n)) performance and prerequisites for next one

10. Analyze log(n), visualize the math behind it and how it relates to algorithms

An in-depth look at log(n) and what it represents

11. Merge sort visualization and complexity analysis

Look at the merge sort algorithm and its big O analysis

12. Implement merge function - part 1

Start building the merge function - comparison

13. Implement merge function - part 2

Continue building merge function - iteration through lists

14. Implement merge function - part 3

Complete merge function - add remaining items

15. A look at the recursive divide function

A look at the divide/split function which introduces recursion

16. In-depth look at execution context of recursive divide function

Analyze execution context and frames created by recursive divide function in-depth

17. Recursion mini-project 1 - Countdown timer

Build a countdown timer using recursion

18. Recursion mini-project 2 - Factorial

Build a recursive factorial function step by step

19. Recursion mini-project 3 - Fibonacci series

Understand, break down and implement a recursive fibonacci function

20. Complete merge sort algorithm and analyze updated execution context

Complete implementation of the merge sort algorithm and visualize execution context

21. Quicksort demo

A visual look at the Quicksort algorithm

22. Quicksort implementation

Implement Quicksort algorithm step by step

23. Section final project objective and motivation

Final project kickoff and look at objective and motivation for building the project

24. Project specs and runtime execution intro

Look at specs for the project along with actual completed program execution

25. Project phase 1: Build random int list generator

Build a function that generates lists of integers of various sizes and ranges

26. Project phase 2: Get input from user for size and range

Get the list size and range of ints for each list element from the user during program execution

27. Project phase 3: Add functions, calculate and analyze runtime

Add functions to analyze and implement time analysis functionality

28. Project phase 4: Extract redundancies, create function and cleanup code

Add additional functionality to the program by extracting redundant code into a function and beautifying output

29. Project phase 5: Add multiple run functionality and perform additional testing

Add ability to perform several runs of the functions under analysis and perform testing using additional functions and test cases

1. Introduction to section 5

Intro to section 5 and a brief overview of the material covered in this section

2. Intro to search - Linear, Bisection/Binary search

A look at basic searching techniques and the bisection search algorithm

3. Bisection/Binary search - Iterative implementation

Build the binary search function using iteratively

4. Bisection search - recursive implementation

Replace the while loop built in the iterative solution in the prior video with recursive function calls to achieve the same goal

5. Project handoff: Bringing it together

Design and build a project that utilizes the algorithms and tools that have been developed so far

6. Project conclusion walkthrough

Go through implementation steps from concluded project

7. Hashmaps and O(1) search complexity

Visualization of how a hashmap works to achieve O(1) complexity/performance

8. Hash project 1: Define and set up class blueprint with __init__ and __str__

Define the structure requirement for a hash table and setup the class definition

9. Hash project 2: Set up insert and hashing functionality for data structure

Start building the set_val method and introduce python's hash function

10. Hash project 3: Add update functionality

Modify set_val method to include update functionality

11. Hash project 4: Build search method

Implement the get_val method and add search functionality for the class

12. Project: Use hash structure in a practical exercise - Quote finder

Start a project using the hash table structure/class that was built called quote finder

13. Project: Complete quote finder using hash table

Project execution and completion for quote finder using the implemented hash table class

14. Intro to linear data structures - Linked Lists

Introduction to idea and operations of linked lists.

15. Build a custom linked list

Build methods in the custom linked list class and homework assignment

16. Recursively reverse a linked list

Reverse a linked list using recursion

17. Visualize Stacks and Queues, and their operations

Visualize and analyze operations associated with Stacks and Queues

18. Introduction to Trees and Binary Search Trees

An in-depth look at trees, rules surrounding them and a tree known as Binary Search Tree

19. In-order traversal of a Binary Search Tree

In-depth look at in-order traversal and how it results in a sorted representation of the nodes of a BST

20. Build a Binary Search Tree from scratch - Insert

Inserting nodes into a BST in-depth with test cases

21. BST from scratch - In-order traversal

Build the in-order traversal method so nodes can be displayed in order based on the values of their keys

22. BST from scratch - Search

Add a search method to the BST class

23. BST from scratch - Delete demo

Visualize and understand the process of the delete functionality from a BST

24. BST - Deleting leaf nodes

Delete scenario one - deleting nodes with no children (leaf nodes)

25. BST - Deleting nodes with 1 child node

Delete scenario 2 - deleting nodes with 1 child node

26. BST - Deleting nodes with 2 children

Delete scenario 3 - deleting nodes with both left and right child nodes

27. Project: Job Scheduler using Binary Search Trees - Introduction

Introduction to the job scheduler project - to be implemented by students, including motivation and requirements

28. Project: Job Scheduler execution flow

Step by step display of the functionality of the completed job scheduler project

29. Project: Job Scheduler implementation tips and notes

Go through my implementation of the project and discuss code, tips and pointers

30. Thank you for taking the course and next steps

Here, the author thanks everyone for taking the course and suggestions for possible next steps