The try block is used to run code that might raise an error.
The except block catches and handles any errors that occur in the try block.
The else block runs only if no exceptions were raised in the try block.
The finally block executes no matter what—whether an error occurred or not.
Examples:
try:
print(x)
except:
print("An exception occurred")
Multiple Except:
try:
print(x)
except NameError:
print("Variable x is not defined")
except:
print("Something else went wrong")
With Else:
try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")
Using Finally:
try:
print(x)
except:
print("Something went wrong")
finally:
print("The 'try except' is finished")
Raise an exception
As a Python developer you can choose to throw an exception if a condition occurs.
To throw (or raise) an exception, use the raise keyword.
x = "hello"
if not type(x) is int:
raise TypeError("Only integers are allowed")
def divide_numbers(a, b):
try:
result = a / b
except ZeroDivisionError:
print("Error: Cannot divide by zero.")
else:
print(f"Result is: {result}")
finally:
print("Execution completed.")
# Example usage
divide_numbers(10, 2) # No error
divide_numbers(10, 0) # Triggers exception
Encapsulation is the process of bundling data and methods that operate on that data
within a single unit — typically a class. It helps in hiding internal state and requiring all
interaction to be performed through an object’s methods.
Benefits of Encapsulation:
Improves modularity
Prevents accidental modification
Makes code easier to maintain and debug
class Employee:
def __init__(self, name):
self.Name = name
def set_salary(self,salary):
self.__Salary = salary
def get_salary(self):
return self.__Salary
emp1 = Employee("Mohan")
emp1.set_salary(25000)
emp1.age= 23
print(emp1.get_salary(),emp1.age)
Using @property
class Employee:
allowance = 10000
def __init__(self, name):
self.Name = name
def set_salary(self,salary):
self.__Salary = 10000 + salary
@property
def get_salary(self):
return self.__Salary
emp1 = Employee("Mohan")
emp1.set_salary(25000)
emp1.age= 23
# print(emp1.Name()) #error
print(emp1.get_salary)
# print(emp1.get_salary(),emp1.age)
Using @property and setter
class Employee:
allowance = 10000
def __init__(self, name):
self.Name = name
self.__age = 30
def set_salary(self,salary):
self.__Salary = 10000 + salary
@property
def set_age(self):
return self.__age
@set_age.setter
def set_age(self,a):
self.__age = a
emp1 = Employee("Mohan")
emp1.set_salary(25000)
print (emp1.set_age)
emp1.set_age = 27
print(emp1.set_age)
# print(emp1.Name()) #error
print(emp1.get_salary)
# print(emp1.get_salary(),emp1.age)
Abstraction:
Abstraction means hiding complex implementation details and exposing only the
necessary parts of an object or function.
Benefits of Abstraction
● Simplifies interface
● Reduces complexity
● Improves reusability
Use Case:
● Building APIs
● Game development
● Data analysis tools
● GUI applications
ABCs ensure that subclasses implement specific methods. If they don’t, Python will raise
an error.
ABCs help define a blueprint for other classes. This is useful in large systems where
consistency matters.
from abc import ABC, abstractmethod
class animal(ABC):
@abstractmethod
def speak(self):
print("animal Speaks")
class dog(animal):
def speak(self):
print("Dog barks")
super().speak()
class cat(animal):
def speak(self):
print("cat meow")
def sound(obj):
obj.speak()
d =dog()
c= cat()
sound(d)
sound(c)
sound(animal())
Feature With ABC :
● Compile-time Method enforcement
● Early (safer) Error timing
● Code quality: High (explicit declaration )
● Preferred to Use in real-world projects
Exception Description
ArithmeticError Raised when an error occurs in numeric calculations
AssertionError Raised when an assert statement fails
AttributeError Raised when attribute reference or assignment fails
Exception Base class for all exceptions
EOFError Raised when the input() method hits an "end of file" condition (EOF)
FloatingPointError Raised when a floating point calculation fails
GeneratorExit Raised when a generator is closed (with the close() method)
ImportError Raised when an imported module does not exist
IndentationError Raised when indentation is not correct
IndexError Raised when an index of a sequence does not exist
KeyError Raised when a key does not exist in a dictionary
KeyboardInterrupt Raised when the user presses Ctrl+c, Ctrl+z or Delete
LookupError Raised when errors raised cant be found
MemoryError Raised when a program runs out of memory
NameError Raised when a variable does not exist
NotImplementedError Raised when an abstract method requires an inherited class to override the
method
OSError Raised when a system related operation causes an error
OverflowError Raised when the result of a numeric calculation is too large
ReferenceError Raised when a weak reference object does not exist
RuntimeError Raised when an error occurs that do not belong to any specific exceptions
StopIteration Raised when the next() method of an iterator has no further values
SyntaxError Raised when a syntax error occurs
TabError Raised when indentation consists of tabs or spaces
SystemError Raised when a system error occurs
SystemExit Raised when the sys.exit() function is called
TypeError Raised when two different types are combined
UnboundLocalError Raised when a local variable is referenced before assignment
UnicodeError Raised when a unicode problem occurs
UnicodeEncodeError Raised when a unicode encoding problem occurs
UnicodeDecodeError Raised when a unicode decoding problem occurs
UnicodeTranslateError Raised when a unicode translation problem occurs
ValueError Raised when there is a wrong value in a specified data type
ZeroDivisionError Raised when the second operator in a division is zero
