Back to Async, Concurrency & Performance

Generators, Iterators & itertools

Lazy evaluation. Process huge datasets with O(1) memory; compose pipelines elegantly. FIND_VIDEO: search 'python generators iterators itertools tutorial' — recommended channel: mCoding / Raymond Hettinger. Aim for 10 min or under.

21 minutesVideo LessonPDF notes

Watch Generators, Iterators & itertools on YouTube

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Loading progress...

Key moments

Iterator Protocol Basics — Introduces the iterator protocol along with the iter and next dunder methods.
StopIteration and For Loops — Demonstrates manual next traversal, StopIteration handling, and automatic for-loop execution.
Iterables vs. Iterators — Contrasts repeatable iterable sequence creation against self-returning stateful iterators.
Sentinel-Based Iteration — Applies the two-argument iter function with sentinel values for streamlined file reading.
Type Abstraction and Hashability — Uses Iterable type hints for polymorphism and explains why set iterables require frozen dataclasses.
Custom Iterator Implementations — Builds custom infinite and finite iterator classes using Self annotations and StopIteration guards.
Streaming with itertools — Constructs functional pipelines using itertools count, repeat, accumulate, permutations, and combinations.

PDF notes

Bottom line: You will be able to implement and inspect custom iterators using Python's iterator protocol, process unbounded streams with sentinel-based calls, and leverage itertools functions to replace complex loops with declarative data pipelines.

This lesson on Generators, Iterators & itertools is hands-on and example-driven. You will be able to implement and inspect custom iterators using Python's iterator protocol, process unbounded streams with sentinel-based calls, and leverage itertools functions to replace complex loops with declarative data pipelines.

What You'll Be Able To Do

Implement custom finite and infinite iterators by defining __iter__ and __next__ dunder methods.
Differentiate between iterables and iterators to avoid state-exhaustion bugs during repeated traversals.
Stream callable outputs and file reads using the two-argument sentinel form of iter().
Build memory-efficient streaming pipelines using itertools.count, repeat, accumulate, permutations, and combinations.

Detailed Concept Walkthrough

1. The Python Iterator Protocol

An iterator is a stateful traversal object that produces the next item in a sequence on demand or raises StopIteration when exhausted. An iterable is an object capable of returning an iterator when passed to iter().

Mechanism: An object satisfies the iterator protocol by implementing __iter__() (which returns the iterator object itself) and __next__() (which returns subsequent values). Calling the built-in next() on an exhausted iterator raises StopIteration.
Under the Hood: Python's for loop encapsulates this mechanics automatically. It requests an iterator via iter(), continuously evaluates next(), and catches StopIteration internally to break execution without manual error handling.
Best Practice: Distinguish sequences (iterables) from active iterators. Calling iter() on an iterable generates a fresh, independent iterator that restarts traversal, whereas calling iter() on an existing iterator merely returns its current stateful self.

countries = ("Germany", "France", "Greece")
country_iter = iter(countries)

# Manual iterator consumption
print(next(country_iter))  # Output: Germany
print(next(country_iter))  # Output: France

# Calling iter() on an iterator returns itself (does not reset)
iter_copy = iter(country_iter)
print(next(iter_copy))     # Output: Greece

# next(country_iter) now raises StopIteration

Key Takeaway: Iterables produce independent iterators on every iter() call, while iterators maintain mutable progress and return themselves.

2. Sentinel-Based Iteration Pattern

The built-in iter() function accepts a two-argument form that converts zero-argument callables into iterators terminated by a sentinel marker.

Mechanism: Invoking iter(callable, sentinel) repeatedly executes the zero-argument callable on each next() step. The iterator produces the returned value until the return matches the sentinel argument, at which point it raises StopIteration.
Under the Hood: This eliminates manual buffering and explicit while True loop boilerplate when interacting with stream-based or chunk-reading APIs. It evaluates lazily without loading the entire payload into RAM.
Best Practice: Use this pattern when reading IO buffers, line streams, or polling queues. For instance, reading lines with iter(f.readline, '') halts cleanly when the empty string signals EOF.

# Process a text stream until reaching an empty string sentinel (EOF)
with open("countries.txt", "r") as f:
    # f.readline is called repeatedly until it returns ""
    for line in iter(f.readline, ""):
        print(line, end="")

Key Takeaway: Two-argument iter(callable, sentinel) abstracts while-loop IO reads into clean, standard for-loop iteration.

3. Custom Class Iterators

Custom classes can implement the iterator protocol directly to produce sequence elements dynamically, supporting both bounded and infinite streams.

Mechanism: A custom iterator class stores traversal state in instance attributes. Its __iter__() method returns self (typed with typing.Self), while __next__() calculates the next state and returns the current value.
Under the Hood: Finite iterators enforce boundaries by raising StopIteration explicitly within __next__() when the termination condition is met. Infinite iterators omit this guard, generating values continuously.
Best Practice: When iterating custom objects across generic functions, annotate inputs with collections.abc.Iterable rather than concrete types (like list or tuple) to maintain loose coupling across data structures.

from typing import Self

class NumberIterator:
    def __init__(self, start: int, maximum: int) -> None:
        self.number = start
        self.maximum = maximum

    def __iter__(self) -> Self:
        return self

    def __next__(self) -> int:
        if self.number > self.maximum:
            raise StopIteration
        val = self.number
        self.number += 1
        return val

for num in NumberIterator(start=1, maximum=3):
    print(num)  # Prints 1, 2, 3

Key Takeaway: Custom iterators encapsulate arbitrary state transitions and terminate deterministically via StopIteration.

4. Functional Streaming with itertools

The itertools module provides composable, high-performance iterator algebra to build lazy data-processing pipelines without loop overhead.

Mechanism: itertools constructs C-level iterator pipelines. Infinite generators like count(start) generate endless progressions, while repeat(elem, n) produces fixed repetitions. Running computations like accumulate() yield intermediate states.
Under the Hood: Combinatoric iterators calculate permutations and combinations on-the-fly without allocating memory for the full combinatorial Cartesian product up front.
Best Practice: Choose permutations(iterable, r) when item order matters (where ('a', 'b') != ('b', 'a')), and combinations(iterable, r) when order is irrelevant.

import itertools

# Count infinitely from 10; break at threshold
for val in itertools.count(10):
    if val > 12:
        break
    print(val)  # Prints 10, 11, 12

# Running cumulative sum
running_sums = list(itertools.accumulate([1, 2, 3, 4]))
print(running_sums)  # [1, 3, 6, 10]

# Combinatorics: combinations vs permutations
items = ["a", "b", "c"]
perms = list(itertools.permutations(items, 2))   # len 6: ('a','b'), ('b','a'), ...
combs = list(itertools.combinations(items, 2))   # len 3: ('a','b'), ('a','c'), ('b','c')

Key Takeaway: itertools delivers memory-efficient, functional streaming primitives that eliminate manual loop accumulators and combinatoric recursion.

Topics Covered in Generators, Iterators & itertools

Iterator Protocol Basics (0:00 - 1:25) — Introduces the iterator protocol along with the iter and next dunder methods.
StopIteration and For Loops (1:25 - 2:30) — Demonstrates manual next traversal, StopIteration handling, and automatic for-loop execution.
Iterables vs. Iterators (2:30 - 4:00) — Contrasts repeatable iterable sequence creation against self-returning stateful iterators.
Sentinel-Based Iteration (4:00 - 5:15) — Applies the two-argument iter function with sentinel values for streamlined file reading.
Type Abstraction and Hashability (5:15 - 6:45) — Uses Iterable type hints for polymorphism and explains why set iterables require frozen dataclasses.
Custom Iterator Implementations (6:45 - 8:10) — Builds custom infinite and finite iterator classes using Self annotations and StopIteration guards.
Streaming with itertools (8:10 - 10:00) — Constructs functional pipelines using itertools count, repeat, accumulate, permutations, and combinations.

Python Cheat Sheet

iter(iterable) — Obtains an iterator from an iterable container
```
stream = iter([1, 2, 3])
```
next(iterator) — Retrieves the next element or raises StopIteration
```
item = next(stream)
```
iter(callable, sentinel) — Iterates a zero-argument callable until reaching sentinel
```
stream = iter(f.readline, "")
```
itertools.count(start=0, step=1) — Generates an infinite arithmetic progression of numbers
```
counter = itertools.count(10)
```
itertools.repeat(object, times) — Yields an object repeatedly for n times
```
ones = itertools.repeat(1, 4)
```
itertools.accumulate(iterable) — Yields running cumulative reductions of an iterable
```
totals = itertools.accumulate(range(1, 5))
```
itertools.permutations(iterable, r) — Yields ordered r-length tuples without replacement
```
pairs = itertools.permutations(["a", "b"], 2)
```
itertools.combinations(iterable, r) — Yields unordered r-length tuples without replacement
```
pairs = itertools.combinations(["a", "b"], 2)
```

Comparison Table

Property	Iterable (e.g. List, Tuple)	Iterator (e.g. iter(List))
Protocol Methods	Implements `__iter__()`	Implements `__iter__()` and `__next__()`
Calling `iter(obj)`	Returns fresh, independent iterator	Returns self with shared state
State & Resetting	Can be traversed multiple times	Single-pass; consumed permanently
Memory Footprint	Stores complete collection in memory	Evaluates and streams elements lazily

Common Pitfalls

Mistake: Calling iter() on an active iterator expecting a fresh restart. Avoid: Call iter() on the original sequence container to obtain a new iterator instance.
Mistake: Forgetting to raise StopIteration inside custom iterator next methods. Avoid: Check boundary conditions explicitly and raise StopIteration when iteration completes.
Mistake: Passing mutable custom classes into set-based iterable pipelines. Avoid: Mark dataclasses as frozen=True or implement a valid hash method.
Mistake: Consuming itertools.count() in a loop without break conditions. Avoid: Include explicit termination checks or pair with slicing utilities to prevent infinite loops.

FAQs

Why must custom iterators implement iter in addition to next? Implementing __iter__ to return self allows the iterator to be passed directly to for loops and functions expecting generic iterables.
What happens when you pass an already exhausted iterator into a for loop? The loop calls next() immediately, receives StopIteration, and terminates without executing the loop body or throwing an error.
When is permutations preferred over combinations in itertools? Use permutations when element ordering matters (('a', 'b') != ('b', 'a')), and use combinations when groups with identical members are considered equal.

Common pitfalls

Mistake: Calling iter() on an active iterator expecting a fresh restart. Avoid: Call iter() on the original sequence container to obtain a new iterator instance.
Mistake: Forgetting to raise StopIteration inside custom iterator __next__ methods. Avoid: Check boundary conditions explicitly and raise StopIteration when iteration completes.
Mistake: Passing mutable custom classes into set-based iterable pipelines. Avoid: Mark dataclasses as frozen=True or implement a valid __hash__ method.
Mistake: Consuming itertools.count() in a loop without break conditions. Avoid: Include explicit termination checks or pair with slicing utilities to prevent infinite loops.

Hey there, today I'm going to cover iterators in Python and the itertools standard library. Actually, a while ago somebody in the audience mentioned that they really liked these deeper dives into the Python standard library. I think there's a couple of really cool packages that I want to dive into, so I thought, you know what, let's make this a thing. So, welcome to this new series on the Python standard library and a deep dive into the possibilities without having to install any third-party modules. Even cup of coffee for the occasion. This will actually already take seven, so I'm like this is a video about itertools. No, just kidding. I'm actually I can deal with caffeine pretty efficiently, so I normally don't have to worry about that. Anyway, knowledge about the Python standard library is actually really useful. If you're writing your own code, it can often provide you with certain shortcuts to make things easier, but it's also helpful if you're reviewing somebody else's code. If you want to become better at reviewing somebody else's code and giving more useful feedback and also being able to do that efficiently, I've got a free workshop for you. You can get access by going to arjan.codes/diagnosis and this workshop is like 30-40 minutes of me diving into existing code bases and doing a review and show you how to detect issues in code efficiently and effectively. It's really practical, to the point. You can just take those ideas, apply it immediately to your own code base. So arjan.codes/diagnosis to get access. The link is also in the description of this video. So what is an iterator? Well, it's an object that's used to traverse through some sequence of items, and this process of traversal is called iteration. In Python, an iterator is an object that implements the iterator protocol and that protocol defines two methods: iter and next, both dunder methods. Iterators in Python are basically everywhere. You've probably used them already lots of times while not even realizing that you were using iterators. They're elegantly implemented within for loops, list comprehensions, generators, and more. Basically, they're all over the language, but they're hidden in plain sight. Let's take a look at some examples. What I have here is a sequence of countries. In this case, countries is a tuple of strings and what I can do now, there's basically two functions that are important: there's the iter function, and there's the next function. So first I can get an iterator as follows, like so. So this gives me an iterator over the sequence of countries. And now what I can do is print the next element in the country sequence by calling next on the iterator. And when I run this, this is what we get. Now I can call next a number of times. For example, there's in total six countries in this sequence, so I can call this six times to print out all the countries in the sequence, then this is what we get. If you do it one more time, then next is actually going to raise a StopIteration error. This is what you're seeing here. So if you want to go over all the elements in the sequence and then stopping at the end, you can basically use a while loop for that. So let me delete this. And then And then we're going to say, while True: I'm going to try getting a country using next like so. And if we catch a StopIteration error, I'm going to break out of the while loop. Else: I'm going to print the country. So, when I run this, this simply prints out all the countries in the sequence until we reach the last one, which is Greece. Now of course, this isn't normally how you would do it in Python. I just want to show you how it works with the StopIteration error catching and so on. There's a much shorter way to do it, which is using a for loop, and that actually internally more or less does this. And then I don't even need to create an iterator, the for loop already does this for me. And this gives, obviously, exactly the same result. So the while loop I just showed you before, don't use that. Simply use a for loop like this. You may have heard two terms being used in the Python world related to iterators, which is iterators and iterables. And those are actually not the same thing. An iterable is an object that can provide you with an iterator. And an iterator is an iterable that also has a next dunder method. So they are related, but they're not the same thing. Now, sequences like lists, tuples, dictionaries, etc., are all examples of iterables and they allow you to get an iterator from them, which is what I've just shown you in this example. Initially, I thought the way that iterables and iterators were organized in Python a bit strange. I mean, why would an iterator have an iter method, like the country iterator, for example? It itself has an iterator method and that's called by the iter function in turn. And what it actually does in this case is it returns exactly the same iterator. So for example, what I can do is I can print next of the country iterator, so that's going to print Germany, right? But then if I create an iter copy which is the iterator of country iterator and then I print the next one from this copy, you see that this is going to print France, because it's actually the same iterator. So that's what you see here: Germany, then France. So I could just as well have called here next country iterator. It would have been the same thing. And that's what happens when you call an iter function on an iterator. But if you call iter on the sequence, which is the iterable, the behavior is different. So for example, I can print here next using this iterator, but now I'm creating a new iterator from the sequence. And that's actually going to be another separate iterator. So now this is going to print Germany twice. Though I don't find this completely logical, the main thing you can do with this is basically restart an iterator or have the possibility to iterate a sequence at the same time in various places in the sequence. So, in that sense, it can be useful, but it's good to know the difference between iterables, which allow you to restart an iterator, and iterators, which simply just give back themselves when you call iter on them. Okay, couple of other things you can do with iterators that are actually pretty cool. One is that you can call iter, the iter function, with a function and a sentinel value and what that does is it's going to call the function until the function returns the sentinel value. And that's very useful, for example, if you want to go through let's say a text file, and you want to read lines of text until you reach the end of the text file. So, what I have here is I have a file called countries.txt which contains the same countries as I have in my main file. But now what I can do is let me replace this, I can simply use a for loop and then I can use with to open the file countries. -- uh, I need to type correctly -- txt, like so, and then for line in and now I can use actually an iterator: f.readline, file.readline, so I'm going to use the readline function until it reaches the sentinel value of the empty string, which is the end of the file. And now, I can simply print each of these lines. In order to print it nicely, I can tell the print statement to end it with the empty string and not with a new line, and then this is what we get. It simply prints all of the countries like we had before. So this is useful if you want to call a function a number of times in a sequence until you reach some sort of value. Another nice thing that you can do with iterators is that they provide you a mechanism of abstraction. So here I have an example that shows you how this works. I have a simple class called LineItem, that's a dataclass. It's frozen, so it's basically read-only. It has price and a quantity and a total_price method that simply multiplies the two. Now I've used this example before in other videos, so you may recognize it, but it's just to keep it simple. There's also a print_totals function that basically takes a number of items, so here you see I'm using the type Iterable, so it's basically anything that's iterable and that contains line items. And that's going to use a for loop for item in items, and it's going to print the total price. And then in my main function, I have my line_items list, which contains a couple of line items. It doesn't really matter what the values are. And then I'm calling print_total. When I run this, we simply get a number of totals printed here on the screen. But what's interesting is because print_totals now relies on the type being an Iterable, I can basically replace this by any type of sequence. So instead of list, I could also decide to use a tuple like so. And when I run this now, obviously I'm going to get exactly the same result because I'm simply iterating through the sequence. But print_totals doesn't care about the specific type of sequence that items is, and that means we've now introduced a level of abstraction. The only thing that print_totals needs to know is that it's some iterable sequence and it just uses a for loop to traverse that sequence. We don't really care what the data structure is exactly, and that's really nice. By the way, it is important for the dataclass to be frozen in this example because some data structures, like like the set, for example, it relies on being able to find the element quickly using a hashing function. So when I run this, this works without issues, but if I remove the frozen indicator in here and then I try to run this again, and you see we're going to get an error that LineItem is unhashable. If you use frozen, this problem is solved. What you can also do is add your own hash function to the LineItem, and then that's also perfectly fine. By the way, if you're enjoying this video so far, give the like. It helps others on YouTube find the content as well. Iterators are, in principle, something that you can build yourself using your own classes with iter and next dunder methods. So here you see an example of that, really simple. We have a class called InfiniteNumberIterator and that has an iter dunder method, and it has a next dunder method. It has only one instance variable, the number, and what it does for next, it simply increases the number by one and then returns that number. So that just goes through the numbers and it does it infinitely. So this also shows that iterators don't have to be finite. They can, in principle, be infinite if you want to have that kind of behavior. What's interesting here is that the iter dunder method simply returns the iterator, like what happens if you get an iterator from a list and then ask that iterator to provide an iterator. Ah, is that confusing? It's probably getting pretty confusing. Sorry about that. But what's nice is that since I'm using Python 3.11, I can use the Self type here. So, another useful case of the Self type. Here I have a variety of this, which I'm simply calling a NumberIterator, and that not only has a number, like this one, but it also has a maximum. And then, well, iter is the same, but in the next dunder method, I check whether the number is above the maximum. If it is, I'm going to raise a StopIteration error. Otherwise, I simply call number + 1 and return self.number. And then in my main function here, I'm simply calling number on the NumberIterator and printing that number. And of course, we see it does that until it reaches the maximum that we indicated here as a parameter. So this is, in the core, how an iterator works under the hood, and you can build your own iterators this way, and then it integrates nicely with things like for loops, etc., in Python. If you want to take iterators to the next level, you should take a look at the itertools package in Python. It's included in the standard library and it has some really cool features, and I'm going to show you a couple of them now. Basically, what itertools does is that it provides a sort of algebra of iterators that you can combine in various ways. In that sense, it builds on functional programming principles, like higher-order functions. I did a video about functional programming in Python a while ago. If you want to learn more about that, check out this video at the top. Now in order to get started with itertools, the only thing we need to do is simply import it at the top. And I'm going to show you a few examples of what you can do with this. So this ranges from very basic things to pretty powerful things, and you can combine these iterators in all kinds of different ways in order to result in complex behavior. And where iterators really shine is by replacing loops with combinations of iterators. For example, let's say you want to print out totals and you have a list of prices and a list of quantities, well, you could write a for loop to do that sort of naively, but you can also use the starmap function provided with a multiplication function and a tuple of iterables, and that's also going to work. I'll show you an example of that in a minute, but let's start with something a bit more simple. I'm going to start with a simple example of using an iterator to do counting. So I will use a for loop and then I'll use itertools.count, and I can provide it with an integer which is the starting value. So let's say that's 10. Going to print i, and then if i == 15: I'm going to break out of the for loop. When I run this, then this is what we get. Very basic. Another thing we can do is repeating, and repeat gets an object, and that's going to return that object a number of times. So for example, I can provide it with an object of type integer, let's say 10, and I want it to return that integer four times. So, this is no longer needed, of course, and let's add a colon. So when I run this, we get 10 printed four times, so simply repeating. Another thing you can do is accumulate, and accumulate, you can provide it with a range, let's say a range from 1 until 11, and then we run this and you see it's going to accumulate these numbers: 1 + 2 + 3 + 4, etc. etc., until 11. And there's way more functions. For example, let's say we have a list of items: 'a', 'b', and 'c'. Very simple. What I can do now is use itertools.permutations to get all the possible permutations of these three items. So I'm using permutations function and I'm providing it with the items, and I want all the permutations of the three items, and then I'm using a for loop again to print the permutation. When I run this, then this is what we get, all the possible permutations. I can also supply an extra number here, so if I, for example, supply the number 2, then these are all the permutations of length two. So when I run this then, this is what we get. As you see, it's ordered, so ('a', 'b') is considered a different permutation than ('b', 'a'). If the order doesn't matter, then you don't use permutations, but you use combinations. And now, when I run this again, you see that we get way less: we get ('a', 'b'), ('a', 'c'), and ('b', 'c'). And as a variety, you also have combinations_with_replacement. And when I run this, then this is what you get. combinations_with_replacement works slightly differently because it also allows, for example, for two a's or two b's or two c's. There's, by the way, a simpler way to print this. You can also simply print a list made from the iterator like so. So I can remove this for loop, and then when I run this, it's simply going to print the list of all the elements that the iterator produced. Other things you can do. Let's say I have a second list: more_items. And now I can use the chain function to combine them into a single iterator. So I can print a list made from itertools.chain, and then I'm going to provide it with items and more_items, and now it's going to print all these elements in a chain. And then of course, you can combine things. For example, I could call an itertools.combinations on the chain of items and more_items like so. And then when I print this, then I'm going to get all the combinations, except I need to provide a number, I think. Yeah. So, let's provide a number here. I want all combinations of two, and then let's run this again, and now I'm going to get all the combinations of two on the chain of items and more_items. And this is exactly the type of thing that itertools likes to do. It's an algebra that allows you to combine different iterators in different ways by chaining them or by calling other itertools functions repeatedly on the iterator. You have to be careful, though, that your code remains readable. Sometimes if you combine these things in very complex ways, then it's really hard to understand. In that case, the general design principles always apply of keeping things simple, and readability is obviously very important, so in that case it might make sense to split things up a bit more, use sensible variable names, or even create a function that groups several itertools functions into something new and then give that function a logical name. So a few more things I want to show you. So first, there is filterfalse, which is also quite useful. So what this does, it filters out the values for which some predicate is false. So if I do a print of a list itertools.filterfalse, and I'm going to provide it a lambda function where I'm simply going to check all the elements divisible by 2 and that colon shouldn't be there, and then let's say I provide it with a range, so that's a sequence of numbers. When I print this, you see that it prints only the odd numbers. So it's going to filter out the things for which this lambda function returns false, and then it's going to put that, in this case, in the iterator and then put it in the list and then I print it. There's also takewhile, which gets elements from the list until the function is true. So in this case, if I run this, well, the first element is 0, so it only takes the first element. If I turn this into the opposite, != 0, then it gets the empty list because the first element already doesn't agree to that. Another thing I want to show you is starmap, which is also a very useful function. So in this case, I mentioned the example of having an iterable of tuples, so that's what you see here, and starmap applies the function on each element in the tuple. So in this case, it takes an x and a y and it's going to multiply the values. So what it will do is it goes through this iterable, takes each tuple, and then applies the function on it. So we're going to get 2 * 6, 8 * 4, and 5 * 3 when I run this, so that's what you see here. So itertools can be pretty powerful. You can create pretty complex iterator behavior by combining these functions in different ways. And what's nice is that this is also pretty fast and memory efficient, so you don't have to worry about performance too much when you're using these itertools functions. So question for you: are you already using these itertools functions? And what are some of the more complex and uncommon ways in which you use them? I'll collect them, and then if there are enough examples, I might do a follow-up video where I dive into some of those non-conventional uses of itertools functions. This was a deeper dive into Python's iterators and itertools package. If you like this, you might also like the deeper dive I did into the datetime package recently. I've put that video right here. Thanks for watching, and see you next week.

Frequently asked questions

Why must custom iterators implement __iter__ in addition to __next__?

Implementing `__iter__` to return `self` allows the iterator to be passed directly to `for` loops and functions expecting generic iterables.

What happens when you pass an already exhausted iterator into a for loop?

The loop calls `next()` immediately, receives `StopIteration`, and terminates without executing the loop body or throwing an error.

When is permutations preferred over combinations in itertools?

Use `permutations` when element ordering matters (`('a', 'b')` != `('b', 'a')`), and use `combinations` when groups with identical members are considered equal.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.