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

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

by Mashrur Hossain
Released September 2019
Publisher(s): Packt Publishing
ISBN: 9781839216510

Watch it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Video description

This course is one of the most comprehensive and beginner-friendly courses 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 from scratch.

We 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; you'll see it all and then build it all.

Since it caters to a broad spectrum of students, the course is split into two parts: part 1 focusing on the Python programming language and part 2 focusing on Algorithms, data structures, performance analysis, and larger-scale projects.

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, and sets

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

• Functions, execution context and frames, and building custom functions

• List comprehension

• Lambda expressions

• Generators and creating your own generators with yield

• Objects and building classes, methods, and special methods

• Reading from and writing to files using context managers

• Visualization with each topic and more!

Part 2: Algorithms, Data Structures, and Performance Analysis

• Sorting algorithms (basic) - bubble sort, selection sort, and insertion sort

• Sorting algorithms (advanced) - merge sort and quick sort

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

• Recursion in-depth with examples

• Searching algorithms - bisection search and hashing

• Data structures with linked lists, stacks, queues, trees, and binary search trees

• Operations with data structures - insert, search, update, and delete

• Multiple projects with increasing levels of complexity to tie concepts together

• Visualizations of all algorithms, data structure, operations, and more!

What You Will Learn

  • Learn Python 3 from scratch, in-depth
  • Understand the fundamentals of programming languages
  • Learn to visualize algorithms, data structures, program executions, and information flows
  • Learn to use Python to build projects

Audience

This course is designed for beginners who have never programmed before; programmers switching to Python; intermediate and advanced programmers looking to understand algorithms and data structures; Job interview candidates looking to understand the subject matter behind technical interview questions, and anyone keen to learn how to visualize programs and information flows.

About The Author

Mashrur Hossain: Mashrur is a full-time programming instructor specializing in programming fundamentals, web application development, machine learning, and cybersecurity. He has been a technology professional for over a decade and has degrees in Computer Science and Economics.

His niche is building comprehensive career-focused technology courses for students entering new/complex and challenging fields in today's technology space. This is a nice segway for him since his real passion is building and tinkering with programming languages. He loves everything to do with development and learning about new tools and technologies. His favorite languages are Python and Ruby on Rails, and his favorite tech fields are web app development, machine learning, and data analytics (which is where Ruby on Rails and Python fall into place nicely). He encourages his students to focus on these technologies as well.

In the past, he has worked with Enterprise Software Systems with roles played in analysis, development, management, and training. He led projects using both agile and waterfall methodologies and thus is well versed in the inner workings of the software development and delivery world.

During his time in corporate America, he realized how much he enjoyed training new hires and new team members and helping them succeed. He dedicated a good amount of time over 7 years on-boarding new analysts and developers and then worked with them to build and maintain systems which put him in a unique position to know and understand what new entrants to a field need in order to succeed. He strongly believes in focusing on fundamentals and practice; and not in shortcuts or gimmicks.

Table of contents

  1. Chapter 1 : Introduction
    1. Introduction
    2. Course structure and content overview
  2. Chapter 2 : Development environment setup
    1. Section intro and overview
    2. Download and install Python
    3. Setup Atom as text editor (setup used in this course)
    4. Exploring Jupyter Notebooks interface (optional)
  3. Chapter 3 : Python in-depth
    1. Section intro and overview
    2. Command line/Terminal basics
    3. Strings, variables, top down execution flow
    4. Strings: concatenation, indexing, slicing, python console
    5. String methods, functions and import statements
    6. Print formatting and special characters
    7. Numbers, math, type casting and input
    8. Introduction to branching (if, elif, else) and conditionals
    9. Building if, elif, else blocks incrementally
    10. Lists, dicts, sets and tuples - Intro to compound data types in Python
    11. Lists - an in-depth look 1
    12. Lists - an in-depth look 2
    13. Dictionaries, sets and tuples
    14. Iterators, for loops, generators, list comprehension
    15. While loops, enumerate, zip
    16. Functions - an introductory look
    17. Functions - implementation step by step
    18. Functions - execution context, frames, mutable vs. immutable arguments in-depth
    19. Classes and objects - an introductory look
    20. Building a custom Student class and intro to special methods
    21. Add some methods to the class
    22. Special methods and what they are
    23. Reading from and writing to files
    24. Add read functionality and utilize special and static methods
    25. Inheritance, subclasses and complete example class
    26. Lambda expressions and map function
    27. Generators - under the hood
    28. Build your own generators using yield
  4. Chapter 4 : Algorithms - Sort, performance, complexity and big O notation
    1. Introduction to section 4 and overview of the material covered in it
    2. Bubble sort demonstration and complexity analysis
    3. Bubble sort implementation
    4. Selection sort demonstration and complexity analysis
    5. Selection sort implementation
    6. Insertion sort demonstration and assignment handoff
    7. Insertion sort programmatic execution step by step
    8. Performance measures - deep dive with a programmatic view
    9. O(nlog(n)) performance and algorithm prerequisites
    10. Analyze log(n), visualize the math behind it and how it relates to algorithms
    11. Merge sort visualization and complexity analysis
    12. Implement merge function - part 1
    13. Implement merge function - part 2
    14. Implement merge function - part 3
    15. A look at the recursive divide function
    16. In-depth look at execution context of recursive divide function
    17. Recursion mini-project 1 - Countdown timer
    18. Recursion mini-project 2 - Factorial
    19. Recursion mini-project 3 - Fibonacci series
    20. Complete merge sort algorithm and analyze updated execution context
    21. Quicksort demo
    22. Quicksort implementation
    23. Section final project objective and motivation
    24. Project specs and runtime execution intro
    25. Project phase 1: Build random int list generator
    26. Project phase 2: Get input from user for size and range
    27. Project phase 3: Add functions, calculate and analyze runtime
    28. Project phase 4: Extract redundancies, create function and cleanup code
    29. Project phase 5: Add multiple run functionality and perform additional testing
  5. Chapter 5 : Algorithms - Search and abstract data structures
    1. Introduction to section 5
    2. Intro to search - Linear, Bisection/Binary search
    3. Bisection/Binary search - Iterative implementation
    4. Bisection search - recursive implementation
    5. Project handoff: Bringing it together
    6. Project conclusion walkthrough
    7. Hashmaps and O(1) search complexity
    8. Hash project 1: Define and set up class blueprint with __init__ and __str__
    9. Hash project 2: Set up insert and hashing functionality for data structure
    10. Hash project 3: Add update functionality
    11. Hash project 4: Build search method
    12. Project: Use hash structure in a practical exercise - Quote finder
    13. Project: Complete quote finder using hash table
    14. Intro to linear data structures - Linked Lists
    15. Build a custom linked list
    16. Recursively reverse a linked list
    17. Visualize Stacks and Queues, and their operations
    18. Introduction to Trees and Binary Search Trees
    19. In-order traversal of a Binary Search Tree
    20. Build a Binary Search Tree from scratch - Insert
    21. BST from scratch - In-order traversal
    22. BST from scratch - Search
    23. BST from scratch - Delete demo
    24. BST - Deleting leaf nodes
    25. BST - Deleting nodes with 1 child node
    26. BST - Deleting nodes with 2 children
    27. Project: Job Scheduler using Binary Search Trees - Introduction
    28. Project: Job Scheduler execution flow
    29. Project: Job Scheduler implementation tips and notes
    30. Thank you for taking the course and next steps

Product information

  • Title: Python 3: Project-based Python, Algorithms, Data Structures
  • Author(s): Mashrur Hossain
  • Release date: September 2019
  • Publisher(s): Packt Publishing
  • ISBN: 9781839216510