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']