Disclosure: when you buy through links on our site, we may earn an affiliate commission.

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

Sequences, Iterables, Iterators, Generators, Context Managers and Generator-based Coroutines
(1,780 reviews)
24,134 students
Created by


CourseMarks Score®







Platform: Udemy
Video: 36h 9m
Language: English
Next start: On Demand

Table of contents


Part 2 of this Python 3: Deep Dive series is an in-depth look at:
•context managers
•generator based coroutines
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.
Finally, we’ll look at how we can use generators to create coroutines.
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 *)
•Boolean truth values and how any object has an associated truth value
•named tuples
•the zip, map, filter, sorted, reduce functions
•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
•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)

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


• This is a relatively advanced course, so you should already be familiar with basic Python concepts, as well as some in-depth knowledge as described in the prerequisites in the course description. Please be sure you check those and make sure!
• You will need Python 3.6 or above, and a development environment of your choice (command line, PyCharm, Jupyter, etc.)

This course is for

• Python developers who want a deeper understanding of sequences, iterables, iterators, generators and context managers.
Professional Developer and Mathematician
My name is Fred Baptiste.
I started my career with a PhD in mathematics and have been programming professionally for over 25 years in a variety of technologies and languages, including Python, .Net (C# and VB), Java, C++, and JavaScript to name a few, and databases including relational SQL databases such as MS SQL Server and Postgres as well as No-SQL databases such as MongoDB, Couchbase and Neo4j.
Since 2011 I have been focused on Python almost exclusively, mainly in REST API development and data management and analysis.
I have spent a lot of time and effort learning and gaining an in-depth understanding of Python and writing idiomatic Python, and I’d like to share that with you.
I’m definitely a Python enthusiast for many reasons, and I’d like to share that passion with you too!
Browse all courses by on Coursemarks.
Platform: Udemy
Video: 36h 9m
Language: English
Next start: On Demand

Students are also interested in