Python布尔值评估顺序

Question

I'm working with linked lists in Python and couldn't quite figure out the error statement it was putting out.

This is my code to increment through the nodes from the head of the list:

    while current.next_node is not None and value > current.next_node.data:
        current = current.next_node
    current.next_node = Node(value, current.next_node)

While the above works, this doesn't:

    while value > current.next_node.data and current.next_node is not None:
        current = current.next_node
    current.next_node = Node(value, current.next_node)

I figured that as long as the while statement evaluated to either true or false, that it would behave accordingly. Instead, it throws an error when it tries to run value > current.next_node.data alone and realizes that the current.next_node doesn't exist.

Why is this?

Answer 1

Arguments evaluate left to right and there is a "principle of economy".

• In an "and" clause, the first that gives a False value stops the evaluation and returns False.

• In an "or" clause, the First that returns True stops the evaluation and returns True.

You can use it in your favor, by first evaluating the "safety" condition and then the other.

while current.next_node is not None and value > current.next_node.data:
    current = current.next_node
current.next_node = Node(value, current.next_node)

In this way, the failure of the first condition will always stop the evaluation. And if it returns true, then the second will execute correctly.

In the other version, you may be trying to access current.next_node.data without the safety. And if current is None, it will trigger an exception.

Answer 2

Python does short circuit evaluation which is why you're seeing the behavior you are. This comes into play in and and or clauses similarly.

With and clauses, if the expression on the left side evaluates to False there is no way the entire statement can evaluate to True (False and anything is False) so it doesn't bother to evaluate the expression on the right-hand side. If the left-hand side of expression is True , then the right-hand one is evaluated to see what the full expression should be.

Similarly, with or clauses, if the expression on the left evaluates to True , there is no way the entire statement can be False since True or anything is always True. So again, the right-hand expression will not be evaluated. But if the left-hand expression is False, the right-hand one must be evaluated to know the value of the entire expression.

You can see this in action here:

>>> def foo():
...     print('foo')
...     return 0

>>> def bar():
...     print('bar')
...     return 1

>>> foo() and bar()
foo
0

>>> bar() and foo()
bar
foo
0