Recurring patterns: Am I missing it, or can we get these added to the language?

[Erich]

Hello all,

Today I found myself once again defining two functions that I use all
the time: nsplit and iterable.  These little helper functions of mine
get used all the time when I work. Im sick of having to define them
(but am very good at it these days, less than 1 typo per function!).
It leads me to the following questions

1. Is this functionality already built in and im just missing it
2. Is there some well known, good technique for these that I missed?
3. Insert question I need to ask here (with a response)

These are the funtions w/ explaination:

def nsplit(s,p,n):
    n -= 1
    l = s.split(p, n)
    if len(l) < n:
        l.extend([''] * (n - len(l)))
    return l

This is like split() but returns a list of exactly lenght n. This is
very useful when using unpacking, e.g.:
x, y = nsplit('foo,bar,baz', ',', 2)

def iterable(item, count_str=False):
    if not count_str and isinstance(item, str):
        return False
    try:
        iter(item)
    except:
        return False
    return True
This is just simple boolean test for whether or not an object is
iterable. I would like to see this in builtins, to mirror callable.
The optional count_str adds flexibility for string handling, since
sometimes I need to iterate over a string, but usually not. I
frequently use it to simplify my case handling in this type of
costruct:

def foo(bar):
    bar = bar if iterable(bar) else [bar]
    for x in bar:
        ....

Thanks for feeback,
Erich