[].keys() and [].items() (Was: Why I think range is a wart)

[Tim Hochberg]

James_Althoff wrote:
> Here's a q&d sample implementation in case anyone wants to test out the
> idea before deciding on its merits.
[Implementation of keys, iterkeys, values, itervalues, etc. for a list
object]

FWIW, here's the corresponding implementation in terms of generic functions
instead of methods, an approach I like better than the method approach.

# itertools.py
"""
Tools for working with iterables.

Note: several of these functions assumes that if an object has a
'keys' method, it will also have an 'iterkeys' method and they will be
consistent.

Contents:

* keys(I) / iterkeys(I) -> list / iterator for I's keys

>>> list(iterkeys('abcd'))
[0, 1, 2, 3]
>>> _sorted(iterkeys({'fee' : 'one', 'fie' : 'two', 'foe' : 'three', 'fum' :
'four'}))
['fee', 'fie', 'foe', 'fum']

* values(I) / itervalues(I) -> return a list / iterator for I's values

>>> list(itervalues('abcd'))
['a', 'b', 'c', 'd']
>>> _sorted(itervalues({'fee' : 'one', 'fie' : 'two', 'foe' : 'three', 'fum'
: 'four'}))
['four', 'one', 'three', 'two']

* items(I) / iteritems(I) -> list / iterator for I's items [(key, value)
pairs]

>>> list(iteritems('abcd'))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> _sorted(iteritems({'fee' : 'one', 'fie' : 'two', 'foe' : 'three', 'fum'
: 'four'}))
[('fee', 'one'), ('fie', 'two'), ('foe', 'three'), ('fum', 'four')]

* iterzip(I1, [I2, [...]]) -> lazy version of zip.

>>> list(iterzip('abcdef', [1,2,3,4], ('cold', 'warm', 'hot')))
[('a', 1, 'cold'), ('b', 2, 'warm'), ('c', 3, 'hot')]


"""
from __future__ import generators

def _sorted(iterable):
    l = list(iterable)
    l.sort()
    return l

def iterkeys(iterable):
    """iterkeys(I) -> iterator for I's keys"""
    if hasattr(iterable, 'iterkeys'):
        for k in iterable.iterkeys():
            yield k
    else:
        k = 0
        for v in iterable:
            yield k
            k += 1

def keys(iterable):
    """keys(I) -> list of I's keys"""
    return list(iterkeys(iterable))

def itervalues(iterable):
    """itervalues(I) -> iterator for I's values"""
    if hasattr(iterable, 'itervalues'):
        for v in iterable.itervalues():
            yield v
    else:
        for v in iterable:
            yield v

def values(iterable):
    """values(I) -> list of I's values"""
    return list(itervalues(iterable))

def iteritems(iterable):
    """iteritems(I) -> iterator for I's items [(key, value) pairs]"""

    if hasattr(iterable, 'iteritems'):
        for i in iterable.iteritems():
            yield i
    else:
        k = 0
        for v in iterable:
            yield k, v
            k += 1

def items(iterable):
    """items(I) -> list of I's items [(key, value) pairs]"""
    return list(iteritems(iterable))

def iterzip(*args):
    """iterzip(I1 [, I2 [...]]) -> (I1[0], I2[0] ...), ...

    Return an iterator yielding tuples, where each tuple contains the
    i-th element from each of the argument iterables.  The iterator returns
    as many tuples as are in the shortest argument sequence.
"""
    if not args:
        raise TypeError("iterzip requires at least one sequence")
    iters = [iter(a) for a in args]
    while 1:
        value = []
        for i in iters:
            value.append(i.next())
        yield tuple(value)