Exception Handling

In Python, there are several built-in Python exceptions that can be raised when an error occurs
during the execution of a program. Here are some of the most common types of exceptions in
Python:

• SyntaxError: This exception is raised when the interpreter encounters a syntax error in the
code, such as a misspelled keyword, a missing colon, or an unbalanced parenthesis.

• TypeError: This exception is raised when an operation or function is applied to an object of

the wrong type, such as adding a string to an integer.

• NameError: This exception is raised when a variable or function name is not found in the
current scope.

• IndexError: This exception is raised when an index is out of range for a list, tuple, or other
sequence types.

• KeyError: This exception is raised when a key is not found in a dictionary.

• ValueError: This exception is raised when a function or method is called with an invalid
argument or input, such as trying to convert a string to an integer when the string does not
represent a valid integer.

• AttributeError: This exception is raised when an attribute or method is not found on an

object, such as trying to access a non-existent attribute of a class instance.

• IOError: This exception is raised when an I/O operation, such as reading or writing a file, fails
due to an input/output error.

• ZeroDivisionError: This exception is raised when an attempt is made to divide a number by

zero.

• ImportError: This exception is raised when an import statement fails to find or load a
module.

Modules

A document with definitions of functions and various statements written in Python is called a Python
module.

In Python, we can define a module in one of 3 ways

o Python itself allows for the creation of modules.

 o Similar to the re (regular expression) module, a module can be primarily written in C
programming language and then dynamically inserted at run-time.

o A built-in module, such as the itertools module, is inherently included in the interpreter.

A module is a file containing Python code, definitions of functions, statements, or classes. An

example_module.py file is a module we will create and whose name is example_module.

We employ modules to divide complicated programs into smaller, more understandable pieces.
Modules also allow for the reuse of code.

Rather than duplicating their definitions into several applications, we may define our most frequently
used functions in a separate module and then import the complete module.

Here, we are creating a simple Python program to show how to create a module.

# defining a function in the module to reuse it

def square( number ):

# here, the above function will square the number passed as the input

result = number ** 2

return result # here, we are returning the result of the function

Import Module

In Python, we may import functions from one module into our program, or as we say into, another
module.

For this, we make use of the import Python keyword. In the Python window, we add the next to
import keyword, the name of the module we need to import. We will import the module we defined
earlier example_module.

Syntax:

1. import example_module

The functions that we defined in the example_module are not immediately imported into the
present program. Only the name of the module, i.e., example_ module, is imported here.

Lambda function

Python Lambda Functions are anonymous functions means that the function is without a name. As
we already know the def keyword is used to define a normal function in Python. Similarly,
the lambda keyword is used to define an anonymous function in Python.

Python Lambda Function Syntax

Syntax: lambda arguments : expression

• This function can have any number of arguments but only one expression, which is evaluated
and returned.

• One is free to use lambda functions wherever function objects are required.
 • You need to keep in your knowledge that lambda functions are syntactically restricted to a
single expression.

• It has various uses in particular fields of programming, besides other types of expressions in
functions.

Python Lambda Function Example

In the example, we defined a lambda function(upper) to convert a string to its upper case
using upper().

This code defines a lambda function named upper that takes a string as its argument and converts it
to uppercase using the upper() method. It then applies this lambda function to the string
‘GeeksforGeeks’ and prints the result

str1 = 'GeeksforGeeks'

upper = lambda string: string.upper()

print(upper(str1))

LISTS, TUPLES, DICTIONARIES

Lists: list operations, list slices, list methods, list loop, mutability, aliasing, cloning lists, list

parameters, list comprehension; Tuples: tuple assignment, tuple as return value, tuple

comprehension; Dictionaries: operations and methods, comprehension;

Lists, Tuples, Dictionaries:

List:

It is a general purpose most widely used in data structures

List is a collection which is ordered and changeable and allows duplicate members.

(Grow and shrink as needed, sequence type, sortable).

To use a list, you must declare it first. Do this using square brackets and separate

values with commas.

We can construct / create list in many ways.

List operations:

These operations include indexing, slicing, adding, multiplying, and checking for

membership

Basic List Operations:

Lists respond to the + and * operators much like strings; they mean concatenation and

repetition here too, except that the result is a new list, not a string.
Append()

Extend()

Insert()

Pop()

Remove()

Reverse()

Sort()

Delete: Delete a list or an item from a list

Aliasing:

1. An alias is a second name for a piece of data, often easier (and more useful) than

making a copy.

2. If the data is immutable, aliases don’t matter because the data can’t change.

3. But if data can change, aliases can result in lot of hard – to – find bugs.

4. Aliasing happens whenever one variable’s value is assigned to another variable.

Tuples:

A tuple is a collection which is ordered and unchangeable. In Python tuples are written

with round brackets.

Supports all operations for sequences.

Immutable, but member objects may be mutable.

If the contents of a list shouldn’t change, use a tuple to prevent items from accidently being
added, changed, or deleted.

Tuples are more efficient than list due to python’s implementation

Some of the operations of tuple are:

Access tuple items

Change tuple items

Loop through a tuple

Count()

Index()

Length()

Dictionaries:
A dictionary is a collection which is unordered, changeable and indexed. In Python

dictionaries are written with curly brackets, and they have keys and values.

Key-value pairs

Unordered

We can construct or create dictionary like:

X={1:’A’,2:’B’,3:’c’}

X=dict([(‘a’,3) (‘b’,4)]

X=dict(‘A’=1,’B’ =2)

Data types:

The data stored in memory can be of many types. For example, a student roll number is

stored as a numeric value and his or her address is stored as alphanumeric characters. Python

has various standard data types that are used to define the operations possible on them and

the storage method for each of them.

Int:

Int, or integer, is a whole number, positive or negative, without decimals, of unlimited

length.

>>> print(24656354687654+2)

24656354687656

>>> print(20)

20

# To verify the type of any object in Python, use the type() function:

>>> type(10)

<class 'int'>

Float:

Float, or "floating point number" is a number, positive or negative, containing one or more

decimals.

Float can also be scientific numbers with an "e" to indicate the power of 10.

>>> y=2.8

>>> y

2.8
Boolean:

Objects of Boolean type may have one of two values, True or False:

>>> type(True)

<class 'bool'>

String:

1. Strings in Python are identified as a contiguous set of characters represented in the

quotation marks. Python allows for either pairs of single or double quotes.

• 'hello' is the same as "hello".

• Strings can be output to screen using the print function. For example: print("hello").

>>> print("mrcet college")

mrcet college

If you want to include either type of quote character within the string, the simplest way is to

delimit the string with the other type. If a string is to contain a single quote, delimit it with

double quotes and vice versa:

>>> print("mrcet is an autonomous (') college")

mrcet is an autonomous (') college

Suppressing Special Character:

Specifying a backslash (\) in front of the quote character in a string “escapes” it and causes

Python to suppress its usual special meaning. It is then interpreted simply as a literal single

quote character:

>>> print("mrcet is an autonomous (\') college")

mrcet is an autonomous (') college

Functions

Functions and its use: Function is a group of related statements that perform a specific task.

Functions help break our program into smaller and modular chunks. As our program grows

larger and larger, functions make it more organized and manageable. It avoids repetition and

makes code reusable.

Basically, we can divide functions into the following two types:

1. Built-in functions - Functions that are built into Python.

Ex: abs(),all().ascii(),bool()………so on….

integer = -20

print('Absolute value of -20 is:', abs(integer))

Output:

Absolute value of -20 is: 20

2. User-defined functions - Functions defined by the users themselves.

def add_numbers(x,y):

sum = x + y

return sum

print("The sum is", add_numbers(5, 20))

Output:

The sum is 25

Function definition consists of following components:

1. Keyword def indicates the start of function header.

2. A function name to uniquely identify it. Function naming follows the same rules of writing

identifiers in Python.

3. Parameters (arguments) through which we pass values to a function. They are optional.

4. A colon (:) to mark the end of function header.

5. Optional documentation string (docstring) to describe what the function does.

6. One or more valid python statements that make up the function body. Statements must have

same indentation level (usually 4 spaces).

7. An optional return statement to return a value from the function

def hf():

print("hw")

print("gh kfjg 66666")

hf()

The return statement is used to exit a function and go back to the place from where it was

called. This statement can contain expression which gets evaluated and the value is returned.

If there is no expression in the statement or the return statement itself is not present inside a

function, then the function will return the None object.

Arguments
# Passing Arguments

def hello(wish):

return '{}'.format(wish)

print(hello("mrcet"))

Output:

Mrcet

Below is a call to this function with one and no arguments along with their respective error

messages.

>>> wish("MRCET") # only one argument

TypeError: wish() missing 1 required positional argument: 'msg'

>>> wish() # no arguments

TypeError: wish() missing 2 required positional arguments: 'name' and 'msg'

#Keyword Arguments

When we call a function with some values, these values get assigned to the arguments

according to their position.

Python allows functions to be called using keyword arguments. When we call functions in

this way, the order (position) of the arguments can be changed.

There are two advantages - one, using the function is easier since we do not need to

worry about the order of the arguments. Two, we can give values to only those

parameters which we want, provided that the other parameters have default argument values.

#Default Arguments

Function arguments can have default values in Python.

We can provide a default value to an argument by using the assignment operator (=)

def hello(wish,name='you'):

return '{},{}'.format(wish,name)

print(hello("good morning"))

Output:

good morning,you
Note: Any number of arguments in a function can have a default value. But once we have a

default argument, all the arguments to its right must also have default values.

This means to say, non-default arguments cannot follow default arguments.

Variable-length arguments

Sometimes you may need more arguments to process function then you mentioned in the

definition. If we don’t know in advance about the arguments needed in function, we can use

variable-length arguments also called arbitrary arguments.

For this an asterisk (*) is placed before a parameter in function definition which can hold

non-keyworded variable-length arguments and a double asterisk (**) is placed before a

parameter in function which can hold keyworded variable-length arguments.

If we use one asterisk (*) like *var, then all the positional arguments from that point till the

end are collected as a tuple called ‘var’ and if we use two asterisks (**) before a variable like

**var, then all the positional arguments from that point till the end are collected as

a dictionary called ‘var’.

#Program to find area of a circle using function use single return value function with

argument.

pi=3.14

def areaOfCircle(r):

return pi*r*r

r=int(input("Enter radius of circle"))

print(areaOfCircle(r))

Conditional (if):

The if statement contains a logical expression using which data is compared and a decision

is made based on the result of the comparison.

Syntax:

if expression:
statement(s)

If the boolean expression evaluates to TRUE, then the block of statement(s) inside the if

statement is executed. If boolean expression evaluates to FALSE, then the first set of

code after the end of the if statement(s) is executed.

Alternative if (If-Else):

An else statement can be combined with an if statement. An else statement contains the

block of code (false block) that executes if the conditional expression in the if statement

resolves to 0 or a FALSE value.

The else statement is an optional statement and there could be at most only one else

Statement following if.

Syntax of if - else :

if test expression:

Body of if stmts

else:

Body of else stmts

Chained Conditional: (If-elif-else):

The elif statement allows us to check multiple expressions for TRUE and execute a

block of code as soon as one of the conditions evaluates to TRUE. Similar to the else,

the elif statement is optional. However, unlike else, for which there can be at most one

statement, there can be an arbitrary number of elif statements following an if.

Syntax of if – elif - else :

If test expression:

Body of if stmts

elif test expression:

Body of elif stmts

else:

Body of else stmts

Loops
A loop statement allows us to execute a statement or group of statements multiple times as

long as the condition is true. Repeated execution of a set of statements with the help of loops

is called iteration.

Loops statements are used when we need to run same code again and again, each time with a

different value.

Statements:

In Python Iteration (Loops) statements are of three types:

1. While Loop

2. For Loop

3. Nested For Loops

While loop:

Loops are either infinite or conditional. Python while loop keeps reiterating a block of

code defined inside it until the desired condition is met.

The while loop contains a boolean expression and the code inside the loop is

repeatedly executed as long as the boolean expression is true.

The statements that are executed inside while can be a single line of code or a block of

multiple statements.

Syntax:

while(expression):

Statement(s)

For loop

The For Loops in Python are a special type of loop statement that is used for sequential traversal.
Python For loop is used for iterating over an iterable like a String, Tuple, List, Set, or Dictionary.

Python For Loop Syntax

for var in iterable:

# statements

Note: In Python, for loops only implement the collection-based iteration.

Here we will see Python for loop examples with different types of iterables:

Python For Loop with String

This code uses a for loop to iterate over a string and print each character on a new line. The loop
assigns each character to the variable i and continues until all characters in the string have been
processed.
Python

# Iterating over a String

print("String Iteration")

s = "Geeks"

for i in s:

print(i)

Output:

String Iteration
G
e
e
k
s

Python for loop with Range

This code uses a Python for loop with index in conjunction with the range() function to generate a
sequence of numbers starting from 0, up to (but not including) 10, and with a step size of 2. For each
number in the sequence, the loop prints its value using the print() function. The output will show the
numbers 0, 2, 4, 6, and 8.

Python

for i in range(0, 10, 2):

print(i)

Output :

0
2
4
6
8

Iterating over a list:

#list of items

list = ['M','R','C','E','T']

i=1

#Iterating over the list

for item in list:

print ('college ',i,' is ',item)

i = i+1

Iterating over a Tuple:

tuple = (2,3,5,7)

print ('These are the first four prime numbers ')

#Iterating over the tuple

for a in tuple:

print (a)

Iterating over a dictionary:

#creating a dictionary

college = {"ces":"block1","it":"block2","ece":"block3"}

#Iterating over the dictionary to print keys

print ('Keys are:')

for keys in college:

print (keys)

#Iterating over the dictionary to print values

print ('Values are:')

for blocks in college.values():

print(blocks)

Iterating over a String:

#declare a string to iterate over

college = 'MRCET'

#Iterating over the string

for name in college:

print (name)

Nested For loop:

When one Loop defined within another Loop is called Nested Loops.

Syntax:

for val in sequence:

for val in sequence:

48

statements

statements

# Example 2 of Nested For Loops (Pattern Programs)

for i in range(1,6):

for j in range(5,i-1,-1):

print(i, end=" ")

print('')

String slices:

A segment of a string is called a slice. Selecting a slice is similar to selecting a character:

Subsets of strings can be taken using the slice operator ([ ] and [:]) with indexes starting at 0

in the beginning of the string and working their way from -1 at the end.

Slice out substrings, sub lists, sub Tuples using index.

Syntax:[Start: stop: steps]

Slicing will start from index and will go up to stop in step of steps.

Default value of start is 0,

65

Stop is last index of list

And for step default is 1

For example 1−

str = 'Hello World!'

print str # Prints complete string

print str[0] # Prints first character of the string

print str[2:5] # Prints characters starting from 3rd to 5th

print str[2:] # Prints string starting from 3rd character print

str * 2 # Prints string two times

print str + "TEST" # Prints concatenated string

Python codes

1. Correct word

string = input("Enter a string: ")

# replaced_string = replace_consecutive(user_input)

#def replace_consecutive(string):

"""Replace consecutive same alphabets with two alphabets"""

result = ''

i=0

while i < len(string):

count = 1

while i + 1 < len(string) and string[i] == string[i + 1]:

count += 1

i += 1

if count >= 3:

result += string[i] * 2

else:

result += string[i] * count

i += 1

print("String after replacement:", result)

2. Division

num=int(input("Enter a number:"))

d=int(input("Enter the number divisor:"))

while(num):

if(d==0):

print("cannot divide by 0!")

break

else:

result=num/d

print(result)
 break

3. Fibonacci series

range_limit = int(input("Enter the range limit: "))

print("Fibonacci series up to", range_limit, "is:")

fibonacci_series = []

a, b = 0, 1

while a <= range_limit:

fibonacci_series.append(a)

a, b = b, a + b

print(fibonacci_series)

4. For loop

str="BBA-CA 3"

for i in str:

print(i, end=" ")

print()

print("outside of for loop")

5. Magic number

# Take input date

date = input("Enter a date (DD-MM-YYYY format): ")

# Initialize sum

sum = 0

# Iterate through each character in the input date

for char in date:

# Check if the character is a digit

if char.isdigit():

# Convert the digit character to integer and add it to the sum

 sum += int(char)

# Repeat the process until you get a single-digit output

while sum >= 10:

temp_sum = 0

while sum > 0:

temp_sum += sum % 10

sum //= 10

sum = temp_sum

print("Sum of Digits:", sum)

6. String list

list1=["sinha","arvind","aakash","binod","chetan"]

name="aakash"

for i in list1:

if (i==name):

continue

else:

print(i)

7. Print vibgyor

while (True):

str=input("Enter a single characeter: ")

if (str=="r" or str=="R"):

print("Red")

elif (str=="o" or str=="O"):

print("Orange")

elif (str=="y" or str=="Y"):

 print("Yellow")

elif (str=="g" or str=="G"):

print("Green")

elif (str=="b" or str=="B"):

print("Blue")

elif (str=="i" or str=="I"):

print("Indigo")

elif (str=="v" or str=="V"):

print("Violet")

elif (str=="q" or str=="Q"):

break

else:

print("invalid input")

break

8. Prime number

num = int(input("Enter a number: "))

if num <= 1:

print(num, "is not a prime number.")

else:

is_prime = True

for i in range(2, int(num**0.5) + 1):

if num % i == 0:

is_prime = False

break

if is_prime:

print(num, "is a prime number.")

else:

print(num, "is not a prime number.")

9. Check numbers in a string, add them, display sum as output

def extract_numbers(s):
 """Extract numbers from a string"""

numbers = []

current_number = ''

for char in s:

if char.isdigit():

current_number += char

elif current_number:

numbers.append(int(current_number))

current_number = ''

if current_number:

numbers.append(int(current_number))

return numbers

if __name__ == "__main__":

user_input = input("Enter a string: ")

numbers = extract_numbers(user_input)

if numbers:

total_sum = sum(numbers)

print("Sum of numbers in the string:", total_sum)

else:

print("No numbers found in the string.")

Fat 2 questions

1. Create a program that reads a CSV file and extracts specific columns, then

writes the extracted data to a new CSV file.

Solution ->

import csv

def extract_columns(input_file, output_file, columns):

with open(input_file, 'r', newline='') as infile, open(output_file, 'w',

newline='') as outfile:

reader = csv.DictReader(infile)

writer = csv.DictWriter(outfile, fieldnames=columns)

writer.writeheader()

for row in reader:

extracted_row = {col: row[col] for col in columns}

writer.writerow(extracted_row)

# Example usage:

input_file = 'industry.csv'

output_file = 'output.csv'

columns_to_extract = [‘industry’]

extract_columns(input_file, output_file, columns_to_extract)

2. Develop a program that reads a JSON file and converts it to a Python

dictionary.

Solution ->

import json

def json_to_dict(json_file):

with open(json_file, 'r') as file:

data = json.load(file)

return data

# Example usage:

json_file = 'Downloads/example_1.json'

result = json_to_dict(json_file)

print(result) # This will print the converted Python dictionary

3. Develop a function that takes a list of integers and returns a new list

containing only the unique elements, preserving their order.

Solution ->

def unique_elements(input_list):

unique_list = []

seen = set() # To keep track of elements seen so far

for item in input_list:

if item not in seen:

unique_list.append(item)

seen.add(item)

return unique_list

# Example usage:

input_list = [1, 2, 3, 4, 2, 3, 5, 1]

result = unique_elements(input_list)

print(result)

4. Develop a program to find the factorial of a given number using recursion.

Solution ->

def factorial(n):

# Base case: factorial of 0 or 1 is 1

if n == 0 or n == 1:

return 1

# Recursive case: factorial of n is n * factorial(n-1)

else:

return n * factorial(n - 1)

# Example usage:

num = 5

print("Factorial of", num, "is:", factorial(num))

5. Write a Python program to count the number of lines, words, and

characters in a text file.

Solution ->

def count_file_stats(file_path):

line_count = 0

word_count = 0

char_count = 0

with open(file_path, 'r') as file:

for line in file:

# Counting lines

line_count += 1
# Counting words

words = line.split()

word_count += len(words)

# Counting characters

char_count += len(line)

return line_count, word_count, char_count

# Example usage:

file_path = 'sample.txt'

lines, words, characters = count_file_stats(file_path)

print("Number of lines:", lines)

print("Number of words:", words)

print("Number of characters:", characters)

6. Implement a stack and use it to check if a given string of parentheses is

balanced.

Solution ->

class Stack:

def __init__(self):

self.items = []

def is_empty(self):

return self.items == []

def push(self, item):

self.items.append(item)

def pop(self):

if not self.is_empty():

return self.items.pop()

else:

return None

def peek(self):

if not self.is_empty():

return self.items[-1]

else:
 return None

def is_balanced(parentheses):

stack = Stack()

for char in parentheses:

if char in '([{':

stack.push(char)

elif char in ')]}':

if stack.is_empty():

return False

elif (char == ')' and stack.peek() == '(') or \

(char == ']' and stack.peek() == '[') or \

(char == '}' and stack.peek() == '{'):

stack.pop()

else:

return False

return stack.is_empty()

# Example usage:

parentheses_str = "[{()}]"

if is_balanced(parentheses_str):

print("The parentheses are balanced.")

else:

print("The parentheses are not balanced.")

7. Write a program to find the longest consecutive sequence of numbers in a

list.

Solution- >

def longest_consecutive_sequence(nums):

if not nums:

return []

nums.sort()

longest_sequence = [nums[0]]

current_sequence = [nums[0]]
 for i in range(1, len(nums)):

if nums[i] == nums[i - 1] + 1:

current_sequence.append(nums[i])

else:

if len(current_sequence) > len(longest_sequence):

longest_sequence = current_sequence

current_sequence = [nums[i]]

if len(current_sequence) > len(longest_sequence):

longest_sequence = current_sequence

return longest_sequence

# Example usage:

nums = [100, 4, 200, 1, 3, 2, 5, 6, 7, 8, 9]

result = longest_consecutive_sequence(nums)

print("Longest consecutive sequence:", result)

8. Create a program that reads an integer from the user and handles the

ValueError if the input is not an integer.

def read_integer_from_user():

while True:

try:

user_input = input("Please enter an integer: ")

user_integer = int(user_input)

return user_integer

except ValueError:

print("Invalid input! Please enter an integer.")

# Example usage:

user_integer = read_integer_from_user()

print("You entered:", user_integer)

9. Write a function that divides two numbers and handles the

ZeroDivisionError.

Solution ->

def safe_divide(a, b):