python __import__ vs import

Bonnie 72 Published: 09/17/2024

python __import__ vs import

The __import__ and import statements are two fundamental mechanisms for importing modules in Python. While they seem similar, they serve distinct purposes and have different use cases.

Import Statement

The import statement is used to load a module from a file. When you use import, Python looks for a module with the specified name in the current package or one of its parents (in the case of relative imports). The imported module is then made available as a namespace, allowing you to access its functions, classes, and variables.

For example:

import math

print(math.pi)  # prints 3.14159265359...

In this example, Python loads the math module from the mathmodule.py file (assuming it exists in one of the directories in your sys.path) and makes its contents available as a namespace.

import Function

The __import__ function is a low-level mechanism for importing modules. It allows you to import modules dynamically, without having to use the import statement. The function takes two arguments: the module name and the level of package searching (defaulting to 0).

When using __import__, Python looks for a module with the specified name in the current package or one of its parents (similar to the import statement). However, unlike import, __import__ returns the loaded module object itself, rather than making it available as a namespace.

Here's an example:

module = __import__('math')

print(module.pi)  # prints 3.14159265359...

In this case, __import__('math') loads the math module and returns the module object. You can then access its contents using dot notation (module.pi, for instance).

Key Differences

Here are the main differences between __import__ and import:

Return value: import makes the imported module available as a namespace, while __import__ returns the loaded module object itself. Namespace access: With import, you can access the imported module's contents using dot notation (e.g., math.pi). With __import__, you need to use the returned module object directly (e.g., module.pi). Dynamic loading: __import__ allows for dynamic loading of modules, while import requires a static reference to the module name.

Use Cases

When should you use each?

Use import when you want to load a module statically and make its contents available as a namespace. Use __import__ when: You need to dynamically load a module (e.g., based on user input or configuration). You require the loaded module object itself, rather than just accessing its contents. You're working with modules that don't have a direct Python equivalent (e.g., C-based extensions).

In conclusion, while both __import__ and import are used for importing modules in Python, they serve different purposes. Understanding when to use each can help you write more effective and flexible code.

Python __ import __ example

Here's an explanation of the __import__ function in Python:

In Python, the __import__ function is a built-in function that allows you to dynamically import modules at runtime. This function is particularly useful when you need to load modules that are not imported upfront or when you need to dynamically determine which module to import based on certain conditions.

The basic syntax of the __import__ function is as follows:

module_name = __import__(module_name, globals=globals(), locals=locals())

Here's a breakdown of what each parameter does:

module_name: This is the name of the module you want to import. It can be a string or a callable (e.g., a class or function). globals=globals(): This is an optional parameter that specifies the global scope in which the module should be imported. The default value is globals() which refers to the current global scope. locals=locals(): This is also an optional parameter that specifies the local scope in which the module should be imported. The default value is locals() which refers to the current local scope.

Here's a simple example of how you can use the __import__ function:

# Importing the math module

math_module = import('math')


print(math_module.pi)  # Output: 3.14159265359

You can also import specific functions or classes from the math module

sin_function = getattr(math_module, 'sin')


cos_function = getattr(math_module, 'cos')


print(sin_function(30))  # Output: 0.98870399783...


print(cos_function(45))  # Output: 0.70710678113...

As you can see from the example above, you can use the __import__ function to dynamically import modules and access their contents at runtime.

Here are some more examples of how you can use the __import__ function:

# Dynamically determine which module to import based on a condition

module_name = 'random' if random.random() < 0.5 else 'time'


imported_module = import(module_name)


print(imported_module.randint(1, 100))  # Output: A random integer between 1 and 100

You can also use the import function with a list of module names

modules_to_import = ['random', 'math']


for module_name in modules_to_import:


imported_module = import(module_name)


print(getattr(imported_module, 'randint')(1, 100))  # Output: A random integer between 1 and 100

You can also use the import function with a dictionary of module names

modules_to_import = {'random': 'random', 'math': 'math'}


for module_name, imported_module_name in modules_to_import.items():


imported_module = import(imported_module_name)


print(getattr(imported_module, 'randint')(1, 100))  # Output: A random integer between 1 and 100

As you can see from the examples above, the __import__ function is very flexible and powerful. It allows you to dynamically import modules at runtime based on various conditions and scenarios.

However, it's worth noting that while the __import__ function is useful in certain situations, it can also lead to namespace pollution if not used carefully. It's always a good idea to use this function judiciously and with caution.

Related Articles