Python 3: Project-based Python, Algorithms, Data Structures
4.6 (408 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
3,290 students enrolled

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

Learn programming with Python 3; visualize Algorithms and Data Structures and implement them in projects with Python
4.6 (408 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
3,293 students enrolled
Last updated 11/2019
English
English
Current price: $139.99 Original price: $199.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 14.5 hours on-demand video
  • 9 articles
  • 81 downloadable resources
  • 14 coding exercises
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Learn Python 3 from scratch, in-depth
  • Understand the fundamentals of programming languages
  • Learn to visualize Algorithms, Data Structures, Program Execution and Information flow
  • Learn to use Python to build projects
  • Algorithms (basic to advanced) - sort, search, insert, delete
  • Data Structures - elementary to complex
  • Become proficient in technical interview topics
Course content
Expand all 102 lectures 14:36:00
+ Introduction
3 lectures 08:51

Welcome to the course!

Preview 01:50

This text lecture includes information on live help, office hours and an e-book based on the content from the introductory "Python in-depth" section (Section 3) of this course. I will post updated versions of the book here if/when they become available.

Live help, office hours and Python e-book
01:19

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

Preview 05:42
+ Development environment setup
6 lectures 45:24

An introductory message to complete beginners to programming

[IMPORTANT] - Note to beginners, please don't skip this
01:51

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

Section intro and overview
05:55

Some basic commands you can use to navigate through the command line/terminal

Command line basics cheat sheet
01:02

Explore various options available and download Python 3

Download and install Python
05:59

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

Setup Atom as text editor (setup used in this course)
13:38

A detailed look at using Jupyter Notebooks for developing Python code

Exploring Jupyter Notebooks interface (optional)
16:58
+ Python in-depth
34 lectures 05:58:38

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

Preview 07:51

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

Command line/Terminal basics
06:27

Working with strings and variables to handle text

Preview 10:31

Review some string basics covered in the previous video

Strings basics - I
2 questions
Let's get started!
1 question

Some helpful tips on quizzes and assessment tests

(IMPORTANT) A note on quizzes, coding exercises and assessment tests
01:36

Detailed look at string concatenation, indexing and slicing

Strings: concatenation, indexing, slicing, python console
14:13
Strings basics - II
2 questions

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

String methods, functions and import statements
17:20
Strings basics - III
3 questions
Strings basics exercise
1 question

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

Print formatting and special characters
13:28
Print formatting basics
3 questions

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

Numbers, math, type casting and input
16:47
Math fun
3 questions
Numbers practice
1 question

This is an assessment test for Python basics we have covered so far including working with text, numbers and print formatting

Assessment test - Python basics: Text, numbers and print formatting
00:29

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

Introduction to branching (if, elif, else) and conditionals
12:16

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

Building if, elif, else blocks incrementally
12:54
Branching practice
1 question

An introductory look at collections in Python

Lists, dicts, sets and tuples - Intro to compound data types in Python
11:02
Compound data types
4 questions

Working with lists and exploring functions and methods

Lists - an in-depth look 1
12:06
Lists 1
1 question
Lists practice
1 question

Working with sublists, slicing, indexing and basic iteration

Lists - an in-depth look 2
11:18
Lists 2
3 questions
More lists practice
1 question

Working with dictionaries, sets and tuples

Dictionaries, sets and tuples
18:23
Compound data types
3 questions
Dictionaries practice
1 question
Sets and Tuples practice
1 question

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

Iterators, for loops, generators, list comprehension
18:07
For loops, generators and list comprehension
3 questions

This is an assessment test for compound data structure fundamentals.

Assessment test - Lists, dicts, tuples, sets and iteration
00:33

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

While loops, enumerate, zip
12:43
While loops and more generators
3 questions

A look at functions, their structure, properties and examples

Functions - an introductory look
13:01
Function basics - 1
1 question

Take a program and build a function step by step

Functions - implementation step by step
14:51
Functions basics - 2
1 question

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

Functions - execution context, frames, mutable vs. immutable arguments in-depth
14:19
Functions
6 questions
Functions warm-up
1 question
(Challenge exercise) Function and logic practice
1 question

This is the final assessment test for Python fundamentals and will test knowledge of lists, tuples, dictionaries, iterators and functions

Assessment test - Functions, data types, iterators
00:51

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

Classes and objects - an introductory look
09:29
Classes intro
2 questions

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

Building a custom Student class and intro to special methods
11:58
Custom object intro
1 question

Add the add and remove_course methods to the class

Add some methods to the class
06:48

Explore some special methods like __init__ and __repr__

Special methods and what they are
12:33
Special methods
4 questions

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

Reading from and writing to files
12:22
Read/write ops
1 question

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

Add read functionality and utilize special and static methods
19:46

Complete Student class and look at inheritance and subclasses

Inheritance, subclasses and complete example class
14:46
Classes practice
1 question

Description lecture for bonus content I will post in the rest of the section

Bonus Python specific content (Optional)
00:26

In this optional last part of the section, we will look at some Python specifics, starting with Lambda expressions, also known as anonymous functions.

Python specifics - Lambda expressions
01:59

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

Lambda expressions and map function
10:38
Lambda expressions coding practice
1 question

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

Generators - under the hood
06:41

Create custom generators using yield

Build your own generators using yield
10:05
+ Algorithms - Sort, performance, complexity and big O notation
29 lectures 03:24:56

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

Introduction to section 4 and overview of the material covered in it
01:17

Visual presentation and complexity analysis of the bubble sort algorithm

Bubble sort demonstration and complexity analysis
05:39

Implement the bubble sort algorithm step by step

Bubble sort implementation
16:39

Visual presentation and complexity analysis of the selection sort algorithm

Selection sort demonstration and complexity analysis
09:10

Implement the selection sort algorithm step by step

Selection sort implementation
13:01
Complexity quiz
1 question

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

Insertion sort demonstration and assignment handoff
05:22

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

Insertion sort programmatic execution step by step
02:20

Take a look at best, worst and average cases for complexity in more detail

Performance measures - deep dive with a programmatic view
10:10
Performance measure - calculation
1 question

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

O(nlog(n)) performance and algorithm prerequisites
02:07

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

Analyze log(n), visualize the math behind it and how it relates to algorithms
11:53

Take a look at the merge sort algorithm and its big O analysis

Preview 13:35

Start building the merge function - comparison

Implement merge function - part 1
06:31

Continue building merge function - iteration through lists

Implement merge function - part 2
06:50

Complete merge function - add remaining items

Implement merge function - part 3
04:59

A look at the divide/split function which introduces recursion

A look at the recursive divide function
05:49

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

In-depth look at execution context of recursive divide function
11:47

Build a countdown timer using recursion

Recursion mini-project 1 - Countdown timer
05:47

Build a recursive factorial function step by step

Recursion mini-project 2 - Factorial
06:45

Understand, break down and implement a recursive fibonacci function

Recursion mini-project 3 - Fibonacci series
07:20

Complete implementation of the merge sort algorithm and visualize execution context

Complete merge sort algorithm and analyze updated execution context
07:26
Algorithm complexity quiz
4 questions

A visual look at the Quicksort algorithm

Quicksort demo
05:08

Implement Quicksort algorithm step by step

Quicksort implementation
07:28

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

Preview 01:07

Take a look at specs for the project along with actual completed program execution

Project specs and runtime execution intro
04:15

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

Project phase 1: Build random int list generator
06:42

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

Project phase 2: Get input from user for size and range
02:49

Add functions to analyze and implement time analysis functionality

Project phase 3: Add functions, calculate and analyze runtime
07:35

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

Project phase 4: Extract redundancies, create function and cleanup code
09:48

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

Project phase 5: Add multiple run functionality and perform additional testing
05:37
+ Algorithms - Search and abstract data structures
30 lectures 04:18:09

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

Introduction to section 5
01:10

A look at basic searching techniques and the bisection search algorithm

Intro to search - Linear, Bisection/Binary search
05:56
Search
2 questions

Build the binary search function using iteratively

Bisection/Binary search - Iterative implementation
14:27

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

Bisection search - recursive implementation
09:19

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

Project handoff: Bringing it together
05:20

Go through implementation steps from concluded project

Project conclusion walkthrough
06:41

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

Hashmaps and O(1) search complexity
07:58
Operation complexity
1 question

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

Hash project 1: Define and set up class blueprint with __init__ and __str__
06:47

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

Hash project 2: Set up insert and hashing functionality for data structure
07:56

Modify set_val method to include update functionality

Hash project 3: Add update functionality
09:17

Implement the get_val method and add search functionality for the class

Hash project 4: Build search method
05:50

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

Project: Use hash structure in a practical exercise - Quote finder
06:07

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

Project: Complete quote finder using hash table
08:49

Introduction to idea and operations of linked lists.

Intro to linear data structures - Linked Lists
10:39
Linked list
4 questions

Build methods in the custom linked list class and homework assignment

Build a custom linked list
15:50

Reverse a linked list using recursion

Recursively reverse a linked list
08:37

Visualize and analyze operations associated with Stacks and Queues

Preview 11:56
Stacks and Queues
3 questions

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

Introduction to Trees and Binary Search Trees
14:06
Trees
4 questions

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

Preview 06:47
Traversal order
3 questions

Inserting nodes into a BST in-depth with test cases

Build a Binary Search Tree from scratch - Insert
13:07

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

BST from scratch - In-order traversal
05:02
Traversal implementation
1 question

Add a search method to the BST class

BST from scratch - Search
05:16

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

BST from scratch - Delete demo
06:58

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

BST - Deleting leaf nodes
13:10

Delete scenario 2 - deleting nodes with 1 child node

BST - Deleting nodes with 1 child node
08:44

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

BST - Deleting nodes with 2 children
12:27
Binary Search Trees
5 questions

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

Preview 07:08

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

Project: Job Scheduler execution flow
08:57

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

Project: Job Scheduler implementation tips and notes
10:45

A heart-felt thank you from me to you for taking the course and suggestions for possible next steps

Thank you for taking the course and next steps
03:03
Requirements
  • Access to a computer (Mac, Windows, Linux) with internet connection
Description

Join the most comprehensive and beginner friendly course on learning to code with Python - one of the top programming languages in the world - and using it to build Algorithms and Data Structures with Projects utilizing them from scratch.

You will get:

1) 14+ hours of animation heavy instructional video

2) 14 coding exercises using Udemy's internal python coding environment

3) Quizzes to test your understanding at every step

4) 80+ Python scripts with practice exercises and lecture notes

5) Live help channel and designated office hours with the instructor

6) Multiple assessment tests to test your progress

7) A free Python e-book

and much, much more!

This course is truly one of a kind and focused solely on your learning.

Check out some of the amazing reviews it's receiving:

From Ryan - "I've only had it for one day and it's been absolutely incredible. Wonderful instructor that does a terrific job of explaining complex topics. I'm not even a quarter of the way in and I already feel that I've gotten exponentially more than what I paid."

From Jason - "Great course, the instructor is clearly well-versed with Python programming and gives very clear instruction. I particularly found the algorithms and data structures section to be valuable. Strongly recommend this course, the best Python programming course I've taken by a significant margin."

From Rob - "As a software engineer that needs to get up to speed on some Python for a data-science project, this was perfect. It's in-depth where it needs to be, clear, and very well put together."

I will walk you step-by-step through the fascinating world of Python programming using visualizations of programs as they execute, algorithms as they run and data structures as they are constructed. Nothing is left to the imagination, we'll see it all and then build it all.

Since it caters to a broad spectrum of students, the course is split in two parts, part 1 focusing on the Python programming language and part 2 focusing on Algorithms, Data Structures, Performance Analysis and larger scale projects. Details below:

Part 1: Python and programming fundamentals

  • Text - Strings

  • Numbers - Ints and Floats

  • Execution flow control - Branching with if/elif/else

  • Compound data types - Lists, Dictionaries, Tuples, Sets

  • Iterables and Iteration with generators, for and while loops and more!

  • Functions, execution context and frames, building custom functions

  • List comprehension

  • Lambda expressions

  • Generators and creating your own generators with yield

  • Objects and building classes, methods, special methods

  • Reading from and writing to files using context managers

  • Projects

  • Visualization with each topic and more!

Part 2: Algorithms, Data Structures and Performance Analysis

  • Sorting algorithms (basic) - Bubble sort, Selection sort, Insertion sort

  • Sorting algorithms (advanced) - Merge sort, Quick sort

  • Big O notation, complexity analysis, divide and conquer, math visualizations

  • Recursion in-depth with examples

  • Searching algorithms - Bisection search, hashing

  • Data Structures with Linked lists, Stacks, Queues, Trees, Binary Search Trees

  • Operations with Data structures - insert, search, update, delete

  • Multiple projects with increasing level of complexity that tie the concepts together

  • Visualizations of every algorithm, data structure and operations and more!

So whether you are interested in learning the top programming language in the world in-depth

OR interested in learning the fundamental Algorithms, Data Structures and performance analysis that make up the core foundational skillset of every accomplished programmer/designer or software architect

OR you are looking to ace your next technical interview 

OR all 3 above - This is the course for you!

And on top of that, it comes with a 30 day money back guarantee. If you are not satisfied in any way, you will not only get your money back but you also get to keep the free e-book and tons of downloadable practice exercises and code just for trying it out!

So what are you waiting for? Learn to code with Python while building projects and implementing algorithms and data structures, and gain a core competency in Computer Science that will advance your career and increase your knowledge in the most effective way!

Who this course is for:
  • Beginners who have never programmed before
  • Programmers switching to Python
  • Job interview candidates looking to understand the subject matter behind technical interview questions
  • Intermediate and advanced programmers looking to understand algorithms and data structures
  • Anyone looking to understand the foundations of computer science
  • Anyone looking to learn how to visualize programs and information flow