groupby() For Unsorted Input (Python)

2017-05-12T10:40:58-07:00

Python recipe 580800 by Alfe (algorithm, datastructures, generators, grouping, lazy).

We all know the groupby() which is available in the itertools standard module. This one yields groups of consecutive elements in the input which are meant to be together in one group. For non-consecutive elements this will yield more than one group for the same key.

So effectively, groupby() only reformats a flat list into bunches of elements from that list without reordering anything. In practice this means that for input sorted by key this works perfect, but for unsorted input it might yield several groups for the same key (with groups for other keys in between). Typically needed, though, is a grouping with reordering if necessary.

I implemented a likewise lazy function (yielding generators) which also accepts ungrouped input.

Pure Python implementation of PEP 380 (yield from) (Python)

2009-04-25T09:03:42-07:00

Python recipe 576727 by profjim (decorator, generators). Revision 7.

Decorator-based implementation of PEP 380 (yield from). This is the simple version (no special handling of nested "yield _from"s).

Permutation and combination using recursive generator (Python)

2011-10-04T05:44:19-07:00

Python recipe 577890 by Shao-chuan Wang (combinatorics, generators, permutation, recursion). Revision 2.

This recipes demonstrates how to use recursive generator to implement permutation and combination.

extract emails from a mbox read on stdin (Python)

2013-09-07T10:24:17-07:00

Python recipe 576553 by Romain Dartigues (email, generators, mbox, read_only, stdin). Revision 2.

The Python mailbox.mbox class require a real file to initialize, which was an issue in my case. These simple functions let you iter through a mailbox read from a read-only file descriptor (like sys.stdin).

This script use the generators which were introduced in Python-2.2. Let me know if you are interested a similar functionnality on older Python versions.

Indexable Generator (Python)

2012-01-03T06:10:18-08:00

Python recipe 578000 by Peter Donis (decorators, generators). Revision 4.

A decorator for generators that makes them indexable like a sequence.

Lazy Lists (Python)

2008-08-08T10:23:52-07:00

Python recipe 576410 by Dan Spitz (generators, lazy, memoization). Revision 6.

This is a (python 3.0) recipe for LazyLists, or ordered sequences whose contents are generated lazily by an iterator.

Lazy Lists for python 2.5 (Python)

2008-08-18T19:59:03-07:00

Python recipe 576429 by Michael Pust (generators, lazy, memoization).

Dan Spitz submitted a recipe ( 576410 ) for recursively defined lazy lists backed by a generator. Only catch was that it was written for python 3k. But there is nothing intrinsic in 3k that prevents you from having the same functionality in python 2.5, so I am supplying the backport here.

Pure Python implementation of PEP 380 (yield from) -- Optimized (Python)

2009-04-29T09:11:31-07:00

Python recipe 576728 by profjim (decorator, generators). Revision 6.

Decorator-based implementation of PEP 380 (yield from). This is the optimized version (special handling of nested "yield _from"s).

Memoize Generator (Python)

2012-01-02T05:53:19-08:00

Python recipe 577992 by Peter Donis (decorators, generators, memoization, memoize). Revision 2.

A wrapper class for generators that "memoizes" them, so that even if the generator is realized multiple times, each term only gets computed once (after that the result is simply returned from a cache).

Pluggable Python generators (Python)

2016-03-18T19:11:48-07:00

Python recipe 580628 by Vasudev Ram (generator, generators, python).

This is a simple recipe to show that Python generators are pluggable, i.e., they can be passed as arguments into functions, and then used inside those functions.

Interleaving file lines using iterators (Python)

2009-02-23T04:07:37-08:00

Python recipe 576665 by David Moss (file, generators, iterators, manipulation).

Accepts one of more files and/or globs and interleaves the lines from each writing the result to stdout.

where() function for generator expressions (Python 3) (Python)

2014-10-05T04:10:21-07:00

Python recipe 578946 by Alan Cristhian Ruiz (generators). Revision 3.

Function that work like an "where statement" for generator expression. The code below

x, y, z = 1, 2, 3
((x, y, z) for _ in range(5))

Is equivalent to:

((x, y, z) for _ in range(5)) < where(x=1, y=2, z=3)

Generator with lookahead (Python)

2013-09-24T10:44:56-07:00

Python recipe 578671 by Rutger Saalmink (background, generator, generators, lookahead, performance, python).

Python generators are a great way of reducing memory usage due to the lazy (on demand) generation of values. However, when the process-time of generating such a value is relatively high, we can improve performance even more by obtaining the next n values of the generator in a separate thread in the background. Hence, the BackgroundGenerator.

Most viewed recipes tagged "generators"