Category: Tutorials

Nested try Block in Python

In a Python program, if there is another try-except construct either inside either a try block or inside its except block, it is known as a nested-try block. This is needed when different blocks like outer and inner may cause different errors. To handle them, we need nested try blocks.

We start with an example having a single “try − except − finally” construct. If the statements inside try encounter exception, it is handled by except block. With or without exception occurred, the finally block is always executed.

Example 1

Here, the try block has “division by 0” situation, hence the except block comes into play. It is equipped to handle the generic exception with Exception class.

Open Compiler

a=10
b=0try:print(a/b)except Exception:print("General Exception")finally:print("inside outer finally block")

It will produce the following output −

General Exception
inside outer finally block

Example 2

Let us now see how to nest the try constructs. We put another “try − except − finally” blocks inside the existing try block. The except keyword for inner try now handles generic Exception, while we ask the except block of outer try to handle ZeroDivisionError.

Since exception doesn’t occur in the inner try block, its corresponding generic Except isn’t called. The division by 0 situation is handled by outer except clause.

Open Compiler

a=10
b=0try:print(a/b)try:print("This is inner try block")except Exception:print("General exception")finally:print("inside inner finally block")except ZeroDivisionError:print("Division by 0")finally:print("inside outer finally block")

It will produce the following output −

Division by 0
inside outer finally block

Example 3

Now we reverse the situation. Out of the nested try blocks, the outer one doesn’t have any exception raised, but the statement causing division by 0 is inside inner try, and hence the exception handled by inner except block. Obviously, the except part corresponding to outer try: will not be called upon.

Open Compiler

a=10
b=0try:print("This is outer try block")try:print(a/b)except ZeroDivisionError:print("Division by 0")finally:print("inside inner finally block")except Exception:print("General Exception")finally:print("inside outer finally block")

It will produce the following output −

This is outer try block
Division by 0
inside inner finally block
inside outer finally block

In the end, let us discuss another situation which may occur in case of nested blocks. While there isn’t any exception in the outer try:, there isn’t a suitable except block to handle the one inside the inner try: block.

Example 4

In the following example, the inner try: faces “division by 0”, but its corresponding except: is looking for KeyError instead of ZeroDivisionError. Hence, the exception object is passed on to the except: block of the subsequent except statement matching with outer try: statement. There, the zeroDivisionError exception is trapped and handled.

Open Compiler

a=10
b=0try:print("This is outer try block")try:print(a/b)except KeyError:print("Key Error")finally:print("inside inner finally block")except ZeroDivisionError:print("Division by 0")finally:print("inside outer finally block")

It will produce the following output −

This is outer try block
inside inner finally block
Division by 0
inside outer finally block

Exception Chaining

Exception chaining is a technique of handling exceptions by re-throwing a caught exception after wrapping it inside a new exception. The original exception is saved as a property (such as cause) of the new exception.

During the handling of one exception ‘A’, it is possible that another exception ‘B’ may occur. It is useful to know about both exceptions in order to debug the problem. Sometimes it is useful for an exception handler to deliberately re-raise an exception, either to provide extra information or to translate an exception to another type.

In Python 3.x, it is possible to implement exception chaining. If there is any unhandled exception inside an except section, it will have the exception being handled attached to it and included in the error message.

Example

In the following code snippet, trying to open a non-existent file raises FileNotFoundError. It is detected by the except block. While handling another exception is raised.

Open Compiler

try:open("nofile.txt")except OSError:raise RuntimeError("unable to handle error")

It will produce the following output −

Traceback (most recent call last):
  File "/home/cg/root/64afcad39c651/main.py", line 2, in <module>
open("nofile.txt")
FileNotFoundError: [Errno 2] No such file or directory: 'nofile.txt'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/cg/root/64afcad39c651/main.py", line 4, in <module>
raise RuntimeError("unable to handle error")
RuntimeError: unable to handle error

The raise . . from Statement

If you use an optional from clause in the raise statement, it indicates that an exception is a direct consequence of another. This can be useful when you are transforming exceptions. The token after from keyword should be the exception object.

Open Compiler

try:open("nofile.txt")except OSError as exc:raise RuntimeError from exc

It will produce the following output −

Traceback (most recent call last):
  File "/home/cg/root/64afcad39c651/main.py", line 2, in <module>
open("nofile.txt")
FileNotFoundError: [Errno 2] No such file or directory: 'nofile.txt'

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "/home/cg/root/64afcad39c651/main.py", line 4, in <module>
raise RuntimeError from exc
RuntimeError

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

The raise . . from None Statement

If we use None in from clause instead of exception object, the automatic exception chaining that was found in the earlier example is disabled.

Open Compiler

try:open("nofile.txt")except OSError as exc:raise RuntimeError fromNone

It will produce the following output −

Traceback (most recent call last):
 File "C:\Python311\hello.py", line 4, in <module>
  raise RuntimeError from None
RuntimeError

The __context__ and __cause__ Expression

Raising an exception in the except block will automatically add the captured exception to the __context__ attribute of the new exception. Similarly, you can also add __cause__ to any exception using the expression raise … from syntax.

Open Compiler

try:try:raise ValueError("ValueError")except ValueError as e1:raise TypeError("TypeError")from e1
except TypeError as e2:print("The exception was",repr(e2))print("Its __context__ was",repr(e2.__context__))print("Its __cause__ was",repr(e2.__cause__))

It will produce the following output −

The exception was TypeError('TypeError')
Its __context__ was ValueError('ValueError')
Its __cause__ was ValueError('ValueError')

Raising Exceptions in Python

In Python, you can raise exceptions explicitly using the raise statement. Raising exceptions allows you to indicate that an error has occurred and to control the flow of your program by handling these exceptions appropriately.

Raising an exception refers to explicitly trigger an error condition in your program. This can be useful for handling situations where the normal flow of your program cannot continue due to an error or an unexpected condition.

In Python, you can raise built-in exceptions like ValueError or TypeError to indicate common error conditions. Additionally, you can create and raise custom exceptions.

Raising Built-in Exceptions

You can raise any built-in exception by creating an instance of the exception class and using the raise statement. Following is the syntax −

raise Exception("This is a general exception")

Example

Here is an example where we raise a ValueError when a function receives an invalid argument −

Open Compiler

defdivide(a, b):if b ==0:raise ValueError("Cannot divide by zero")return a / b

try:
   result = divide(10,0)except ValueError as e:print(e)

Following is the output of the above code −

Cannot divide by zero

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

Raising Custom Exceptions

In addition to built-in exceptions, you can define and raise your own custom exceptions by creating a new exception class that inherits from the base Exception class or any of its subclasses −

Open Compiler

classMyCustomError(Exception):passdefrisky_function():raise MyCustomError("Something went wrong in risky_function")try:
   risky_function()except MyCustomError as e:print(e)

Output of the above code is as shown below −

Something went wrong in risky_function

Creating Custom Exceptions

Custom exceptions is useful for handling specific error conditions that are unique to your application, providing more precise error reporting and control.

To create a custom exception in Python, you define a new class that inherits from the built-in Exception class or any other appropriate built-in exception class. This custom exception class can have additional attributes and methods to provide more detailed context about the error condition.

Example

In this example −

• We define a custom exception class “InvalidAgeError” that inherits from “Exception”.
• The __init__() method initializes the exception with the invalid age and a default error message.
• The set_age() function raises “InvalidAgeError” if the provided age is outside the valid range.

Open Compiler

classInvalidAgeError(Exception):def__init__(self, age, message="Age must be between 18 and 100"):
  self.age = age
  self.message = message
  super().__init__(self.message)defset_age(age):if age <18or age >100:raise InvalidAgeError(age)print(f"Age is set to {age}")try:
   set_age(150)except InvalidAgeError as e:print(f"Invalid age: {e.age}. {e.message}")

The result obtained is as shown below −

Invalid age: 150. Age must be between 18 and 100

Re-Raising Exceptions

Sometimes, you may need to catch an exception, perform specific actions (such as logging, cleanup, or providing additional context), and then re-raise the same exception to be handled further up the call stack

This is useful when you want to ensure certain actions are taken when an exception occurs, but still allow the exception to propagate for higher-level handling.

To re-raise an exception in Python, you use the “raise” statement without specifying an exception, which will re-raise the last exception that was active in the current scope.

Example

In the following example −

• The process_file() function attempts to open and read a file.
• If the file is not found, it prints an error message and re-raises the “FileNotFoundError” exception.
• The exception is then caught and handled at a higher level in the call stack.

Open Compiler

defprocess_file(filename):try:withopen(filename,"r")asfile:
     data =file.read()# Process dataexcept FileNotFoundError as e:print(f"File not found: {filename}")# Re-raise the exceptionraisetry:
   process_file("nonexistentfile.txt")except FileNotFoundError as e:print("Handling the exception at a higher level")

After executing the above code, we get the following output −

File not found: nonexistentfile.txt
Handling the exception at a higher level

Python Try-Finally Block

In Python, the try-finally block is used to ensure that certain code executes, regardless of whether an exception is raised or not. Unlike the try-except block, which handles exceptions, the try-finally block focuses on cleanup operations that must occur, ensuring resources are properly released and critical tasks are completed.

Syntax

The syntax of the try-finally statement is as follows −

try:# Code that might raise exceptions
   risky_code()finally:# Code that always runs, regardless of exceptions
   cleanup_code()

In Python, when using exception handling with try blocks, you have the option to include either except clauses to catch specific exceptions or a finally clause to ensure certain cleanup operations are executed, but not both together.

Example

Let us consider an example where we want to open a file in write mode (“w”), writes some content to it, and ensures the file is closed regardless of success or failure using a finally block −

try:
   fh =open("testfile","w")
   fh.write("This is my test file for exception handling!!")finally:print("Error: can\'t find file or read data")
   fh.close()

If you do not have permission to open the file in writing mode, then it will produce the following output −

Error: can't find file or read data

The same example can be written more cleanly as follows −

Open Compiler

try:
   fh =open("testfile","w")try:
  fh.write("This is my test file for exception handling!!")finally:print("Going to close the file")
  fh.close()except IOError:print("Error: can\'t find file or read data")</code></pre>


When an exception is thrown in the try block, the execution immediately passes to the finally block. After all the statements in the finally block are executed, the exception is raised again and is handled in the except statements if present in the next higher layer of the try-except statement.



Exception with Arguments



An exception can have an argument, which is a value that gives additional information about the problem. The contents of the argument vary by exception. You capture an exception's argument by supplying a variable in the except clause as follows −



try:
   You do your operations here
   ......................except ExceptionType as Argument:
   You can print value of Argument here...



If you write the code to handle a single exception, you can have a variable follow the name of the exception in the except statement. If you are trapping multiple exceptions, you can have a variable follow the tuple of the exception.



This variable receives the value of the exception mostly containing the cause of the exception. The variable can receive a single value or multiple values in the form of a tuple. This tuple usually contains the error string, the error number, and an error location.



Example



Following is an example for a single exception −



Open Compiler



# Define a function here.deftemp_convert(var):try:returnint(var)except ValueError as Argument:print("The argument does not contain numbers\n",Argument)# Call above function here.
temp_convert("xyz")



It will produce the following output −



The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Python Syntax Errors

In Python, syntax errors are among the most common errors encountered by programmers, especially those who are new to the language. This tutorial will help you understand what syntax errors are, how to identify them, and how to fix them.

What is a Syntax Error?

A syntax error in Python (or any programming language) is an error that occurs when the code does not follow the syntax rules of the language. Syntax errors are detected by the interpreter or compiler at the time of parsing the code, and they prevent the code from being executed.

These errors occur because the written code does not conform to the grammatical rules of Python, making it impossible for the interpreter to understand and execute the commands.

Common Causes of Syntax Errors

Following are the common causes of syntax errors −Missing colons (:) after control flow statements (e.g., if, for, while) − Colons are used to define the beginning of an indented block, such as in functions, loops, and conditionals.

Open Compiler

# Error: Missing colon (:) after the if statementifTrueprint("This will cause a syntax error")

Incorrect indentation − Python uses indentation to define the structure of code blocks. Incorrect indentation can lead to syntax errors.

Open Compiler

# Error: The print statement is not correctly indenteddefexample_function():print("This will cause a syntax error")

Misspelled keywords or incorrect use of keywords.

Open Compiler

# Error: 'print' is misspelled as 'prnt'
prnt("Hello, World!")

Unmatched parentheses, brackets, or braces − Python requires that all opening parentheses (, square brackets [, and curly braces { have corresponding closing characters ), ], and }.

Open Compiler

# Error: The closing parenthesis is missing.print("This will cause a syntax error"

Learn Python in-depth with real-world projects through our Python certification course. Enroll and become a certified expert to boost your career.

How to Identify Syntax Errors

Identifying syntax errors in Python can sometimes be easy, especially when you get a clear error message from the interpreter. However, other times, it can be a bit tricky. Here are several ways to help you identify and resolve syntax errors effectively −

Reading Error Messages

When you run a Python script, the interpreter will stop execution and display an error message if it encounters a syntax error. Understanding how to read these error messages is very important.

Example Error Message

File "script.py", line 1print("Hello, World!"^
SyntaxError: EOL while scanning string literal

This error message can be broken down into parts −

• File “script.py”: Indicates the file where the error occurred.
• line 1: Indicates the line number in the file where the interpreter detected the error.
• print(“Hello, World!”: Shows the line of code with the error.
• ^: Points to the location in the line where the error was detected.

Using an Integrated Development Environment (IDE)

IDEs are helpful in identifying syntax errors as they often provide real-time feedback. Here are some features of IDEs that helps in identifying syntax errors −

• Syntax Highlighting: IDEs highlight code syntax in different colors. If a part of the code is incorrectly colored, it may indicate a syntax error.
• Linting: Tools like pylint or flake8 check your code for errors and stylistic issues.
• Error Underlining: Many IDEs underline syntax errors with a red squiggly line.
• Tooltips and Error Messages: Hovering over the underlined code often provides a tooltip with a description of the error.

Popular IDEs with these features include PyCharm, Visual Studio Code, and Jupyter Notebook.

Running Code in Small Chunks

If you have a large script, it can be useful to run the code in smaller chunks. This can help isolate the part of the code causing the syntax error.

For example, if you have a script with multiple functions and you get a syntax error, try running each function independently to narrow down where the error might be.

Using Version Control

Version control systems like Git can help you track changes to your code. If you encounter a syntax error, you can compare the current version of the code with previous versions to see what changes might have introduced the error.

Fixing Syntax Errors

Fixing syntax errors in Python involves understanding the error message provided by the interpreter, identifying the exact issue in the code, and then making the necessary corrections. Here is a detailed guide on how to systematically approach and fix syntax errors −

Read the Error Message Carefully

Python’s error messages are quite informative. They indicate the file name, line number, and the type of syntax error −

Example Error Message

Assume we have written a print statement as shown below −

print("Hello, World!"

The following message indicates that there is a syntax error on line 1, showing that somewhere in the code, a parenthesis was left unclosed, which leads to a syntax error.

File "/home/cg/root/66634a37734ad/main.py", line 1print("Hello, World!"^
SyntaxError:'(' was never closed

To fix this error, you need to ensure that every opening parenthesis has a corresponding closing parenthesis. Here is the corrected code −

Open Compiler

print("Hello, World!")

Locate the Error

To locate the error, you need to go to the line number mentioned in the error message. Additionally, check not only the indicated line but also the lines around it, as sometimes the issue might stem from previous lines.

Understand the Nature of the Error

To understand the nature of the error, you need to identify what type of syntax error it is (e.g., missing parenthesis, incorrect indentation, missing colon, etc.). Also, refer to common syntax errors and their patterns.

Correct the Syntax

Based on the error type, fix the code.