Function
Syntax
def functionname(parameters ):
function_suite
return [expression]
Example
def my_function():
print("Hello from a function")
my_function()
Output:
Hello from a function
Arithmetic operation using Function
def add(a,b):
c=a+b
print("add:",c)
def sub(a,b):
c=a-b
print("sub:",c)
def mul(a,b):
c=a*b
print("Mulitiplication:",c)
def divi(a,b):
c=a//b
print("Division:",c)
def rem(a,b):
c=a%b
print("Remainder:",c)
a = int(input("Enter number A: "))
b = int(input("Enter number B: "))
add(a,b)
sub(a,b)
mul(a,b)
divi(a,b)
rem(a,b)
Output :
function with return
def func1():
print ("I am learning Python function")
print ("still in func1")
func1()
def square(x):
return x*x
print(square(4))
def multiply(x=5,y=0):
print("value of x=",x)
print("value of y=",y)
return x*y
print(multiply(y=2,x=4))
Output :
Return the String
def printme(str):
return(str)
string ="This prints a passed string into this function"
str1=printme(string)
print(str1)
Output :
This prints a passed string into this function
Global vs. Local variables
total = 0; # This is global variable.
def sum( arg1, arg2 ):
total = arg1 + arg2; # Here total is local variable.
print ("Inside the function local total : ", total)
return total;
a = int(input("Enter number A: "))
b = int(input("Enter number B: "))
sum(a, b);
print ("Outside the function global total : ", total)
Output :
Enter number A: 20
Enter number B: 30
Inside the function local total :50
Outside the function global total : 0
Multiple Calling
def my_function(fname):
print(fname + " Reference")
my_function("Emil")
my_function("Whatsup")
my_function("Telegram")
Output :
Emil Reference
Whatsup Reference
Telegram Reference
Default Parameter Value
If we call the function without argument, it uses the default value:
def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
Output :
I am from Sweden
I am from India
I am from Norway
I am from Brazil
The pass Statement
function definitions cannot be empty, but if you for some reason have a function definition with
no content, put in the pass statement to avoid getting an error.
def myfunction():
pass
Python program for simple calculator
def add(num1, num2):
return num1 + num2
def subtract(num1, num2):
return num1 - num2
def multiply(num1, num2):
return num1 * num2
def divide(num1, num2):
return num1 / num2
print("Please select operation -\n" \
"1. Add\n" \
"2. Subtract\n" \
"3. Multiply\n" \
"4. Divide\n")
select = int(input("Select operations form 1, 2, 3, 4 :"))
number_1 = int(input("Enter first number: "))
number_2 = int(input("Enter second number: "))
if select == 1:
print(number_1, "+", number_2, "=",add(number_1, number_2))
elif select == 2:
print(number_1, "-", number_2, "=", subtract(number_1, number_2))
elif select == 3:
print(number_1, "*", number_2, "=",multiply(number_1, number_2))
elif select == 4:
print(number_1, "/", number_2, "=",divide(number_1, number_2))
else:
print("Invalid input")
Output:
CLASSES AND OBJECTS
A class in Python serves as a blueprint for creating objects. It encapsulates data (attributes) and
functionality (methods) related to those objects. Classes provide a way to define custom data
types, enabling the creation of complex structures.
An object can be defined as a data field that has unique attributes and behavior
class and objects
class MyClass:
variable = "BALA"
myobjectx = MyClass()
print(myobjectx.variable)
output: BALA
class with function
class Person:
def greet(self):
print('Hello')
harry = Person()
harry.greet()
output: 'Hello'
class with function Return and Parameters
class add:
def findsum(self, n1, n2):
sum = n1 + n2
return sum
n1 = 100
n2 = 50
Obj = add()
sum =Obj.findsum(n1, n2)
print("The sum of two numbers is: ", sum)
Output: The sum of two numbers is: ", 150
class with function and Parameters
class add:
def findsum(self, n1, n2):
print(n1,n2)
n1 = input("enter name")
n2 = int(input("enter age"))
Obj = add()
sum =Obj.findsum(n1, n2)
Output: senthil,23
Constructor Program with class
class Employee:
def __init__(self, name, age):
self.name = name
self.age = age
def details(self):
print("Employee Name:", self.name)
print("Employee Age:", self.age)
emp = Employee("Sam", 36)
emp.details()
Output:
Employee Name: Sam
Employee Age: 36
Bank Program with class
class bank:
def __init__(self,lno,amo):
self.lno=lno
self.amo=amo
def loan(self):
print("Loan number :",self.lno)
print("Amount :",self.amo)
intr=self.amo*(2/100)
print("Interest : ", intr)
n1 = input("Enter loan number")
n2 = int(input("Enter Amount"))
ba = bank(n1, n2)
ba.loan()
Output:
Enter loan number : 8963
Enter Amount: 50000
Loan number: 8963
Amount: 50000
Interest : 2500.0
INHERITANCE
Inheritance is defined as the capability of one class to derive or inherit the properties from some
other class and use it whenever needed.
Example :
class Child:
def __init__(self, name):
self.name = name
def getName(self):
return self.name
class Student(Child):
std = Child("Ram")
nam=std.getName()
print("Name:",nam)
Output:
Name: Ram
Single Inheritance: Single inheritance enables a derived class to inherit properties from a single
parent class, thus enabling code reusability and the addition of new features to existing code.
class Parent:
def func1(self):
print("This function is in parent class.")
class Child(Parent):
def func2(self):
print("This function is in child class.")
object = Child()
object.func1()
object.func2()
Output:
This function is in parent class.
This function is in child class.
Multiple Inheritance: When a class can be derived from more than one base class this type of
inheritance is called multiple inheritance. In multiple inheritance, all the features of the base
classes are inherited into the derived class.
class Mother:
def mother(self):
print(self.mothername)
class Father:
def father(self):
print(self.fathername)
# Derived class
class Son(Mother, Father):
def parents(self):
print("Father :", self.fathername)
print("Mother :", self.mothername)
# Driver's code
s1 = Son()
s1.fathername = "RAM"
s1.mothername = "SITA"
s1.parents()
Output:
Father : RAM
Mother : SITA
Multilevel Inheritance: In multilevel inheritance, features of the base class and the derived class
are further inherited into the new derived class. This is similar to a relationship representing a
child and grandfather.
Employee Salary Calculation
class emp:
eno=int(input("Enter Emp no:"))
nam=(input("Enter Emp Name:"))
des=(input("Enter Emp Desigination:"))
def dispaly(self):
print("Emp no:",self.eno)
print("Emp Name:",self.nam)
print("Emp Desigination:",self.des)
class salary (emp):
bpay=int(input("Enter Emp Bpay:"))
hra=int(input("Enter Emp HRA:"))
da=int(input("Enter Emp DA:"))
def result(self):
ns=self.bpay+self.hra+self.da
print("Net Salary :",ns)
class sign:
sa=salary()
sa.dispaly()
sa.result()
Output:
Enter Emp no : 85630
Enter Emp Name: Raja
Enter Emp Desigination: Manager
Enter Emp Bpay: 25000
Enter Emp HRA:2000
Enter Emp DA:3000
Emp no : 85630
Emp Name: Raja
Emp Desigination: Manager
Net Salary : 30000
class emp:
no=int(input("enter employee no: "))
name=input("enter employee name: ")
des=input("enter designation: ")
def display(self):
print("employee no: ",self.no)
print("employee name: ",self.name)
print("designation: ",self.des)
class salary(emp):
bp=int(input("enter employee bpay: "))
hra=int(input("enter employee hra: "))
da=int(input("enter employee da: "))
ns=bp+hra+da
def result(self):
print("employee bp: ",self.bp)
print("employee hra: ",self.hra)
print("da: ",self.da)
print("net salary: ",self.ns)
class bonus(salary):
n=int(input("enter increment:"))
def out(self):
bo=self.ns+self.n
print("Increment salary: ",bo)
e=bonus()
e.display()
e.result()
e.out()
Output:
Enter Emp no : 85630
Enter Emp Name: Raja
Enter Emp Desigination: Manager
Enter Emp Bpay: 25000
Enter Emp HRA:2000
Enter Emp DA:3000
Enter increment:1000
Emp no : 85630
Emp Name: Raja
Emp Desigination: Manager
Net Salary : 30000
Increment salary:31000
Hierarchical Inheritance: When more than one derived classes are created from a single base
this type of inheritance is called hierarchical inheritance. In this program, we have a parent
(base) class and two child (derived) classes .
class Parent:
def func1(self):
print("This function is in parent class.")
class Child1(Parent):
def func2(self):
print("This function is in child 1.")
class Child2(Parent):
def func3(self):
print("This function is in child 2.")
class Child3(Parent):
def func4(self):
print("This function is in child 3.")
object1 = Child1()
object2 = Child2()
object3 = Child3()
object1.func1()
object1.func2()
object2.func1()
object2.func3()
object3.func1()
object3.func4()
Output:
This function is in parent class.
This function is in child 1.
This function is in parent class.
This function is in child 2.
This function is in parent class.
This function is in child 3.
Hybrid Inheritance: Inheritance consisting of multiple types of inheritance is called hybrid
inheritance
class School:
def func1(self):
print("This function is in school.")
class Student1(School):
def func2(self):
print("This function is in student 1. ")
class Student2(School):
def func3(self):
print("This function is in student 2.")
class Student3(Student1, Student2):
def func4(self):
print("This function is in student 3.")
object = Student3()
object.func1()
object.func2()
object.func3()
object.func4()
Output:
This function is in school
This function is in student 1
This function is in student 2
This function is in student 3
