Difference between getattr and getattribute

python

magic-methods

attribute-access

python-3

byAnton Shumikhin·Nov 19, 2024

The __getattr__ function comes into action when an attribute isn't found and is used to manage missing attributes in a dynamic fashion.

On the other hand, __getattribute__ is triggered during each attribution access, providing thorough control over attribute retrieval. However, one must implement it wisely to avoid an infinite recursion crash.

Here's an example demonstrating their use:

class MyClass:
    def __getattr__(self, attribute):
        # Reddit humor: If I had a penny for every missing attribute…
        return f'Oops! {attribute} missing.'

    def __getattribute__(self, attribute):
        # You found the Holy Grail? Not bad…
        if attribute == 'holy_grail':
            return 'You nailed it, congrats!'
        # The Bermuda Triangle of attribute access: things disappear here!
        return object.__getattribute__(self, attribute)

instance = MyClass()
print(instance.holy_grail)  # "You nailed it, congrats!"
print(instance.ghost)  # "Oops! ghost missing."

In the above instance.holy_grail commands __getattribute__, and instance.ghost utilizes __getattr__ when __getattribute__ fails to locate the attribute.

Nitty gritty of attribute control

To gain mastery over attribute access, understanding the sequence of calls and the contexts that warrant each method's application is essential. While they might appear similar on the surface, they serve distinct purposes and carry unique functionalities.

getattribute: Handle with care

Being engaged during each attribute call, __getattribute__ is powerful but needs to be implemented with care. A common pitfall is infinite recursion caused when calling self.any_attribute within __getattribute__ which triggers itself in an endless loop.

In order to avoid this, bypass the overridden method using super():

class SmartAttributeAccess:
    def __getattribute__(self, item):
        # When 'manual' attribute is smoother than an automatic transmission.
        if item == 'reliable':
            return 'Manual override success!'
        else:
            # Hold my recursion...I'm going in!
            return super().__getattribute__(item)

getattr: The backup guy

__getattr__ saves the day when you need a default protocol for missing attributes. Acting as a safety net for unresolved attribute lookups, it is less intrusive compared to __getattribute__. Assigning a default value within __getattr__ is pretty simple:

class ReliableFallback:
    def __getattr__(self, attr):
        # Thanks for the memory: default value, coming right up!
        self.__dict__[attr] = 'default value'
        return 'default value'

Welcome to Python 3: Consistency is king

In Python 3, new-style classes are the norm (all classes implicitly derive from object). Though understanding class types is less critical, it is beneficial for coding acumen. New-style classes offer uniform behavior, enabling consistent use of __getattr__ and __getattribute__.

Tricks, traps, and rescues

Remember security

When overriding __getattribute__, bear in mind to maintain tight security. Leading over control might expose class internals to malicious manipulations.

Staying clear of errors

To dodge common mistakes with attribute access, remember these best practices:

Utilize __getattr__ for lazily resolving attributes or setting up nonexistent fallbacks.
Ensure __getattribute__ always either returns an attribute or raises an exception to pass control to __getattr__.
Use super().__getattribute__(item) within __getattribute__ to prevent recursion.
Be aware that magic methods like __getattr__ can't be called directly on instances of built-in types.