Generic iterator over the values (instead of over the keys) of any iterable

Question

Is there a generic way of getting an iterator that always iterates over the values (preferably, although it may work iterating the keys too) of either dictionaries or other iterables (lists, sets...)?

Let me elaborate: When you execute "iter(list)" you get an iterator over the values (not the indexes, which sound pretty similar to the "key" in the dictionary) but when you do "iter(dict)" you get the keys.

Is there an instruction, attribute... whatever... which always iterates over the values (or the keys) of an iterable, no matter what type of iterable it is?

I have a code with an "append" method that needs to accept several different types of iterable types, and the only solution I've been able to come up with is something like this:

#!/usr/bin/python2.4

class Sample(object):
    def __init__(self):
        self._myListOfStuff = list()

    def addThings(self, thingsToAdd):
        myIterator = None
        if (isinstance(thingsToAdd, list) or 
            isinstance(thingsToAdd, set) or 
            isinstance(thingsToAdd, tuple)):
                myIterator = iter(thingsToAdd)
            elif isinstance(thingsToAdd, dict):
                myIterator = thingsToAdd.itervalues()

        if myIterator:
            for element in myIterator:
                self._myListOfStuff.append(element)


if __name__ == '__main__':
    sample = Sample()
    myList = list([1,2])
    mySet = set([3,4])
    myTuple = tuple([5,6])
    myDict = dict(
        a= 7,
        b= 8
    )

    sample.addThings(myList)    
    sample.addThings(mySet) 
    sample.addThings(myTuple)   
    sample.addThings(myDict)
    print sample._myListOfStuff
    #Outputs [1, 2, 3, 4, 5, 6, 7, 8]

I don't know... It looks a little bit... clunky to me

It would be great to be able to get a common iterator for cases like this, so I could write something like...

def addThings(self, thingsToAdd):
    for element in iter(thingsToAdd):
        self._myListOfStuff.append(element)

... if the iterator always gave the values, or...

def addThings(self, thingsToAdd):
    for element in iter(thingsToAdd):
        self._myListOfStuff.append(thingsToAdd[element])

... if the iterator returned the keys (I know the concept of key in a set is kind of "special", that's why I would prefer iterating over the values but still... maybe it could return the hash of the stored value).

Is there such thing in Python? (I have to use Python2.4, by the way)

Thank you all in advance

Answer 1

I don't know of anything built in that does this. I suppose you could do something like:

def itervalues(x):
  if hasattr(x, 'itervalues'): return x.itervalues()
  if hasattr(x, 'values'): return iter(x.values())
  return iter(x)

Answer 2

Most collections have no concept or "keys" or "values". They just store items, and iterating over them gives you those items. Only mappings (dict-likes) provide "keys" and "values". And the default way of iterating them uses the keys because for x in collection: assert x in collection should be an invariant (and a (key, value) in d rarely makes sense, as opposed to key in d). So there is no method to iterate over the values only, because the least collections have things called "values".

You can, however, choose to ignore the keys in mappings. Since you have to use Python 2.4, using ABCs is out of questions... I fear the simplest way would be:

def iter_values(it):
    if hasattr(it, 'itervalues'):
        return it.itervalues()
    return iter(x)

Which can still break, but handles dicts and similar mappings.

Answer 3

What you're looking for is the dict.items() method, which return (key, value) tuples. Here is a usage example:

d = {'a': 1, 'b': 2, 'c': 3}
for k, v in d.items():
    print "key:", k, "- value:", v

Which, as you can imagine, would output

key: a - value: 1
key: b - value: 2
key: c - value: 3

Edit: if you want to get a real iterator and not just a sequence, you can also use the dict.iteritems() method, which works the same way.

Edit2: seems i misunderstood your question, as you seem to ask for a generic function that would work with any iterable, forget my answer ;-)