UNIT I

Syntax Error
During the syntax analysis phase, this type of error appears. Syntax error is found
during the execution of the program.

Some syntax error can be:

o Error in structure
o Missing operators
o Unbalanced parenthesis

When an invalid calculation enters into a calculator then a syntax error can also
occurs. This can be caused by entering several decimal points in one number or by
opening brackets without closing them.

For example 1: Using "=" when "==" is needed.

1. 16 if (number=200)
2. 17 count << "number is equal to 20";
3. 18 else
4. 19 count << "number is not equal to 200"

The following warning message will be displayed by many compilers:

Syntax Warning: assignment operator used in if expression line 16 of program

firstprog.cpp

In this code, if expression used the equal sign which is actually an assignment
operator not the relational operator which tests for equality.

Due to the assignment operator, number is set to 200 and the expression
number=200 are always true because the expression's value is actually 200. For this
example the correct code would be:

1. 16 if (number==200)

Example 2: Missing semicolon:

1. int a = 5 // semicolon is missing

Compiler message:

1. ab.java:20: ';' expected

2. int a = 5

Example 3: Errors in expressions:

1. x = (3 + 5; // missing closing parenthesis ')'

2. y = 3 + * 5; // missing argument between '+' and '*'

Python Exception
An exception can be defined as an unusual condition in a program resulting in the
interruption in the flow of the program.

Whenever an exception occurs, the program stops the execution, and thus the
further code is not executed. Therefore, an exception is the run-time errors that are
unable to handle to Python script. An exception is a Python object that represents
an error

Python provides a way to handle the exception so that the code can be executed
without any interruption. If we do not handle the exception, the interpreter doesn't
execute all the code that exists after the exception.

Python has many built-in exceptions that enable our program to run without
interruption and give the output. These exceptions are given below:

Common Exceptions
Python provides the number of built-in exceptions, but here we are describing the
common standard exceptions. A list of common exceptions that can be thrown from
a standard Python program is given below.

1. ZeroDivisionError: Occurs when a number is divided by zero.

2. NameError: It occurs when a name is not found. It may be local or global.
3. IndentationError: If incorrect indentation is given.
 4. IOError: It occurs when Input Output operation fails.
5. EOFError: It occurs when the end of the file is reached, and yet operations are being
performed.

The problem without handling exceptions

As we have already discussed, the exception is an abnormal condition that halts the
execution of the program.

Suppose we have two variables a and b, which take the input from the user and
perform the division of these values. What if the user entered the zero as the
denominator? It will interrupt the program execution and through
a ZeroDivision exception. Let's see the following example.

Example
1. a = int(input("Enter a:"))
2. b = int(input("Enter b:"))
3. c = a/b
4. print("a/b = %d" %c)
5.
6. #other code:
7. print("Hi I am other part of the program")

Output:

Enter a:10
Enter b:0
Traceback (most recent call last):
File "exception-test.py", line 3, in <module>
c = a/b;
ZeroDivisionError: division by zero

The above program is syntactically correct, but it through the error because of
unusual input. That kind of programming may not be suitable or recommended for
the projects because these projects are required uninterrupted execution. That's
why an exception-handling plays an essential role in handling these unexpected
exceptions. We can handle these exceptions in the following way.
 Exception handling in python
The try-expect statement
If the Python program contains suspicious code that may throw the exception, we
must place that code in the try block. The try block must be followed with
the except statement, which contains a block of code that will be executed if there
is some exception in the try block.

Syntax

1. try:
2. #block of code
3.
4. except Exception1:
5. #block of code
6.
7. except Exception2:
8. #block of code
9.
10. #other code

Consider the following example.

Example 1
1. try:
2. a = int(input("Enter a:"))
3. b = int(input("Enter b:"))
4. c = a/b
5. except:
6. print("Can't divide with zero")

Output:

Enter a:10
Enter b:0
Can't divide with zero

We can also use the else statement with the try-except statement in which, we can
place the code which will be executed in the scenario if no exception occurs in the
try block.

The syntax to use the else statement with the try-except statement is given below.

1. try:
2. #block of code
3.
4. except Exception1:
5. #block of code
6.
7. else:
8. #this code executes if no except block is executed
 Consider the following program.

Example 2

1. try:
2. a = int(input("Enter a:"))
3. b = int(input("Enter b:"))
4. c = a/b
5. print("a/b = %d"%c)
6. # Using Exception with except statement. If we print(Exception) it will return exception cl
ass
7. except Exception:
8. print("can't divide by zero")
9. print(Exception)
10. else:
11. print("Hi I am else block")
 Output:

Enter a:10
Enter b:0
can't divide by zero
<class 'Exception'>

The except statement with no exception

Python provides the flexibility not to specify the name of exception with the
exception statement.

Consider the following example.

Example

1. try:
2. a = int(input("Enter a:"))
3. b = int(input("Enter b:"))
4. c = a/b;
5. print("a/b = %d"%c)
6. except:
7. print("can't divide by zero")
8. else:
9. print("Hi I am else block")
The except statement using with exception variable
We can use the exception variable with the except statement. It is used by using
the as keyword. this object will return the cause of the exception. Consider the
following example:

1. try:
2. a = int(input("Enter a:"))
3. b = int(input("Enter b:"))
4. c = a/b
5. print("a/b = %d"%c)
6. # Using exception object with the except statement
7. except Exception as e:
8. print("can't divide by zero")
9. print(e)
10. else:
11. print("Hi I am else block")

Output:

Enter a:10
Enter b:0
can't divide by zero
division by zero

Points to remember
1. Python facilitates us to not specify the exception with the except statement.
2. We can declare multiple exceptions in the except statement since the try block may
contain the statements which throw the different type of exceptions.
3. We can also specify an else block along with the try-except statement, which will be
executed if no exception is raised in the try block.
4. The statements that don't throw the exception should be placed inside the else
block.

Example

1. try:
2. #this will throw an exception if the file doesn't exist.
3. fileptr = open("file.txt","r")
4. except IOError:
5. print("File not found")
6. else:
7. print("The file opened successfully")
8. fileptr.close()

Output:

File not found

Declaring Multiple Exceptions

The Python allows us to declare the multiple exceptions with the except clause.
Declaring multiple exceptions is useful in the cases where a try block throws
multiple exceptions. The syntax is given below.
 Syntax

1. try:
2. #block of code
3.
4. except (<Exception 1>,<Exception 2>,<Exception 3>,...<Exception n>)
5. #block of code
6.
7. else:
8. #block of code

Consider the following example.

1. try:
2. a=10/0;
3. except(ArithmeticError, IOError):
4. print("Arithmetic Exception")
5. else:
6. print("Successfully Done")

Output:

Arithmetic Exception

The try...finally block

Python provides the optional finally statement, which is used with
the try statement. It is executed no matter what exception occurs and used to
release the external resource. The finally block provides a guarantee of the
execution.

We can use the finally block with the try block in which we can pace the necessary
code, which must be executed before the try statement throws an exception.

The syntax to use the finally block is given below.

Syntax

1. try:
2. # block of code
3. # this may throw an exception
4. finally:
5. # block of code
6. # this will always be executed

Example

1. try:
2. fileptr = open("file2.txt","r")
3. try:
4. fileptr.write("Hi I am good")
5. finally:
6. fileptr.close()
7. print("file closed")
8. except:
9. print("Error")

Output:

file closed
Error

Raising exceptions
An exception can be raised forcefully by using the raise clause in Python. It is useful
in in that scenario where we need to raise an exception to stop the execution of the
program.

For example, there is a program that requires 2GB memory for execution, and if the
program tries to occupy 2GB of memory, then we can raise an exception to stop the
execution of the program.

The syntax to use the raise statement is given below.

Syntax

1. raise Exception_class,<value>

Points to remember

1. To raise an exception, the raise statement is used. The exception class name follows
it.
2. An exception can be provided with a value that can be given in the parenthesis.
3. To access the value "as" keyword is used. "e" is used as a reference variable which
stores the value of the exception.
4. We can pass the value to an exception to specify the exception type.

Example

1. try:
2. age = int(input("Enter the age:"))
3. if(age<18):
4. raise ValueError
5. else:
6. print("the age is valid")
7. except ValueError:
8. print("The age is not valid")

Output:

Enter the age:17

The age is not valid

Example 2 Raise the exception with message

1. try:
2. num = int(input("Enter a positive integer: "))
3. if(num <= 0):
4. # we can pass the message in the raise statement
5. raise ValueError("That is a negative number!")
6. except ValueError as e:
7. print(e)

Output:

Enter a positive integer: -5

That is a negative number!

Example 3

1. try:
2. a = int(input("Enter a:"))
3. b = int(input("Enter b:"))
4. if b is 0:
5. raise ArithmeticError
6. else:
7. print("a/b = ",a/b)
8. except ArithmeticError:
9. print("The value of b can't be 0")
 Output:

Enter a:10
Enter b:0
The value of b can't be 0

Custom Exception
The Python allows us to create our exceptions that can be raised from the program
and caught using the except clause. However, we suggest you read this section after
visiting the Python object and classes.

Consider the following example.

Example

1. class ErrorInCode(Exception):
2. def __init__(self, data):
3. self.data = data
4. def __str__(self):
5. return repr(self.data)
6.
7. try:
8. raise ErrorInCode(2000)
9. except ErrorInCode as ae:
10. print("Received error:", ae.data)

User Defined Exceptions

In F#, you can create user defined exception. It provides flexibility to define custom
exceptions according to requirement. Let's see an example.

1. exception InvalidAgeException of string

2. let validate x =
3. if (x < 18) then
4. raise (InvalidAgeException "Sorry, Age must be greater than 18")
5.
6. let TestUserDefinedException =
7. try
8. validate 15
9. with
10. | InvalidAgeException(e) -> printfn "%s" e
11. printfn "Rest of the code"
12.
13. TestUserDefinedException

Output:

Sorry, Age must be greater than 18

Rest of the code
Defining Clean Up Actions in Python

There are numerous situation occurs when we want our program to do this specific
task, irrespective of whether it runs perfectly or thrown some error. Mostly to catch
at any errors or exceptions, we use to try and except block.
The “try” statement provides very useful optional clause which is meant for
defining ‘clean-up actions’ that must be executed under any circumstances. For
example −
>>> try:
raise SyntaxError
finally:
print("Learning Python!")
Learning Python!
Traceback (most recent call last):
File "<pyshell#11>", line 2, in <module>
raise SyntaxError
File "<string>", line None
SyntaxError: <no detail available>
The final clause will execute no matter what, however, the else clause executes
only if an exception was not raised.
Example1 − Consider below example, where everything looks ok and writing to a
file with no exception (the program is working), will output the following −
file = open('finally.txt', 'w')
try:
file.write("Testing1 2 3.")
print("Writing to file.")
except IOError:
print("Could not write to file.")
else:
print("Write successful.")
finally:
 file.close()
print("File closed.")
On running above program, will get −
Writing to file.
Write successful.
File closed.

Pre-defined Clean Up Actions

In Python, pre-defined clean up actions are mostly used to close the
files. When we are executing some operations like read and write in
the file, generally files are left open for long period of time. This may
not cause any serious problem in simple scripts, but its sure causes
trouble while working with larger applications. This pre-defined clean
up actions automatically closes the file after its suite finishes, even
though an exception raised on the way. It can used by the keyword
“with”.
Python Code:
with open('C:\\Users\\sriharshithaghali\\Documents\\mynotes\\examples.txt',
'r') as f:
read_data = f.read()
print(read_data)
f.closed
Output:
True