How to ignore error python

How to properly ignore Exceptions?

There are several ways of doing this.

However, the choice of example has a simple solution that does not cover the general case.

Specific to the example:

Instead of

try:
    shutil.rmtree(path)
except:
    pass

Do this:

shutil.rmtree(path, ignore_errors=True)

This is an argument specific to shutil.rmtree. You can see the help on it by doing the following, and you’ll see it can also allow for functionality on errors as well.

>>> import shutil
>>> help(shutil.rmtree)

Since this only covers the narrow case of the example, I’ll further demonstrate how to handle this if those keyword arguments didn’t exist.

General approach

Since the above only covers the narrow case of the example, I’ll further demonstrate how to handle this if those keyword arguments didn’t exist.

New in Python 3.4:

You can import the suppress context manager:

from contextlib import suppress

But only suppress the most specific exception:

with suppress(FileNotFoundError):
    shutil.rmtree(path)

You will silently ignore a FileNotFoundError:

>>> with suppress(FileNotFoundError):
...     shutil.rmtree('bajkjbkdlsjfljsf')
... 
>>> 

From the docs:

As with any other mechanism that completely suppresses exceptions,
this context manager should be used only to cover very specific errors
where silently continuing with program execution is known to be the
right thing to do.

Note that suppress and FileNotFoundError are only available in Python 3.

If you want your code to work in Python 2 as well, see the next section:

Python 2 & 3:

When you just want to do a try/except without handling the exception,
how do you do it in Python?

Is the following the right way to do it?

try :
    shutil.rmtree ( path )
except :
    pass

For Python 2 compatible code, pass is the correct way to have a statement that’s a no-op. But when you do a bare except:, that’s the same as doing except BaseException: which includes GeneratorExit, KeyboardInterrupt, and SystemExit, and in general, you don’t want to catch those things.

In fact, you should be as specific in naming the exception as you can.

Here’s part of the Python (2) exception hierarchy, and as you can see, if you catch more general Exceptions, you can hide problems you did not expect:

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StandardError
      |    +-- BufferError
      |    +-- ArithmeticError
      |    |    +-- FloatingPointError
      |    |    +-- OverflowError
      |    |    +-- ZeroDivisionError
      |    +-- AssertionError
      |    +-- AttributeError
      |    +-- EnvironmentError
      |    |    +-- IOError
      |    |    +-- OSError
      |    |         +-- WindowsError (Windows)
      |    |         +-- VMSError (VMS)
      |    +-- EOFError
... and so on

You probably want to catch an OSError here, and maybe the exception you don’t care about is if there is no directory.

We can get that specific error number from the errno library, and reraise if we don’t have that:

import errno

try:
    shutil.rmtree(path)
except OSError as error:
    if error.errno == errno.ENOENT: # no such file or directory
        pass
    else: # we had an OSError we didn't expect, so reraise it
        raise 

Note, a bare raise raises the original exception, which is probably what you want in this case. Written more concisely, as we don’t really need to explicitly pass with code in the exception handling:

try:
    shutil.rmtree(path)
except OSError as error:
    if error.errno != errno.ENOENT: # no such file or directory
        raise 

1. Use the pass Statement in the except Block in Python
2. Use the sys.exc_clear() Statement in the except Block in Python

An exception is an event that, when raised, alters the flow of the program.

Exceptions result from the program being syntactically correct but still giving an error on the execution of the code. This error does not halter the program’s execution but rather changes the default flow of the program.

In Python, we handle exceptions using the try...except block. This tutorial will discuss several methods to ignore an exception and proceed with the code in Python.

Use the pass Statement in the except Block in Python

The pass statement can be considered as a placeholder in Python programming. It returns a NULL statement and, therefore, produces no value. However, the Python interpreter does not ignore the pass statement, and we prevent getting errors for empty code where the statement is used.

When the pass statement is used in the try...except statements, it simply passes any errors and does not alter the flow of the Python program.

The following code uses the pass statement in the except block to ignore an exception and proceed with the code in Python.

try:
    print(hey)
except Exception:
    pass

print("ignored the exception")

The above code provides the following output.

Although this function always works in Python 3 and above, using the pass statement is considered a bad programming practice. It doesn’t provide a solution to the errors that might arise during the program. Moreover, identifying the errors in a given program is much more difficult as it ignores every single error.

Use the sys.exc_clear() Statement in the except Block in Python

In Python 2, the last thrown exception gets remembered by the interpreter, while it does not happen in the newer versions of Python. Therefore, the sys.exc_clear() statement is not needed in the versions released after Python 3. The sys.exc_clear() statement can be utilized to clear the last thrown exception of the Python interpreter.

The following code uses the sys.exc_clear() statement in the except block to ignore an exception and proceed with the code in Python.

try:
    print(hey)
except Exception:
    sys.exc_clear()

print("ignored the exception")

Although these two ways manage to make the program run without any errors, it is not recommended to ignore all the errors in a program. However, ignoring only a particular error or some errors is a practice that most programmers do for a healthy program.

Limiting the use of the pass statement and sys.exc_clear() statement in a program also improves the readability and identification of errors of a program.