Python Itertools

In this tutorial, we are going to learn about Python’s itertools module. This powerful module provides a collection of fast, memory-efficient tools for performing iterator algebra. We’ll cover the most common itertools functions, demonstrating their usefulness with example code snippets.

What is Itertools?

The itertools module in Python is a standard library module that offers a variety of tools for creating and working with iterators. This module helps in creating complex iterators, enabling efficient looping. There are 3 different types of Itertools:

• Infinite Iterators
• Combinatoric Iterators
• Terminating Iterators

Infinite Iterators:

Infinite iterators can generate an infinite sequence of values. The most commonly used infinite iterators are count, cycle and repeat.

• count(start,step):
  This iterator generates consecutive values starting from start and increments by step.
• cycle(iterable):
  This iterator generates cycles of the values indefinitely.
• repeat(object,times):
  This iterator repeats an object specified number of times.

Example:

rom itertools import count, cycle, repeat

# Example using count
print("Count Example:")
for i in count(10, 2):
    if i > 20:
        break
    print(i)

print("\nCycle Example:")
# Example using cycle
count = 0
for item in cycle(['A', 'B', 'C']):
    if count >= 6:
        break
    print(item)
    count += 1

print("\nRepeat Example:")
# Example using repeat
for item in repeat('Hello', 3):
    print(item)

Output:

Count Example: 
10 
12 
14 
16 
18 
20 
Cycle Example: 
A 
B 
C 
A 
B 
C 
Repeat Example: 
Hello 
Hello 
Hello

Combinatoric Iterators:

These iterators are efficient looping constructs for producing combinations, permutations, and Cartesian products.There are 4 types of combinatoric iterators:

• product(iterables, repeat=1):
  This iterator returns Cartesian product of input variables.
• permutations(iterable, r= None):
  This iterator returns succesive ‘r’ length permutations of elements in the iterable.
• combinations(iterable,r):
  This iterator returns succesive ‘r’ length combinations of elements in the iterable.
• combinations_with_replacement(iterable, r):
  This iterator returns successive r length combinations of elements in the iterable allowing individual elements to be repeated more than once.

Example:

from itertools import product, permutations, combinations, combinations_with_replacement

# Example using product
print("Product Example:")
for item in product([1, 2], ['a', 'b']):
    print(item)

print("\nPermutations Example:")
# Example using permutations
for item in permutations('ABC', 2):
    print(item)

print("\nCombinations Example:")
# Example using combinations
for item in combinations('ABC', 2):
    print(item)

print("\nCombinations with Replacement Example:")
# Example using combinations_with_replacement
for item in combinations_with_replacement('ABC', 2):
    print(item)

Output:

Product Example: 
(1, 'a')
(1, 'b') 
(2, 'a') 
(2, 'b') 
Permutations Example: 
('A', 'B') 
('A', 'C') 
('B', 'A') 
('B', 'C') 
('C', 'A') 
('C', 'B') 
Combinations Example: 
('A', 'B') 
('A', 'C') 
('B', 'C') 
Combinations with Replacement Example: 
('A', 'A') 
('A', 'B') 
('A', 'C') 
('B', 'B') 
('B', 'C') 
('C', 'C')

 

Terminating Iterators:

These iterators generate sequences based on the input data, and they terminate once the input is exhausted.Commonly used terminating iterators are:

• accumulate(iterable, func):
  This iterator returns an accumulated sums, or accumulated results of other binary functions specified via the optional func argument.
  
• compress(data, selectors):
  This iterator filters elements from data based on selectors.
  
• chain(iterables):
  This function returns an iterator that links multiple iterables together

Example:

from itertools import accumulate, compress, chain
import operator

# Accumulate Example
print("Accumulate Example:")
data = [1, 2, 3, 4, 5]
print(list(accumulate(data)))  # Default addition
print(list(accumulate(data, operator.mul)))  # Multiplication

# Compress Example
print("\nCompress Example:")
data = ['A', 'B', 'C', 'D']
selectors = [1, 0, 1, 0]
print(list(compress(data, selectors)))

# Chain Example
print("\nChain Example:")
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
print(list(chain(list1, list2)))

Output:

Accumulate Example: 
[1, 3, 6, 10, 15] 
[1, 2, 6, 24, 120] 
Compress Example: 
['A', 'C'] 
Chain Example: 
[1, 2, 3, 'a', 'b', 'c']