Python 3: Deep Dive (Part 2 – Iterators, Generators) [Udemy Coupon Code]

"When you purchase something through one of the links on our site, we may earn an affiliate commission at no additional cost to you."

Limited offer hurry up

Python 3: Deep Dive (Part 2 – Iterators, Generators) is a top-rated Udemy course taught by Dr. Fred Baptiste — with over 37320+ students enrolled since it launched.

Sequences, Iterables, Iterators, Generators, Context Managers

Don’t wait! This special offer won’t last long.

Click the button below to Get up to 100% OFF the regular price.

(The discount will be applied automatically at checkout — no code needed!)

Hurry — this discount on Python 3: Deep Dive (Part 2 – Iterators, Generators) won’t be around forever. Take action now!

100% off Udemy coupon code

Why enroll in the Python 3: Deep Dive (Part 2 – Iterators, Generators) Udemy Course?

  • Udemy gives you access to over 250,000 courses and 85,000 expert instructors worldwide.
  • Courses are led by experienced professionals dedicated to delivering a high-quality learning experience.
  • Many of Udemy’s most popular courses have hundreds of thousands of students enrolled.
  • Udemy offers online coupons, promo codes and voucher for the majority of its courses.

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

Course Sections
Introduction
Sequence Types
Project 1
Iterables and Iterators
Project 2
Generators
Project 3
Iteration Tools
Project 4
Context Managers
Project 5
Python Updates
Generators as Coroutines (DEPRECATED)
Project 6 (DEPRECATED – relates to preceding deprecated section)
Course Description
Requirements
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.)

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)