Thread by @gusthema

Following up from my previous thread, let's continue taking a look at some additional itertools methods

Some of them, as you will see, have very similar built-in versions but the key here is: itertools works on iterables and generators that are lazy evaluated collections

1/14🧵

One example is the method islice. It does slicing but for iterables (potentially endless collections). The main difference is that it doesn't accept negative indexes like regular slicing.

numbers = range(10)
items = it.islice(numbers, 2, 4)
>>> [2, 3]

2/14🧵

zip_longest vs zip
both do the same thing: aggregates elements from multiple iterators.

The difference is that zip_longest aggregates until the longest iterator ends while zip stops on the shortest one.

It will fill the missing values with any value you want

3/14🧵

starmap vs map:
Use elements of a collection as parameters for a function

starmap is a little bit smarter as it can use multiple parameters on tuples:

b = [2, 3, 10]
exp = [5, 5, 5]
z = zip(b, exp)
it.starmap(pow, z) == map(lambda x, y: pow(x, y), b, exp)

4/14🧵

filterfalse vs filter: they do the complementary task of each other

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
it.filterfalse(lambda x: x%2, numbers) == filter(lambda x: not (x%2), numbers)

5/14🧵

Talking about complementary methods, itertools have dropwhile and takewhile

Given a predicate, they drop or take all elements while true:

it.takewhile(lambda n: n < 4, range(10))
>>> 0,1,2,3

it.dropwhile(lambda n: n < 4, range(10))
>>> 4,5,6,7,8,9

6/14🧵

The accumulate function returns an accumulated result based on a function. The default is a sum:

numbers = range(5) # [0, 1, 2, 3, 4]
it.accumulate(numbers)
>>> 0, 1, 3, 6, 10

letters = ['a', 'b', 'c']
it.accumulate(letters)
>>> a, ab, abc

7/14🧵

If you want to iterate over multiple iterators, one after the other, you can use the chain method:

ls = it.repeat('a', 3) # ['a', 'a', 'a']
ns = range(5) # [0, 1, 2, 3, 4]
it.chain(ls, ns)
>>> a, a, a, 0, 1, 2, 3, 4

8/14🧵

Sometimes you want to remove items from a list based on a mask (called selector). That's where the compress method comes in:

letters = ['a', 'b', 'c', 'd', 'e', 'f']
it.compress(letters, [1, 0, 1, 0, 1])
>>> a, c, e

9/14🧵

Imagine you need to iterate over the same iterator multiple times, you can make independent copies of them using the tee method.

it1, it2 = it.tee(range(5))
It1 -> [0, 1, 2, 3, 4]
It2 -> [0, 1, 2, 3, 4]

10/14🧵

If you know a little bit of SQL, you know about the GROUP BY statement. Itertools has a similar function but with some caveats!

word = 'aabbbnnnaa'
it.groupby(word)
>>> a ['a','a']
>>> b ['b', 'b','b']
>>> a ['a','a']

11/14🧵

💡: The main difference between itertools version from the SQL version is that it won't group elements if they are out of order. It will create different groups instead.

12/14🧵

I've talked about some other itertools methods here:

https://twitter.com/gusthema/status/1404499857184804868

13/14🧵

I hope this was helpful, some of these methods are very helpful and knowing they exist can make your life easier.

I'll keep posting the text version of the code to make your life easier to try it out

I'm learning a lot with these threads, I hope you are too!

14/14🧵