HOT
blank

Python 3: Deep Dive (Part 2 – Iterators, Generators)

Development

Python 3: Deep Dive (Part 2 – Iterators, Generators), available at $139.99, has an average rating of 4.86, with 142 lectures, based on 2681 reviews, and has 34724 subscribers.

Rating4.9
Enroll Now

You will learn about You'll be able to leverage the concepts in this course to take your Python programming skills to the next level. Sequence Types and the sequence protocol Iterables and the iterable protocol Iterators and the iterator protocol List comprehensions and their relation to closures Generator functions Generator expressions Context managers Creating context managers using generator functions Using Generators as Coroutines This course is ideal for individuals who are Python developers who want a deeper understanding of sequences, iterables, iterators, generators and context managers. It is particularly useful for Python developers who want a deeper understanding of sequences, iterables, iterators, generators and context managers.

Enroll now: Python 3: Deep Dive (Part 2 – Iterators, Generators)

Summary

Title: Python 3: Deep Dive (Part 2 – Iterators, Generators)

Price: $139.99

Average Rating: 4.86

Number of Lectures: 142

Number of Published Lectures: 142

Number of Curriculum Items: 142

Number of Published Curriculum Objects: 142

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

  • You'll be able to leverage the concepts in this course to take your Python programming skills to the next level.
  • Sequence Types and the sequence protocol
  • Iterables and the iterable protocol
  • Iterators and the iterator protocol
  • List comprehensions and their relation to closures
  • Generator functions
  • Generator expressions
  • Context managers
  • Creating context managers using generator functions
  • Using Generators as Coroutines

Who Should Attend

  • Python developers who want a deeper understanding of sequences, iterables, iterators, generators and context managers.

Target Audiences

  • Python developers who want a deeper understanding of sequences, iterables, iterators, generators and context managers.

Part 2 of this Python 3: Deep Dive series is an in-depth look at:

  • sequences

  • iterables

  • iterators

  • generators

  • comprehensions

  • context managers

I will show you exactly how iteration works in Python – from the sequence protocol, to the iterable and iterator protocols, and how we can write our own sequence and iterable data types.

We’ll go into some detail to explain sequence slicing and how slicing relates to ranges.

We look at comprehensions in detail as well and I will show you how list comprehensions are actually closures and have their own scope, and the reason why subtle bugs sometimes creep in to list comprehensions that we might not expect.

We’ll take a deep dive into the itertools module and look at all the functions available there and how useful (but overlooked!) they can be.

We also look at generator functions, their relation to iterators, and their comprehension counterparts (generator expressions).

Context managers, an often overlooked construct in Python, is covered in detail too. There we will learn how to create and leverage our own context managers and understand the relationship between context managers and generator functions.

Each section is followed by a project designed to put into practice what you learn throughout the course.

This course series is focused on the Python language and the standard library. There is an enormous amount of functionality and things to understand in just the standard CPython distribution, so I do not cover 3rd party libraries – this is a Python deep dive, not an exploration of the many highly useful 3rd party libraries that have grown around Python – those are often sufficiently large to warrant an entire course unto themselves! Indeed, many of them already do!

** Prerequisites **

Please note that this is a relatively advanced Python course, and a strong knowledge of some topics in Python is required. 

In particular you should already have an in-depth understanding of the following topics:

  • functions and function arguments

  • packing and unpacking iterables and how that is used with function arguments (i.e. using *)

  • closures

  • decorators

  • Boolean truth values and how any object has an associated truth value

  • named tuples

  • the zip, map, filter, sorted, reduce functions

  • lambdas

  • importing modules and packages

You should also have a basic knowledge of the following topics:

  • various data types (numeric, string, lists, tuples, dictionaries, sets, etc)

  • for loops, while loops, break, continue, the else clause

  • if statements

  • try…except…else…finally…

  • basic knowledge of how to create and use classes (methods, properties) – no need for advanced topics such as inheritance or meta classes

  • understand how certain special methods are used in classes (such as __init__, __eq__, __lt__, etc)

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course Overview

Lecture 2: Pre-Requisites

Lecture 3: Python Tools Needed

Lecture 4: Course Slides

Chapter 2: Sequence Types

Lecture 1: Introduction

Lecture 2: Sequence Types – Lecture

Lecture 3: Sequence Types – Coding

Lecture 4: Mutable Sequence Types – Lecture

Lecture 5: Mutable Sequence Types – Coding

Lecture 6: Lists vs Tuples

Lecture 7: Index Base and Slice Bounds – Rationale

Lecture 8: Copying Sequences – Lecture

Lecture 9: Copying Sequences – Coding

Lecture 10: Slicing – Lecture

Lecture 11: Slicing – Coding

Lecture 12: Custom Sequences – Part 1 – Lecture

Lecture 13: Custom Sequences – Part 1 – Coding

Lecture 14: In-Place Concatenation and Repetition – Lecture

Lecture 15: In-Place Concatenation and Repetition – Coding

Lecture 16: Assignments in Mutable Sequences – Lecture

Lecture 17: Assignments in Mutable Sequences – Coding

Lecture 18: Custom Sequences – Part 2 – Lecture

Lecture 19: Custom Sequences – Part 2A – Coding

Lecture 20: Custom Sequences – Part 2B – Coding

Lecture 21: Custom Sequences – Part 2C – Coding

Lecture 22: Sorting Sequences – Lecture

Lecture 23: Sorting Sequences – Coding

Lecture 24: List Comprehensions – Lecture

Lecture 25: List Comprehensions – Coding

Chapter 3: Project 1

Lecture 1: Project Description

Lecture 2: Project Solution: Goal 1

Lecture 3: Project Solution: Goal 2

Chapter 4: Iterables and Iterators

Lecture 1: Introduction

Lecture 2: Iterating Collections – Lecture

Lecture 3: Iterating Collections – Coding

Lecture 4: Iterators – Lecture

Lecture 5: Iterators – Coding

Lecture 6: Iterators and Iterables – Lecture

Lecture 7: Iterators and Iterables – Coding

Lecture 8: Example 1 – Consuming Iterators Manually

Lecture 9: Example 2 – Cyclic Iterators

Lecture 10: Lazy Iterables – Lecture

Lecture 11: Lazy Iterables – Coding

Lecture 12: Python's Built-In Iterables and Iterators – Lecture

Lecture 13: Python's Built-In Iterables and Iterators – Coding

Lecture 14: Sorting Iterables

Lecture 15: The iter() Function – Lecture

Lecture 16: The iter() Function – Coding

Lecture 17: Iterating Callables – Lecture

Lecture 18: Iterating Callables – Coding

Lecture 19: Example 3 – Delegating Iterators

Lecture 20: Reversed Iteration – Lecture

Lecture 21: Reversed Iteration – Coding

Lecture 22: Caveat: Using Iterators as Function Arguments

Chapter 5: Project 2

Lecture 1: Project Description

Lecture 2: Project Solution: Goal 1

Lecture 3: Project Solution: Goal 2

Chapter 6: Generators

Lecture 1: Introduction

Lecture 2: Yielding and Generator Functions – Lecture

Lecture 3: Yielding and Generator Functions – Coding

Lecture 4: Example – Fibonacci Sequence

Lecture 5: Making an Iterable from a Generator – Lecture

Lecture 6: Making an Iterable from a Generator – Coding

Lecture 7: Example – Card Deck

Lecture 8: Generator Expressions and Performance – Lecture

Lecture 9: Generator Expressions and Performance – Coding

Lecture 10: Yield From – Lecture

Lecture 11: Yield From – Coding

Chapter 7: Project 3

Lecture 1: Project Description

Lecture 2: Project Solution: Goal 1

Lecture 3: Project Solution: Goal 2

Chapter 8: Iteration Tools

Lecture 1: Introduction

Lecture 2: Aggregators – Lecture

Lecture 3: Aggregators – Coding

Lecture 4: Slicing – Lecture

Lecture 5: Slicing – Coding

Lecture 6: Selecting and Filtering – Lecture

Lecture 7: Selecting and Filtering – Coding

Lecture 8: Infinite Iterators – Lecture

Lecture 9: Infinite Iterators – Coding

Lecture 10: Chaining and Teeing – Lecture

Lecture 11: Chaining and Teeing – Coding

Lecture 12: Mapping and Reducing – Lecture

Lecture 13: Mapping and Reducing – Coding

Lecture 14: Zipping – Lecture

Lecture 15: Zipping – Coding

Lecture 16: Grouping – Lecture

Lecture 17: Grouping – Coding

Lecture 18: Combinatorics – Lecture

Lecture 19: Combinatorics – Coding (Product)

Lecture 20: Combinatorics – Coding (Permutation, Combination)

Chapter 9: Project 4

Instructors

Rating Distribution

  • 1 stars: 3 votes
  • 2 stars: 6 votes
  • 3 stars: 41 votes
  • 4 stars: 419 votes
  • 5 stars: 2212 votes

Frequently Asked Questions


How long do I have access to the course materials?


You can view and review the lecture materials indefinitely, like an on-demand channel.


Can I take my courses with me wherever I go?


Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

You may also like

Top 10 Ethical AI Courses to Learn in November 2024

Top 10 Game Development Courses to Learn in November 2024

Top 10 Software Testing Courses to Learn in November 2024