When there are two different errors in a statement, how does Python decide which one to display?

Question

When we type in the interpreter the following:

10(b)

We get a NameError that b is not defined. However, when we try:

10(4)

Now, we get the error message that int is not callable. Why didn't Python give the same error in the first case above, since even there, int was not callable? In other words, in the first snippet, we have both errors of "int not callable" and "NameError". If Python were to scan left to right, it would have first seen the call operation being performed on an int (10). So it should have given the "int not callable" error for the first one too. Why didn't it?

I assumed that this was probably because it evaluates the expression within parenthesis first. However, when we try this:

f(print("Hello"))

Now, it says NameError that f is not defined. It doesn't even print "Hello". So this indicates that our assumption of evaluating parenthesized expressions doesn't seem to hold.

So how exactly does it work?

Answer 1

You are simply executing valid expressions, which have runtime errors. The code is executed in the stated evaluation order, with operators executed according to their precedence. Within each expression, you need to check the documentation for that specific operation to see what order the parts of the operation are executed in.

In all three cases you are asking Python to execute a call, for which the rules are documented:

The primary must evaluate to a callable object[.] All argument expressions are evaluated before the call is attempted.

The callable is evaluated to an object first, and 10 successfully executes to produce an object. No call is attempted yet until the argument expresssions have been evaluated.

The argument expressions are the expressions that make up the values to be passed to the call, the bits inside the (...). Only once those expressions have been evaluated, the call is is made.

Your first example gives a NameError exception, because the b expression evaluation failed. Python never got to executing the call because evaluation of the argument expressions has failed.

In your second example, the argument expression is 4, a valid expression that succeeds, so only then can Python can proceed to executing the call. But 10 is not callable, so that is then the next failure.

The final example fails right at the start at the f expression, because Python evaluated the callable part first but can’t load the callable because the name is not defined.

For other operators different rules of evaluation order apply, you have to check to documentation for that specific operator to see in what order the component parts will be executed.