python What is a “callable”?

Classes like SampleClass are objects of type, which you can confirm by calling type() with the class object as an argument or by accessing the .__class__ attribute. Sinking fund redemption requires the issuer to adhere to a set schedule while redeeming a portion or all of its debt. On specified dates, the company will remit a portion of the bond to bondholders. A sinking fund helps the company save money over time and avoid a large lump-sum payment at maturity. A sinking fund has bonds issued whereby some of them are callable for the company to pay off its debt early. Now, let us see a real use case to understand callable objects.

In the example above, the callable() function correctly indicates the callability of the two objects. Simply, you make an object callable by overriding the special method __call__(). In Python any object with a __call__() method can be called using function-call syntax. There will be hardly any Python user who hasn’t stumbled upon exceptions like ‘dict’ object is not callable or ‘int’ object is not callable.

Three years from the date of issuance, interest rates fall by 200 basis points (bps) to 4%, prompting the company to redeem the bonds. Under the terms of the bond contract, if the company calls the bonds, it must pay the investors $102 premium to par. Therefore, the company pays the bond investors $10.2 million, which it borrows from the bank at a 4% interest rate.

Writing Stateful Callables

So, even if you don’t define an explicit .__init__() method in one of your custom classes, that class will still inherit the default implementation from object. That’s because .__call__() returns the result of calculating the desired power. If you want the instances of a given class to be callable, then you need to implement the .__call__() special method in the underlying class. This method enables you to call the instances of your class as you’d call regular Python functions. Functions and classes are both callables, but you can actually invent your own callable objects too.

• An issuer will usually call the bond when interest rates fall.
• Understanding how to create and use callable instances is a valuable skill for you as a Python developer.
• Therefore, the company pays the bond investors $10.2 million, which it borrows from the bank at a 4% interest rate.

The bond may also stipulate that the early call price goes down to 101 after a year. The function returns True if the object appears to be callable. To allow your Dart class to be called like a function, implement the call() method.

Example code 1

When you write your Python code, you can usually call your predefined functions and methods, but not your class objects. Another interesting use case of .__call__() is when you need to implement the strategy design pattern in Python. In this case, you can take advantage of .__call__() to create classes that provide implementations for your different strategies. Before jumping into common use cases of callable instances, you’ll explore the differences between the .__init__() and .__call__() methods. These two methods and their corresponding roles in Python classes can be confusing for people who are beginning to work with Python. The strategy design pattern allows you to define a family of similar algorithms and make them interchangeable at runtime.

In cumulative_average(), you use a local variable called data to hold the data between calls. This function takes a new value in each call and appends it to data. Then the function computes and returns the average of the currently stored data. Remember that object is the ultimate parent class of all Python classes.

Then you print a message with the function’s name and the execution time in milliseconds. The final step is to return the result of calling the input function. Python’s decorators are callables that take another callable as an argument and extend its behavior without explicitly modifying its code.

How to Implement Multilevel Inheritance Relationship: Python OOP Complete Course — Part 26

To make these class objects callable, we must override the __call__() method. This method will determine how the class should split the passed text according to the attributes word_ind and num_words . Next, you use time.perf_counter() to get the time before and after the input function executes.

This Demo class implements both .__init__() and .__call__(). In .__init__(), you print a message and initialize the .attr attribute. In .__call__(), you only print a message so that you learn when the method gets called with a given argument. However, instances of this custom class aren’t callable, and you get an error if you try to call them. So, callable() only guarantees that the target instance comes from a class that implements a .__call__() method. The callable() function takes an object as an argument and returns True if the object is callable.

This updated version of ExecutionTimer is quite different from your original implementation. The class initializer takes repetitions an argument that you need to provide as part of the decorator call. Once the function is decorated, whenever you run it, you get a message with the function name and the execution time in milliseconds. In practice, it returns a closure, which is a special object that packs together the average() function and its non-local scope. Here, you use PowerFactory to create two different callable instances. The first instance raises numbers to the power of 2, while the second instance raises numbers to the power of 3.

Creating Callable Instances With .__call__() in Python

It reissues the bond with a 4% coupon rate and a principal sum of $10.2 million, reducing its annual interest payment to 4% x $10.2 million or $408,000. However, the investor might not make out as well as the company when the bond is called. For example, let’s say a 6% coupon bond is issued and is due to mature in five years. An investor purchases $10,000 worth and receives coupon payments of 6% x $10,000 or $600 annually. Three years after issuance, the interest rates fall to 4%, and the issuer calls the bond. The bondholder must turn in the bond to get back the principal, and no further interest is paid.

In this example, .__call__() falls back to calling .increment(), providing a shortcut for running the increment operation. We cannot pass parameters to the instanciation and the __call__ of each instance returns the value of the area of the triangle. In Python, functions can be called and classes can be called. As you can see, the behavior of the object depends on the parameters’ values, and this is how much easy you can create a callable object.

How to Implement Multiple Inheritance Relationship: Python OOP Complete Course — Part 27

Finally, companies must offer a higher coupon to attract investors. This higher coupon will increase the overall cost of taking on new projects or expansions. If market interest rates decline after a corporation floats a bond, the company can issue new debt, receiving a lower interest rate than the original callable bond. The company uses the proceeds from the second, lower-rate issue to pay off the earlier callable bond by exercising the call feature. As a result, the company has refinanced its debt by paying off the higher-yielding callable bonds with the newly-issued debt at a lower interest rate.

Learn how to make your class objects callable in Python OOP.

Its main goal is to initialize instance attributes with sensible initial values. In this example, your PowerFactory class takes exponent as an argument, which you’ll use later to run different power operations. The .__call__() method takes a base argument and calculates its power using the previously provided exponent. The .__call__() method in the above example doesn’t take any arguments. However, there are no restrictions on how to write the .__call__() method in your custom classes.

For example, say that you want to compute the factorial of a given number. Because you plan to run this computation multiple times, you need to make it efficient. A way to do this is to cache the already-computed values so that you don’t have to recompute them all the time.