# Determine whether integer is between two other integers

## Question:

How do I determine whether a given integer is between two other integers (e.g. greater than/equal to `10000`

and less than/equal to `30000`

)?

## Answers:

```
if number >= 10000 and number <= 30000:
print ("you have to pay 5% taxes")
```

Use `if number >= 10000 and number <= 30000:`

. Alternately, Python has a shorthand for this sort of thing, `if 10000 <= number <= 30000:`

.

```
if 10000 <= number <= 30000:
pass
```

For details, see the docs.

To check that the number is in the range 10000 – 30000, use the Python interval comparison:

```
if 10000 <= number <= 30000:
print ("you have to pay 5% taxes")
```

This Python feature is further described in the Python documentation.

```
>>> r = range(1, 4)
>>> 1 in r
True
>>> 2 in r
True
>>> 3 in r
True
>>> 4 in r
False
>>> 5 in r
False
>>> 0 in r
False
```

Python lets you just *write* what you mean in words:

```
if number in xrange(10000, 30001): # ok you have to remember 30000 + 1 here :)
```

In Python3, use `range`

instead of `xrange`

.

edit: People seem to be more concerned with microbench marks and how cool chaining operations. My answer is about defensive (less attack surface for bugs) programming.

As a result of a claim in the comments, I’ve added the micro benchmark here for Python3.5.2

```
$ python3.5 -m timeit "5 in range(10000, 30000)"
1000000 loops, best of 3: 0.266 usec per loop
$ python3.5 -m timeit "10000 <= 5 < 30000"
10000000 loops, best of 3: 0.0327 usec per loop
```

If you are worried about performance, you could compute the range once

```
$ python3.5 -m timeit -s "R=range(10000, 30000)" "5 in R"
10000000 loops, best of 3: 0.0551 usec per loop
```

Define the range between the numbers:

```
r = range(1,10)
```

Then use it:

```
if num in r:
print("All right!")
```

There are **two ways** to compare three integers and check whether **b** is between **a** and **c**:

```
if a < b < c:
pass
```

and

```
if a < b and b < c:
pass
```

The first one looks like more readable, but the **second one runs faster**.

Let’s compare using **dis.dis**:

```
>>> dis.dis('a < b and b < c')
1 0 LOAD_NAME 0 (a)
2 LOAD_NAME 1 (b)
4 COMPARE_OP 0 (<)
6 JUMP_IF_FALSE_OR_POP 14
8 LOAD_NAME 1 (b)
10 LOAD_NAME 2 (c)
12 COMPARE_OP 0 (<)
>> 14 RETURN_VALUE
>>> dis.dis('a < b < c')
1 0 LOAD_NAME 0 (a)
2 LOAD_NAME 1 (b)
4 DUP_TOP
6 ROT_THREE
8 COMPARE_OP 0 (<)
10 JUMP_IF_FALSE_OR_POP 18
12 LOAD_NAME 2 (c)
14 COMPARE_OP 0 (<)
16 RETURN_VALUE
>> 18 ROT_TWO
20 POP_TOP
22 RETURN_VALUE
>>>
```

and using **timeit**:

```
~$ python3 -m timeit "1 < 2 and 2 < 3"
10000000 loops, best of 3: 0.0366 usec per loop
~$ python3 -m timeit "1 < 2 < 3"
10000000 loops, best of 3: 0.0396 usec per loop
```

also, you may use **range**, as suggested before, however it is much more slower.

Suppose there are 3 non-negative integers: `a`

, `b`

, and `c`

. Mathematically speaking, if we want to determine if `c`

is between `a`

and `b`

, inclusively, one can use this formula:

(c – a) * (b – c) >= 0

or in Python:

```
> print((c - a) * (b - c) >= 0)
True
```

You want the output to print the given statement if and only if the number falls between 10,000 and 30,000.

Code should be;

```
if number >= 10000 and number <= 30000:
print("you have to pay 5% taxes")
```

The condition should be,

```
if number == 10000 and number <= 30000:
print("5% tax payable")
```

reason for using `number == 10000`

is that if number’s value is 50000 and if we use `number >= 10000`

the condition will pass, which is not what you want.

Try this simple function; it checks if `A`

is between `B`

and `C`

(`B`

and `C`

may not be in the right order):

```
def isBetween(A, B, C):
Mi = min(B, C)
Ma = max(B, C)
return Mi <= A <= Ma
```

so `isBetween(2, 10, -1)`

is the same as `isBetween(2, -1, 10)`

.

You used >=30000, so if number is 45000 it will go into the loop, but we need it to be more than 10000 but less than 30000. Changing it to <=30000 will do it!

While `10 <= number <= 20`

works in Python, I find this notation using `range()`

more readable:

```
if number in range(10, 21):
print("number is between 10 (inclusive) and 21 (exclusive)")
else:
print("outside of range!")
```

Keep in mind that the 2nd, upper bound parameter is not included in the range set as can be verified with:

```
>>> list(range(10, 21))
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
```

However prefer the `range()`

approach only if it’s not running on some performance critical path. A single call is still fast enough for most requirements, but if run 10,000,000 times, we clearly notice nearly 3 times slower performance compared to `a <= x < b`

:

```
> { time python3 -c "for i in range(10000000): x = 50 in range(1, 100)"; } 2>&1 | sed -n 's/^.*cpu (.*) total$/1/p'
1.848
> { time python3 -c "for i in range(10000000): x = 1 <= 50 < 100"; } 2>&1 | sed -n 's/^.*cpu (.*) total$/1/p'
0.630
```

Below are few possible ways, ordered from best to worse performance (i.e first one will perform best)

```
# Old school check
if 10000 >= b and b <=30000:
print ("you have to pay 5% taxes")
# Python range check
if 10000 <= number <= 30000:
print ("you have to pay 5% taxes")
# As suggested by others but only works for integers and is slow
if number in range(10000,30001):
print ("you have to pay 5% taxes")
```

I’m adding a solution that nobody mentioned yet, using Interval class from sympy library:

```
from sympy import Interval
lower_value, higher_value = 10000, 30000
number = 20000
# to decide whether your interval shhould be open or closed use left_open and right_open
interval = Interval(lower_value, higher_value, left_open=False, right_open=False)
if interval.contains(number):
print("you have to pay 5% taxes")
```