拥有“这不应该发生”的陈述是一种好习惯吗

Question

In python (and coding in general, really) is it good practice to have an error that should never happen, or is it just code clutter?

eg

if thing:
   num = 1
elif thing2:
   num = 2
else:
   num = 3

#Lots of other code goes here interacting with num, but not modifying it

if num == 1:
   option1()
elif num == 2:
   option2()
elif num == 3:
   option3()
else:
   #this should never happen
   print("Instead of being 1, 2, or 3, num was " + str(num))
   raise Exception("Error! num was an unexpected value!")

So basically, is including the final else (which should never happen) good practice, or just cluttering up the code?

My real code is more complicated than this -- specifically, num is assigned in a main loop, then passed to a function. Maybe it's worth including then because the function might be called from somewhere else with a bad value for num?

Answer 1

It is generally considered good practice to handle default conditions, even if unreachable in current code. The reason for this is that code grows and transfers ownership with time, and what currently seems like an unreachable condition may well happen in the future. In this case it is better to have an exception raised, as you do, rather than have unspecified behavior.

Answer 2

If there is a possibility the error ever could happen, due to another part of the system behaving incorrectly, or due to future maintainers making a mistake, then handling the error has value.

If the error is not possible by design, unchangeable system properties, or is guaranteed by previous processing that cannot change in a way that would lead to the error (without being obvious) then the check is clutter.

Answer 3

If you make a change to the first chunk of code, and forget to update the second, you could get mildly undesirable results without a catastrophic, obvious effect indicating a problem.

It would be best for it to fail entirely if you get bad data. If something must be done with the data in the second part, and receiving bad data alone wouldn't cause a massive failure, it would be safer to manually ensure failure so you can fix the code instead of allowing it to go unnoticed.

Massive failure is better than silent failure in most circumstances.

Answer 4

Depends. You don't necessarily want a user-facing message like that, but it helps to log that kind of thing.