## 5.16.3 Recipes

This section shows recipes for creating an extended toolset using the existing itertools as building blocks.

The extended tools offer the same high performance as the underlying toolset. The superior memory performance is kept by processing elements one at a time rather than bringing the whole iterable into memory all at once. Code volume is kept small by linking the tools together in a functional style which helps eliminate temporary variables. High speed is retained by preferring ``vectorized'' building blocks over the use of for-loops and generators which incur interpreter overhead.

```def take(n, seq):
return list(islice(seq, n))

def enumerate(iterable):
return izip(count(), iterable)

def tabulate(function):
"Return function(0), function(1), ..."
return imap(function, count())

def iteritems(mapping):
return izip(mapping.iterkeys(), mapping.itervalues())

def nth(iterable, n):
"Returns the nth item"
return list(islice(iterable, n, n+1))

def all(seq, pred=bool):
"Returns True if pred(x) is True for every element in the iterable"
for elem in ifilterfalse(pred, seq):
return False
return True

def any(seq, pred=bool):
"Returns True if pred(x) is True for at least one element in the iterable"
for elem in ifilter(pred, seq):
return True
return False

def no(seq, pred=bool):
"Returns True if pred(x) is False for every element in the iterable"
for elem in ifilter(pred, seq):
return False
return True

def quantify(seq, pred=bool):
"Count how many times the predicate is True in the sequence"
return sum(imap(pred, seq))

"""Returns the sequence elements and then returns None indefinitely.

Useful for emulating the behavior of the built-in map() function.
"""
return chain(seq, repeat(None))

def ncycles(seq, n):
"Returns the sequence elements n times"
return chain(*repeat(seq, n))

def dotproduct(vec1, vec2):
return sum(imap(operator.mul, vec1, vec2))

def flatten(listOfLists):
return list(chain(*listOfLists))

def repeatfunc(func, times=None, *args):
"""Repeat calls to func with specified arguments.

Example:  repeatfunc(random.random)
"""
if times is None:
return starmap(func, repeat(args))
else:
return starmap(func, repeat(args, times))

def pairwise(iterable):
"s -> (s0,s1), (s1,s2), (s2, s3), ..."
a, b = tee(iterable)
try:
b.next()
except StopIteration:
pass
return izip(a, b)

def grouper(n, iterable, padvalue=None):
"grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')"
return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)
```