69. Callable Objects

Here's a collection of 10 Python code snippets to demonstrate the concept of Callable Objects by implementing the __call__ method, which allows instances of a class to be invoked like functions:

---

1. Basic Callable Object

Creating an object that can be called like a function using __call__.

class CallableClass:
    def __call__(self, *args, **kwargs):
        return "Hello from __call__!"

obj = CallableClass()
print(obj())  # Output: Hello from __call__!

---

2. Callable Object with Arguments

Accepting arguments in the __call__ method.

class Adder:
    def __call__(self, a, b):
        return a + b

add = Adder()
result = add(5, 3)
print(result)  # Output: 8

---

3. Callable Object with Dynamic Behavior

The object changes its behavior based on internal state.

class Multiplier:
    def __init__(self, factor):
        self.factor = factor
    
    def __call__(self, number):
        return number * self.factor

double = Multiplier(2)
triple = Multiplier(3)

print(double(4))  # Output: 8
print(triple(4))  # Output: 12

---

4. Callable Object with Return Value

Return a dynamic value based on the input.

class PowerCalculator:
    def __call__(self, base, exponent):
        return base ** exponent

power = PowerCalculator()
print(power(2, 3))  # Output: 8

---

5. Callable Object for Sorting

Using __call__ to sort elements dynamically.

class Sorter:
    def __call__(self, lst):
        return sorted(lst)

sorter = Sorter()
print(sorter([3, 1, 2]))  # Output: [1, 2, 3]

---

6. Callable Object with Internal State Update

Callable object updates its internal state based on function calls.

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

counter = Counter()
print(counter())  # Output: 1
print(counter())  # Output: 2

---

7. Callable Object with Keyword Arguments

Accepting keyword arguments in __call__.

class Printer:
    def __call__(self, message, repeat=1):
        return message * repeat

printer = Printer()
print(printer("Hello", repeat=3))  # Output: HelloHelloHello

---

8. Callable Object for Function Composition

Using __call__ to chain or compose functions.

class FunctionComposer:
    def __init__(self, function):
        self.function = function
    
    def __call__(self, value):
        return self.function(value)

def add_two(x):
    return x + 2

add_two_func = FunctionComposer(add_two)
print(add_two_func(3))  # Output: 5

---

9. Callable Object with Default Parameters

Use default parameters inside the __call__ method.

class Greeter:
    def __call__(self, name="Guest"):
        return f"Hello, {name}!"

greet = Greeter()
print(greet("Alice"))  # Output: Hello, Alice!
print(greet())  # Output: Hello, Guest!

---

10. Callable Object with Logging

Implement a callable object that logs its calls.

class Logger:
    def __call__(self, *args, **kwargs):
        print(f"Calling with arguments: {args}, {kwargs}")
        return "Logging complete!"

logger = Logger()
print(logger(1, 2, 3, key="value"))
# Output: Calling with arguments: (1, 2, 3), {'key': 'value'}
# Output: Logging complete!

---

These examples showcase how you can create objects that behave like functions using the __call__ method, which makes them versatile and useful in a variety of contexts, such as dynamic behavior, function composition, logging, and more.