Python sets: “in” set command not working

I have a list of tuples that I want to get all the combinations for as a set and filter out certain sets based on criteria.

For example

pairs = [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]
combs = []
for i in range(len(pairs)):
        intermediate = (set(list(combinations(pairs, i))))
        if ((2,3) and (2,2) and (3,2)) in intermediate:
                combs.append(intermediate)

But it doesn’t detect if any of the tuples are in the set, so I tried a more basic test version.

pairs = [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]
test = set(combinations(pairs,1))
if (1,1) in test:
        print("true")

This also doesn’t work even though I can clearly see in my variable explorer that the set contains (1,1).

I’ve also tried adding an integer 1 as one of the elements in pairs and checking if 1 is in the set but that still doesn’t work. I’ve run out of ideas and some help would be appreciated.

Answer

There are two issues here…

First, it would seem like you are not testing membership at the correct depth of a nested data structure. When you call set(combinations(pairs, i)), you get a structure that is 3 levels deep: A set of tuples of tuples of ints (ints 3 containers deep).

>>> pairs = [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]
>>> test = set(combinations(pairs,1))
>>> test
{((3, 2),), ((2, 3),), ((1, 1),), ((2, 2),), ((3, 1),), ((1, 3),), ((1, 2),), ((3, 3),), ((2, 1),)}

It is perfectly valid to test if a specific tuple of tuples of ints is contained within the set, but those tuples aren’t automatically flattened for you to be able to test against a simple tuple of ints.

>>> ((1,1),) in test
True
>>> (1,1) in test
False

If you want to check if any tuples within the set contain a specific sub-tuple, you’ll have to iterate over the set and check each top level tuple individually (hint: things like map can make this iteration a little shorter and sweeter)

for top_tuple in test:
    if (1,1) in top_tuple:
        print("found it!")

Second, is a somewhat common trap for new python programmers, which is chaining logical operators. You must think of and or in etc.. as similar to mathematical operators similar to + - * / etc.. The other important thing is how the logical operators treat things that aren’t True and False. In general python treats things that are empty such as empty lists, strings, tuples, sets, etc.. as False, as well as things that are equal to 0. Basically everything else non-zero or non-empty is treated as True. Then when you run into an and, if the first value (on the left) is True-ish the return value of the and statement will be whatever is on the right. if The first value is False-ish, the return value will be that first value. When you chain them together, they get evaluated left to right.

>>> (1,1) and "cookies"
"cookies"
>>> False and "cookies"
False
>>> (2,3) and (2,2) and (3,2)
(3, 2)

Leave a Reply

Your email address will not be published. Required fields are marked *