__invert__ and __abs__ magic functions in Python OOPS

The __invert__ and __abs__ magic methods are used for implementing unary operators in Python. In this article, we will see the concept of __invert__ and __abs__ magic functions in Python.

__invert__() Magic Function in Python

The __invert__ magic function is used to define the behavior of the bitwise NOT operation (~). When this method is implemented in a class, it is called whenever the object is used with the bitwise NOT operator. This allows developers to customize how instances of a class respond to bitwise NOT operations.

Syntax of __invert__() Magic Function

class MyClass:

def __invert__(self):

# Custom implementation for bitwise NOT operation

# Return the result of the operation

pass

Python __invert__() Magic Function Examples

Below are some of the examples by which we can understand about Python __invert__() Function:

Example 1: Customize Bitwise NOT for BinaryNumber Class

In this example, in below code `BinaryNumber` class represents binary numbers, and its `__invert__` method customizes the bitwise NOT operation. When applied to an instance, such as `binary_num`, the result is an inverted binary number, demonstrated by `inverted_num.value`.

class BinaryNumber:
    def __init__(self, value):
        self.value = value

    def __invert__(self):
        # Custom implementation for bitwise NOT operation
        inverted_value = ~self.value
        return BinaryNumber(inverted_value)


# Example usage:
binary_num = BinaryNumber(5)
inverted_num = ~binary_num
print(inverted_num.value)

-6

Example 2: Implement __invert__ For Color Class

In this example, In below code `Color` class represents RGB colors, and its `__invert__` method customizes the bitwise NOT operation on each RGB component. The example creates an original color with RGB values (100, 150, 200), applies bitwise NOT to each component.

class Color:
    def __init__(self, rgb):
        self.rgb = rgb

    def __invert__(self):
        # Custom implementation for bitwise NOT operation
        inverted_rgb = tuple(255 - value for value in self.rgb)
        return Color(inverted_rgb)


# Example usage:
original_color = Color((100, 150, 200))
inverted_color = ~original_color
print(inverted_color.rgb)

(155, 105, 55)

__abs__() Magic Function in Python

The __abs__ magic function is related to the absolute value of an object. When this method is defined in a class, it is called when the abs() function is applied to an instance of that class. This enables developers to specify how objects of a particular class should handle absolute value computations.

Syntax of __abs__() Magic Function

class MyClass:

def __abs__(self):

# Custom implementation for bitwise NOT operation

# Return the result of the operation

pass

Python __abs__() Magic Function Examples

Below are some of the examples of __abs__() magic function in Python:

Example 1: Absolute Value of a ComplexNumber class

In this example, the `ComplexNumber` class represents complex numbers, and its `__abs__` method customizes the absolute value computation. The example creates a complex number with real part 3 and imaginary part 4, calculates its absolute value using the `abs()` function.

class ComplexNumber:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    def __abs__(self):
        # Custom implementation for absolute value computation
        return (self.real**2 + self.imag**2)**0.5

# Example usage:
complex_num = ComplexNumber(3, 4)
absolute_value = abs(complex_num)
print(absolute_value)

5.0

Example 2: Absolute Value of Vector class

In this example, In below code the`Vector` class represents mathematical vectors, and its `__abs__` method customizes the computation of the vector's magnitude or absolute value. The example creates a vector with components [1, 2, 3], calculates its magnitude using the `abs()` function.

class Vector:
    def __init__(self, components):
        self.components = components

    def __abs__(self):
        # Custom implementation for absolute value computation
        return sum(component**2 for component in self.components)**0.5

# Example usage:
vector = Vector([1, 2, 3])
magnitude = abs(vector)
print(magnitude)

3.7416573867739413

Conclusion

In conclusion, the __invert__ and __abs__ magic functions provide a way to customize the behavior of objects in Python when subjected to bitwise NOT and absolute value operations, respectively. Incorporating these methods into classes empowers developers to tailor the behavior of their objects, enhancing the flexibility and expressiveness of their code