Introduction to Python NotImplementedError
Python NotImplementedError Exception occurs at runtime when client characterized base classes; conceptual techniques should raise this exception when they require inferred classes to abrogate the strategy or while the class is being created to demonstrate that the genuine usage despite everything should be included. This does not have a valid syntax as it is an exception runtime error. This ought not to be utilized to show that an administrator or technique isn’t intended to be bolstered by any means; all things considered, either leave the administrator or strategy unclear or, if a subclass, set it to None.
An exception is an occasion that happens during the execution of a program that disturbs the program’s directions’ ordinary progression. By and large, when a Python content experiences a circumstance that it cannot adapt to, it raises an exception. An exception is a Python object that speaks to a mistake. When a Python content raises an exception, it should either deal with the exemption promptly else it ends and stops.
How NotImplementedError Works in Python?
Now we look at how these NotImplementedErrors or exceptions work in Python.
Example
Code:
class BaseClass(object):
def __init__(self):
super(BaseClass, self).__init__()
def do_something(self):
raise NotImplementedError(self.__class__.__name__ + '.try_something')
class SubClass(BaseClass):
def do_something(self):
print (self.__class__.__name__ + ' trying something!')
SubClass().do_something()
BaseClass().do_something()
Output:
Code Explanation: In the above program, we first define an abstract class as our base class. In the main class, we define the interface using the init function and declare an index called self. Once this interface is defined in the base class, it gets prepared to be implemented as soon as we provide the command to define the interface. Soon after this is done, we immediately raise a NotImplementedError, preventing this interface from implementing the command. Hence, when we give the command to ‘try something, it automatically terminates from the abstract class. Then we define the subclass, and we again implement the interface and this time, the implementation works, and it produces the output saying that the subclass is trying something, and it raises the NonImplementation error for the base class and asks us to traceback to this exception.
How to Avoid NotImplementedError in Python?
There are a few circumstances where runtime errors are probably going to happen. At whatever point we attempt to peruse a document or get a client’s contribution, quite possibly something startling will occur – the record may have been moved or erased, and the client may enter information that is not in the correct organization. Great developers should add shields to their projects so regular circumstances like this can be taken care of effortlessly and a program that crashes at whatever point it experiences an effectively predictable issue is not extremely lovely to utilize. Most clients anticipate that projects should be sufficiently strong to recuperate from these sorts of difficulties. Hence, we see various aspects on how to prevent these runtime errors or NotImplementedErrors in Python. There are 2 functions that help in preventing these runtime errors, and they are “try” and “except”.
Example
Code:
try:
salary = int(input("Enter salary: "))
print("So cool you earn %d amount." % salary)
except ValueError:
print("Hey, that wasn't a number!")
Output:
Code Explanation: In the above code, we realize that the blunder is probably going to happen when we attempt to change over the client’s contribution to a number. On the off chance that the info string is definitely not a number, this line will trigger a ValueError – that is the reason we indicated it as the sort of blunder that we are going to deal with. We could have determined a progressively broad sort of mistake – or even left the sort out totally, which would have caused to coordinate any sort of exemption – yet that would have been an impractical notion. Imagine a scenario where we got a totally unique mistake that we had not anticipated. It would be dealt with also, and we would not see that anything abnormal was turning out badly. We may likewise need to respond in various manners to various types of blunders. We ought to consistently attempt to pick explicit as opposed to general mistake types for our with the exception of statements. Hence there will not be a runtime error like a NotImplementedError or Value error.
Conclusion
Hence, I conclude by saying that when NotImplementedErrors or exceptions occur in Python during runtime, it will not be interchangeable, and thus the normal implementation is not accepted. This kind of exceptions and errors can be handled by try and except blocks. In NotImplementedError, base classes have unique techniques which will raise this special case when they require determined classes to supersede the strategy or while the class is being created to show that the genuine usage despite everything should be included.
4.8 (13,663 ratings)
View Course
Recommended Articles
This is a guide to Python NotImplementedError. Here we also discuss the introduction and how notimplementederror works in python, along with an example and its code implementation. you may also have a look at the following articles to learn more –
