Python exception handling: ImportError and ModuleNotFoundError (2023)

Make your way through our detailedPython exception handlingwe arrived at the seriesImportError, along with its only child subclass ofModuleNotFoundError. DieImportErroris triggered when ato importThe statement has problems importing the specified module successfully. Typically, this issue occurs due to an invalid or incorrect path that throws aModuleNotFoundErrorin Python 3.6 and newer.

In this article we will examine themImportErroreModuleNotFoundErrora little more detail, starting with where they sit in the overallsPython exception class hierarchy. We'll also look at some simple code examples that illustrate the differences into importInstruction errors in newer (3.6) and older (2.7) versions of Python, so let's get started!

the technical summary

All Python exceptions inherit fromBaseExceptionclass, or extend from an inherited class within it. The complete exception hierarchy for this error is:

• BaseException
  • exception
    • ImportError
      • ModuleNotFoundError

Complete code example

Below is the complete code sample that we will be using in this article. It can be copied and pasted if you want to play around with the code and see how it all works.

# outer_import_2.7.py
import system
import gw_utility.Book
def principal():
Try:
print(sys.version)
except ImportError as error:
# Print expected ImportErrors.
print(error.__class__.__name__ + ": " + error.message)
except exception as exception:
# Throw unexpected exceptions.
print(Exception, False)
print(Exception.__Class__.__Name__ + ": " + Exception.Message)
se __name__ == "__main__":
principally()

# inner_import_2.7.py
import system
def principal():
Try:
print(sys.version)
import gw_utility.Book
except ImportError as error:
# Print expected ImportErrors.
print(error.__class__.__name__ + ": " + error.message)
except exception as exception:
# Throw unexpected exceptions.
print(Exception, False)
print(Exception.__Class__.__Name__ + ": " + Exception.Message)
se __name__ == "__main__":
principally()

# outer_import_3.6.py
import system
import gw_utility.Book
aus gw_utility.logging import Logging
def principal():
Try:
log.log (sys.version)
except ImportError as error:
# Print expected ImportErrors.
Logging.log_exception (erro)
# Include the name and path attributes in the output.
Logging.log(f'error.name: {error.name}')
Logging.log(f'error.path: {error.path}')
except exception as exception:
# Throw unexpected exceptions.
Logging.log_exception(Exception, False)
(Video) Python 3 .9 ModuleNotFoundError Fix (Windows10)
se __name__ == "__main__":
principally()

# inner_import_3.6.py
import system
aus gw_utility.logging import Logging
def principal():
Try:
log.log (sys.version)
import gw_utility.Book
except ImportError as error:
# Print expected ImportErrors.
Logging.log_exception (erro)
# Include the name and path attributes in the output.
Logging.log(f'error.name: {error.name}')
Logging.log(f'error.path: {error.path}')
except exception as exception:
# Throw unexpected exceptions.
Logging.log_exception(Exception, False)
See Also
How to fix ImportError: Relative import attempt with no known parent package (Python)
se __name__ == "__main__":
principally()

# Protokollierung.py
import math
import system
import traceability
Class registration:
separador_character_default = '-'
separador_length_default = 40
@Class method
def __output(cls, *args, sep: str = ' ', end: str = '\n', file=None):
"""Returns the value(s) passed to the console.
:param args: Values ​​to be emitted.
:param sep: String inserted between values, a space by default.
:param end: String appended after the last value, a newline by default.
:param file: A file-like object (stream); by default, the current sys.stdout.
:back: None
"""
print(*args, set=set, end=end, file=file)
@Class method
def line_separator(cls, Wert: str = None, Länge: int = separator_length_default,
char: str = separador_character_default):
"""Print line separator with inserted text centered in the middle.
:param value: Text inserted to be centered.
:param length: Total length of the delimiter.
:param char: delimiter.
"""
output = value
# If no value is passed, print the length delimiter.
if value == None oder len(value) == 0:
output = f'{characters * length}'
elif len(value) < length:
# Update the length based on the insert length minus a space for the margin.
length -= length(value) + 2
# Divide the length and bottom left.
left = math.floor(Länge / 2)
right = left
# If odd, add the omitted remainder to the right.
if length % 2 != 0:
right += 1
# Surrounding insert with tabs.
Output = f'{character * left} {value} {character * right}'
(Video) Python Module Import Error in VS Code Solved | Virtual Environment in Visual Studio Code
cls.__output(output)
@Class method
def log(cls, *args, sep: str = ' ', end: str = '\n', file=None):
"""Returns the value(s) passed to the console.
:param args: Values ​​to be emitted.
:param sep: String inserted between values, a space by default.
:param end: String appended after the last value, a newline by default.
:param file: A file-like object (stream); by default, the current sys.stdout.
"""
cls.__output(*args, set=set, end=end, file=file)
@Class method
def log_exception(cls, exception: BaseException, expected: bool = True):
"""Returns the BaseException passed to the console, including traceback.
:param exception: The BaseException to throw.
:param expected: Determines whether BaseException was expected.
"""
output = "[{}] {}: {}".format('EXPECTED' if expected, otherwise 'UNEXPECTED', Type(Exception).__Name__, Exception)
cls.__output(output)
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_tb(exc_traceback)

When should you use it?

the seemingly simpleto importThe instruction found in Python is actually quite complex when you look under the hood. At the simplest levelto importThe statement is used to perform two tasks. It first tries to find the module specified by name, then loads and initializes it if necessary. It also automatically defines a name in the local namespace as part of the associatedto importExpression. This local name can then be used to refer to the module being accessed throughout the following scoped code.

Duringto importinstruction is the most commonly used technique for gaining access to the code of other modules, Python also offers othermethods and functionsthat make up the built-in import system. Developers can choose to use certain features to gain finer control over the import process.

For our code examples, let's stick to the usualto importStatement most of us are used to. As mentioned in the introduction, the behavior for failureimporteddiffers depending on the version of Python. To illustrate, let's start with theouter_import_2.7.pyArchive:

# outer_import_2.7.py
import system
import gw_utility.Book
def principal():
Try:
print(sys.version)
except ImportError as error:
# Print expected ImportErrors.
print(error.__class__.__name__ + ": " + error.message)
except exception as exception:
# Throw unexpected exceptions.
print(Exception, False)
print(Exception.__Class__.__Name__ + ": " + Exception.Message)
se __name__ == "__main__":
principally()
(Video) Adding __init__.py not working - Module Not Found: Fixing Python Sibling Directory Import Error

DieexteriorThe filename prefix indicates that we are testing an "external" or global scopeto importdeclaration ofgw_utility.Book. Running this code produces the following output:

Traceback (last call):
Datei „C:\Users\Gabe\AppData\Local\JetBrains\Toolbox\apps\PyCharm-P\ch-0\172.3968.37\helpers\pydev\pydevd.py“, Zeile 1599, in <module>
globals = debugger.run(setup['file'], None, None, is_module)
Datei "C:\Users\Gabe\AppData\Local\JetBrains\Toolbox\apps\PyCharm-P\ch-0\172.3968.37\helpers\pydev\pydevd.py", Zeile 1026, em execução
pydev_imports.execfile(file, global, local) # Run the script
Datei "D:/work/Airbrake.io/Exceptions/Python/BaseException/Exception/ImportError/outer_import_2.7.py", Zeile 3, in <module>
import gw_utility.Book
ImportError: No module named Book

The general problem here is that thegw_utility.BookThe module does not exist. In fact, the right modulesmall letters:gw_utility.book. Sinceto importThe instruction is at the beginning of the file, it exists outside of ourtry - exceptblock, then theImportErrorWe don't get caught in the log - execution stopped completely when the error was thrown.

Alternatively, let's see what happens when we move theto importstatement within atry - exceptblock as seen ininner_import_2.7.py:

# inner_import_2.7.py
import system
def principal():
Try:
print(sys.version)
import gw_utility.Book
except ImportError as error:
# Print expected ImportErrors.
print(error.__class__.__name__ + ": " + error.message)
except exception as exception:
# Throw unexpected exceptions.
print(Exception, False)
print(Exception.__Class__.__Name__ + ": " + Exception.Message)
se __name__ == "__main__":
principally()

Running this code - even with Python 2.7 - produces the same thingImportError, but we can capture it and process it laterImportError, if necessary:

2.7.14 (v2.7.14:84471935ed, 16 de setembro de 2017, 20:25:58) [MSC v.1500 64 bits (AMD64)]
ImportError: No module named Book

DieModuleNotFoundErrorwas added in Python 3.6 as a subclass ofImportErrorand an explicit reference to the same type of error we see in the 2.7 code above. For example, let's look at the outsideto importExample in Python 3.6 withouter_import_3.6.py:

# outer_import_3.6.py
import system
import gw_utility.Book
aus gw_utility.logging import Logging
def principal():
Try:
log.log (sys.version)
except ImportError as error:
# Print expected ImportErrors.
Logging.log_exception (erro)
# Include the name and path attributes in the output.
Logging.log(f'error.name: {error.name}')
Logging.log(f'error.path: {error.path}')
except exception as exception:
# Throw unexpected exceptions.
Logging.log_exception(Exception, False)
se __name__ == "__main__":
principally()

Again, here we run thisto importoutside oftry - exceptblock, so running this code stops execution and produces the following output:

Traceback (last call):
Datei „C:\Users\Gabe\AppData\Local\JetBrains\Toolbox\apps\PyCharm-P\ch-0\172.3968.37\helpers\pydev\pydevd.py“, Zeile 1599, in <module>
globals = debugger.run(setup['file'], None, None, is_module)
Datei "C:\Users\Gabe\AppData\Local\JetBrains\Toolbox\apps\PyCharm-P\ch-0\172.3968.37\helpers\pydev\pydevd.py", Zeile 1026, em execução
pydev_imports.execfile(file, global, local) # Run the script
Datei „C:\Users\Gabe\AppData\Local\JetBrains\Toolbox\apps\PyCharm-P\ch-0\172.3968.37\helpers\pydev\_pydev_imps\_pydev_execfile.py“, Zeile 18, in der Exec-Datei
exec(compile(content+"\n", file, 'exec'), glob, loc)
Datei "D:/work/Airbrake.io/Exceptions/Python/BaseException/Exception/ImportError/outer_import_3.6.py", Zeile 3, in <module>
import gw_utility.Book
ModuleNotFoundError: No module named "gw_utility.Book"

The cause of this error is exactly the same as in version 2.7, but is more specific in version 3.6+ModuleNotFoundErrornow it's up. Furthermore, we can detect such errors if theto importruns within atry - exceptContext:

# inner_import_3.6.py
import system
aus gw_utility.logging import Logging
def principal():
Try:
log.log (sys.version)
import gw_utility.Book
except ImportError as error:
# Print expected ImportErrors.
Logging.log_exception (erro)
# Include the name and path attributes in the output.
Logging.log(f'error.name: {error.name}')
Logging.log(f'error.path: {error.path}')
except exception as exception:
# Throw unexpected exceptions.
Logging.log_exception(Exception, False)
se __name__ == "__main__":
principally()

With this code, we can generate the Python version and handle the error:

3.6.3 (v3.6.3:2c5fed8, 3. Out. 2017, 18:11:49) [MSC v.1900 64 bits (AMD64)]
[EXPECTED] ModuleNotFoundError: No module named "gw_utility.Book"
error.name: gw_utility.Book
error.path: None

We give them tooNameeA wayright attributeImportErrorobject added in Python 3.3 to specify the name of the module that attempted to be imported, along with the path to the file that threw the exception, if applicable. In this case, our code is quite simple, so unfortunately none of the attributes are particularly useful.

The air brake is robusterror monitoringThe software provides real-time error monitoring and automatic exception reporting for all your development projects. Airbrake's state-of-the-art web dashboard ensures you receive 24/7 status updates on the health and error rates of your application. No matter what you're working on, Airbrake easily integrates with all major languages ​​and frameworks. Airbrake also makes it easy to customize exception parameters and gives you full control over the active error filtering system, so you catch only the most important errors.

Try Airbrake error tracking software today and see for yourself why so many of the world's best engineering teams are using Airbrake to revolutionize their exception handling techniques! Try Airbrake for free with a14 days free trial.