I tried making a function to check if an image is displayed on the screen using PyAutoGui and came up with this:
def check_image_on_screen(image):
try:
pyautogui.locateCenterOnScreen(image)
return True
except:
return False
And it works fine, but PyCharm tells me I shouldn't leave except bare. What is the problem with leaving it like this? Is there a more appropriate way of creating the same function?
Bare except will catch exceptions you almost certainly don't want to catch, including KeyboardInterrupt (the user hitting Ctrl+C) and Python-raised errors like SystemExit
If you don't have a specific exception you're expecting, at least except Exception, which is the base type for all "Regular" exceptions.
That being said: you use except blocks to recover from known failure states. An unknown failure state is usually irrecoverable, and it is proper behavior to fatally exit in those states, which is what the Python interpreter does naturally with an uncaught exception.
Catch everything you know how to handle, and let the rest propagate up the call stack to see if something else can handle it. In this case the error you're expecting (per the docs) is pyautogui.ImageNotFoundException
try/finally rather than try/except. Using finally means that you can guarantee cleanup but the exception will still be propagated afterwards.
[][0] and observe the stack says "IndexError," or {"ok":None}['nope'] and observe the stack says "KeyError"Basically, you're not taking advantage of the language to help you find problems. If you used except Exception as ex: you could do something like log the exception and know exactly what happened.
raise, there's no code path that would allow this to conceal the issue from code. And python is not a 50 year old language. And I've been managing production code quite a while too. My comments are not about experience but logical possibility in the language.try blocks which may result in the exception getting handled by the main thread’s exception handler and so crashing the program. logging isn’t supposed to interfere with the flow of execution, just report on progress.Removing bare except: is sometimes a good idea but not always. Beware about Pycharm's warning on this.
PyCharm is reporting a warning from pycodestyle which cannot enforce the rule correctly so it enforces the rule incorrectly. See issue: E722: (bare excepts) too strict (reraise)
As a general rule:
finally: won't do.In both cases you MUST re-raise with a subsiquent bare raise.
A bare except: clause will catch
SystemExitandKeyboardInterruptexceptions, making it harder to interrupt a program with Control-C, and can disguise other problems. If you want to catch all exceptions that signal program errors, useexcept Exception:(bare except is equivalent toexcept BaseException:). A good rule of thumb is to limit use of bare ‘except’ clauses to two cases:
- If the exception handler will be printing out or logging the traceback; at least the user will be aware that an error has occurred.
- If the code needs to do some cleanup work, but then lets the exception propagate upwards with raise. try...finally can be a better way to handle this case.
try:
do_something()
except:
logging.exception("Failed")
raise
try:
do_something()
except:
logger.exception("Failed")
💥 This just ate a Ctrl-C or SystemExit
In cases were you need to clean up on error (and only on error), bare except is better
file = open("my_file.txt", "w")
try:
with file:
file.write("something")
except:
os.unlink("my_file.txt")
raise
file = open("my_file.txt", "w")
try:
with file:
file.write("something")
except Exception:
os.unlink("my_file.txt")
raise
💥 If the user hits CTRL-C at the keyboard at the wrong moment, the file gets left behind.
open explicitly on the same line as with. Obviously valid syntax, but I think habits have replaced thought.