Ever Had Your Program Randomly Crashing For No Reason? This happens quite often when you are dealing with errors or unexpected inputs. However, it does include some tools to help you deal with them. `Python Try Except` block is one of the most important tools for this purpose. Moreover, this helps to manage errors and take care of the program in a more controlled way. However, it is a simple guide with some Examples of the use.
What is Python Try Except?
Its syntax errors and exceptions Syntax errors will prevent the program from running since they violate the rules of grammar for that language. Exceptions, however, are errors that occur during program execution and cause the flow of the program to be interrupted. Also, these could be caused by an unexpected input (seeing something that doesn’t fit) or an operation not allowed — like dividing with zero.
Furthermore, this is where the Python `Try Except` statement comes in. Also, it allows you to check a code block for errors and specify how your program should react if something goes wrong. Furthermore, here is a simple overview of how it works.
1. Try Block: Moreover, the code that may produce an error is written inside this block. Additionally, this Code will execute this.
2. Try and Except Block: If any error occurs in the try block then that piece of code will be executed which is given inside except. You can also group exceptions by type and separately handle them.
Syntax:
Python Try Except
Python try:
# Some Code
except:
# code to run if not error
Python Try Except
Working of Try Except
If you use this in a `try except python` Block so Python will execute code inside. However, if something runs into an error, skip the `except` Block. Once there is an error tempting to work with the code, Python leaves the `try` Block and goes to the `except` Block. Additionally, if the `except` Block does not catch such an exception, it bubbles up and terminates your application if unhandled.
Additionally, you can handle different exceptions by using multiple except blocks. Now, this is how it works:
Python Try Except Code Example 1:
Handling Zero Division Error
Python Try Except Python
def divide(x, y):
try:
result = x // y
print(“Yeah! Your answer is:”, result)
except ZeroDivisionError:
print(“Sorry! You are dividing by zero.”)
divide(3, 2) # Output: Yeah! Your answer is: 1
divide(3, 0) # Output of the above line is: Sorry! You are dividing by zero.
Python Try Except
Code Example 2:
Handling Multiple Exceptions
Python Try Except
def divide(x, y):
try:
result = x // y
print(“Yeah! Your answer is:”, result)
Except Exception as e:
print(“The error is:”, e)
# Output: The error is unsupported operand type(s) for //:’int’ and ‘str’divide(3, “GFG”)
divide(3, 0) #Output: The error is an integer division or modulo by zero
Python Try Except
The `else` Clause
You can use an else clause with the try/except block to perform some action only if no exception occurs. Move the `else` Block placed above all except blocks after every block of `except`.
Code Example:
Using `else` Clause
Python Try Except
def AbyB(a, b):
try:
c = ((a + b) // (a – b))
except ExceptvisionError:
print(“a/b results in 0”)
else:
print(c)
AbyB(2.0, 3.0) # Returns: -5
AbyB(3.0, 3.0) # => a/b gives us 0
Try Except
The `Finally` Keyword
A `finally` Block (if used) runs after the `try:` and any of its matching `excepts`, but before either reaching a surrounding containing block or producing an unhandled exception This comes very handy when you want certain clean-up task to run no matter an error occurs or not.
Code Example:
Using `finally`
Python Try Except:
k = 5 // 0
print(k)
except ZeroDivisionError:
print(“Can’t divide by zero”)
finally:
print(“This is always printed”)
# Output:
# Can’t divide by zero
# This is always executed
Conclusion
While, writing good programs requires that we handle errors. With Python try except, you can create a program that easily runs your application even if some unexpected cases come across. The try block lets you test a lot of possibly problematic code, except the part that manages errors and helps when a problem occurs in your feature amongst others; or runs some piece of code for most scenarios that went right until now on; used to do clean up work. In conclusion, with the help of this tool, your code will be more sturdy and user-friendly.
Also Read About: Troubleshooting error:0308010C:digital envelope routines::unsupported