How to Check If a Module Has a Specific Attribute in Python

Introduction

In this lab, you will learn how to check if a Python module has a specific attribute. This involves exploring module attributes, using the hasattr() function, and safely accessing attributes with getattr().

First, you'll create a simple module named my_module.py containing a variable and a function. Then, you'll create a script explore_module.py to import my_module and explore its attributes using __name__ and __dict__, as well as direct access via dot notation. Finally, you'll execute the script to observe the module's attributes.

Skills Graph

Explore Module Attributes

In this step, you will learn how to explore the attributes of a Python module. Modules are fundamental building blocks in Python, and understanding their attributes is crucial for effective programming. Attributes can be variables, functions, or even other modules defined within a module.

First, let's create a simple Python module named my_module.py in your ~/project directory. You can use the VS Code editor to create this file.

## ~/project/my_module.py
my_variable = 10

def my_function():
    return "Hello from my_module!"

This module defines a variable my_variable and a function my_function. Now, let's create another Python script named explore_module.py in the same ~/project directory to explore the attributes of my_module.py.

## ~/project/explore_module.py
import my_module

print("Module name:", my_module.__name__)
print("Module dictionary:", my_module.__dict__)

print("Variable from module:", my_module.my_variable)
print("Function from module:", my_module.my_function())

In this script:

• We import the my_module module.
• We use my_module.__name__ to print the name of the module.
• We use my_module.__dict__ to print the dictionary containing the module's attributes.
• We access the my_variable and my_function attributes directly using dot notation.

Now, execute the explore_module.py script using the following command in the terminal:

python ~/project/explore_module.py

You should see output similar to this:

Module name: my_module
Module dictionary: {'__name__': 'my_module', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x...>, '__spec__': None, '__file__': '/home/labex/project/my_module.py', '__cached__': None, '__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions and constants etc.", '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__build_class__': <built-in function __build_class__>, '__import__': <built-in function __import__>, 'abs': <built-in function abs>, 'all': <built-in function all>, 'any': <built-in function any>, 'ascii': <built-in function ascii>, 'bin': <built-in function bin>, 'breakpoint': <built-in function breakpoint>, 'callable': <built-in function callable>, 'chr': <built-in function chr>, 'compile': <built-in function compile>, 'complex': <class 'complex'>, 'delattr': <built-in function delattr>, 'dict': <class 'dict'>, 'dir': <built-in function dir>, 'divmod': <built-in function divmod>, 'enumerate': <class 'enumerate'>, 'eval': <built-in function eval>, 'exec': <built-in function exec>, 'filter': <class 'filter'>, 'float': <class 'float'>, 'format': <built-in function format>, 'frozenset': <class 'frozenset'>, 'getattr': <built-in function getattr>, 'globals': <built-in function globals>, 'hasattr': <built-in function hasattr>, 'hash': <built-in function hash>, 'help': <built-in function help>, 'hex': <built-in function hex>, 'id': <built-in function id>, 'input': <built-in function input>, 'int': <class 'int'>, 'isinstance': <built-in function isinstance>, 'issubclass': <built-in function issubclass>, 'iter': <built-in function iter>, 'len': <built-in function len>, 'list': <class 'list'>, 'locals': <built-in function locals>, 'map': <class 'map'>, 'max': <built-in function max>, 'memoryview': <class 'memoryview'>, 'min': <built-in function min>, 'next': <built-in function next>, 'object': <class 'object'>, 'oct': <built-in function oct>, 'open': <built-in function open>, 'ord': <built-in function ord>, 'pow': <built-in function pow>, 'print': <built-in function print>, 'property': <class 'property'>, 'range': <class 'range'>, 'repr': <built-in function repr>, 'reversed': <class 'reversed'>, 'round': <built-in function round>, 'set': <class 'set'>, 'setattr': <built-in function setattr>, 'slice': <class 'slice'>, 'sorted': <built-in function sorted>, 'staticmethod': <class 'staticmethod'>, 'str': <class 'str'>, 'sum': <built-in function sum>, 'super': <class 'super'>, 'tuple': <class 'tuple'>, 'type': <class 'type'>, 'vars': <built-in function vars>, 'zip': <class 'zip'>, '__import_submodule__': <built-in function __import_submodule__>, '__import_module__': <built-in function __import_module__>, 'warning': <class 'Warning'>, 'warn': <built-in function warn>, 'ImportWarning': <class 'ImportWarning'>, 'PendingDeprecationWarning': <class 'PendingDeprecationWarning'>, 'DeprecationWarning': <class 'DeprecationWarning'>, 'SyntaxWarning': <class 'SyntaxWarning'>, 'RuntimeWarning': <class 'RuntimeWarning'>, 'FutureWarning': <class 'FutureWarning'>, 'UserWarning': <class 'UserWarning'>, 'BytesWarning': <class 'BytesWarning'>, 'UnicodeWarning': <class 'UnicodeWarning'>, 'EncodingWarning': <class 'EncodingWarning'>, 'ResourceWarning': <class 'ResourceWarning'>}, 'my_variable': 10, 'my_function': <function my_function at 0x...>
Variable from module: 10
Function from module: Hello from my_module!

This output shows the module's name, its dictionary of attributes, and the values of the variable and function defined in the module. Exploring module attributes is a fundamental step in understanding how to use and interact with Python modules effectively.

Use hasattr() on the Module

In this step, you will learn how to use the hasattr() function to check if a module has a specific attribute. This is a useful technique for writing robust code that can handle modules with varying attributes.

Continuing from the previous step, we already have a module named my_module.py in your ~/project directory. Let's reuse it.

## ~/project/my_module.py
my_variable = 10

def my_function():
    return "Hello from my_module!"

Now, let's modify the explore_module.py script to use hasattr() to check for the existence of attributes in my_module.py.

## ~/project/explore_module.py
import my_module

if hasattr(my_module, 'my_variable'):
    print("my_module has attribute my_variable")
else:
    print("my_module does not have attribute my_variable")

if hasattr(my_module, 'my_function'):
    print("my_module has attribute my_function")
else:
    print("my_module does not have attribute my_function")

if hasattr(my_module, 'non_existent_attribute'):
    print("my_module has attribute non_existent_attribute")
else:
    print("my_module does not have attribute non_existent_attribute")

In this script:

• We use hasattr(my_module, 'my_variable') to check if my_module has an attribute named my_variable.
• We use hasattr(my_module, 'my_function') to check if my_module has an attribute named my_function.
• We use hasattr(my_module, 'non_existent_attribute') to check if my_module has an attribute named non_existent_attribute.

Now, execute the explore_module.py script using the following command in the terminal:

python ~/project/explore_module.py

You should see output similar to this:

my_module has attribute my_variable
my_module has attribute my_function
my_module does not have attribute non_existent_attribute

This output shows that hasattr() correctly identifies the existing attributes (my_variable and my_function) and the non-existent attribute (non_existent_attribute). Using hasattr() allows you to write code that gracefully handles modules with different sets of attributes, making your code more flexible and robust.

Access with getattr() Safely

In this step, you will learn how to use the getattr() function to access module attributes safely. The getattr() function allows you to provide a default value if the attribute does not exist, preventing your program from crashing.

Continuing from the previous steps, we already have a module named my_module.py in your ~/project directory. Let's reuse it.

## ~/project/my_module.py
my_variable = 10

def my_function():
    return "Hello from my_module!"

Now, let's modify the explore_module.py script to use getattr() to access attributes in my_module.py with a default value.

## ~/project/explore_module.py
import my_module

variable_value = getattr(my_module, 'my_variable', 'Default Value')
print("Value of my_variable:", variable_value)

function_value = getattr(my_module, 'my_function', lambda: "Default Function")
print("Value of my_function:", function_value())

non_existent_value = getattr(my_module, 'non_existent_attribute', 'Attribute Not Found')
print("Value of non_existent_attribute:", non_existent_value)

In this script:

• We use getattr(my_module, 'my_variable', 'Default Value') to access my_variable. If my_variable exists, its value is assigned to variable_value. Otherwise, variable_value is assigned the default value 'Default Value'.
• We use getattr(my_module, 'my_function', lambda: "Default Function") to access my_function. If my_function exists, it's assigned to function_value. Otherwise, function_value is assigned a default lambda function that returns "Default Function". We then call the function using function_value().
• We use getattr(my_module, 'non_existent_attribute', 'Attribute Not Found') to access non_existent_attribute. Since this attribute does not exist, non_existent_value is assigned the default value 'Attribute Not Found'.

Now, execute the explore_module.py script using the following command in the terminal:

python ~/project/explore_module.py

You should see output similar to this:

Value of my_variable: 10
Value of my_function: Hello from my_module!
Value of non_existent_attribute: Attribute Not Found

This output demonstrates how getattr() safely accesses attributes, providing default values when attributes are not found. This technique is crucial for writing robust and flexible Python code.

Summary

In this lab, you learned how to explore the attributes of a Python module. This involved creating a simple module named my_module.py containing a variable and a function.

You then created a script explore_module.py to import and inspect the module's attributes using __name__ to get the module name, __dict__ to view the module's dictionary, and direct dot notation to access specific variables and functions within the module. Finally, you executed the script to observe the module's attributes.