Checking length of each argument - seems like I'm fighting Python

[Sam Pointon]

It depends what you mean by 'scalar'. If you mean in the Perlish sense
(ie, numbers, strings and references), then that's really the only way
to do it in Python - there's no such thing as 'scalar context' or
anything - a list is an object just as much as a number is.

So, assuming you want a Things object to break if either a) all three
arguments aren't sequences of the same length, or b) all three
arguments aren't a number (or string, or whatever), this should work:

#Not tested.
class Things(object):
    def __init__(self, x, y, z):
        try:
            if not (len(x) == len(y) and len(y) == len(z)):
                raise ValueError('Things don't match up.')
        except TypeError:
            #one of x, y or z doesn't do __len__
            #check if they're all ints, then.
            if not (isinstance(x, int) and isinstance(y, int) and
                    isinstance(z, int)):
                raise ValuError('Things don't match up')
        #do stuff.

Personally, I find nothing wrong with having a separate Thing object
that can do validation for itself, and I think it's a pleasantly object
oriented solution

I'm also wondering why something like this could accept something other
than sequences if it depends on their length. If you just want to treat
non-sequences as lists with one value, then something like this is more
appropriate, and might lead to less redundancy in other places:

def listify(obj):
    try:
        return list(obj)
    except TypeError
        return [obj]

class Things(object):
    def __init__(self, *args):
        x, y, z = [listify(arg) for arg in args]
        if not (len(x) == len(y) and len(y) == len(z)):
            raise ValueError('Things don't match up')