Test if all objects have same member value

Question

I have a simple class in python:

class simple(object):
    def __init__(self, theType, someNum):
        self.theType = theType
        self.someNum = someNum

Later on in my program, I create multiple instantiations of this class, i.e.:

a = simple('A', 1)
b = simple('A', 2)
c = simple('B', 3)
d = simple('B', 4)
e = simple('C', 5)

allThings = [a, b, c, d, e] # Fails "areAllOfSameType(allThings)" check

a = simple('B', 1)
b = simple('B', 2)
c = simple('B', 3)
d = simple('B', 4)
e = simple('B', 5)

allThings = [a, b, c, d, e] # Passes "areAllOfSameType(allThings)" check

I need to test if all of the elements in allThings have the same value for simple.theType. How would I write a generic test for this, so that I can include new "types" in the future (i.e. D, E, F, etc) and not have to re-write my test logic? I can think of a way to do this via a histogram, but I figured there's a "pythonic" way to do this.

Answer 1

Just compare each object with the first item's type, using the all() function:

all(obj.theType == allThings[0].theType for obj in allThings)

There will be no IndexError if the list is empty, too.

all() short-circuits, so if one object is not the same type as the other, the loop breaks immediately and returns False.

Answer 2

You could use an itertools recipe for this: all_equal (copied verbatim):

from itertools import groupby

def all_equal(iterable):
    "Returns True if all the elements are equal to each other"
    g = groupby(iterable)
    return next(g, True) and not next(g, False)

Then you could call it with a generator expression that accesses the theType attribute:

>>> allThings = [simple('B', 1), simple('B', 2), simple('B', 3), simple('B', 4), simple('B', 5)]
>>> all_equal(inst.theType for inst in allThings)
True

>>> allThings = [simple('A', 1), simple('B', 2), simple('B', 3), simple('B', 4), simple('B', 5)]
>>> all_equal(inst.theType for inst in allThings)
False

Given that it is actually put as recipe in the Python documentation seems like it's probably one of the best (or at least recommended) ways to solve this kind of problem.