Multiple condition declaration when checking for numerical zero - python

Question

There's a question on Idiomatic Python - checking for zero but this question is consider with also checking the type of variables within the conditions.

Given the 0 if not variable else variable style statement, it will let nully object slip through, e.g.

>>> x, y = None, []
>>> 0 if not(x and y) else x / y
0
>>> x, y = None, 0
>>> 0 if not(x and y) else x / y
0
>>> x, y = 0, 1
>>> 0 if not(x and y) else x / y
0
>>> x, y = 2, ""
>>> 0 if not(x and y) else x / y
0
>>> x, y = 2, 1
>>> 0 if not(x and y) else x / y
2

But if I explicitly check for variables' value to be zero, it will be somewhat better since it raises error when both types are different or types that cannot be compared to the zero value, e.g.:

>>> x, y = 2, ""
>>> 0 if (x&y) == 0 else x / y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'int' and 'str'
>>> x,y = "",""
>>> 0 if (x&y) == 0 else x / y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'str' and 'str'
>>> x,y = [],[]
>>> 0 if (x&y) == 0 else x / y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'list' and 'list'

So normally when defining a condition to check for numerical value, is something like the 0 if (x|y) == 0 else x/y code more pythonic / more appropriate?

But it's also problematic since it let's boolean type slip through and that causes some quite disturbing thing like ZeroDivisionError or ValueError to occur, e.g.:

>>> x,y = True, True
>>> 0 if (x&y) == 0 else x / y
1
>>> x,y = True, False
>>> 0 if (x&y) == 0 else x / y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
>>> x,y = False, True
>>> 0 if (x&y) == 0 else x / y
0
>>> x,y = False, True
>>> 0 if (x&y) == 0 else math.log(x/y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error

Also, this causes problem when types of variable are numerical but somewhat different:

>>> x, y = 1, 3.
>>> 0 if (x|y) == 0 else math.log(x/y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'int' and 'float'

And also the fact that the _or operator can't take float, it's weird:

>>> x, y = 1., 3.
>>> 0 if (x&y) == 0 and type(x) == type(y) == float else math.log(x/y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'float' and 'float'
>>> x, y = 1., 3.
>>> 0 if (x&y) == 0. and type(x) == type(y) == float else math.log(x/y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'float' and 'float'
>>> x, y = 1, 3
>>> 0 if (x&y) == 0 and type(x) == type(y) == float else math.log(x/y)
-1.0986122886681098

So the question is:

• What is the pythonic way to check for multiple variable for the value zero?
• Also, it's important to not like boolean type slip and raise a error instead of letting it return zero, how can this be done?
• And how should the TypeError: unsupported operand type(s) for |: 'float' and 'float' be resolved for checking (x|y) == 0 with x and y as float types?

Answer 1

With PEP 20's "Simple is better than complex" in mind, I would claim that if you want to check whether a value has a numeric type other than boolean (mind: Boolean is a numeric type in Python, and 1/True is valid), the most pythonic way to do that is to do exactly that, explicitly, without any bitwise operations or relying on implicit checks.

import numbers

if not isinstance(y, numbers.Number) or type(y) is bool:
    raise TypeError("y must be a number")
return x / y if y else 0