Short-circuiting a condition statement

Question

I wrote a function:

# given a n x m grid return how many different ways there are to move from top left to 
# bottom right by only being able to move right or down

def grid(n, m, memo = {}):
    if f'{n},{m}' in memo:
        return memo[f'{n},{m}']

    if n == 1 and m == 1:
        return 1
    
    if n == 0 or m == 0:
        return 0

    memo[f'{n},{m}'] = grid(n,m-1,) + grid(n-1,m)

    return grid(n,m-1,) + grid(n-1,m)

Recently I read a bit about short-circuiting in Python and I am trying to understand it further.

As I understand it does not provide any boost in runtime, just sort of syntax sugar.

For example:

1 < 2 < 3 # is True
1 < 2 and 2 < 3 # is also True

# hence
(1 < 2 < 3) == 1 < 2 and 2 < 3 # is True

I was wondering can I write my function with this kind of short-circuiting in my if statements?

I came up with this:

 def grid(n, m, memo = {}):
    if f'{n},{m}' in memo:
        return memo[f'{n},{m}']

    if (n or m) == 1:
        return 1
    
    if (n and m) == 0:
        return 0

    memo[f'{n},{m}'] = grid(n,m-1,) + grid(n-1,m)

    return grid(n,m-1,) + grid(n-1,m)

Is there any smarter way of using the short-circuit here?

Answer 1

(1 < 2 < 3) is not short-circuiting - I think you misunderstood the meaning of the term. You are correct that it is merely syntax sugar - although it can produce some very weird results in obscure cases. (1 < 2 < 3) expands to (1 < 2) and (2 < 3) - the middle operand is copied to both and and is used for the joining operator.

Short circuiting occurs when python already knows the answer to a boolean expression, even before calculating both the inputs. For example

def false():
    print("false")
    return False

def true():
    print("true")
    return True

print(false() and true())

The output would be

false
False

Because when python sees False and, it already knows that the result is False (because and requires both operands to be True), so it doesn't bother running the second half of the line. This real short circuiting does result in a performance boost, but since you can't turn off short circuiting, it doesn't really matter ¯\_(ツ)_/¯

Answer 2

if (n or m) == 1

evaluates to

if (<bool>) == 1  # e.g. if {True,False} == 1

which is probably not what you want, since it is essentially evaluating the truthiness of n or m.

Your existing code already captures the nature of short-circuiting;

if n == 1 and m == 1

will only evaluate the second argument m == 1 iff n == 1, or will otherwise short-circuit.

To your comment

As I understand it does not provide any boost in runtime, just sort of syntax suggar.

Well, actually it does provide a runtime boost if Python is able to skip evaluating what would otherwise be "expensive" conditions to evaluate because it is able to short-circuit early.

Answer 3

if (n or m) == 1 is definitely not the same thing as if n == 1 or m == 1. The first if statement is equivalent to:

value = n
if not value:
    value = m
if value == 1:
    # do something:

Or expressed more succinctly:

if (n if n else m) == 1:
       # do something

In other words, n or m only evaluates m if n is False (or 0 if n is an integer), otherwise the result of the expression is n.

What you want to avoid redundancy is:

if 1 in (n, m): # equivalent to: if 1 is either n or m:

Update: Demo

n = 4
m = 1
if (n or m) == 1:
    print('if branch taken')
else:
    print('else branch taken')

Prints:

else branch taken