# How to test multiple variables against a value?

Posted on

Solving problem is about exposing yourself to as many situations as possible like How to test multiple variables against a value? and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.
In this post, my aim is to share an overview the topic about How to test multiple variables against a value?, which can be followed any time. Take easy to follow this discuss.

How to test multiple variables against a value?

I’m trying to make a function that will compare multiple variables to an integer and output a string of three letters. I was wondering if there was a way to translate this into Python. So say:

``````x = 0
y = 1
z = 3
mylist = []
if x or y or z == 0 :
mylist.append("c")
if x or y or z == 1 :
mylist.append("d")
if x or y or z == 2 :
mylist.append("e")
if x or y or z == 3 :
mylist.append("f")
``````

which would return a list of:

``````["c", "d", "f"]
``````

Is something like this possible?

You misunderstand how boolean expressions work; they don’t work like an English sentence and guess that you are talking about the same comparison for all names here. You are looking for:

``````if x == 1 or y == 1 or z == 1:
``````

`x` and `y` are otherwise evaluated on their own (`False` if `0`, `True` otherwise).

You can shorten that using a containment test against a tuple:

``````if 1 in (x, y, z):
``````

or better still:

``````if 1 in {x, y, z}:
``````

using a `set` to take advantage of the constant-cost membership test (`in` takes a fixed amount of time whatever the left-hand operand is).

When you use `or`, python sees each side of the operator as separate expressions. The expression `x or y == 1` is treated as first a boolean test for `x`, then if that is False, the expression `y == 1` is tested.

This is due to operator precedence. The `or` operator has a lower precedence than the `==` test, so the latter is evaluated first.

However, even if this were not the case, and the expression `x or y or z == 1` was actually interpreted as `(x or y or z) == 1` instead, this would still not do what you expect it to do.

`x or y or z` would evaluate to the first argument that is ‘truthy’, e.g. not `False`, numeric 0 or empty (see boolean expressions for details on what Python considers false in a boolean context).

So for the values `x = 2; y = 1; z = 0`, `x or y or z` would resolve to `2`, because that is the first true-like value in the arguments. Then `2 == 1` would be `False`, even though `y == 1` would be `True`.

The same would apply to the inverse; testing multiple values against a single variable; `x == 1 or 2 or 3` would fail for the same reasons. Use `x == 1 or x == 2 or x == 3` or `x in {1, 2, 3}`.

``````x = 0
y = 1
z = 3
d = {0: 'c', 1:'d', 2:'e', 3:'f'}
mylist = [d[k] for k in [x, y, z]]
``````

As stated by Martijn Pieters, the correct, and fastest, format is:

``````if 1 in {x, y, z}:
``````

Using his advice you would now have separate if-statements so that Python will read each statement whether the former were `True` or `False`. Such as:

``````if 0 in {x, y, z}:
mylist.append("c")
if 1 in {x, y, z}:
mylist.append("d")
if 2 in {x, y, z}:
mylist.append("e")
...
``````

This will work, but if you are comfortable using dictionaries (see what I did there), you can clean this up by making an initial dictionary mapping the numbers to the letters you want, then just using a for-loop:

``````num_to_letters = {0: "c", 1: "d", 2: "e", 3: "f"}
for number in num_to_letters:
if number in {x, y, z}:
mylist.append(num_to_letters[number])
``````

The direct way to write `x or y or z == 0` is

``````if any(map((lambda value: value == 0), (x,y,z))):
``````

But I dont think, you like it. ðŸ™‚
And this way is ugly.

The other way (a better) is:

``````0 in (x, y, z)
``````

BTW lots of `if`s could be written as something like this

``````my_cases = {
0: Mylist.append("c"),
1: Mylist.append("d")
# ..
}
for key in my_cases:
if key in (x,y,z):
my_cases[key]()
break
``````

If you ARE very very lazy, you can put the values inside an array. Such as

``````list = []
list.append(x)
list.append(y)
list.append(z)
letters = [add corresponding letters here]
for index in range(len(nums)):
for obj in list:
if obj == num[index]:
MyList.append(letters[index])
break
``````

You can also put the numbers and letters in a dictionary and do it, but this is probably a LOT more complicated than simply if statements. That’s what you get for trying to be extra lazy ðŸ™‚

One more thing, your

``````if x or y or z == 0:
``````

will compile, but not in the way you want it to. When you simply put a variable in an if statement (example)

``````if b
``````

the program will check if the variable is not null. Another way to write the above statement (which makes more sense) is

``````if bool(b)
``````

Bool is an inbuilt function in python which basically does the command of verifying a boolean statement (If you don’t know what that is, it is what you are trying to make in your if statement right now :))

Another lazy way I found is :

``````if any([x==0, y==0, z==0])
``````

To check if a value is contained within a set of variables you can use the inbuilt modules `itertools` and `operator`.

For example:

Imports:

``````from itertools import repeat
from operator import contains
``````

Declare variables:

``````x = 0
y = 1
z = 3
``````

Create mapping of values (in the order you want to check):

``````check_values = (0, 1, 3)
``````

Use `itertools` to allow repetition of the variables:

``````check_vars = repeat((x, y, z))
``````

Finally, use the `map` function to create an iterator:

``````checker = map(contains, check_vars, check_values)
``````

Then, when checking for the values (in the original order), use `next()`:

``````if next(checker)  # Checks for 0
# Do something
pass
elif next(checker)  # Checks for 1
# Do something
pass
``````

etc…

This has an advantage over the `lambda x: x in (variables)` because `operator` is an inbuilt module and is faster and more efficient than using `lambda` which has to create a custom in-place function.

Another option for checking if there is a non-zero (or False) value in a list:

``````not (x and y and z)
``````

Equivalent:

``````not all((x, y, z))
``````

Set is the good approach here, because it orders the variables, what seems to be your goal here. `{z,y,x}` is `{0,1,3}` whatever the order of the parameters.

``````>>> ["cdef"[i] for i in {z,x,y}]
['c', 'd', 'f']
``````

This way, the whole solution is O(n).

All of the excellent answers provided here concentrate on the specific requirement of the original poster and concentrate on the `if 1 in {x,y,z}` solution put forward by Martijn Pieters.
What they ignore is the broader implication of the question:
How do I test one variable against multiple values?
The solution provided will not work for partial hits if using strings for example:
Test if the string “Wild” is in multiple values

``````>>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in {x, y, z}: print (True)
...
``````

or

``````>>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in [x, y, z]: print (True)
...
``````

for this scenario it’s easiest to convert to a string

``````>>> [x, y, z]
['Wild things', 'throttle it back', 'in the beginning']
>>> {x, y, z}
{'in the beginning', 'throttle it back', 'Wild things'}
>>>
>>> if "Wild" in str([x, y, z]): print (True)
...
True
>>> if "Wild" in str({x, y, z}): print (True)
...
True
``````

It should be noted however, as mentioned by `@codeforester`, that word boundries are lost with this method, as in:

``````>>> x=['Wild things', 'throttle it back', 'in the beginning']
>>> if "rot" in str(x): print(True)
...
True
``````

the 3 letters `rot` do exist in combination in the list but not as an individual word. Testing for ” rot ” would fail but if one of the list items were “rot in hell”, that would fail as well.
The upshot being, be careful with your search criteria if using this method and be aware that it does have this limitation.