Python Return Error
Contents |
here for a quick overview of the site Help Center Detailed answers to any questions you might have Meta Discuss the workings and policies of this site About Us Learn more about Stack Overflow
Python Error Types
the company Business Learn more about hiring developers or posting ads with us Stack Overflow python custom exception Questions Jobs Documentation Tags Users Badges Ask Question x Dismiss Join the Stack Overflow Community Stack Overflow is a community of syntax for generic except clause in python 6.2 million programmers, just like you, helping each other. Join them; it only takes a minute: Sign up Manually raising (throwing) an exception in Python up vote 800 down vote favorite 189 How can I raise
Python Exception Message
an exception in Python so that it can later be caught via an except block? python exception exception-handling share|improve this question edited Feb 3 '15 at 14:37 DavidRR 5,20472747 asked Jan 12 '10 at 21:07 TIMEX 41.2k201525826 add a comment| 3 Answers 3 active oldest votes up vote 787 down vote accepted How do I manually throw/raise an exception in Python? Use the most specific Exception constructor that semantically fits your issue. Be
Python Raise Valueerror
specific in your message, e.g.: raise ValueError('A very specific bad thing happened') Don't do this: Avoid raising a generic Exception, to catch it, you'll have to catch all other more specific exceptions that subclass it. Hiding bugs raise Exception('I know Python!') # don't, if you catch, likely to hide bugs. For example: def demo_bad_catch(): try: raise ValueError('represents a hidden bug, do not catch this') raise Exception('This is the exception you expect to handle') except Exception as error: print('caught this error: ' + repr(error)) >>> demo_bad_catch() caught this error: ValueError('represents a hidden bug, do not catch this',) Won't catch and more specific catches won't catch the general exception: def demo_no_catch(): try: raise Exception('general exceptions not caught by specific handling') except ValueError as e: print('we will not catch e') >>> demo_no_catch() Traceback (most recent call last): File "
you have probably seen some. There are (at least) two distinguishable kinds of errors: syntax errors and exceptions. 8.1. Syntax Errors¶ Syntax errors, also known python exception stack trace as parsing errors, are perhaps the most common kind of complaint you
Python Print Exception
get while you are still learning Python: >>> while True print('Hello world') File "
is important to understand some of the basics of Python exception handling. It works somewhat like the Unix errno variable: there is a global indicator (per thread) of the last error that occurred. Most https://docs.python.org/2/c-api/exceptions.html functions don't clear this on success, but will set it to indicate the cause https://jeffknupp.com/blog/2013/02/06/write-cleaner-python-use-exceptions/ of the error on failure. Most functions also return an error indicator, usually NULL if they are supposed to return a pointer, or -1 if they return an integer (exception: the PyArg_*() functions return 1 for success and 0 for failure). When a function must fail because some function it called python exception failed, it generally doesn't set the error indicator; the function it called already set it. It is responsible for either handling the error and clearing the exception or returning after cleaning up any resources it holds (such as object references or memory allocations); it should not continue normally if it is not prepared to handle the error. If returning due to an error, it is important to indicate to python return error the caller that an error has been set. If the error is not handled or carefully propagated, additional calls into the Python/C API may not behave as intended and may fail in mysterious ways. The error indicator consists of three Python objects corresponding to the Python variables sys.exc_type, sys.exc_value and sys.exc_traceback. API functions exist to interact with the error indicator in various ways. There is a separate error indicator for each thread. void PyErr_PrintEx(intset_sys_last_vars)¶ Print a standard traceback to sys.stderr and clear the error indicator. Call this function only when the error indicator is set. (Otherwise it will cause a fatal error!) If set_sys_last_vars is nonzero, the variables sys.last_type, sys.last_value and sys.last_traceback will be set to the type, value and traceback of the printed exception, respectively. void PyErr_Print()¶ Alias for PyErr_PrintEx(1). PyObject* PyErr_Occurred()¶ Return value: Borrowed reference.Test whether the error indicator is set. If set, return the exception type (the first argument to the last call to one of the PyErr_Set*() functions or to PyErr_Restore()). If not set, return NULL. You do not own a reference to the return value, so you do not need to Py_DECREF() it. Note Do not compare the return
Cleaner Python: Use Exceptions Many programmers have had it drilled into their head that exceptions, in any language, should only be used in truly exceptional cases. They're wrong. The Python community's approach to exceptions leads to cleaner code that's easier to read. And that's without the monstrous hit to performance commonly associated with exceptions in other languages. EDIT: Updated with more useful exception idioms Using exceptions to write cleaner code? When I talk about "using exceptions", I'm specifically not referring to creating some crazy exception hierarchy for your package and raising exceptions at every possible opportunity. That will most certainly lead to unmaintainable and difficult to understand code. This notion has been widely discussed and is well summarized on Joel Spolsky's blog. Note: Python avoids much of the tension of the "error codes vs exceptions" argument. Between the ability to return multiple values from a function and the ability to return values of different types (e.g. None or something similar in the error case) the argument is moot. But this is besides the point. The style of exception usage I'm advocating is quite different. In short: take advantage of Python built-ins and standard library modules that already throw exceptions. Exceptions are built in to Python at the lowest levels. In fact, I guarantee your code is already using exceptions, even if not explicitly. Intermezzo: How the for statement works Any time you use for to iterate over an iterable (basically, all sequence types and anything that defines __iter__() or __getitem__()), it needs to know when to stop iterating. Take a look at the code below: words = ['exceptions', 'are', 'useful'] for word in words: print(word) How does for know when it's reached the last element in words and should stop trying to get more items? The answer may surprise you: the list raises a StopIteration exception. In fact, all iterables follow this pattern. When a for statement is first evaluated