2 :mod:`itertools` --- Functions creating iterators for efficient looping
3 =======================================================================
6 :synopsis: Functions creating iterators for efficient looping.
7 .. moduleauthor:: Raymond Hettinger <python@rcn.com>
8 .. sectionauthor:: Raymond Hettinger <python@rcn.com>
13 from itertools import *
17 This module implements a number of :term:`iterator` building blocks inspired
18 by constructs from APL, Haskell, and SML. Each has been recast in a form
21 The module standardizes a core set of fast, memory efficient tools that are
22 useful by themselves or in combination. Together, they form an "iterator
23 algebra" making it possible to construct specialized tools succinctly and
24 efficiently in pure Python.
26 For instance, SML provides a tabulation tool: ``tabulate(f)`` which produces a
27 sequence ``f(0), f(1), ...``. This toolbox provides :func:`imap` and
28 :func:`count` which can be combined to form ``imap(f, count())`` to produce an
31 These tools and their built-in counterparts also work well with the high-speed
32 functions in the :mod:`operator` module. For example, the multiplication
33 operator can be mapped across two vectors to form an efficient dot-product:
34 ``sum(imap(operator.mul, vector1, vector2))``.
37 **Infinite Iterators:**
39 ================== ================= ================================================= =========================================
40 Iterator Arguments Results Example
41 ================== ================= ================================================= =========================================
42 :func:`count` start, [step] start, start+step, start+2*step, ... ``count(10) --> 10 11 12 13 14 ...``
43 :func:`cycle` p p0, p1, ... plast, p0, p1, ... ``cycle('ABCD') --> A B C D A B C D ...``
44 :func:`repeat` elem [,n] elem, elem, elem, ... endlessly or up to n times ``repeat(10, 3) --> 10 10 10``
45 ================== ================= ================================================= =========================================
47 **Iterators terminating on the shortest input sequence:**
49 ==================== ============================ ================================================= =============================================================
50 Iterator Arguments Results Example
51 ==================== ============================ ================================================= =============================================================
52 :func:`chain` p, q, ... p0, p1, ... plast, q0, q1, ... ``chain('ABC', 'DEF') --> A B C D E F``
53 :func:`compress` data, selectors (d[0] if s[0]), (d[1] if s[1]), ... ``compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F``
54 :func:`dropwhile` pred, seq seq[n], seq[n+1], starting when pred fails ``dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1``
55 :func:`groupby` iterable[, keyfunc] sub-iterators grouped by value of keyfunc(v)
56 :func:`ifilter` pred, seq elements of seq where pred(elem) is True ``ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9``
57 :func:`ifilterfalse` pred, seq elements of seq where pred(elem) is False ``ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8``
58 :func:`islice` seq, [start,] stop [, step] elements from seq[start:stop:step] ``islice('ABCDEFG', 2, None) --> C D E F G``
59 :func:`imap` func, p, q, ... func(p0, q0), func(p1, q1), ... ``imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000``
60 :func:`starmap` func, seq func(\*seq[0]), func(\*seq[1]), ... ``starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000``
61 :func:`tee` it, n it1, it2 , ... itn splits one iterator into n
62 :func:`takewhile` pred, seq seq[0], seq[1], until pred fails ``takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4``
63 :func:`izip` p, q, ... (p[0], q[0]), (p[1], q[1]), ... ``izip('ABCD', 'xy') --> Ax By``
64 :func:`izip_longest` p, q, ... (p[0], q[0]), (p[1], q[1]), ... ``izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-``
65 ==================== ============================ ================================================= =============================================================
67 **Combinatoric generators:**
69 ============================================== ==================== =============================================================
70 Iterator Arguments Results
71 ============================================== ==================== =============================================================
72 :func:`product` p, q, ... [repeat=1] cartesian product, equivalent to a nested for-loop
73 :func:`permutations` p[, r] r-length tuples, all possible orderings, no repeated elements
74 :func:`combinations` p[, r] r-length tuples, in sorted order, no repeated elements
75 :func:`combinations_with_replacement` p[, r] r-length tuples, in sorted order, with repeated elements
77 ``product('ABCD', repeat=2)`` ``AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD``
78 ``permutations('ABCD', 2)`` ``AB AC AD BA BC BD CA CB CD DA DB DC``
79 ``combinations('ABCD', 2)`` ``AB AC AD BC BD CD``
80 ``combinations_with_replacement('ABCD', 2)`` ``AA AB AC AD BB BC BD CC CD DD``
81 ============================================== ==================== =============================================================
84 .. _itertools-functions:
89 The following module functions all construct and return iterators. Some provide
90 streams of infinite length, so they should only be accessed by functions or
91 loops that truncate the stream.
94 .. function:: chain(*iterables)
96 Make an iterator that returns elements from the first iterable until it is
97 exhausted, then proceeds to the next iterable, until all of the iterables are
98 exhausted. Used for treating consecutive sequences as a single sequence.
101 def chain(*iterables):
102 # chain('ABC', 'DEF') --> A B C D E F
108 .. function:: itertools.chain.from_iterable(iterable)
110 Alternate constructor for :func:`chain`. Gets chained inputs from a
111 single iterable argument that is evaluated lazily. Equivalent to::
114 def from_iterable(iterables):
115 # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
120 .. versionadded:: 2.6
123 .. function:: combinations(iterable, r)
125 Return *r* length subsequences of elements from the input *iterable*.
127 Combinations are emitted in lexicographic sort order. So, if the
128 input *iterable* is sorted, the combination tuples will be produced
131 Elements are treated as unique based on their position, not on their
132 value. So if the input elements are unique, there will be no repeat
133 values in each combination.
137 def combinations(iterable, r):
138 # combinations('ABCD', 2) --> AB AC AD BC BD CD
139 # combinations(range(4), 3) --> 012 013 023 123
140 pool = tuple(iterable)
145 yield tuple(pool[i] for i in indices)
147 for i in reversed(range(r)):
148 if indices[i] != i + n - r:
153 for j in range(i+1, r):
154 indices[j] = indices[j-1] + 1
155 yield tuple(pool[i] for i in indices)
157 The code for :func:`combinations` can be also expressed as a subsequence
158 of :func:`permutations` after filtering entries where the elements are not
159 in sorted order (according to their position in the input pool)::
161 def combinations(iterable, r):
162 pool = tuple(iterable)
164 for indices in permutations(range(n), r):
165 if sorted(indices) == list(indices):
166 yield tuple(pool[i] for i in indices)
168 The number of items returned is ``n! / r! / (n-r)!`` when ``0 <= r <= n``
169 or zero when ``r > n``.
171 .. versionadded:: 2.6
173 .. function:: combinations_with_replacement(iterable, r)
175 Return *r* length subsequences of elements from the input *iterable*
176 allowing individual elements to be repeated more than once.
178 Combinations are emitted in lexicographic sort order. So, if the
179 input *iterable* is sorted, the combination tuples will be produced
182 Elements are treated as unique based on their position, not on their
183 value. So if the input elements are unique, the generated combinations
188 def combinations_with_replacement(iterable, r):
189 # combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
190 pool = tuple(iterable)
195 yield tuple(pool[i] for i in indices)
197 for i in reversed(range(r)):
198 if indices[i] != n - 1:
202 indices[i:] = [indices[i] + 1] * (r - i)
203 yield tuple(pool[i] for i in indices)
205 The code for :func:`combinations_with_replacement` can be also expressed as
206 a subsequence of :func:`product` after filtering entries where the elements
207 are not in sorted order (according to their position in the input pool)::
209 def combinations_with_replacement(iterable, r):
210 pool = tuple(iterable)
212 for indices in product(range(n), repeat=r):
213 if sorted(indices) == list(indices):
214 yield tuple(pool[i] for i in indices)
216 The number of items returned is ``(n+r-1)! / r! / (n-1)!`` when ``n > 0``.
218 .. versionadded:: 2.7
220 .. function:: compress(data, selectors)
222 Make an iterator that filters elements from *data* returning only those that
223 have a corresponding element in *selectors* that evaluates to ``True``.
224 Stops when either the *data* or *selectors* iterables has been exhausted.
227 def compress(data, selectors):
228 # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
229 return (d for d, s in izip(data, selectors) if s)
231 .. versionadded:: 2.7
234 .. function:: count(start=0, step=1)
236 Make an iterator that returns evenly spaced values starting with *n*. Often
237 used as an argument to :func:`imap` to generate consecutive data points.
238 Also, used with :func:`izip` to add sequence numbers. Equivalent to::
240 def count(start=0, step=1):
241 # count(10) --> 10 11 12 13 14 ...
242 # count(2.5, 0.5) -> 3.5 3.0 4.5 ...
248 When counting with floating point numbers, better accuracy can sometimes be
249 achieved by substituting multiplicative code such as: ``(start + step * i
252 .. versionchanged:: 2.7
253 added *step* argument and allowed non-integer arguments.
255 .. function:: cycle(iterable)
257 Make an iterator returning elements from the iterable and saving a copy of each.
258 When the iterable is exhausted, return elements from the saved copy. Repeats
259 indefinitely. Equivalent to::
262 # cycle('ABCD') --> A B C D A B C D A B C D ...
264 for element in iterable:
266 saved.append(element)
268 for element in saved:
271 Note, this member of the toolkit may require significant auxiliary storage
272 (depending on the length of the iterable).
275 .. function:: dropwhile(predicate, iterable)
277 Make an iterator that drops elements from the iterable as long as the predicate
278 is true; afterwards, returns every element. Note, the iterator does not produce
279 *any* output until the predicate first becomes false, so it may have a lengthy
280 start-up time. Equivalent to::
282 def dropwhile(predicate, iterable):
283 # dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
284 iterable = iter(iterable)
293 .. function:: groupby(iterable[, key])
295 Make an iterator that returns consecutive keys and groups from the *iterable*.
296 The *key* is a function computing a key value for each element. If not
297 specified or is ``None``, *key* defaults to an identity function and returns
298 the element unchanged. Generally, the iterable needs to already be sorted on
299 the same key function.
301 The operation of :func:`groupby` is similar to the ``uniq`` filter in Unix. It
302 generates a break or new group every time the value of the key function changes
303 (which is why it is usually necessary to have sorted the data using the same key
304 function). That behavior differs from SQL's GROUP BY which aggregates common
305 elements regardless of their input order.
307 The returned group is itself an iterator that shares the underlying iterable
308 with :func:`groupby`. Because the source is shared, when the :func:`groupby`
309 object is advanced, the previous group is no longer visible. So, if that data
310 is needed later, it should be stored as a list::
314 data = sorted(data, key=keyfunc)
315 for k, g in groupby(data, keyfunc):
316 groups.append(list(g)) # Store group iterator as a list
319 :func:`groupby` is equivalent to::
321 class groupby(object):
322 # [k for k, g in groupby('AAAABBBCCDAABBB')] --> A B C D A B
323 # [list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC D
324 def __init__(self, iterable, key=None):
328 self.it = iter(iterable)
329 self.tgtkey = self.currkey = self.currvalue = object()
333 while self.currkey == self.tgtkey:
334 self.currvalue = next(self.it) # Exit on StopIteration
335 self.currkey = self.keyfunc(self.currvalue)
336 self.tgtkey = self.currkey
337 return (self.currkey, self._grouper(self.tgtkey))
338 def _grouper(self, tgtkey):
339 while self.currkey == tgtkey:
341 self.currvalue = next(self.it) # Exit on StopIteration
342 self.currkey = self.keyfunc(self.currvalue)
344 .. versionadded:: 2.4
347 .. function:: ifilter(predicate, iterable)
349 Make an iterator that filters elements from iterable returning only those for
350 which the predicate is ``True``. If *predicate* is ``None``, return the items
351 that are true. Equivalent to::
353 def ifilter(predicate, iterable):
354 # ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9
355 if predicate is None:
362 .. function:: ifilterfalse(predicate, iterable)
364 Make an iterator that filters elements from iterable returning only those for
365 which the predicate is ``False``. If *predicate* is ``None``, return the items
366 that are false. Equivalent to::
368 def ifilterfalse(predicate, iterable):
369 # ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
370 if predicate is None:
377 .. function:: imap(function, *iterables)
379 Make an iterator that computes the function using arguments from each of the
380 iterables. If *function* is set to ``None``, then :func:`imap` returns the
381 arguments as a tuple. Like :func:`map` but stops when the shortest iterable is
382 exhausted instead of filling in ``None`` for shorter iterables. The reason for
383 the difference is that infinite iterator arguments are typically an error for
384 :func:`map` (because the output is fully evaluated) but represent a common and
385 useful way of supplying arguments to :func:`imap`. Equivalent to::
387 def imap(function, *iterables):
388 # imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000
389 iterables = map(iter, iterables)
391 args = [next(it) for it in iterables]
395 yield function(*args)
398 .. function:: islice(iterable, [start,] stop [, step])
400 Make an iterator that returns selected elements from the iterable. If *start* is
401 non-zero, then elements from the iterable are skipped until start is reached.
402 Afterward, elements are returned consecutively unless *step* is set higher than
403 one which results in items being skipped. If *stop* is ``None``, then iteration
404 continues until the iterator is exhausted, if at all; otherwise, it stops at the
405 specified position. Unlike regular slicing, :func:`islice` does not support
406 negative values for *start*, *stop*, or *step*. Can be used to extract related
407 fields from data where the internal structure has been flattened (for example, a
408 multi-line report may list a name field on every third line). Equivalent to::
410 def islice(iterable, *args):
411 # islice('ABCDEFG', 2) --> A B
412 # islice('ABCDEFG', 2, 4) --> C D
413 # islice('ABCDEFG', 2, None) --> C D E F G
414 # islice('ABCDEFG', 0, None, 2) --> A C E G
416 it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
418 for i, element in enumerate(iterable):
423 If *start* is ``None``, then iteration starts at zero. If *step* is ``None``,
424 then the step defaults to one.
426 .. versionchanged:: 2.5
427 accept ``None`` values for default *start* and *step*.
430 .. function:: izip(*iterables)
432 Make an iterator that aggregates elements from each of the iterables. Like
433 :func:`zip` except that it returns an iterator instead of a list. Used for
434 lock-step iteration over several iterables at a time. Equivalent to::
436 def izip(*iterables):
437 # izip('ABCD', 'xy') --> Ax By
438 iterables = map(iter, iterables)
440 yield tuple(map(next, iterables))
442 .. versionchanged:: 2.4
443 When no iterables are specified, returns a zero length iterator instead of
444 raising a :exc:`TypeError` exception.
446 The left-to-right evaluation order of the iterables is guaranteed. This
447 makes possible an idiom for clustering a data series into n-length groups
448 using ``izip(*[iter(s)]*n)``.
450 :func:`izip` should only be used with unequal length inputs when you don't
451 care about trailing, unmatched values from the longer iterables. If those
452 values are important, use :func:`izip_longest` instead.
455 .. function:: izip_longest(*iterables[, fillvalue])
457 Make an iterator that aggregates elements from each of the iterables. If the
458 iterables are of uneven length, missing values are filled-in with *fillvalue*.
459 Iteration continues until the longest iterable is exhausted. Equivalent to::
461 def izip_longest(*args, **kwds):
462 # izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
463 fillvalue = kwds.get('fillvalue')
464 def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
465 yield counter() # yields the fillvalue, or raises IndexError
466 fillers = repeat(fillvalue)
467 iters = [chain(it, sentinel(), fillers) for it in args]
469 for tup in izip(*iters):
474 If one of the iterables is potentially infinite, then the
475 :func:`izip_longest` function should be wrapped with something that limits
476 the number of calls (for example :func:`islice` or :func:`takewhile`). If
477 not specified, *fillvalue* defaults to ``None``.
479 .. versionadded:: 2.6
481 .. function:: permutations(iterable[, r])
483 Return successive *r* length permutations of elements in the *iterable*.
485 If *r* is not specified or is ``None``, then *r* defaults to the length
486 of the *iterable* and all possible full-length permutations
489 Permutations are emitted in lexicographic sort order. So, if the
490 input *iterable* is sorted, the permutation tuples will be produced
493 Elements are treated as unique based on their position, not on their
494 value. So if the input elements are unique, there will be no repeat
495 values in each permutation.
499 def permutations(iterable, r=None):
500 # permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
501 # permutations(range(3)) --> 012 021 102 120 201 210
502 pool = tuple(iterable)
504 r = n if r is None else r
508 cycles = range(n, n-r, -1)
509 yield tuple(pool[i] for i in indices[:r])
511 for i in reversed(range(r)):
514 indices[i:] = indices[i+1:] + indices[i:i+1]
518 indices[i], indices[-j] = indices[-j], indices[i]
519 yield tuple(pool[i] for i in indices[:r])
524 The code for :func:`permutations` can be also expressed as a subsequence of
525 :func:`product`, filtered to exclude entries with repeated elements (those
526 from the same position in the input pool)::
528 def permutations(iterable, r=None):
529 pool = tuple(iterable)
531 r = n if r is None else r
532 for indices in product(range(n), repeat=r):
533 if len(set(indices)) == r:
534 yield tuple(pool[i] for i in indices)
536 The number of items returned is ``n! / (n-r)!`` when ``0 <= r <= n``
537 or zero when ``r > n``.
539 .. versionadded:: 2.6
541 .. function:: product(*iterables[, repeat])
543 Cartesian product of input iterables.
545 Equivalent to nested for-loops in a generator expression. For example,
546 ``product(A, B)`` returns the same as ``((x,y) for x in A for y in B)``.
548 The nested loops cycle like an odometer with the rightmost element advancing
549 on every iteration. This pattern creates a lexicographic ordering so that if
550 the input's iterables are sorted, the product tuples are emitted in sorted
553 To compute the product of an iterable with itself, specify the number of
554 repetitions with the optional *repeat* keyword argument. For example,
555 ``product(A, repeat=4)`` means the same as ``product(A, A, A, A)``.
557 This function is equivalent to the following code, except that the
558 actual implementation does not build up intermediate results in memory::
560 def product(*args, **kwds):
561 # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
562 # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
563 pools = map(tuple, args) * kwds.get('repeat', 1)
566 result = [x+[y] for x in result for y in pool]
570 .. versionadded:: 2.6
572 .. function:: repeat(object[, times])
574 Make an iterator that returns *object* over and over again. Runs indefinitely
575 unless the *times* argument is specified. Used as argument to :func:`imap` for
576 invariant function parameters. Also used with :func:`izip` to create constant
577 fields in a tuple record. Equivalent to::
579 def repeat(object, times=None):
580 # repeat(10, 3) --> 10 10 10
585 for i in xrange(times):
589 .. function:: starmap(function, iterable)
591 Make an iterator that computes the function using arguments obtained from
592 the iterable. Used instead of :func:`imap` when argument parameters are already
593 grouped in tuples from a single iterable (the data has been "pre-zipped"). The
594 difference between :func:`imap` and :func:`starmap` parallels the distinction
595 between ``function(a,b)`` and ``function(*c)``. Equivalent to::
597 def starmap(function, iterable):
598 # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
599 for args in iterable:
600 yield function(*args)
602 .. versionchanged:: 2.6
603 Previously, :func:`starmap` required the function arguments to be tuples.
604 Now, any iterable is allowed.
606 .. function:: takewhile(predicate, iterable)
608 Make an iterator that returns elements from the iterable as long as the
609 predicate is true. Equivalent to::
611 def takewhile(predicate, iterable):
612 # takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
620 .. function:: tee(iterable[, n=2])
622 Return *n* independent iterators from a single iterable. Equivalent to::
624 def tee(iterable, n=2):
626 deques = [collections.deque() for i in range(n)]
629 if not mydeque: # when the local deque is empty
630 newval = next(it) # fetch a new value and
631 for d in deques: # load it to all the deques
633 yield mydeque.popleft()
634 return tuple(gen(d) for d in deques)
636 Once :func:`tee` has made a split, the original *iterable* should not be
637 used anywhere else; otherwise, the *iterable* could get advanced without
638 the tee objects being informed.
640 This itertool may require significant auxiliary storage (depending on how
641 much temporary data needs to be stored). In general, if one iterator uses
642 most or all of the data before another iterator starts, it is faster to use
643 :func:`list` instead of :func:`tee`.
645 .. versionadded:: 2.4
648 .. _itertools-recipes:
653 This section shows recipes for creating an extended toolset using the existing
654 itertools as building blocks.
656 The extended tools offer the same high performance as the underlying toolset.
657 The superior memory performance is kept by processing elements one at a time
658 rather than bringing the whole iterable into memory all at once. Code volume is
659 kept small by linking the tools together in a functional style which helps
660 eliminate temporary variables. High speed is retained by preferring
661 "vectorized" building blocks over the use of for-loops and :term:`generator`\s
662 which incur interpreter overhead.
666 def take(n, iterable):
667 "Return first n items of the iterable as a list"
668 return list(islice(iterable, n))
670 def enumerate(iterable, start=0):
671 return izip(count(start), iterable)
673 def tabulate(function, start=0):
674 "Return function(0), function(1), ..."
675 return imap(function, count(start))
677 def consume(iterator, n):
678 "Advance the iterator n-steps ahead. If n is none, consume entirely."
679 collections.deque(islice(iterator, n), maxlen=0)
681 def nth(iterable, n, default=None):
682 "Returns the nth item or a default value"
683 return next(islice(iterable, n, None), default)
685 def quantify(iterable, pred=bool):
686 "Count how many times the predicate is true"
687 return sum(imap(pred, iterable))
689 def padnone(iterable):
690 """Returns the sequence elements and then returns None indefinitely.
692 Useful for emulating the behavior of the built-in map() function.
694 return chain(iterable, repeat(None))
696 def ncycles(iterable, n):
697 "Returns the sequence elements n times"
698 return chain.from_iterable(repeat(iterable, n))
700 def dotproduct(vec1, vec2):
701 return sum(imap(operator.mul, vec1, vec2))
703 def flatten(listOfLists):
704 return list(chain.from_iterable(listOfLists))
706 def repeatfunc(func, times=None, *args):
707 """Repeat calls to func with specified arguments.
709 Example: repeatfunc(random.random)
712 return starmap(func, repeat(args))
713 return starmap(func, repeat(args, times))
715 def pairwise(iterable):
716 "s -> (s0,s1), (s1,s2), (s2, s3), ..."
721 def grouper(n, iterable, fillvalue=None):
722 "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
723 args = [iter(iterable)] * n
724 return izip_longest(fillvalue=fillvalue, *args)
726 def roundrobin(*iterables):
727 "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
728 # Recipe credited to George Sakkis
729 pending = len(iterables)
730 nexts = cycle(iter(it).next for it in iterables)
735 except StopIteration:
737 nexts = cycle(islice(nexts, pending))
739 def powerset(iterable):
740 "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
742 return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
744 def unique_everseen(iterable, key=None):
745 "List unique elements, preserving order. Remember all elements ever seen."
746 # unique_everseen('AAAABBBCCDAABBB') --> A B C D
747 # unique_everseen('ABBCcAD', str.lower) --> A B C D
751 for element in iterable:
752 if element not in seen:
756 for element in iterable:
762 def unique_justseen(iterable, key=None):
763 "List unique elements, preserving order. Remember only the element just seen."
764 # unique_justseen('AAAABBBCCDAABBB') --> A B C D A B
765 # unique_justseen('ABBCcAD', str.lower) --> A B C A D
766 return imap(next, imap(itemgetter(1), groupby(iterable, key)))