0% found this document useful (0 votes)

34 views257 pages

Data Science - Python Programme Tutorial

The document provides a comprehensive guide to Python programming, covering topics such as variables, operators, control statements, and application types. It includes practical examples and exercises to illustrate concepts like memory allocation, data types, and arithmetic operations. The content is structured with a table of contents and detailed explanations aimed at beginners in Python programming.

Uploaded by

Meesala Madhu mukesh

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

34 views257 pages

Data Science - Python Programme Tutorial

Uploaded by

Meesala Madhu mukesh

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

Affordable AI Education

PYTHON (Simplified)

SRINIVAS GARAPATI

Manyavar Building 3rd Floor, MIG 221 Road No.2, KPHB Phase-1 Colony, Kukatpally Hyderabad Telangana 500085
[Link] Contact – 98859 46789
Contents

S No Topics Page Num

01 Introduction to Python 02
02 Python Variables 08
03 Python Operators & Control Statements 10
04 Python input() 15
05 Data conversion functions 16
06 Python Loops 33
07 Pattern Programs 51
08 Python Functions 74
09 Python OOPS 84
10 Access Modifiers 100
11 Python Inheritance 105
12 Exception Handling 116
13 Inner Classes 124
14 Python Modules 128
15 Multi Threading 134
16 Python Strings 143
17 Collection Data types 151
18 List Collection 152
19 Tuple, Set and Dictionary 168
20 File Handling, CSV Module, Pickle Module 178
21 Lambda expressions 192
22 Map() andFilter() 194
23 CommandLine Arguments 196
24 PIP 201
25 DatabaseConnectiviry 203
26 Tkinter–GUI 219
27 RegularExpressions 228
28 Datetimeand Calendar modules 232
29 OS module 234
30 Python–Numpy 235
31 Python–Pandas 240
32 Python-MatPlotLib 248
33 GarbageCollection 252
34 NestedFunctions, Closures & Decorators 255

[Link] Contact – 98859 46789 Page - 1

Introduction to Python

Introduction:
• Using Programming languages and technologies we develop applications.
• Applications are used to store data and perform operations on data.

Types of applications:
Standalone apps:
• The application runs from single machine.
• Internet connection is not required to run the application.
• Application needs to be installed on machine.
• Examples: VLC, MS-office, Anti-virus, Browser, Programming languages.

Web apps:
• The application runs from multiple machines in a network.
• Internet connection is required to run the application.
• Application installed in server and run from the clients.
• Examples: Gmail, YouTube, IRCTC, Flip Kart etc.

Download python:
• Python is an Open-Source Technology.
• We can download and install Python software from official website [Link]

Python is used to develop both Standalone and Web applications:

• Core + Advance python + GUI + DBMS = Standalone app development
• Core + Advance + DBMS + HTML + CSS + JavaScript + Django = Web app develop

[Link] Contact – 98859 46789 Page - 2

Translators:
• Programmer can define only source code.
• We need to convert the source code into binary code before run.
• We use 2 translators to convert Source code into byte code.
o Compiler
o Interpreter

Compiler:
• Compiler checks the source code syntactically correct or not.
• If we define the code correctly, it converts source code into byte code.
• Compiler shows error message with line number if there is a syntax error.

Note: Java programming language use compilation

class Program
{
public static void main(String[] args)
{
int a=10;
[Link]("a val : " + a);
int b=20;
[Link]("b val : " + b);
[Link]("c val : " + c);
}
}
Compile: Error @ line – 11 (variable “c” not present)

[Link] Contact – 98859 46789 Page - 3

Interpreter:
• Line by line translation of source code into binary code.
• Python uses interpreter for program execution.

Note: Python programming uses interpretation

a=10
print("a val :",a)
b=20
print("b val :",b)
print("c val :",c)

Output: a val : 10
b val : 20
NameError: name 'c' is not defined

Python(Programming & Scripting):

• Programming language are directly used to develop applications.
o Examples: C, C++, PythonJava, .Net etc.
• Scripting languages always run from another program.
o Examples: JavaScript, TypeScript, Python….

Program:
• A set of instructions.
• Program runs alone.

Script:
• Script is a set of Instructions
• Scripts is a program that always execute from another program.
• JavaScript is the best example of Scritping language.
• JavaScript code always run with HTML program.

[Link] Contact – 98859 46789 Page - 4

Python is Dynamic:
• Every programming language is used to develop applications
• Application is used to store and process the data.
• Generally we allocate memory to variables in 2 ways
1. Static memory allocation
2. Dynamic memory allocation

Static memory:
• Static means “fixed memory”
• The languages which are supporting primitive types allowed allocating static memory.
• Primitive variable size and type are fixed.
• Primitive variable stores data directly.
• Compiler raises error when data limit or type is deviated from specified.

[Link] Contact – 98859 46789 Page - 5

Dynamic memory:
• Python is dynamic.
• Dynamic memory means type and size of data can vary.
• Python can store information in Object format.
• Dynamic variables cannot store the data directly.
• Dynamic variables store the reference of Object which holds data.
• In Python, object location changes every time when we modify the data.

>>> a=10
>>> print(a)
10
>>> print("Address :",id(a))
Address : 1628169120
>>> a=a+15
>>> print(a)
25
>>> print("Address :",id(a))
Address : 1628169360

>>> a="python"
>>> print(a)
python
>>> print("Address :",id(a))
Address : 48576832

[Link] Contact – 98859 46789 Page - 6

Edit and Run python program:

Working with IDLE:

• Once python installed, we can open IDLE by searching its name.
• A shell window will be opened where we can run only commands.

Writing and executing programs:

• We can write and execute programs from editor
• Go to File menu
• Select “new” file – Opens an editor
• Write code and Save with .py extension
• Run – with shortcut f5

[Link] Contact – 98859 46789 Page - 7

Python Variables

Variable: Variable is an identity of memory location. Variable is used to store data of program.

You can assign any value to a variable using the "=" operator.
x = 10

Variables can be of different types in Python, such as integer, float, string, boolean, etc.
age = 25
height = 5.7
name = "Amar"
is_student = True

You can assign the same value to multiple variables at once using the "=" operator.
x=y=z=0

Variables can be updated with new values as the program runs.

x = 10
x=x+1

Variables can be deleted using the "del" keyword.

x = 10
del x

Python allows you to assign values to variables in a single line

x, y, z = 10, 20, 30
Python variables are case-sensitive, which means "a" and "A" are different variables.
a = 10
A = 20

You can use underscores in variable names for better readability.

my_variable = 10

Practice Codes on Variables

Define variable and display:

a = 42
print(a)

Print with message:

a = 10
print("a value =", a)

[Link] Contact – 98859 46789 Page - 8

Print a value using f-string:
a = 10
print(f"a value = {a}")

Printing a and b values:

a=10
b=20
print(a,b)

Print a and b values in different lines:

a=10
b=20
print(a,"\n",b)

Print a, b values in different line using f-string:

a=10
b=20
print(f"{a}\n{b}")

Print values in different lines with messages:

a=10
b=20
print(f"a val = {a}")
print(f"b val = {b}")

Declare variables in same line:

a,b,c = 10,20,30
print(f"{a},{b},{c}")

Declare and print details or employee:

num=101
name='Amar'
salary=35000
gender='M'
married=False
print("Details : ",num, name, salary, gender, married)

Display using f-string:

num=101
name='Amar'
salary=35000
gender='M'
married=False
print(f"Details : {num}, {name}, {salary}, {gender}, {married}")

[Link] Contact – 98859 46789 Page - 9

Operators and Control Statements
Operator:
• Operator is a symbol that performs operation on one or more operands.
• The member on which operator operates is called the operand.
• In the expression a = 5+9,
a, 5,9 are operands
=, + are operators

Arithmetic operators:
Arithmetic operators are used to perform mathematical operations like addition,
subtraction, multiplication etc.
Operators are +, - , * , / , % , // , **

Operator Meaning Example

+ Add 2 operands X+Y
- Subtract right from left X-Y
* Multiply 2 operands X*Y
/ Divide left with right X/Y
% Divide and returns Remainder X%Y
// Floor division – return integer part from result X//Y
** Exponent - left operand raised to the power of right X**Y

Division ( / ) : Operator divide and returns quotient. Result is float value.

Remainder (%): It returns the remainder after division. It performs operation only on integers.
Division Mod
>>> 5/2 >>> 5%2
2.5 1
>>> 10/3 >>> 10%4
3.3333333333333335 2
>>> 10/5 >>> 5.0%2.5
2.0 0.0
>>> 5.0%2
1.0

Practice worksheet

a=10; a a=5; a
a=20; a=a+1;
a=30; a=a+1;
a=40; a=a+1;
a=50; a=a+1;
print(a); print(a);
a=5; a a=15; a
a=a+1; a=a+5;
a=a+2; a=a+4;
a=a+3; a=a+3;
a=a+4; a=a+4;
print(a); print(a);
a=5, x=1; a a=5, b=5; a
a=a+x; a=a+b;
x = x+1; b = b-1;
a=a+x; a=a+b;
x = x+1; x b= b-1; b
a=a+x; a=a+b;
x = x+1; b = b-1;
a=a+x; a=a+b;
print(a, x); print(a,b);

n=2; n s n=2; n c
s=n*n; c=n*n*n;
print(s); print(c);

[Link] Contact – 98859 46789 Page - 11

n=2; s c bal=5000; bal amt
s=n*n; amt=3500;
c=n*n*n; bal = bal+amt;
print(s+c); print(bal);

a=5, b=3; a b c a=5, b=3; a b

c=a+b; a=b;
print(c); b=a;
print(a,b);

a=5, b=3, c; a b c a=2, b=3; a b

c=a; a=a+b;
a=b; b=a+a;
b=c; print(a,b);
print(a,b);
a=2, b=3; a b a=2, b=3; a b
a=a+b; a=a*b;
b=a-b; b=a//b;
a=a-b; a=a//b;
print(a,b); print(a,b);

n=234; n d n=234; n d
d=n%10; d=n//10;
print(d); print(d);

sum=0, i=1; i sum fact=1, i=1; i fact

sum=sum+i; fact=fact*i;
i=i+1; i=i+1;
sum=sum+i; fact=fact*i;
i=i+1; i=i+1;
sum=sum+i; fact=fact*i;
i=i+1; i=i+1;
sum=sum+i; fact=fact*i;
print(sum); print(fact);

[Link] Contact – 98859 46789 Page - 12

n=2345, sum=0; n=2345, rev=0;

sum=sum+n%10; rev=rev*10+n%10;
n=n//10; n=n//10;

print(sum, n); Print(rev, n);

Practice codes on Arithmetic operators

Adding 2 numbers:
a=10
b=20
print("Sum = ", a+b)

Display with fString:

a=10
b=20
print(f"Sum = {a+b}")

Perform All arithmetic operations:

a,b=5,2 print(f"{a} + {b} =
{a+b}") print(f"{a} - {b} =
{a-b}") print(f"{a} * {b} =
{a*b}") print(f"{a} / {b} =
{a/b}") print(f"{a} // {b} =
{a//b}") print(f"{a} % {b} =
{a%b}") print(f"{a} ** {b} =
{a**b}")

[Link] Contact – 98859 46789 Page - 13

Display Last digit of given number:
num = 356
last = num%10
print(f"Last Digit of {num} is {last}")

Remove Last digit from given number:

num = 356
print(f"Given num = {num}")
num = num//10
print(f"After removal : {num}")

Average of 4 numbers:
a,b,c,d=5,2,8,6
sum=a+b+c+d
avg=sum/4
print(f"Given nums : {a},{b},{c},{d}")
print(f"Sum = {sum}")
print(f"Average = {avg}")

Swapping 2 numbers:
a,b = 5, 3
print(f"Before swap : {a},{b}")
a,b = b,a
print(f"After swap : {a},{b}")

Find the sum of first n numbers:

n = 10
sum = (n*(n+1))//2
print(f"Sum of first {n} nums is : {sum}")

Find the total price for quantity of fruits purchased:

quantity = 50
price = 55.50
total = (quantity/12)*price
print("Total price is : ", total)

[Link] Contact – 98859 46789 Page - 14

Python Input()

Reading input from End-user :

• The input() function is used read data from user.
• The function prompts the message to enter the value
o input(prompt)
• The function waits for the user to enter the value followed by pressing the "Enter" key.
• The function reads the input as string.

Reading the name and display:

print("Enter your name :")
name = input()
print("Hello,",name)

We can give the prompt while reading input

name = input("Enter your name : ")
print("Hello,",name)

Every input value will be returned in String format only.

print("Enter 2 numbers :")
a = input()
b = input()
c = a+b # "5" + "6" = "56"
print("Sum :",c)

We need to convert the string type input values into corresponding type to perform
operations.
int( ) :

• It is pre-defined function
• It can convert input value into integer type.
• On success, it returns integer value
• On failure(if the input is not valid, raised error)

Adding 2 numbers
print("Enter 2 numbers :")
a= input()
b= input()
c= int(a)+int(b)
print("Sum :",c)

[Link] Contact – 98859 46789 Page - 15

Data Conversion Functions
int( ) :
• It is pre-defined function
• It can convert input value into integer type.
• On success, it returns integer value
• On failure(if the input is not valid, raised error)

>>> int(10)
10
>>> int(23.45)
23
>>> int(True)
1
>>> int(False)
0
>>> int("45")
45
>>> int("python") # Error : Invalid input

Adding 2 numbers:
print("Enter 2 numbers :")
a = input()
b = input()
c = int(a)+int(b)
print("Sum :",c)

We can give the prompt directly while calling input() function.

x = int(input("First Num :"))
y = int(input("Second Num :"))
print("Sum : ",x+y)

float() :
• converts the input value into float type.
• Raise error if the input is not valid.

>>> float(2.3)
2.3
>>> float(5)
5.0
>>> float(True)
1.0
>>> float("3.4")
3.4

[Link] Contact – 98859 46789 Page - 16

>>> float("abc")
ValueError: could not convert string to float: 'abc'

bool():
• Returns a boolean value depends on input value.
• boolean values are pre-defiend (True , False)
>>> bool(True)
True
>>> bool(-13)
True
>>> bool(0.0013)
True
>>> bool(0)
False
>>> bool("abc")
True
>>> bool(" ")
True
>>> bool("")
False
>>> bool(False)
False
>>> bool("False")
True

str(): convert any input int string type.

>>> str(3)
'3'
>>> str(2.3)
'2.3'
>>> str(True)
'True'

bin(): Returns binary value for specified decimal value.

>>> bin(10)
'0b1010'
>>> bin(8)
'0b1000'

[Link] Contact – 98859 46789 Page - 17

Character System:
• File is a collection of bytes.
• Every symbol occupies 1 byte memory in File.
• Every symbol stores into memory in binary format.
• Symbol converts into binary based on its ASCII value.
• Character system is the representation of all symbols of a language using constant
integer values.
• Examples are ASCII and UNICODE.

ASCII : (Americans Standard Code for Information Interchange)

• Represents all symbols 1 language using constants
• The range is 0 - 255
• A language is at most having 256 symbols.
• 1 byte range is (0-255) - 2^8 value
• Hence we represent a symbol using 1 byte memory.

A-65 a-97 0-48 #-35

B-66 b-98 1-49 $-36
.. .. .. ..
.. .. .. ..
Z-90 z-122 9-57 ..
___________________________________________
26 + 26 + 10 + 150 < 256 symbols
___________________________________________

chr(): Return the symbol for specified integer value.

ord():Returns the integer for specified symbol.

>>> chr(65)
'A'
>>> chr(50)
'2'
>>> ord('a')
97
>>> ord('$')
36
>>> ord('1')
49

[Link] Contact – 98859 46789 Page - 18

Programs On Arithmetic Operators

Adding 2 numbers:

num1 = float(input("Enter the first number: "))

num2 = float(input("Enter the second number: "))
sum = num1 + num2
print("The sum of", num1, "and", num2, "is", sum)

Program to display the last digit of given number:

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

last_digit = num % 10
print("The last digit of", num, "is", last_digit)

Progam to remove last digit of given number:

num = int(input("Enter a number: "))
num = num//10
print("The number with the last digit removed is", num)

Swapping 2 number without third variable:

num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
num1, num2 = num2, num1 print("After

swapping:")
print("num1 =", num1)
print("num2 =", num2)

Calculate Total price for the given quantity of fruits:

print("Enter quantity of fruits : ")
quantity = int(input())
print("Enter price per dozen : ")
price = float(input())
total = (quantity/12)*price
print("Total price is : ", total)

[Link] Contact – 98859 46789 Page - 19

Relational Operators:
• Operators are > , < , >= , <= , == , !=
• These operators validate the relation among operands and return a boolean value.
• If relation is valid returns True else False

Program to understand Relational operators:

print("Relational operations")
print("5>3 :", 5>3)
print("5==3 :", 5==3)
print("5<3 :", 5<3)
print("5!=3 :", 5!=3)
print("5>=3 :", 5>=3)
print("5<=3 :", 5<=3)

Writing Conditions using Arithmetic & Relational Operations

Conditionto check the number is Positive or Negative:
Variables Condition Testing
Valid case Invalid case
n=13 n=-5
intn= ? n >= 0 13>=0 -5>=0
true false

Conditionto check the number is equal to zero

Condition to check the 2 numbers equal

Condition to check First Num greater than Second Num

Condition to check Square of the First Number equals to Second Number

Condition to check sum of 2 numbers equal to 10

Condition to check multiplication of first 2 numbers equal to 3 rd

Condition to check the number divisible by 7

[Link] Contact – 98859 46789 Page - 20

Condition to check the number is even

Condition to check the last digit of given Number is 0

Condition to check the last digit of Number divisible by 3

Condition to check the multiplication of first 2 numbers equal to square of 3 rd number

Condition to check the last digits of both numbers equal

Condition to check the sum of last digits of given two numbers is equals to 10

Condition to check average of 4 subjects marks greater than 60

Condition to check the sum of First 2 numbers equals to last digit of 3 rd num

Condition to check average of 3 numbers equals to first number

Condition to check the given quantity of fruits exactly in dozens

Condition to check the square of last digit is greater than 10

Condition to check square of last digit of given number divisible by 3

[Link] Contact – 98859 46789 Page - 21

If-else Conditional Statement:

Checkthe Number is Zero or Not

n=int(input("Enter number : "))
if(n==0):
print("Number equals to zero")
else:
print("Number is not zero")

Checkthe Number is Positive or Not

n=int(input("Enter number : "))
if(n>=0):
print("Positive Number")
else:
print("Negative Number")

Checkthe 2 numbers equal or not

n1=int(input("Enter First num : "))
n2=int(input("Enter Second num : "))
if(n1==n2):
print("Equal numbers")
else:
print("Not equal Numbers")

Checkthe first number greater than second number or not

n1=int(input("Enter First num : "))
n2=int(input("Enter Second num : "))
if(n1>n2):
print("First Number is big")
else:
print("Second Number is big")

[Link] Contact – 98859 46789 Page - 22

Check the person eligible for vote or not
age = int(input("Enter age : "))
if(age>=18):
print("Eligible for vote")
else:
print("Not eligible for vote")

Check the number is divisible by 7 or not

num = int(input("Enter number : "))
if(num%7==0):
print("Divisible by 7")
else:
print("Not divisible by 7")

Check the number is even or not

num = int(input("Enter number : "))
if(num%2==0):
print("Even Number")
else:
print("Not Even")

Checkthe last digit of number is zero or not

num=int(input("Enter number : "))
if(num%10==0):
print("Last digit is zero")
else:
print("Last digit is not zero")

Checklast digits of given 2 numbers equal or not

n1=int(input("Enter First number : "))
n2=int(input("Enter Second number : "))
if(n1%10 == n2%10):
print("Equal")
else:
print("Not equal")

Checkthe last digit of number is divisible by 3 or not

n=int(input("Enter num : "))
if((n%10)%3==0):
print("Last digit divisible by 3")
else:
print("Not divisible")

[Link] Contact – 98859 46789 Page - 23

Logical operators: These operators returns True or False be validating more than one
expression

Operator Meaning Example

and True if both the operands are true x and y
or True if either of the operands is true x or y
not True if operand is false (complements the operand) not x

And examples: Or examples: Not examples:

>>> True and True >>> False or False >>> not True
True False False
>>> 5>3 and 3>2 >>> False or True >>> not False
True True True
>>> True and False >>> True or False >>> not 5>3
False True False
>>> False and True >>> True or True >>> not 3!=3
False True True
>>> False and False >>> 3>5 or 5>2
False True
>>> 5>3 and 5!=5
False

Write conditions for following

1. Writethecondition to check FirstNum isgreater than bothSecond &Third Nums

2. Condition to check the number divisible by both 3 and 5

3. Condition to check the number is in between 30 and 50

4. Condition to check the number is 3 digits number

5. Condition to check the student passed in all 5 subjects

6. Condition to check the character is Vowel

7. Condition to check the character is Upper case alphabet

[Link] Contact – 98859 46789 Page - 24

8. Condition to check the character is digit

9. Condition to check the character is Alphabet

10. Condition to check the character is Symbol

11. Condition to check the 3 numbers equal

12. Condition to check any 2 numbers equal or not among the 3 numbers

13. Condition to check the 3 numbers are unique or not

Program to check the Number Divisible by both 3 and 5:

n = int(input("enter number : "))
if n%3==0 and n%5==0:
print("Divisible by 3 and 5")
else:
print("Not divisible")

Check the person age between 20 and 50:

age = int(input("enter age : "))
if age>=20 and age<=50:
print("Age between 20 and 50")
else:
print("Not in between")

Check the Number is Single Digit or Not:

n = int(input("enter num : "))
if n>=0 and n<=9:
print("Single Digit")
else:
print("Not Sigle Digit")

Check the Character is Upper case Alphabet or Not:

ch = input("enter character : ")
if ch>='A' and ch<='Z':
print("Upper case Alphabet")
else:
print("Not")

[Link] Contact – 98859 46789 Page - 25

Check the Character is Lower case Alphabet or Not:
ch = input("enter character : ")
if ch>='a' and ch<='z':
print("Lower case Alphabet")
else:
print("Not")

Check the Character is Digit or Not:

ch = input("enter character : ")
if ch>='0' and ch<='9':
print("Digit")
else:
print("Not")

Character is Vowel or Not:

ch = input("enter character : ")
if ch=='a' or ch=='e' or ch=='i' or ch=='o' or ch=='u':
print("Vowel")
else:
print("Not")

Check the Character is Alphabet or Not:

ch = input("enter character : ")
if((ch>='A' and ch<='Z') or (ch>='a' and ch<='z')):
print("Alphabet")
else:
print("Not")

Check the Student passed in all 3 subjects or not with minimum 35 marks:
subj1 = int(input("Enter subj1 score: "))
subj2 = int(input("Enter subj2 score: "))
subj3 = int(input("Enter subj3 score: "))
if subj1 >= 35 and subj2 >= 35 and subj3 >= 35:
print("Pass")
else:
print("Fail")

Check A greater than both B and C:

x, y, z = 10, 30, 20
if(x>y and x>z):
print("Yes")
else:
print("No")

[Link] Contact – 98859 46789 Page - 26

If-block: Execute a block of instructions only if the given condition if true

Print Bill Amount of Customer:

# Get the bill amount from the user
bill = float(input("Enter bill : "))
print("Pay :", bill)

Give 15% bill amounttoeverycustomer:

# Get the bill amountfromtheuser
bill = float(input("Enterbill:"))

# Calculatethediscount(15%ofthebill)
discount = 0.15 * bill

# Applythediscounttothebill
bill -=discount

# Printthefinalbillamount
print("Pay :", bill)

Programtogive20%discounttocustomer if the bill amount is > 5000

# Get the bill amount from the user
bill = float(input("Enter bill : "))
#Checkifthebillisgreaterthanorequal to 5000
if bill >= 5000:

#Calculatethediscount(15%ofthe bill)
discount = 0.15 * bill
# Apply the discount to the bill
bill -= discount

# Print the final bill amount

print("Pay :", bill)

[Link] Contact – 98859 46789 Page - 27

if-elif-else: if-elif-else is a control flow structure in programming that allows a program to
execute different blocks of code based on one or more conditions.

Check the Number is Positive or Negative or Zero

n = int(input("Enter n value : "))
if n > 0:
print("Positive num")
elif n < 0:
print("Negative num")
else:
print("Zero")

Check the Character is Alphabet or Digit or Symbol

ch = input("Enter character : ")
if ('A' <= ch <= 'Z') or ('a' <= ch <= 'z'):
print("Alphabet")
elif '0' <= ch <= '9':
print("Digit")
else:
print("Special Symbol")

Program to check the input year is Leap or Not:

Leap Year rules:
• 400 multiples are leap years : 400, 800, 1200, 1600….
• 4 multiples are leap years: 4, 8, 12, … 92, 96…
• 100 multiples are not leap years: 100, 200, 300, 500, 600…

year = int(input("Enter year : "))

if(year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
print("Leap year")
else:
print("Not leap year")

[Link] Contact – 98859 46789 Page - 28

Program to find Biggest of Three Numbers:
# Get the input values for a, b, and c from the user
a = int(input("Enter a value : "))
b = int(input("Enter b value : "))
c = int(input("Enter c value : "))
# Determine which variable is the largest
if a > b and a > c:
print("a is big")
elif b > c:
print("b is big")
else:
print("c is big")

Program to Calculate current bill based on units consumed:

• 0-100 -> 0.80 per unit
• 101-200 -> 1.2 per unit
• 201-300 -> 1.5 per unit
• above 300 -> 1.8 per unit

# Get the number of units from the user

units = int(input("Enter number of units : "))
# Initialize the bill amount to 0.0
bill = 0.0
# Calculate the bill based on the number of units
if 0 <= units <= 100:
bill = units * 0.8

elif 101 <= units <= 200:

bill = 80 + (units - 100) * 1.2
elif 201 <= units <= 300:
bill = 200 + (units - 200) * 1.5
else:
bill = 350 + (units - 300) * 1.8

# Print the total bill amount

print("Total bill amount :", bill)

Output: Enter number of units: 150

Total bill amount : 140.0

[Link] Contact – 98859 46789 Page - 29

Nested-If: Writing if block inside another if block

Check Even Number or Not only if it is Positive

n = int(input("Enter number : "))
if n > 0:
# Check if the positive number is even
if n % 2 == 0:
print("Even number")
else:
print("Not even number")
else:
print("Negative number given")

Biggest of two only if the two numbers or not equal

n = int(input("Enter number : "))
if n > 0:
# Check if the positive number is even
if n % 2 == 0:
print("Even number")
else:
print("Not even number")
else:
print("Negative number given")

Program to check the person can donate blood or not

Requirements: Age between 18 to 60 and Weight must be greater than 50
# Get the input values for a and b from the user
a = int(input("Enter a value : "))
b = int(input("Enter b value : "))

DisplayStudentGradeonlyifthestudentpassed in all Subjects

m1 = int(input("Enter marks for subject 1: "))
m2 = int(input("Enter marks for subject 2: "))
m3 = int(input("Enter marks for subject 3: "))
if m1 >= 40 and m2 >= 40 and m3 >= 40:

avg=(m1+m2+m3)/3
if avg >= 60:

print("Grade-A")
elif avg >= 50:
print("Grade-B")
else:
print("Grade-C")
else:
print("Student failed")

Display days for the specified month

# Get the input month number from the user
n = int(input("Enter Month number : "))

#Checkifthemonthnumberiswithinavalidrange (1 to 12)
if 1 <= n <= 12:
if n == 2:
print("28 days / 29 days")
elif n in (4, 6, 9, 11):
print("30 days")
else:
print("31 days")
else:
print("Invalid month number")

[Link] Contact – 98859 46789 Page - 31

Bitwise operators:
• Bitwise operators act on operands as if they were string of binary digits. It operates bit
by bit, hence the name.
• For example, 2 is 10 in binary and 7 is 111.
• In the table below: Let x = 10 (0000 1010 in binary) and y = 4 (0000 0100 in binary)

Operator Meaning Example

& Bitwise AND x& y = 0 (0000 0000)
| Bitwise OR x | y = 14 (0000 1110)
~ Bitwise NOT ~x = -11 (1111 0101)
^ Bitwise XOR x ^ y = 14 (0000 1110)
>> Bitwise right shift x>> 2 = 2 (0000 0010)
<< Bitwise left shift x<< 2 = 40 (0010 1000)

Bitwise truth table:

>>> x=15 >>> x|y
>>> y=8 15
>>> x&y >>> x^y
8 7

Shift operators:
• These are used to move the bits in the memory either to right side or to left side.
• Moving binary bits in the memory change the value of variable.
• These operators return the result in decimal format only.
• Operators are Right shift (>>) and Left shift (<<)
>>> x=8 Right shift: n/2^s → 8/2^2 → 8/4 → 2
>>> x>>2 Left shift : n*2^s → 8*2^2 → 8*4 → 32
2
>>> x<<2
32

[Link] Contact – 98859 46789 Page - 32

Introduction to Loops

Loop: A Block of instructions execute repeatedly as long the condition is valid.

Note: Block executes only once whereas Loop executes until condition become False
Python Supports 3 types of Loops:

1. For Loop
2. While Loop
3. While - else Loop

For Loop: We use for loop only when we know the number of repetitions. For example,
• Print 1 to 10 numbers
• Print String elements
• Print Multiplication table
• Print String character by character in reverse order

While loop: We use while loop when we don’t know the number of repetitions.
• Display contents of File
• Display records of Database table

While – else : while-else loop is a type of loop that combines a while loop with an else
statement that is executed after the loop has completed. The else block is executed only if the
while loop completed normally

[Link] Contact – 98859 46789 Page - 33

For Loop
for loop:
• "for" is a keyword.
• for loop executes a block repeatedly as long as the condition is valid.
• for loop uses range() function for loop repetition.

range():
• The range() function in Python generates a sequence of numbers within a given range.
• It takes up to three arguments: start (optional), stop (required), and step (optional).
• The sequence generated by the range() function is commonly used in for loops.

Print the numbers from 0 to 9:

for i in range(10):
print(i)

Print the numbers from 3 to 8:

for i in range(3,9):
print(i)

Print the numbers from 10 to 1:

for i in range(10, 0, -1):
print(i)

Print every third number from 0 to 20:

for i in range(0, 21, 3):
print(i)

Print the even numbers from 0 to 10:

for i in range(0, 11, 2):
print(i)

Print the odd numbers from 1 to 9:

for i in range(1, 10, 2):
print(i)

[Link] Contact – 98859 46789 Page - 34

Print the even numbers from 10 to 0:
for i in range(10, -1, -2):
print(i)

Display values side by side:

for i in range(1,6):
# print(i)
# print(i, end=' ') -> print values with spaces
# print(i, end='\t') -> print values with tab spaces
print(i, end='\n') # print values in new lines

Program to display A-Z alphabets

# Print the uppercase English alphabet from 'A' to 'Z' separated by a space
for ch in range(ord('A'), ord('Z') + 1):
print(chr(ch), end=' ')

Program to Print 1 to N numbers

# Get the input value 'n' from the user
n = int(input("Enter n val : "))

# Use a for loop to print values from 1 to 'n'

for i in range(1, n + 1):
print("i val:", i)

Program to display A-Z alphabets with ASCII values

# Print the uppercase English alphabet from 'A' to 'Z' with ASCII values
for ch in range(ord('A'), ord('Z') + 1):
print(chr(ch) + " : " + str(ch))

Sum of First N numbers:

n = int(input("Enter a positive integer: "))
sum = 0
for i in range(1, n+1):
sum += i
print("The sum of the first", n, "natural numbers is:", sum)

Find factorial for given number:

n = int(input("Enter a positive integer: "))
factorial = 1
for i in range(1, n+1):
factorial *= i
print("The factorial of", n, "is:", factorial)

[Link] Contact – 98859 46789 Page - 35

Multiplication table program:
n = int(input("Enterapositive integer: "))
for i in range(1,11):
product= i*n
print(n,"x",i,"=", product)

Program to display ASCII character set

#PrintallASCIIcharacters with their ASCII values from 0 to 255
for i in range(256):
print(i, ":", chr(i))

Print even numbers from 1 to 10:

n=int(input("Enterapositive integer: "))
print("Evennumbersfrom 1 to", n, "are:")
for i in range(1, n + 1):
ifi%2==0:
print(i)

Find count of Even numbers:

n=int(input("Enterapositive integer: "))
count=0
for i in range(1, n + 1):
ifi%2==0:
count+= 1
print("Countofevennumbers from 1 to", n, "is:", count)

FindSumofEvenNumbers:
n=int(input("Enterapositive integer: "))
sum_even = 0
for i in range(1, n + 1):
ifi%2==0:
sum_even += i
print("Sumofevennumbers from 1 to", n, "is:", sum_even)

Print factors for given number:

n=int(input("Enterapositive integer: "))
print("Factorsof",n,"are:")
for i in range(1, n + 1):
ifn%i==0:
print(i)

print("Totalnumberoffactors of", n, "is:", count_factors)

Sum of Factors for given number:

n=int(input("Enterapositive integer: "))
sum_factors = 0

print("Factors of", n, "are:")

for i in range(1, n + 1):
ifn%i==0:
print(i)
sum_factors += i

print("Sumoffactorsof",n,"is:", sum_factors)

Prime number program:

• Apositiveintegernumber which has 2 factors 1 and itself
• Examples:2,3,5,7,11, 17, 19…

n=int(input("Enterapositive integer: "))

is_prime = True
for i in range(2, n):

ifn%i==0:
is_prime = False
break
if is_prime:

print(n,"isaprimenumber")
else:
print(n,"isnotaprimenumber")

[Link] Contact – 98859 46789 Page - 37

Perfect number program: A perfect number is a positive integer that is equal to the sum of its
proper divisors (excluding itself).
For example, the first few perfect numbers are:

6(divisors: 1, 2, 3; sum of divisors: 1 + 2 + 3 = 6)

28(divisors: 1, 2, 4, 7, 14; sum of divisors: 1 + 2 + 4 + 7 + 14 = 28)

n = int(input("Enter a positive integer: "))

sum = 0

for i in range(1, n // 2 + 1):

if n % i == 0:
sum += i

if sum == n:
print(n, "is a perfect number")
else:
print(n, "is not a perfect number")

Fibonacci Series program: Fibonacci series, is a sequence of numbers in which each number
(after the firsttwo)isthesum of the two preceding ones.
The Fibonaccisequencestarts with 0 and 1 as its first two terms:
0, 1, 1, 2,3,5,8,13,21,34, ...
Fibonaccisequenceisdefined by the recurrence relation:
F(n) = F(n-1) + F(n-2)

n=int(input("Enterthenumber of terms: "))

a,b=0,1
for i in range(n):
print(a)
c=a+b
a,b=b,c

[Link] Contact – 98859 46789 Page - 38

While Loop
Whileloop: Execute a block of instructions repeatedly until the condition is false. We use while
looponlywhen don’t know the number of iterations to do.

Syntax Flow Chart

while(condition):
statements;

Check even or Not until user exits:

whileTrue:
num= int(input("Enter a number: "))
ifnum % 2 == 0:
print(num, "is even.")
else:
print(num, "is odd.")

choice = input("Do you want to check another number? (y/n): ")

[Link]() != 'y':
break

print("Exiting program.")

Print Multiplication table until user exits:

whileTrue:
n=int(input("Enter table number: "))
foriin range(1, 11):
print(f"{n} * {i} = {n * i}")

choice = input("Do you want to print another table? (y/n): ")

[Link]() != 'y':
break

print("Exiting program.")

choice=input("Doyouwant to check another number? (y/n): ")

if [Link]() != 'y':
break

print("Exiting program.")

Menu driven program to perform arithmetic operations:

while True:
print("1. Add")
print("2. Subtract")
print("3. Multiply")
print("4. Exit")
choice=input("Enteryourchoice: ")
if choice == '1':
a=int(input("Enterfirstnumber: "))
b=int(input("Entersecond number: "))
print("Result =", a + b)
elif choice == '2':
a=int(input("Enterfirstnumber: "))
b=int(input("Entersecond number: "))
print("Result =", a - b)
elif choice == '3':
a=int(input("Enterfirstnumber: "))
b=int(input("Entersecond number: "))
print("Result =", a * b)
elif choice == '4':
print("End of program")
break
else:
print("Error:Invalidchoice")

[Link] Contact – 98859 46789 Page - 40

Digit Based Programs
Program to Display Last Digit ofgiven number
• When we divide any number with 10 then last digit will be the remainder.
• 1234%10 -> 4
• 1005%10 -> 5
• 200%10 -> 0

n = int(input("Enter Num: "))

d = n % 10
print("Last digit is:", d)

Program to remove the last digit of number:

• When we divide any number with 10 then it gives quotient by removing last digit
• 1234/10 -> 123
• 1000/10 -> 100

n = int(input("Enter Num: "))

n = n // 10
print("After removing last digit:", n)

Display digits of a number in reverse order:

n = int(input("Enter Num: "))
while n != 0:
print(n % 10)
n = n // 10

Program to Count the digits in given number

n = int(input("Enter Num: "))
count = 0
while n != 0:
n = n // 10
count += 1

print("Digits count:", count)

Display sum of the digits in the given number

n = int(input("Enter Num: "))
sum = 0
while n != 0:
sum = sum + n % 10
n = n // 10

print("Sum of digits:", sum)

print("SumofEvendigitsare:", sum)

Program to count the number of 0 digits in the given number:

n = int(input("Enter Num: "))
count=0
whilen>0:
r=n%10
if r == 0:
count+= 1
n=n//10

print("Zero's count:", count)

Program to display Multiplication table to each digit in the given number:

n = int(input("Enter Num: "))
whilen>0:

r=n%10
for i in range(1, 11):
print(f"{r} * {i} = {r * i}")
n=n//10

Program to display factoral of each digit in the given number:

n = int(input("Enter Num: "))
whilen>0:
r=n%10
fact= 1

for i in range(1, r + 1):

fact=fact*i

print(f"Factorialof{r}is:{fact}")
n=n//10

[Link] Contact – 98859 46789 Page - 42

Program to display prime number digits in the given number:
n=int(input("EnterNum: "))
whilen>0:

r=n%10
count= 0

foriinrange(1,r+1):
ifr%i==0:
count+= 1

if count==2:
print(f"{r}isprime")

n=n//10

Display Smallest Digit in the given number:

n=int(input("EnterNum: "))
small=9#Initialize'small' to a large value initially

whilen>0:
r=n%10
if r < small:

small = r
n=n//10

print("Smallestdigit:",small)

Program to display biggest digit in the given number:

n=int(input("EnterNum: "))
large = 0
whilen>0:
r=n%10

if r > large:
large = r
n=n//10

print("Largestdigit:",large)

[Link] Contact – 98859 46789 Page - 43

Program to find the sum of Largest and Smallest Digit in the given number:
n = int(input("Enter Num: "))
large = 0 small = 9
while n > 0:

r = n % 10
if r > large:
large = r
if r < small:
small = r
n = n // 10

sum = large + small

print("Sum of large and small:", sum)

Program to display the first digit of given number:

n = int(input("Enter Num: "))
while n >= 10:

n = n // 10

print("First Digit:", n)

Program to Find the Sum of First and Last digits of given number
n = int(input("Enter Num: "))
first = n % 10

while n >= 10:

n = n // 10

last = n % 10
sum = first + last
print("Sum of First & Last Digits:", sum)

Program to reverse the given number

n= int(input("Enter Num: "))
rev = 0

[Link] Contact – 98859 46789 Page - 44

whilen>0:
r=n%10
rev=rev*10+r
n=n//10

print("ReverseNumberis:",rev)

Palindrome Number: The number become same when we reverse is called Palindrome number
Examples: 121, 1001, 123321
n =int(input("EnterNum:"))
rev = 0
temp = n

whilen>0:
r=n%10
rev=rev*10+r
n=n//10

if temp == rev:
print("PalindromeNumber")
else:
print("NotPalindromeNumber")

Check the given 3 digit number is Arm strong Number or not :

Sum of cubes of individual digits equals to the same number
Example: 153->1^3 + 5^3 + 3^3 = 153

n =int(input("EnterNum:"))
temp = n
sum=0
num_digits = len(str(n))
whilen>0:

r=n%10
sum += r ** num_digits
n//= 10

if temp == sum:
print("ArmstrongNumber")
else:
print("NotanArmstrongNumber")

[Link] Contact – 98859 46789 Page - 45

Program to check the given number is Armstrong number or not:
Armstrong Number: Sum of its own digits raised to power number of digits
Examples : 153 = 1^3 + 5^3 + 3^3 = 153
1634 = 1^4 + 6^4 + 3^4 + 4^4 = 1634

n = int(input("Enter Num: "))

temp = n
sum = 0
c=0
while n > 0:

n = n // 10
c += 1

n = temp

while n > 0:
r = n % 10
s=1
for i in range(1, c + 1):
s *= r
sum += s
n = n // 10

if temp == sum:
print("Armstrong Number")
else:
print("Not an Armstrong Number")

Program to find Sum of Digits till Single Digit:

9657 -> 9+6+5+7 -> 27 -> 2+7 -> 9

num = int(input("Enter Num: "))

print(num, end="->")
while num // 10 != 0:

sum = 0
while num != 0:
dig = num % 10
sum += dig
num //= 10
print(sum, end="->")
num = sum

[Link] Contact – 98859 46789 Page - 46

ADAM Number: Take a number then square it then reverse it then find its square root then
reverse. If the given number equals to the final number then it is called ADAM.
• Take the number (12)
• Square the number (144)
• Reverse the number(441)
• Square root of number (21)
• Reverse the number(12)

import math

num = int(input("Enter Num: "))

temp = num * num
print("Square of the num: ", temp)

# Reverse the square

rev1 = 0
while temp != 0:
r1 = temp % 10
rev1 = rev1 * 10 + r1
temp = temp // 10

print("Reverse Num: ", rev1)

# Calculate the square root of the reversed square

sq = int([Link](rev1))
print("Sqrt num: ", sq)

# Reverse the square root

rev2 = 0
while sq != 0:
r2 = sq % 10
rev2 = rev2 * 10 + r2
sq = sq // 10

print("Reverse Num: ", rev2)

ifrev2 == num:
print(num, " is an Adam number")
else:
print(num, " is not an Adam number")

[Link] Contact – 98859 46789 Page - 47

Break and Continue

break:Abranching statement that terminates the execution flow of a Loop or Switch case.
foriinrange(1, 11):
if i == 5:
break
print(i,end=" ")
Output: 1234

Breakstatement terminates the flow of infinite loop also:

while True:
print("Loop", end="")
break
Output: Loop prints infinite times

Continue:Abranching statement that terminates the current iteration of loop execution.

foriinrange(1, 11):
if i == 5:
continue
print(i,end=" ")
Output: 1 2 3 4 5 6 7 8 9 10

PrintOddnumbers using continue:

foriinrange(1, 11):
ifi%2== 0:
continue
print(i)
Output:135 7 9
PrintMultiplication table until user exits:

while True:
n=int(input("Enter table number: "))
foriinrange(1, 11):
print(f"{n} * {i} = {n * i}")

choice=input("Do you want to print another table? (y/n): ")

[Link]() != 'y':
break

print("Exiting program.")

[Link] Contact – 98859 46789 Page - 48

While – Else Loop

while-else:
• In Python, the while loop can be combined with an else block.
• The else block is executed when the while loop condition becomes False or when the
loop is exhausted, but not when the loop is exited using a break statement.
• This can be useful in situations where you want to perform some actions after the loop
has finished executing normally.

Password Validation:
password = input("Enter a password: ")
while len(password) < 8:
print("Password must be at least 8 characters long.")
password = input("Enter a valid password: ")
else:
print("Password is valid.")

Sum of Digits:
num = 12345
sum_of_digits = 0
while num > 0:
digit = num % 10
sum_of_digits += digit
num //= 10
else:
print(f"The sum of digits is {sum_of_digits}")

Finding PrimeNumbers
num = 10
is_prime = True
whilenum>1:
foriinrange(2, num):
ifnum%i== 0:
is_prime= False
break
else:
print(f"{num} is a prime number")
num-= 1

[Link] Contact – 98859 46789 Page - 49

Range Based Programs
Print Evens numbers from 1 to 10:
for n in range(1, 11):
ifn%2==0:
print(n)

Multiplication tables from 5 to 15:

for i in range(5, 16):
print(f"Multiplicationtablefor{i}:")
for j in range(1, 11):
result = i * j
print(f"{i} x {j} = {result}")
print()#Printanemptylinetoseparate tables

Factorials from 2 to 8:
for n in range(2, 9):
factorial=1
foriinrange(1,n+ 1):
factorial *= i
print(f"Factorialof{n}is{factorial}")

Prime numbers from 1 to 50:

for n in range(1, 51):
factors=0
foriinrange(1,n+ 1):
ifn%i==0:
factors= factors+ 1

if factors == 2:
print(n, "is prime")

Perfect numbers in given range:

for n in range(1, 10000):
sum=0
for i in range(1, n):
ifn%i==0:
sum = sum + i

if n == sum:
print(n, "is perfect")

[Link] Contact – 98859 46789 Page - 50

Pattern Programs
Pattern:
• Representation of data in two-dimensional format (rows and columns)
• We use nested loops to print patterns.
• We can print patterns with numbers, characters, starts, symbols
• Patterns can be in different shapes like triangle, rectangle, half triangle, pyramid and so
on.

Basic Number Patterns

Pattern Logic
for i in range(1, 6):
12345 for j in range(1, 6):
12345
12345 print(j, end="")
12345 print()

Pattern Logic
11111 for i in range(1, 6):
22222 for j in range(1, 6):
33333 print(i, end="")
44444
55555 print()

Pattern Logic
***** for i in range(1, 6):
***** for j in range(1, 6):
***** print('*', end="")
*****
***** print()

Pattern Logic
54321 for i in range(5, 0, -1):
54321 for j in range(5, 0, -1):
54321 print(j, end="")
54321
54321 print()
Pattern Logic
for i in range(5, 0, -1):
55555 for j in range(5, 0, -1):
44444 print(i, end="")
33333
print()
22222
11111

[Link] Contact – 98859 46789 Page - 51

Pattern Logic
10101 for i in range(1, 6):
10101 for j in range(1, 6):
10101 print(j % 2, end="")
10101
print()
10101

Pattern Logic
11111 for i in range(1, 6):
00000 for j in range(1, 6):
11111 print(i % 2, end="")
00000
print()
11111

Basic Character Patterns

Pattern Logic
forxinrange(ord('A'), ord('F')):
AAAAA
BBBBB foryinrange(ord('A'), ord('F')):
CCCCC
print(chr(x), end="")
DDDDD
EEEEE print()

Pattern Logic

ABCDE forxinrange(ord('A'), ord('F')):

ABCDE foryinrange(ord('A'), ord('F')):
ABCDE
print(chr(y), end="")
ABCDE
ABCDE print()

Pattern Logic
EEEEE forxinrange(ord('E'), ord('A') - 1, -1):
DDDDD foryinrange(ord('E'), ord('A') - 1, -1):
CCCCC print(chr(x), end="")
BBBBB
print()
AAAAA

Pattern Logic

EDCBA forxinrange(ord('E'), ord('A') - 1, -1):

EDCBA foryinrange(ord('E'), ord('A') - 1, -1):
EDCBA
print(chr(y), end="")
EDCBA
EDCBA print()

Pattern Logic
for i in range(1, 6):
for j in range(1, 6):
$#$#$ if j % 2 == 0:
$#$#$
print("#", end="")
$#$#$
$#$#$ else:
$#$#$ print("$", end="")
print()
Pattern Logic
k=1
12345 for i in range(1, 6):
67891 for j in range(1, 6):
23456
print(k % 10, end="")
78912
34567 k += 1
print()
Pattern Logic
for i in range(1, 6):
for j in range(1, 6):
11111 if i % 2 == 0:
12345
print(j, end="")
33333
12345 else:
55555 print(i, end="")
print()
Pattern Logic
55555 for i in range(1, 6):
54321 for j in range(1, 6):
33333 if i % 2 == 0:
54321
11111 print(j, end="")
else:
print(i, end="")
print()

Pattern Logic
foriinrange(1, 8):
+++++++ forjinrange(1, 8):
+++ +++ ifiin(1, 4, 7) or j in (1, 4, 7):
+++++++
print("+", end="")
+++ +++
+++++++ else:
print(" ", end="")
print()
Pattern Logic
foriinrange(1, 8):
+ forjinrange(1, 8):
+ ifi==j:
+
print("+", end="")
+
+ else:
+ print(" ", end="")
+ print()

Pattern Logic
for i in range(1, 8):
++++ for j in range(1, 8):
+ if (i == 1 and j <= 4) or j == 4 or (i == 7 and j >= 4):
+ print("+", end="")
+ else:
+ print(" ", end="")
+
print()
++++
Pattern Logic
+ for i in range(1, 8):
+ for j in range(1, 8):
+ if i == 4 or (j == 1 and i >= 4) or (j == 7 and i <= 4):
+++++++ print("+", end="")
+
else:
+
+ print(" ", end="")
print()

Patterns – All Digits

Pattern Logic
for i in range(1, 8):
+ + + + + forjinrange(1,6):
+ + ifi==1ori==7orj==1 or j == 5:
+ +
print("+", end="")
+ +
+ + else:
+ + + + + print(" ", end="")
print()

Pattern Logic
for i in range(1, 8):
+ forjinrange(1,6):
++ ifj==4-iorj==3ori== 7:
+ +
print("+", end="")
+
+ else:
+ print(" ", end="")
+++++++ print()

Pattern Logic
for i in range(1, 8):
+ + + + + forjinrange(1,6):
+ ifi==1ori==4ori==7or (j == 5 and i <= 4) or (j ==
+ 1 andi>=4):
+ + + + + print("+", end="")
+
+ else:
+ + + + + print(" ", end="")
print()

[Link] Contact – 98859 46789 Page - 56

Pattern Logic

+ + + + + foriinrange(1, 8):
+ forjinrange(1, 6):
+
ifi== 1 or i == 4 or i == 7 or j == 5:
+ + + + +
+ print("+", end="")
+ else:
+ + + + + print(" ", end="")
print()

Pattern Logic
+
+ + foriinrange(1, 8):
+ + forjinrange(1, 8):
+ +
ifj==5 or i == 5 or j == 6 - i:
+ + + + + + + +
+ print("+", end="")
+ else:
print(" ", end="")
print()

Pattern Logic
foriinrange(1, 8):
+ + + + + forjinrange(1, 6):
+ ifi==1 or i == 4 or i == 7 or (j == 1 and i <= 4) or (j
+
==5andi>= 4):
+ + + + +
+ print("*", end="")
+ else:
+ + + + + print(" ", end="")
print()

Pattern Logic
foriinrange(1, 8):
+ + + + + forjinrange(1, 6):
+ + + + + ifi==1 or j == 1 or i == 4 or i == 7 or (j == 5 and i
+ +
>= 4):
+ + print("*", end="")
+ + else:
+ + + + + print(" ", end="")
print()

[Link] Contact – 98859 46789 Page - 57

Pattern Logic

foriinrange(1, 8):
+ + + + + + forjinrange(1, 6):
+
ifi== 1 or j == 7 - i:
+
+ print("*", end="")
+ else:
+ print(" ", end="")
print()

Pattern Logic
+ + + +
+ + + foriinrange(1, 8):
+ + forjinrange(1, 6):
+ + + +
ifi== 1 or i == 4 or i == 7 or j == 1 or j == 5:
+ + +
+ + print("*", end="")
+ + + + else:
+ print(" ", end="")
print()

Pattern Logic
+ + + + + foriinrange(1, 8):
+ + forjinrange(1, 6):
+ + ifi== 1 or i == 4 or i == 7 or (j == 1 and i <= 4)
+ + + + +
orj== 5:
+
+ print("*", end="")
+ + + + + else:
print(" ", end="")
print()

Patterns – All Alphabets

Pattern Logic
+ foriinrange(1, 6):
+ + forjinrange(1, 10):
+ + ifj== 6 - i or (i == 3 and j >= 3 and j <= 7) or j == 4 + i:
+ + + +
print("+", end="")
+ +
+ + else:
print(" ", end="")
print()

Pattern Logic
+ + + + for i in range(1, 8):
+ + + + forjinrange(1,8):
+ if(i==1andj>1)or(j==1andi> 1 and i < 7) or (i ==
7 and j > 1):
print("+", end="")
+ + + + else:
print(" ", end="")
print()

Pattern Logic

+ + + + for i in range(1, 8):

+ + + ++ forjinrange(1,8):
+ + + + +
ifj==1or(i==1andj<7)or(i== 7 and j < 7) or (j ==
+
+ 7andi>1andi<7):
print("+", end="")
else:
print(" ", end="")
print()

Pattern Logic

+ + + + + for i in range(1, 8):

+ + + + + forjinrange(1,8):
+ + + + +
ifj==1ori==1ori==4ori==7:
+ + + +
print("+", end="")
else:
print(" ", end="")
print()

Pattern Logic
foriinrange(1, 8):
+ + + + + forjinrange(1, 8):
+ + + + + ifi== 1 or j == 4 or i == j + 3:
print("+", end="")
+
else:
+ print(" ", end="")
print()

Pattern Logic
foriinrange(1, 8):
forjinrange(1, 8):
+ + + + + ifj== 1 or i == 7:
+++++
print("+", end="")
else:
print(" ", end="")
print()

Pattern Logic
foriinrange(1, 8):
forjinrange(1, 8):
+ + ifj==1 or j == 7 or (i == j and j <= 4) or (j == 8 - i
+ + + + andj> 4):
+ + + +
+ + print("+", end="")
+
+ + else:
+ + print(" ", end="")
+ + print()

Pattern Logic
for i in range(1, 8):
for j in range(1, 8):
+ + if j == 1 or j == 7 or (i == j):
+ + + print("+", end="")
+ + +
+ + else:
+
+ + + print(" ", end="")
+ + + print()
+ +

[Link] Contact – 98859 46789 Page - 61

Numbers Triangle Patterns

Pattern Logic
1 for i in range(1, 6):
12 for j in range(1, i + 1):
123 print(j, end="")
1234
print()
12345
Pattern Logic
1 for i in range(1, 6):
21 for j in range(i, 0, -1):
321 print(j, end="")
4321 print()
54321
Pattern Logic
12345 foriinrange(5, 0, -1):
1234 forjin range(1, i + 1):
123 print(j, end="")
12 print()
1
Pattern Logic
12345 foriinrange(1, 6):
2345 forjin range(i, 6):
345 print(j, end="")
45
print()
5

Pattern Logic
5 foriinrange(5, 0, -1):
54 forjin range(5, i - 1, -1):
543 print(j, end="")
5432
print()
54321

Pattern Logic
5 foriinrange(5, 0, -1):
45 forjin range(i, 6):
345 print(j, end="")
2345
print()
12345

Pattern Logic
54321 foriinrange(1, 6):
5432 forjin range(5, i - 1, -1):
543 print(j, end="")
54
print()
5

Pattern Logic
foriinrange(5, 0, -1):
forjinrange(i, 5):
12345 print(" ", end="")
1234 forkinrange(1, i + 1):
123
print(k, end="")
12
1 print()

Pattern Logic
foriinrange(1, 6):
12345 forjinrange(1, i):
2345 print(" ", end="")
345
forkinrange(i, 6):
45
print(k, end="")
5 print()

Pattern Logic
foriinrange(5, 0, -1):
forjinrange(1, i):
5 print(" ", end="")
45
forkinrange(i, 6):
345
2345 print(k, end="")
12345 print()

Pattern Logic
foriinrange(5, 0, -1):
forjinrange(1, i):
5 print(" ", end="")
54
forkinrange(5, i - 1, -1):
543
5432 print(k, end="")
54321 print()

Characters Triangle Patterns

Pattern Logic
for i in range(ord('A'), ord('F')):
A for j in range(ord('A'), i + 1):
AB print(chr(j), end="")
ABC
print()
ABCD
ABCDE
Pattern Logic
for i in range(ord('A'), ord('F')):
A for j in range(i, ord('A') - 1, -1):
BA print(chr(j), end="")
CBA
print()
DCBA
EDCBA
Pattern Logic

ABCDE for i in range(ord('E'), ord('A') - 1, -1):

ABCD for j in range(ord('A'), i + 1):
ABC
print(chr(j), end="")
AB
A print()

Pattern Logic

ABCDE for i in range(ord('A'), ord('F')):

BCDE for j in range(i, ord('F')):
CDE
print(chr(j), end="")
DE
E print()

[Link] Contact – 98859 46789 Page - 65

Pattern Logic
E for i in range(ord('E'), ord('A') - 1, -1):
ED for j in range(ord('E'), i - 1, -1):
EDC print(chr(j), end="")
EDCB
print()
EDCBA

Pattern Logic
E for i in range(ord('E'), ord('A') - 1, -1):
DE for j in range(ord('E'), i - 1, -1):
CDE print(chr(j), end="")
BCDE
print()
ABCDE

Pattern Logic
EDCBA for i in range(ord('A'), ord('F')):
EDCB for j in range(ord('E'), i - 1, -1):
EDC print(chr(j), end="")
ED
print()
E

Pattern Logic
EDCBA for i in range(ord('E'), ord('A') - 1, -1):
DCBA for j in range(i, ord('A') - 1, -1):
CBA print(chr(j), end="")
BA
print()
A

Star Triangle Patterns

Pattern Logic
* for i in range(1, 6):
** for j in range(1, i + 1):
*** print("*", end="")
****
print()
*****

Pattern Logic

***** for i in range(5, 0, -1):

**** for j in range(1, i + 1):
***
print("*", end="")
**
* print()

Pattern Logic
for i in range(1, 6):
for j in range(1, i):
***** print(" ", end="")
**** for k in range(i, 6):
***
print("*", end="")
**
* print()

Pattern Logic
foriinrange(1, 10):
ifi<= 5:
* forjinrange(1, i + 1):
**
print("*", end="")
***
**** print()
***** else:
**** forkinrange(i, 10):
*** print("*", end="")
** print()
*
Pattern Logic
foriinrange(1, 10):
ifi<= 5:
forxinrange(i, 6):
print(" ", end="")
* forjinrange(1, i + 1):
print("*", end="")
**
*** print()
**** else:
***** forxinrange(i, 5, -1):
**** print(" ", end="")
***
forkinrange(i, 10):
**
* print("*", end="")
print()

Pattern Logic
for i in range(1, 10):
if i <= 5:
for x in range(1, i + 1):
print(" ", end="")
for j in range(i, 6):
***** print("*", end="")
**** print()
*** else:
** for x in range(i, 10):
* print(" ", end="")
**
for k in range(5, i + 1):
***
**** print("*", end="")
***** print()

Binary Number Patterns

Pattern Logic
k=1
for i in range(1, 6):
1 for j in range(1, i + 1):
01 print(k % 2, end="")
010 k += 1
1010
10101 print()

Pattern Logic
k=1
for i in range(1, 6):
10101 for j in range(1, i + 1):
0101
print(k % 2, end="")
010
10 k += 1
1 print()

[Link] Contact – 98859 46789 Page - 68

Pattern Logic
1 for i in range(1, 6):
10 for j in range(1, i + 1):
101 print(j % 2, end="")
1010
print()
10101

Pattern Logic
1 for i in range(1, 6):
00 for j in range(1, i + 1):
111 print(i % 2, end="")
0000
print()
11111

Pattern Logic
11111 for i in range(5, 0, -1):
0000 for j in range(1, i + 1):
111 print(i % 2, end="")
00
print()
1

Border Only Patterns

Pattern Logic
n=7
* foriinrange(1, n + 1):
** forjinrange(1, i + 1):
* *
ifi== 1 or i == n or j == 1 or j == i:
* *
* * * print("*", end="")
********
* else:
* print(" ", end="")
print()

Pattern Logic
n=7
******** foriinrange(n, 0, -1):
* * forjinrange(1, i + 1):
* *
ifi== 1 or i == n or j == 1 or j == i:
* *
* * print("*", end="")
* * else:
** print(" ", end="")
* print()

Pattern Logic
for i in range(1, 8):
for j in range(i, 7):
* print(" ", end="")
** for k in range(1, i + 1):
* *
if i == 1 or i == 7 or k == 1 or k == i:
* *
* * print("*", end="")
* * else:
* * print(" ", end="")
******** print()

Pyramid Patterns
Pattern Logic
n=7
foriinrange(1, n + 1):
* forjinrange(i, n):
*** print("", end="")
***** forkinrange(1, 2 * i):
*******
********* print("*", end="")
print()
Pattern Logic
n=7
foriinrange(1, n + 1):
forjinrange(i, n):
*
print("", end="")
* * forkinrange(1, 2 * i):
* *
* * ifi==1 or i == n or k == 1 or k == 2 * i - 1:
********* print("*", end="")
else:
print(" ", end="")
print()

Reverse Pyramid Patterns

Pattern Logic
n=7
foriinrange(n, 0, -1):
********* forjinrange(i, n):
******* print(" ", end="")
***** forkinrange(1, 2 * i):
***
print("*", end="")
*
print()

Pattern Logic
n=7
for i in range(n, 0, -1):
for j in range(i, n):
*********
print(" ", end="")
* *
* * for k in range(1, 2 * i):
* * if i == 1 or i == n or k == 1 or k == 2 * i - 1:
* print("*", end="")
else:
print(" ", end="")
print()

Pattern Logic

n=7
for i in range(n, 0, -1):
555555555
for j in range(i, n):
4444444 print(" ", end="")
33333
for k in range(1, 2 * i):
222
1 print(i, end="")
print()

Complex Pattern programs

Pattern Logic
1 n=7
121 for i in range(1, n + 1):
12321 for j in range(i, n):
1234321
print(" ", end="")
123454321
for k in range(1, i + 1):
print(k, end="")
for l in range(i - 1, 0, -1):
print(l, end="")
print()
n=7
for i in range(n, 0, -1):
for j in range(i, n):
123454321
print(" ", end="")
1234321 for k in range(1, i + 1):
12321
print(k, end="")
121
1 for l in range(i - 1, 0, -1):
print(l, end="")
print()

Pattern Logic
n=7
for i in range(n, 0, -1):
for j in range(i, n):
543212345
print(" ", end="")
4321234 for k in range(i, 0, -1):
32123
212 print(k, end="")
1 for l in range(2, i + 1):
print(l, end="")
print()
Pattern Logic
n=7
# Upper half of the diamond
for i in range(1, n + 1):
*
print(" " * (n - i) * 2, end="")
***
print("* " * (2 * i - 1))
*****
*******
********* # Lower half of the diamond (excluding the center row)
*********** for i in range(n - 1, 0, -1):
********* print(" " * (n - i) * 2, end="")
*******
***** print("* " * (2 * i - 1))
***
*

[Link] Contact – 98859 46789 Page - 73

Functions in Python
Functions:
• A block of instructions that performs a task.
• Function takes input, process the input and returns the output.
• “def” is a keyword is used to define functions in python programming.

Syntax:
def identity(arguments) :
……
Logic
……

Ex:
def add(a, b):
c=a+b
return c

Every function consists:

1. Function definition: Function definition is a block which contains the logic.
2. Function call : It is a single statement used to access the function definition.

Definition:
def add(a, b):
c=a+b
return c

Call:
res = add(10,20)

Basic functional programming:

• Function execute only when we call that function.

• Calling is a single statement used to access the function logic

deffun():
print("Hello...")
return

fun() # calling

[Link] Contact – 98859 46789 Page - 74

Note : We cannot call a function before it has defined.
fun() # error :
def fun():
print("Hello...")
return

The main advantage of functions is code re-usability. We can call the function many times
once we defined.
def test():
print("logic..")
return

test()
test()
test()

One source file(.py file) can have more than one function definition. Functions get
executed in the order we invoke.
def m1():
print("m1.....")
return

def m2():
print("m2.....")
return

m2()
m1()

We can access one function from another function.

def m1():
print("control in m1...")
return

def m2():
print("control in m2...")
m1() #calling
print("control back to m2 from m1...")
return

print("Program starts...")
m2() #calling
print("Program ends...")

[Link] Contact – 98859 46789 Page - 75

Classification of functions: The way of passing input and returning output, functions classified
into
1. No arguments and No return values
2. With arguments and No return values
3. With arguments and With return values
4. No arguments and With return value
5. Recursion

No arguments and No return values:

• Defining a function without arguments. No need to pass input values while calling the
function. ‘return’ statement is optional.

def greet(): def display_message():

print("Hello, world!") print("This is a simple message.")

greet() display_message()
import os
def clear_screen(): def print_pattern():
for i in range(1, 6):
print('*' * i)
[Link]('clear') # For Unix/Linux
print_pattern()
clear_screen()

With arguments and No return values:

• Defining a function with arguments(variables)
• Function takes input and it can be any type.
• We need to pass parameter values while calling the function.

def greet(name): def add(a, b):

print(f"Hello, {name}!") result = a + b
print(f"Sum of {a} and {b} is {result}")
greet("Amar")
add(3, 5)
def is_even(number):
def display_info(name, age): if number % 2 == 0:
print(f"Name: {name}") print(f"{number} is an even")
print(f"Age: {age} years") else:
print(f"{number} is not an even")
display_info("Amar", 23)
is_even(10) # Example usage
is_even(7) # Example usage

[Link] Contact – 98859 46789 Page - 76

With arguments and with return values:
• Defining a function with arguments and return values
• The value returned by function need to collect into variable.
• Function returned value back to the calling function.

def add_numbers(a, b): def is_even(number):

return a + b return number % 2 == 0

result = add_numbers(5,3) even = is_even(10)

print(result) # Output:8 print(even) # Output: True

Pre-define maxfunction: def find_maximum(a, b):

if a > b:
def find_max(a,b,c): return a
returnmax(a,b,c) else:
return b
maximum=find_max(8,12, 6)
print(maximum)#Output: 12 max_value = find_maximum(10, 7)
print(f"Maximum value: {max_value}")
deffactorial(n): def sum_of_first_n(n):
ifn==0: return n * (n + 1) // 2
return1
returnn*factorial(n-1) n = 10
result = sum_of_first_n(n)
result=factorial(5) print(f"The sum is {result}")
print("Factorial:", result)
defis_prime(number): def is_perfect(number):
count=0 sum = 0
foriinrange(1,number + 1):
for i in range(1, number):
ifnumber%i==0:
count+=1 if number % i == 0:
sum += i
return sum == number
iffactor_count==2:
returnTrue
if is_perfect(28):
else:
returnFalse
print(f"{number_to_check} is a perfect")
ifis_prime(17): else:
print(f"{number_to_check} is a prime") print(f"{number_to_check} is not")
else:
print(f"{number_to_check} is not")

[Link] Contact – 98859 46789 Page - 77

No arguments and with return values:
• Defining a function with no arguments
• Function returns a value from its definition.
def getPI(): def get_user_name():
PI = 3.142 return input("Enter your name: ")
return PI
user_name = get_user_name()
print("PI value :",getPI()) print("Hello, " + user_name + "!")

Recursion:
• Function calling itself is called recursion.
• Calling the function from the definition of same function.
• Function executes from the allocated memory called STACK.
• While executing the program, if the stack memory is full, the program execution
terminates abnormally.

Recursion codes:
def factorial(n):
def tutorials(): if n == 0:
print("Keep reading...") return 1
tutorials() else:
return return n * factorial(n - 1)

tutorials() result = factorial(5)

print(f"The factorial of {number} is {result}")
def sum(n): def power(base, exponent):
if n == 1: if exponent == 0:
return 1 return 1
else: else:
return n + sum(n - 1) return base * power(base, exponent - 1)

result = sum(10) result = power(2, 3)

print(f"The result is {result}") print(f"2^3 is {result}")
def count_digits(number):
if number == 0:
return 0
else:
return 1 + count_digits(number // 10)

number = 12345
count = count_digits(number)
print(f"The number {number} has {count} digits")

[Link] Contact – 98859 46789 Page - 78

Argument type functions: Depends on the way of passing input and taking input, functions in
python classified into
1. Default arguments function
2. Required arguments function
3. Keyword arguments function
4. Variable arguments function

Default arguments function:

• Defining a function by assigning values to arguments.
• Passing values to these arguments is optional while calling the function.
• We can replace the values of default arguments if required.

def default(a,b=20):
print("a val :",a)
print("b val :",b)
return
default(10)
default(50,100)
default(10,"abc")

• Argument assigned with value is called default argument

• A Non default argument cannot follows default argument

def default(a=10,b):
print("a val :",a)
print("b val :",b)
return

Required arguments function:

• Function definition without default arguments.
• We need to pass input value to all positional arguments of function.

def required(a,b):
print("a val :",a)
print("b val :",b)
return

#required(10) -> Error:

required(10,20)
required(10,"abc")

[Link] Contact – 98859 46789 Page - 79

Keyword arguments function:
• Calling the function by passing values using keys.
• We use arguments names as keys.

def keyword(name, age):

print("Name is :",name)
print("Age is :",age)
return

keyword("Annie",21)
keyword(23,"Amar")

We can change the order of arguments while passing values using keys.
def keyword(name, age):
print("Name is :",name)
print("Age is :",age)
return

keyword(age=23,name="Amar")

Keyword functions are useful mostly in default arguments function.

def default(a=10,b=20,c=30):
print("a :",a)
print("b :",b)
print("c :",c)
return

default()
# I want to change value of b=50
default(10,50,30)
# It is easy to use keyword arguments
default(b=50)

Variable arguments function:

• Passing different length of values while calling the function.
• We can collect these arguments into pointer type argument variable.
defvariable(*arr):
print("Length is :",len(arr))
print("Elements :",arr)
return

variable()

[Link] Contact – 98859 46789 Page - 80

We can pass different types of data elements also
def variable(*arr):
print("Elements :",arr)
return

variable(10,20,30,40,50)
variable(10,2.3,"abc")

We can process the elements easily using for loop

def variable(*arr):
print("Elements :")
for ele in arr:
print(ele)
return

variable(10,20,30,40,50)

Local and Global Variables:

Local variables:
• Defining a variable inside the function.
• Local variables can be accessed only from the same function in which it has defined.
• We access the local variable directly.

def test():
a=10 #local
print("Inside :",a)
return

test()
print("Outside :",a) #error :

Arguments(parameters):
• Variables used to store input of the function.
• Arguments are working like local variables.
• Arguments can access within that function only.

def test(a, b): #a,b are local

print("Inside :",a)
print("Inside :",b)
return

test(10,20)
print("Outside :",a) #error

[Link] Contact – 98859 46789 Page - 81

Global variables:
• Defining a variable outside to all the functions.
• We can access the variable directly.
• It is available throughout the application.
a=10 #global
def m1():
print("Inside m1 :",a)
return

def m2():
print("Inside m2 :",a)
return

m1()
m2()
print("Outside :",a)

• We can define local & global variables with the same name.
• We access both the variables directly using its identity.
• When we access a variable inside the function, it gives the first priority to local variable.
• If local is not present, then it is looking for Global variable.

a=10 #global
def m1():
a=20 #local
print("Inside m1 :",a)
return

def m2():
print("Inside m2 :",a)
return

m1()
m2()
print("Outside :",a)

global:
• It is a keyword.
• It is used to define, access, modify & delete global variables from the function.
• global statement must be placed inside the function before the use of that variable.

Note: We can access global variable inside the function. We cannot modify the global variable
from function directly.

[Link] Contact – 98859 46789 Page - 82

a=10

def test():
print("a val :",a)
a=a+20 #error :
print("a val :",a)
return

test()

We can use global keyword to modify the global variable from the function:
a=10
def test():

global a
print("a val :",a)

a=a+20
print("a val :",a)
a=a+30
return

test()
print("a val :",a)

We can define global variables from the function using "global" :

def test():
global a
a=10
print("Inside :",a)
return

test()
print("Outside :",a)

[Link] Contact – 98859 46789 Page - 83

Introduction to OOPS

Application:
• Programming Languages and Technologies are used to develop applications.
• Application is a collection of Programs.
• We need to design and understand a single program before developing an application.

Program Elements: Program is a set of instructions. Every Program consists,

1. Identity
2. Variables
3. Methods

1. Identity:
o Identity of a program is unique.
o Programs, Classes, Variables and Methods having identities
o Identities are used to access these members.

2. Variable:
o Variable is an identity given to memory location.
or
o Named Memory Location
o Variables are used to store information of program(class/object)

Syntax Examples

identity = value; name = “amar”;

age = 23;
salary = 35000.00;
is_married = False;

3. Method:
• Method is a block of instructions with an identity
• Method performs operations on data(variables)
• Method takes input data, perform operations on data and returns results.

Syntax Example
identity(arguments): add(int a, int b):
body c = a+b
return c

[Link] Contact – 98859 46789 Page - 84

Object Oriented Programming:
• Python is Object Oriented.
• Python is Fully Object Oriented because it doesn't support primitive data types.
• Languages which are supporting primitive types are called, Partial Object oriented
programming languages.
• for example C++, Java, .Net...

Note: Primitive types such as int, float, char occupies fixed memory size and stores specific type
of data.

Python is Dynamic:
• Python is dynamic
• Python variable stores address instead of data directly.
• Python stores information in the form of Objects.
• Depends on the data, the size of memory grows and shrinks dynamically.
• A python variable accepts any type of data assignment.

Note: In python, if we modify the value of variable, it changes the location.

id(): A pre-defined function that returns memory address of specified variable.

a=10
print("Val :",a)
print("Addr :",id(a))
a=a+5
print("Val :",a)
print("Addr :",id(a))

[Link] Contact – 98859 46789 Page - 85

Object Oriented Programming features are:
1. Encapsulation
2. Inheritance
3. Polymorphism
4. Abstraction

Note: We implement Object-Oriented functionality using Classes and Objects

Class: Class contains variables and methods. Java application is a collection of classes
Syntax Example
class Account:
num;
class ClassName: balance;
Variables ; withdraw():
& logic;
Methods ; deposit():
logic;

Object: Object is an instance of class. Instance (non static) variables of class get memory inside
the Object.

Syntax: refVariableName = ClassName();

Example: acc = Account();
Note: Class is a Model from which we can define multiple objects of same type

Encapsulation:
• The concept of protecting the data with in the class itself.
• Implementation rules:
o Class is Public (to make visible to other classes).
o Variables are Private (other objects cannot access the data directly).
o Methods are public (to send and receive the data).

[Link] Contact – 98859 46789 Page - 86

Inheritance:
• Defining a new class by re-using the members of other class.
• We can implement inheritance using “extends” keyword.
• Terminology:
o Parent/Super class: The class from which members are re-used.
o Child/Sub class: The class which is using the members

Abstraction:
• Abstraction is a concept of hiding implementations and shows functionality.
• Abstraction describes "What an object can do instead how it does it?".

Polymorphism:
• Polymorphism is the concept where object behaves differently in different situations.

[Link] Contact – 98859 46789 Page - 87

Class Members or Static members:
• Defining variable or method inside the class.
• We can access these members using class name.

Note: Generally, we access the variables and functions directly after definition.
a=10
def test():
print("test")
return
print("a val :",a)
test()

• In Object Oriented application, variables and methods must be defined inside the class.
• “class” is a keyword.
• Defining variable and method inside the class called “static members”
• We need to access static members using identity of class.
class Test:
a=10 # static
def fun():
print("static fun")
return
print("a val :",Test.a)
[Link]()

Connect classes:
• One python file allowed to define any number of classes
• We can access the members of these classes using “class names”
class First:
def fun():
print("First class fun")
return
class Second:
def fun():
print("Second class fun")
return
class Access:
def main():
print("starts @ main")
[Link]()
[Link]()
return

[Link]()

[Link] Contact – 98859 46789 Page - 88

Local and Static variables:
• Defining a variable inside method is called local variable
• We access local variables directly but only from the same block in which it has defined.
• Defining a variable inside the class and outside to all methods is called static variable.
• We can access static variable using class name.
class Access:
a=10 #static
def main():
a=20 #local
print("local a :", a)
print("static a :", Access.a)
return

[Link]()

Global variables:
• Defining variables outside to all classes.
• We access global variables directly.
• When we access variable inside the method, it is looking for local variable first. If the
local variable is not present, it accesses the global variable.

a=10#Global
classAccess:
a=20 #Static
defm1():
a=30 #Local
print("Inside m1")
print(a)
print(Access.a)
return

defm2():
print("Inside m2")
print(a)
print(Access.a)
return

defmain():
Access.m1()
Access.m2()
return
[Link]()

[Link] Contact – 98859 46789 Page - 89

Dynamic members

Dynamic Members:
• The specific functionality of Object must be defined as dynamic.
• We access dynamic members using object.
• We can create object for a class from static context.

Dynamic method:
• Defining a method inside the class by writing “self” variable as first argument.
• “self” is not a keyword.
• “self” is a recommended variable to define Dynamic methods.
• Definition of dynamic method as follows.

classTest:
defm1():
#static method
return

defm2(self):
#dynamic method
return

def__init__(self):
#constructor
return

self:
• Itis used to define dynamic methods and constructor.
• Itis not a keyword but it is the most recommended variable to define dynamic
functionality.
• Itis an argument(local variable of that function)
• We can access “self” only from the same function or constructor.
• “self” variable holds object address.

Constructor:
• A special method withpre-defined identity( __init__).
• It is a dynamic method(first argument is self)
• It invokes automaticallyin the process of Object creation.

[Link] Contact – 98859 46789 Page - 90

Creating objectinmain():
• Applicationexecution starts from static context(main).
• Wecanaccess non static members using object address.
• Wecreateobject(take permission) in static context(main)

class Test:
def __init__(self):
print("Constructor")
return
def main():

Test()#accessconstructor
return

[Link]()

Constructorexecutes every time when we create the object.

class Test:
def __init__(self):
print("Constructor")
return

def main():
foriinrange(10):
Test()
return
[Link]()

[Link] Contact – 98859 46789 Page - 91

Program that display address of object created:
class Test:
def __init__(self):
print("Address :",self)
return

def main():
Test()
return

[Link]()

id():Apre-defined method that returns integer value of specified Object.

classTest:
def__init__(self):
print("Address :",id(self))
return

Test()

type():Returns the class name of specified object.

classTest:
def__init__(self):
print("Name :",type(self))
return

Test();

Wecannot access ‘self’ in main() method to work with object.

classTest:
def__init__(self):
print("In Constructor :",id(self))
return

Test()
print("In main :", id(self))

[Link] Contact – 98859 46789 Page - 92

Object reference variable:
• Constructor returns address of Object after creation.
• We can collect the address assigning to any variable.
• The variable stores object address is called “Object reference variable”

Wecandisplay object address in main using “object reference variable.

classTest:
def__init__(self):
print("In Constructor :",id(self))
return

defmain():
addr = Test()
print("In main :", id(addr))
return
[Link]()

Accessstatic and dynamic methods from main:

classTest:
defm1():
#static method
return

defm2(self):
#dynamic method
return

[Link] Contact – 98859 46789 Page - 93

Default constructor:
• In objectcreation process, constructor executes implicitly.
• Whenwedon’tdefine any constructor, a default constructor will be added to the source
code.
• Defaultconstructor has empty definition – no logic.

class Test:

def main():
x = Test()
y = Test()
print("Addressofx : ", id(x))
print("Addressofy : ", id(y))
return
[Link]()

We can define the default constructor explicitly to understand the object creation process.
class Test:
def __init__(self):
print("ObjectCreated :", id(self))
return

def main():
x = Test()
y = Test()
print("Addressofx : ", id(x))
print("Addressofy : ", id(y))
return
[Link]()

Accessing static and dynamic methods:

class Test:
def main():
obj = Test()
Test.m1()
obj.m2()
return

def m1():
print("Staticmethod")

[Link] Contact – 98859 46789 Page - 94

return

def m2(self):
print("Dynamic method")
return

[Link]()

Dynamic variables:
Static Variables Dynamic Variables
Static variables store common information of We create dynamic variables inside the object
Object. using ‘self’ variable.
Static variables get memory only once. Variables creation must be from constructor.
We can access static variables using class We can access the variables through object
Name address.

Constructor is used to define dynamic variables:

• Constructor is a special method
• Execute every time automatically in object creation process.
• Constructors used to create dynamic variables.
• As soon as object memory is ready, constructor allocates memory to dynamic variables
inside the object.

Access instace variables:

class Test :
def __init__(self):
self.x = 10
self.y = 20

[Link] Contact – 98859 46789 Page - 95

return

def main():
obj = Test()
print("x val :", obj.x)
print("y val :", obj.y)
return
[Link]()

Note: In the above program, if we assign values directly to dynamic variables, all objects
initializes with same set of values.
class Test:
def __init__(self):
self.a = 10
return

def main():
t1 = Test()
print("t1 a val :", t1.a)

t2 = Test()
print("t2 a val :", t2.a)
return

[Link]()

[Link] Contact – 98859 46789 Page - 96

Arguments constructor:
• Constructor taking input values to initialize dynamic variables in Object creation
process.
• Using arguments constructor, we can set different values to different object variables.
• Arguments are local variables and we can access directly.

class Test :
def __init__(self, a, b):
self.x = a
self.y = b
return

def main():
obj = Test(50,60)
print("x val :", obj.x)
print("y val :", obj.y)
return

[Link]()

• Local variables and dynamic variables can have the same identity.
• We access the local variable directly where as dynamic variable using object address.

class Test:
def __init__(self,a,b):
self.a = a

[Link] Contact – 98859 46789 Page - 97

self.b = b
return

def main():
obj = Test(10,20)
print("a val :", obj.a)
print("b val :", obj.b)
return
[Link]()

WAP to construct the object by taking user input:

class Test:
def __init__(self,a,b):
self.a = a
self.b = b
return

def details(self):
print("a val :", self.a)
print("b val :", self.b)
return

def main():
print("Enter a, b values :")
a = input()
b = input()
obj = Test(a,b)
[Link]()
return
[Link]()

Read Emp details and Construct object:

classEmp:
def__init__(self, num, name):
[Link] = num
[Link] = name
return

defdetails(self):
print("Emp num is :", [Link])
print("Emp name is :", [Link])
return

[Link] Contact – 98859 46789 Page - 98

print("Enter empdetails:")
num = int(input())
name = input()
obj = Emp(num,name)
[Link]()

Account Operations program:

class Account:
def __init__(self,amt):
[Link]= amt
return

def deposit(self,amt):
[Link]=[Link]+amt
print(amt,"deposited")
return

def withdraw(self,amt):
print("Withdrawing:",amt)
print("Availbal:",[Link])
if(amt<=[Link]):
print("Collectcash:",amt)
[Link]=[Link]-amt
else:
print("Error:Lowbalance")
return

class Bank:
def main():
amt=int(input("Enterinitial bal:"))
acc = Account(amt)
print("Balance is :",[Link])

amt = int(input("Enter deposit amt :"))

[Link](amt)
print("After deposit :",[Link])

amt=int(input("Enterwithdraw amt:"))
[Link](amt)
print("Final balance :",[Link])
return

[Link]()

[Link] Contact – 98859 46789 Page - 99

Access Modifiers
Access Modifiers:
• Access modifiers are used to set permissions to access the data.
• Python supports 3 access modifiers.
o private( _ _var)
o protected ( _var)
o public ( var)

Note: Protected members can be discussed with Inheritance concept.

public:
• We can access public members (variables or methods) directly.
• All programs discussed before contains public variables and methods.

class Test:
a=10
def __init__(self,b):
self.b = b
return

class Access:
def main():
obj = Test(20)
print("a val :", Test.a)
print("b val :", obj.b)
return

[Link]()

Private members:
• A member definition preceded by _ _ is called private member.
• One object(class) cannot access the private members of another object directly.
Note: A class itself can access the private members.
class First:
a = 10 #public
__b = 20 #private

def main():
print("a val :", First.a)
print("b val :", First.__b)
return
[Link]()

[Link] Contact – 98859 46789 Page - 100

Accessing private members of another class results Error:
class First:
a = 10 #public
__b = 20 #private

class Second:
def main():
print("a val :", First.a)
print("b val :", First.__b)
return

[Link]()

Private dynamic variables creation and Access:

class First:
def __init__(self,x,y):
self.a = x # 'a' is public
self.__b = y # 'b' is private
return

def main():
obj = First(10,20)
print("a val : ", obj.a)
print("b val : ", obj.__b)
return

[Link]()

Accessing private variables from other class results error:

class First:
def __init__(self,x,y):
self.a = x
self.__b = y
return

class Second:
def main():
obj = First(10,20)
print("a val : ", obj.a)
print("b val : ", obj.__b)
return

[Link]()

[Link] Contact – 98859 46789 Page - 101

Accessing private variables from another class:
• One class cannot access the private information from another class directly.
• A class(object) is allowed to share(send or receive) the private data in communication.
• Communication between objects is possible using methods.
• Two standard methods get() and set() to share the information.

class First:
__a = 10
def getA():
return First.__a

class Second:
def main():
# print("a val : ", First.__a)
print("a val : ", [Link]())
return

[Link]()

Accessing dynamic private variable using dynamic get() method:

class First:
def __init__(self,a):
self.__a = a
return

def getA(self):
return self.__a

class Second:
def main():
obj = First(10)
# print("a val : ", obj.__a)
print("a val : ", [Link]())
return

[Link]()

Modifying private variables data:

• We cannot set values directly to private variables.
• We use set() method to modify the data.

Note: When we try set the value directly to private variable, the value will be omitted.

[Link] Contact – 98859 46789 Page - 102

class First:
__a=10
def getA():
return First.__a
def setA(a):
First.__a = a
return

class Second:
def main():
print("aval:",[Link]())
First.__a=20
print("aval:",[Link]())
[Link](20)
print("aval:",[Link]())
return

[Link]()

Setting values to dynamic private variables:

class First:
def __init__(self,a):
self.__a = a
return
def getA(self):
return self.__a
def setA(self,a):
self.__a = a
return

class Second:
def main():
obj=First(10)
print("aval:",[Link]())
[Link](20)
print("aval:",[Link]())
return

[Link]()

[Link] Contact – 98859 46789 Page - 103

Encapsulation: The concept of protecting object information.
Rules:
1. Class is public – Object is visible to other objects in communication.
2. Variables are private – One object cannot access the information of other object
3. directly.
Communication between objects using get() and set() methods to share the
information.
class Emp:
def __init__(self,num,name,salary):
self.__num = num
self.__name = name
self.__salary = salary
return

def getNum(self):
return self.__num
def getName(self):
return self.__name
def getSalary(self):
return self.__salary

def setNum(self,num):
self.__num = num
return
def setName(self,name):
self.__name = name
return
def setSalary(self,salary):
self.__salary = salary
return

class Access:
def main():
print("Enter Emp details :")
num = int(input("Emp Num : "))
name = input("Emp Name : ")
salary = float(input("Emp Sal : "))
obj = Emp(num, name, salary)
print("Name :",[Link]())
return
[Link]()

[Link] Contact – 98859 46789 Page - 104

Inheritance in Python

Inheritance:
• Defining an object by re-using the functionality of existing object.
• The main advantage of inheritance in code re-usability.

Terminology of inheritance :
• Parent – Child class
• Super – Sub class
• Base – Derived class
.
Types of Inheritance:
• Python supports all types of inheritance supported by Object Oriented Programming.
• The following diagram represents all types

Single Inheritance:
• In parent-child relation, we can access the functionality of Parent through child.
• We cannot access Child functionality using Parent.
• Accessing static members in Parent and Child as follows:
class Parent:
def m1():
print("Parent's m1")
return

class Child(Parent):
def m2():
print("Child's m2")
return

class Inheritance:
def main():
Child.m1()
Child.m2()

[Link]()

[Link] Contact – 98859 46789 Page - 105

Accessing dynamic functionality in Parent-Child relation:
class Parent:
def m1(self):
print("Parent's m1")
return

class Child(Parent):
def m2(self):
print("Child's m2")
return

class Inheritance:
def main():
c = Child()
c.m1()
c.m2()

[Link]()

Method overriding:
• Defining a method in the Child class with same name and same set of arguments of
Parent class method.
• When two methods in Parent and Child with the same identity, it gives the first priority to
Child object.

classParent:
deffun(self):
print("Parent's fun()")
return

classChild(Parent):
deffun(self): #override
print("Child's fun()")
return

classInheritance:
defmain():
obj = Child()
[Link]()
return

[Link]()

[Link] Contact – 98859 46789 Page - 106

Advantage of overriding:
• Overriding is the concept of updating existing object functionality when it is not
sufficient to extended object.
• Re-writing the function logic with the same identity.

Complete Inheritance with Code program:

# 1. Accessing existing functionality
# 2. Adding new features
# 3. Update(override) existing features

classGuru:
defcall(self):
print("Guru - Call")
return
defcamera(self):
print("Guru - Camera - 2MP")
return

classGalaxy(Guru):
defvideoCall(self):
print("Galaxy - Video Call")
return
defcamera(self):
print("Galaxy - Camera - 8MP")
return

classInheritance:
defmain():
g1 = Galaxy()
[Link]()# Access existing
[Link]()# new feature
[Link]() #updated
g2 = Guru()
[Link]()
[Link]()
[Link]() # error:
return

[Link]()

[Link] Contact – 98859 46789 Page - 107

Accessing overridden functionality of Parent class:
super():
• It is pre-defined method.
• It is used to access Parent class functionality(super) from Child(sub).

class Grand:
def fun(self):
print("Grand")
return

class Parent(Grand):
def fun(self):
super().fun()
print("Parent")
return

class Child(Parent):
def fun(self):
super().fun()
print("Child")
return

class Inheritance:
def main():
obj = Child()
[Link]()
return

[Link]()

• We can access the functionality of all classes in the hierarchy from one place using
super() method.
• We need to specify the Class type along with object reference variable.
• If we specify the Child type, it access Parent functionality.

class Grand:
def fun(self):
print("Grand")
return

class Parent(Grand):
def fun(self):
print("Parent")

[Link] Contact – 98859 46789 Page - 108

return

class Child(Parent):
def fun(self):
print("Child")
return

class Inheritance:
def main():
obj = Child()
[Link]()
super(Child, obj).fun()
super(Parent, obj).fun()
return

[Link]()

Accessing the functionality in Multiple Inheritance:

• While accessing the functionality of Multiple Inheritance or Hybrid Inheritance, we need
to understand the concept of MRO(Method Resolution Order).
• MRO is the concept of how the Interpreter searching for methods while accessing using
Child object address.

class A:
defm1(self):
print("A-m1")
return

defm3(self):
print("A-m3")
return

[Link] Contact – 98859 46789 Page - 109

class B:
def m1(self):
print("B-m1")
return

def m2(self):
print("B-m2")
return

class C(A,B):
def m3(self):
print("C-m3")
return

class Multiple:
def main():
c = C()
c.m3()
c.m2()
c.m1()
return

[Link]()

[Link] Contact – 98859 46789 Page - 110

Accessing the complete functionality of all objects in multiple inheritance:
class A:
def m1(self):
print("A-m1")
return

def m3(self):
print("A-m3")
return

class B:
def m1(self):
print("B-m1")
return

def m2(self):
print("B-m2")
return

class C(A,B):
def m3(self):
print("C-m3")
return

class Multiple:
def main():
obj = C()
obj.m1()
obj.m2()
obj.m3()
super(C,obj).m1()
super(C,obj).m2()
A.m3(obj)
B.m1(obj)
return

[Link]()

[Link] Contact – 98859 46789 Page - 111

Hybrid inheritance:

[Link] Contact – 98859 46789 Page - 112

Polymorphism in Python

Polymorphism:
• Defining an object(class) that shows different behavior(methods) with the same identity.
• Polymorphism is of 2 types
o Compile time polymorphism
o Runtime polymorphism

Compile
• time polymorphism:
• Itisalsocalled “Static binding”.
• Itis“Method Overloading” technique.
Definingmultiple methods with same name and different set of arguments is called
• “Overloading”.
Dependson input values, corresponding method executes.

Note:Pythondoesn’t support method overloading. When we define a duplicate method,

existingmethodwill be replaced.

class Calc:
def add(a,b):
res=a+b
print("Sumof 2 num's :", res)
return

defadd(a,b,c):# replace exising add() method

res=a+b+c
print("Sumof 3 num's :", res)
return

class Overload:
def main():
[Link](10,20,30)
[Link](10,20) # error
return

[Link]()

How can we implement overloading in python?

• In other programming languages, we can define overloading by writing multiple
methods either with different types of input or with different length of input.
• As python doesn’t support data types, we can pass different types of data into same
variables.

[Link] Contact – 98859 46789 Page - 113

class Calc:
def add(a,b):
res=a+b
print("Sum:", res)
return

class Overload:
def main():
[Link](10,20)
[Link](2.3,4.5)
[Link]("Python","Class")
return
[Link]()

Python supports variables arguments function. We can pass different length of arguments to
a single method.

class Calc:
def add(*arr):
l = len(arr)
sum=0
for ele in arr:
sum=sum+ele
print("Sumof",l,"elements :",sum)
return

class Overload:
def main():
[Link](10,20)
[Link](10,20,30)
[Link](10,20,30,40,50)
return
[Link]()

[Link] Contact – 98859 46789 Page - 114

Runtime Polymorphism:
• It is called “dynamic binding”.
• It is method “overriding technique”.
• Overriding is the concept of defining a method in Child class with the same name and
same set of arguments in Parent class method.
• A Child object can shows the functionality of Parent and Child. Hence it is called
Polymorphic

classGrand:
deffun(self):
print("Grand")
return

classParent(Grand):
deffun(self):
print("Parent")
return

classChild(Parent):
deffun(self):
print("Child")
return

classOverride:
defmain():
obj = Child()
[Link]()
super(Child,obj).fun()
super(Parent,obj).fun()
return

[Link]()

[Link] Contact – 98859 46789 Page - 115

Exception Handling in Python
Exception Handling:
• Exception is a Class
• Exception is a Runtime Error
• When exception rises, the flow of execution will be terminated with informal information
to the user.

Division by Zero: This program attempts to divide 10 by 0, which will raise a ZeroDivisionError
because division by zero is undefined.

result = 10 / 0

Accessing an Index Out of Range: This program tries to access an element at index 5 in a list
with only 3 elements. It will raise an IndexError because the index is out of range.

my_list = [1, 2, 3]
element = my_list[5]

Value Error (Type Conversion): Here, we attempt to convert the string "abc" to an integer
using int(). This will raise a ValueError because "abc" is not a valid integer.

value = int("abc")

Note the followings:

• Exception handling is the concept of working with failure cases in app developement.
• As a programmer, we need to analyze success cases and failure cases in the transaction
to implement the code.

Default Exception handler:

• It is a pre-defined program.
• When exception raises, an object will be created with the complete information of that
Error is called “Exception Object”.
• It is recommended to handle every exception in the application.
• If we don’t handle, the object will be transferred to “Default Exception Handler”

Handling the exceptions:

Try:
• Try block is used to place the doubtful code that may raise exception.
• If exception raises in try block, an exception object will be raised with the error
information.

Except:
• Except block is used to collect and handle the exception object which is raised in try
block.

[Link] Contact – 98859 46789 Page - 116

Division by Zero Exception Handling:
try:
result = 5 / 0
except ZeroDivisionError as e:
print("Error:", e)
print("Division by zero is not allowed.")

Value Error (Invalid Conversion) Handling:

try:
value = int("abc")
except ValueError as e:
print("Error:", e)
print("Invalid conversion.")

Index Error (List Index Out of Range) Handling:

try:
my_list = [1, 2, 3]
element = my_list[5]
except IndexError as e:
print("Error:", e)
print("Index out of range.")

KeyError (Dictionary Key Not Found) Handling:

try:
my_dict = {"name": "Alice", "age": 30}
value = my_dict["city"]
except KeyError as e:
print("Error:", e)
print("Key not found in the dictionary.")

FileNot Found Error Handling:

try:
file = open("non_existent_file.txt", "r")
except FileNotFoundError as e:
print("Error:", e)
print("File not found.")

[Link] Contact – 98859 46789 Page - 117

try with multi except: One try block can have more than one except blocks to handle different
types of exceptions occur in different lines of code. Only one except block executes among we
defined.
try:
print("Enter 2 numbers:")
x=int(input())
y=int(input())
print("Result:", x / y)

exceptValueError:
print("Exception: Invalid input")

exceptZeroDivisionError:
print("Exception: Denominator should not be zero")

print("End")

Handling IndexError for List Access:

try:
my_list=[1, 2, 3]
index=int(input("Enter an index: "))
value=my_list[index]
print("Value at index", index, "is", value)

exceptIndexError:
print("Exception: Index out of range.")

exceptValueError:
print("Exception: Invalid index input.")

print("End")

Exceptionclass:
• “Exception” is pre-defined class.
• “Exception” is the Parent class of all other exception classes.
• Instead of handling multiple exceptions with number of except blocks, we can specify
“Exception” type to handle all.
• We need to provide the common the error information to handle using “Exception” class.

Note: We can display the message of Exception object by collecting into variable in “except”
block.

[Link] Contact – 98859 46789 Page - 118

try:
print("Enter 2 numbers:")
x = int(input()) y =
int(input())
print("Result:", x / y)

except Exception:
print("Exception: Denominator should not be zero")

print("End")

Finally block: It is used to provide “Resource releasing logic”. All resources (connected to
program) must be closed from finally block.
Note: Finally block executes whether or not an exception has raised in the try block.

class Finally:
def main():
try:
x = 10/5
print("Try block")
except Exception:
print("Except block")
finally:
print("Finally block")
return

[Link]()

Finally block executes though exception occurs

class Finally:
def main():
try:
x = 10/0
print("Try block")

except Exception:
print("Except block")

finally:
print("Finally block")

return
[Link]()

[Link] Contact – 98859 46789 Page - 119

Open and Close the File using Finally block:
• open()ispre-defined and it is used to open the file in specified path.
• Ifthefileisnotpresent, it raises Exception.

Opening a text file:

try:
file=open("[Link]")
print("File opened...")

exceptFileNotFoundError:
print("Exception:Nosuch file")

Closing the File:

file = None
try:

file=open("[Link]")
print("File opened...")

exceptFileNotFoundError:
print("Exception:Nosuch file")

finally:
if file is not None:
[Link]()

Closing the File using locals():

try:
file=open("[Link]")
print("File opened...")

exceptFileNotFoundError:
print("Exception:Nosuch file")

finally:
if'file'inlocals()andnot [Link]:
[Link]()

[Link]()

Closing the File:

class Finally:
file = None
def main():
try:
[Link] = open("[Link]")
print("File opened...")

exceptFileNotFoundError:
print("Exception : No such file")

finally:
[Link] != None:
[Link]()
print("File closed...")
return

[Link]()

Custom Exceptions:
• Pythonlibrary is providing number of exception classes.
• Asaprogrammer, we can define custom exceptions depends on application
requirement.
• Everycustom exception should extends the functionality of pre-defined Exception class.

raise:
• It is a keyword.
• It is used to raise Custom Exception explicitly by the programmer.
• Pre-defined exceptions will be raised automatically when problem occurs.
• If we don’t handle the exception, Default Exception Handler handles.

[Link] Contact – 98859 46789 Page - 121

class CustomError(Exception):
def __init__(self,name):
[Link]=name
return

class RaiseException:
def main():
obj = CustomError("Error-Msg")
raise obj
return

[Link]()

Handling Custom Exception:

• Generally exception rises inside the function.
• We need to handle the exception while calling the function.
• When exception has raised, the object will be thrown to function calling area.
class CustomError(Exception):
def __init__(self,name):
[Link]=name
return

class Test:
def fun():
obj = CustomError("Message")
raise obj
return

class Access:
def main():
try:
[Link]()
except CustomError as e:
print("Exception :",e)
return

[Link]()

Exceptions in Banking application:

• Runtime error is called Exception.
• When we perform the transaction, in case of any error in the middle of transaction called
“Runtime error”.
• We must define every error as Exception.

[Link] Contact – 98859 46789 Page - 122

The following example explains how to define Runtime Errors in Banking trasactions.

class LowBalanceError(Exception):
def __init__(self,name):
[Link] = name
return

class Account:
def __init__(self,balance):
[Link] = balance
return

def withdraw(self,amount):
print("Trying to withdraw :",amount)
print("Avail bal :",[Link])
if amount <= [Link]:
print("Collect cash :",amount)
[Link]=[Link]-amount
else:
err=LowBalanceError("Low Balance")
raise err
return

class Bank:
def main():
amount = int(input("enter amount :"))
acc = Account(amount)
print("Balance is :",[Link])

amount = int(input("Enter withdraw amt :"))

try:
[Link](amount)
except LowBalanceError as e:
print("Exception :",e)
print("Final Balance is :",[Link])
return

[Link]()

[Link] Contact – 98859 46789 Page - 123

Inner classes

Inner class: Defining a class inside another class. It is also called Nested class.

Syntax:
classOuter:
.....
logic
.....
class Inner:
.....
logic
.....

Accessingstatic functionality:
• Staticmembers we access using class name.
• Innerclass can be accessed using Outer class name.

class Outer:
def m1():
print("Outer-m1")
return

class Inner:
def m2():
print("Inner-m2")
return

class Access:
def main():
Outer.m1()
[Link].m2()
return

[Link]()

Accessingdynamic functionality:
• Wecanaccess dynamic member through object address.
• Wecreate object for inner class with the reference of outer class only.

[Link] Contact – 98859 46789 Page - 124

class Outer:
def m1(self):
print("Outer-m1")
return

class Inner:
def m2(self):
print("Inner-m2")
return

class Access:
def main():
obj1=Outer()
obj1.m1()
obj2=[Link]()
obj2.m2()
return

[Link]()

We create object directly to inner class as follows:

class Outer:
class Inner:
def fun(self):
print("Inner-fun")
return

class Access:
def main():
#obj1=Outer()
#obj2=[Link]()
#[Link]()
Outer().Inner().fun()
return

[Link]()

[Link] Contact – 98859 46789 Page - 125

Local innerclasses:
• Definingaclass inside the method.
• Toaccessthat class, first control should enter into that function.
• Weinvokethe functionality of local inner class from that function.

class Outer:
def fun():
print("Outer-fun")

classLocal:
def fun():
print("Outer-Local-fun")
return

[Link]()
return

class Access:
def main():
[Link]()
return

[Link]()

Wecandefineduplicate classes in different functions:

class Outer:
def m1():
print("Outer-m1")
classLocal:

def fun():
print("m1-Local-fun")
return

[Link]()
return

def m2():
print("Outer-m2")
classLocal:

def fun():

[Link] Contact – 98859 46789 Page - 126

print("m2-Local-fun")
return

[Link]()
return

class Access:
def main():
Outer.m1()
Outer.m2()
return

[Link]()

We can define a local inner class inside another local inner class. But it is complex to
access the functionality.
class Outer:
def fun(self):
print("Outer-fun")

classLocal:
deffun(self):
print("Outer-Local-fun")

classInner:
deffun(self):
print("Outer-Local-Inner-fun")
return

Inner().fun()
return

Local().fun()
return

class Access:
def main():
Outer().fun()
return

[Link]()

[Link] Contact – 98859 46789 Page - 127

Python Modules

Importance of Modularity:
• When people write large programs they tend to break their code into multiple different
files for ease of use, debugging and readability.
• In Python we use modules to achieve such goals.
• Modules are nothing but files with Python definitions and statements.
• The name of the file should be valid Python name (think about any variable name) and in
lowercase

Pre-defined modules:
• threading : To implement Parallel processing
• gc : For Garbage collection
• tkinter : To implement GUI programming
• time : To find system time and data and to display in different formats
• numpy : One, two and Multi dimensional
• re : Regular expressions
• mysql : Python – MySQL database connectivity

connecting modules using import:

• import is a keyword.
• import is used to connect the modules to access their members.

Function based modules:

• A module cannot contain classes(object oriented programming).
• We have such type of library modules like time, data and so on.
• We access the functions using module name after import.

[Link]:
defadd(a,b):
c=a+b
return c

defsubtract(a,b):
c=a-b
return c

defmultiply(a,b):
c=a*b
return c

[Link] Contact – 98859 46789 Page - 128

[Link]:
import arithmetic
print("Enter 2 numbers :")
a = int(input())
b = int(input())

res = [Link](a,b)
print("Add result :",res)
res = [Link](a,b)
print("Subtract result :",res)
res = [Link](a,b)
print("Multiply result :",res)

Why we need to call the function using module name after import?
• We can define members with same identity in different modules
• We access the duplicate members from different modules by using the identity of
module while accessing.

[Link]:
deff1():
print("one-f1()")
return

deff2():
print("one-f2()")
return

[Link] Contact – 98859 46789 Page - 129

[Link]:
def f1():
print("two-f1()")
return

def f2():
print("two-f2()")
return

[Link]:
import one
import two

one.f1()
one.f2()
two.f1()
two.f2()

Class Based modules:

• A module is a collection of classes.
• A class is a collection of variables and methods
• To access the class members we need to import the module.

[Link] Contact – 98859 46789 Page - 130

[Link]:
class ABC:
def m1():
print("one-ABC-m1()")
return

class XYZ:
def m2(self):
print("one-XYZ-m2()")
return

[Link]:
import one
class Access:
def main():
[Link].m1()
obj=[Link]()
obj.m2()
return

[Link]()

from:
• “from is a keyword used to access one or more classes from the specified module.
• Note that, no need to specify the module name along with class name if we import using
“from”

Syntax:
from module import class
Or
from module import *
Or
from module import class1, class2, class3

[Link] Contact – 98859 46789 Page - 131

Accessing duplicate classes from different modules:
[Link]:
classABC:
defm1():
print("one-ABC-m1()")
return

classXYZ:
defm2():
print("one-XYZ-m2()")
return

[Link]:
classABC:
defm1():
print("two-ABC-m1()")
return

classXYZ:
defm2():
print("two-XYZ-m2()")
return

[Link]:
importone
importtwo

classAccess:
defmain():
[Link].m1()
[Link].m2()

[Link] Contact – 98859 46789 Page - 132

[Link].m1()
[Link].m2()
return

[Link]()

• When we import classes using ‘from’ keyword, we cannot work with duplicate classes
from different modules.
• Duplicate class replace the existing class as follows

[Link] Contact – 98859 46789 Page - 133

Multi threading

Multi-threading is a process of executing two or more threads(programs) simultaneously to

utilize the processor maximum.

Multi-tasking:
• We can implement multi-tasking in two ways.
o Program(process) based
o Sub program(thread) based.

Note: Multi tasking is the concept of maximum utilization of Processor.

Multi threading:

• Task is a program( or process)

• Thread is a sub program ( or sub process)
• We can execute multiple threads from single process.
•Using multi-threading, we can reduce the stress on processor.

Creating Thread:
• Python provides a threading module that allows you to create and manage threads in
your program.
• To create a new thread, you can define a new class that extends the [Link]
class and override the run() method.

#Example:
importthreading
classMyThread([Link]):

defrun(self):
#Code to be executed in the new thread

[Link] Contact – 98859 46789 Page - 134

You can start a new thread by creating an instance of the class and calling its start()
method.
# Example:
my_thread = MyThread()
my_thread.start()

Single threaded application:

• Every python program is single threaded.
• In single threaded application, execution starts at main() and ends at same.
• Main() thread is called default thread.

class Numbers:
def display(self):
for i in range(50):
print("i val :",i)
return

class Default:
def main():
print("Starts @ main")
obj = Numbers()
[Link]()
for j in range(50):
print("j val :",j)
print("Ends @ main")
return

[Link]()

Multi threaded application:

• Define a Custom thread and execute along with Default thread.
• Every Custom thread inherits the functionality from “Thread” class.
• “Thread” class is belongs to “threading” module.
• We must define thread logic by overriding run() method of Thread class.

from threading import Thread

class Custom(Thread):
def run(self):
for i in range(50):
print("Custom :" + str(i))
return

class Default:

[Link] Contact – 98859 46789 Page - 135

def main():
obj = Custom()
[Link]()
for j in range(50):
print("Default :" + str(j))
return

[Link]()

sleep():
• A pre-defined method belongs to “time” module.
• Sleep() method is used to stop the current thread execution for specified number of
seconds.
• The following example explains clearly about sleep() method.

from threading import Thread

import time
class Custom(Thread):

def run(self):
for i in range(1,11):
print("custom : " + str(i))
[Link](1)
return

class Default:
def main():
obj = Custom()
[Link]()
for i in range(1,11):
print("default : " + str(i))
[Link](1)
return

[Link]()

Note the Following:

• When multiple threads are execution, any thread can complete the execution first.
• The following example explains that Default thread execution may complete after
Custom thread execution.
• The thread execution completely depends on the logic we defined in that thread.

class Default:
def main():
print("Starts at Default thread")
obj = Custom()
[Link]()
for i in range(1,11):
print("default : " + str(i))
[Link](0.3)
print("Default thread execution completed")
return

[Link]()

Can we call run() method directly?

• run() method is pre-defined in Thread class with empty definition.
• Run() method override by programmer with custom thread logic.
• Start() method allocates separate thread space to execute run() logic parallel.
• If we call run() method directly, it will execute from the same thread space sequentially.

from threading import Thread

import time
class Custom(Thread):

def run(self):
for i in range(1,11):
print("custom : " + str(i))
[Link](1)
return

class Default:
def main():
obj = Custom()
[Link]()

[Link] Contact – 98859 46789 Page - 137

for i in range(1,11):
print("default : " + str(i))
[Link](1)
return

[Link]()

Life cycle of Thread:

• Every thread executes according to Life cycle.
• Life cycle consists
o Creation phase by programmer
o Execution phase by scheduler(OS)
• As a programmer, we need to define and start the thread.
• All threads scheduled by the processor.
• Thread has many states
o Runnable state
o Running state
o Waiting state
o Dead state.
• Every thread should wait in the Queue until processor allocates the memory is called
Runnable state.
• Once the memory has been allocated to thread, it moves to running state. In running
state, thread execute independently.
• From the running state, the thread may fall into waiting state to read user input, sleep
and join methods.
• Once the thread execution completed, it moves to dead state.

[Link] Contact – 98859 46789 Page - 138

How to execute different logics from different threads?

• We can define run()method only once in a Thread class.

• To execute different logics, different run() methods need to override.
• It is possible by defining more than one thread class and override run() method in each
class with different logic.

fromthreadingimportThread
import time
class Custom1(Thread):

def run(self):
for i in range(1,11):
print("custom1:"+str(i))
[Link](1)
return

class Custom2(Thread):
def run(self):
for i in range(50,71):
print("custom2:"+str(i))
[Link](1)
return

class Custom3(Thread):
def run(self):
foriinrange(100,90,-1):
print("custom3:"+str(i))
[Link](3)
return

classDefault:
def main():
c1 = Custom1()
[Link]()
c2 = Custom2()
[Link]()
c3 = Custom3()
[Link]()
return

[Link]()

[Link] Contact – 98859 46789 Page - 139

join() method:
• It is a dynamic method belongs the Thread class.
• It is used to stop current thread execution until joined thread moved to dead state.

from threading import Thread

import time
class Custom(Thread):

def run(self):
for i in range(1,11):
print("custom : " + str(i))
[Link](1)
return

class Default:
def main():
print("Starts @ Default")
c = Custom()
[Link]()
[Link]()
print("Ends @ Default")
return

[Link]()

Thread synchronization:
• The concept of allowing threads sequentially when these threads trying to access same
resource parallel.
• “threading” module is providing “Lock” class to implement thread synchronization.
• Lock class is providing dynamic methods to lock specific logic in the function.
o obj = Lock()
o [Link]()
o [Link]()

import time
from threading import Thread, Lock
class Numbers:
x=0
lock=Lock()
def incrementX():
[Link]()
Numbers.x = Numbers.x+1
[Link]()

[Link] Contact – 98859 46789 Page - 140

return

class Custom1(Thread):
def run(self):
foriinrange(100000):
[Link]()
return

class Custom2(Thread):
def run(self):
foriinrange(100000):
[Link]()
return

classDefault:
def main():
t1 = Custom1()
t2 = Custom2()
[Link]()
[Link]()
[Link]()
[Link]()
print("Finalxval:"+str(Numbers.x))
return
[Link]()

You can also create a thread using the threading. Thread() constructor and passing in a
target function as an argument.
# Example:
import threading
def my_function():

#Codetobeexecuted in the new thread

my_thread=[Link](target=my_function)
my_thread.start()

[Link] Contact – 98859 46789 Page - 141

This program creates two threads that run concurrently and print numbers from 1 to 5.
import threading
def print_numbers():

for i in range(1, 6):

print(f"Number {i}")

thread1 = [Link](target=print_numbers)
thread2 = [Link](target=print_numbers)
[Link]()
[Link]()
[Link]()
[Link]()
print("End of program")

Multithreading with Function Arguments:

import threading
def print_message(message, times):

for _ in range(times):
print(message)

thread1 = [Link](target=print_message, args=("Hello", 3))

thread2 = [Link](target=print_message, args=("World", 3))
[Link]()
[Link]()
[Link]()
[Link]()
print("End of program")

[Link] Contact – 98859 46789 Page - 142

Strings

String: String is a sequence of characters. We can specify strings using single, double or triple
quotes.

Accessing strings: We can access the strings using indexing and slicing
Indexing:
• String array elements index starts with 0
• Using indexing, we can process each character.
• Python supports negative indexing from the end.
• Negative indexing starts with -1 from the end.

s = "python"
print("s[2] :", s[2])
print("s[-3] :", s[-3])

print("Length :", len(s))

print("s[len(s)-1] :", s[len(s)-1])
print("s[-len(s)] :", s[-len(s)])

Slicing: Accessing more than one character from the string.

Syntax : [lower : upper : step]

• Specifying the above values are optional

• Lower value by default 0
• Upper value by default len(string)
• Step value is 1 by default.

s = "python"
print("String is :",s)
print("s[:] :", s[:])
print("s[: :] :", s[: :])

[Link] Contact – 98859 46789 Page - 143

print("s[Link] :", s[Link])
print("s[0:len(s)] :", s[0:len(s)])
s = "python"
print("String is :",s)
print("s[2:5] :", s[2:5])
print("s[-5:-2] :", s[-5:-2])
print("s[2:-2] :", s[2:-2])

s = "python"
print("String is :",s)
print("s[Link]-1] :", s[Link]-1])
print("s[-1:-5:-1] :", s[-1:-5:-1])

Boolean methods - String validation methods:

• String is an Object
• String object is providing pre-defined methods to validate the string.
• These methods are called Boolean methods, these methods always return a Boolean
value (True or False)
• Some of the methods :

s1 = "abc"
print(s1,"is alpha :", [Link]())
print(s1,"is alpha numeric :", [Link]())
print(s1,"is digit :", [Link]())
s1 = "1234"
print(s1,"is alpha :", [Link]())
print(s1,"is alpha numeric :", [Link]())
print(s1,"is digit :", [Link]())
s1 = "abc123"
print(s1,"is alpha :", [Link]())
print(s1,"is alpha numeric :", [Link]())
print(s1,"is digit :", [Link]())
s1 = "abc123$#"
print(s1,"is alpha numeric :", [Link]())
print(s1,"is lower :", [Link]())

[Link] Contact – 98859 46789 Page - 144

Displaying Strings with Quotes: Generally a string can be represented in python using single
or double quotes.

#Output : It is 'Python' online session

line = "It is 'Python' online session"
print(line)

#Output : It is "Python" tutorial

line = 'It is "Python" tutorial'
print(line)

# Output : She said, "It's a good one"

# line = "She said, "It's a good one"" -> Error :
# line = 'She said, "It's a good one"' -> Error :
line = '''She said, "It's a good one"'''
print(line)

#Escape characters
# \n = new line
# \t = tab space
# \\ = \
# \' = '
# \" = "
# Output : This is "Python" session
line = "This is \"Python\" session"
print(line)

# Output : Python's tutorial

line = "Python's tutorial"
print(line)

# Output : She said, "It's a good one"

line = 'She said, "It\'s a good one"'
print(line)

# Output : She said, "It's a good one"

line = "She said, \"It's a good one\""
print(line)

[Link] Contact – 98859 46789 Page - 145

Python Comments:
1. Single line comments
2. Multi line comments - Not supported

Single line comment:

• We use comments to describe the instruction of a program.
• We use # symbol preceded by description
# Single line comment

Multi line comment:

• Python doesn’t support multi line comments.
• Generally they call triple quotes as multi line comment but not correct.
• For example,
'''This
is
Multi line
comment '''

• The above declaration is a string and memory.

• If we collect that String value into any variable, we can display the content of that String.

Comments do not get memory in any programming language as follows.

line = #single line comment
print(line)

Old Style formatting:

• We can display string after formatting
• Python supports C style of formatting using access specifiers.
• Format specifiers like int(%d), float(%f), String(%s) can be used.
• We can also concatenate strings using plus(+) operator.

String representation:
name = input("Enter your name : ")
print("Hello" , name)
print("Hello " + name)
print("Hello %s" %name)

String and Integer concatenation:

name = input("Enter your name : ")
age = int(input("Enter your age : "))
print(name , "age is :" , age)
print(name + " age is : " + str(age))
print("%s age is : %d" %(name,age))

[Link] Contact – 98859 46789 Page - 146

Read and print employee details
print("Enter Emp details : ")
no = int(input())
name = input()
salary = float(input())
print(name + " with id : " + str(no) + " is taking salary : " + str(salary))
print("%s with id : %d is taking salary : %f" %(name, no, salary))

Float representation:
val = 34.567
print("Value is :", val)
print("Value is : %f" %val)
print("Value is : %.3f" %val)
print("Value is : %.2f" %val)
Immutability:

• Python is Object oriented programming language.

• Any information(Number, String or Collection) stores in Object format only.

• Object behavior is either Mutable or Immutable.

• Immutable objects : Numbers , Strings and Tuples
• Mutable Objects : Lists, Sets and Dictionaries

Data types divided into Mutable and Immutable objects as follows:

Note: Immutable objects nothing but constants. We can’t modify once we have created

[Link] Contact – 98859 46789 Page - 147

Numbers:
• Integers and Float values comes under Number type Objects.
• Once we assign any number to a variable that cannot be modified.
• If we try to modify the value, a new object will be creating with modified content.

Code:
a=10
print("a val :", a)
print("Loc :", id(a))

a=a+5
print("Modified a val :", a)
print("Loc :", id(a))

String Immutability:
s1="Hello"
s2="World"
print("s1 val :",s1)
print("s1 loc :",id(s1))
print("s2 val :",s2)
print("s2 loc :",id(s2))
s1=s1+s2
print("Modified s1 val :",s1)
print("s1 loc :",id(s1))
print("s2 val :",s2)
print("s2 loc :",id(s2))

When we try to create multiple String objects with the same content, duplicate objects will not
be created. The address of object will be shared.

s1="Hello"
s2="Hello"
print("s1 val :",s1)
print("s1 loc :",id(s1))
print("s2 val :",s2)
print("s2 loc :",id(s2))

[Link] Contact – 98859 46789 Page - 150

Collection data types

Introduction:
• We use programming languages to develop applications.
• Applications are used to store and process the information.
• In the application, when we use set of elements, it is recommended to use collection
type.
• If we can structure the data while storing, can access more effectively while processing.
• Basic data structure that store elements in consecutive locations is called array.

• Different algorithms were proposed to structure the information in application called

Data structures and Algorithms.
• In some of the languages like C or C++, we need to implement these algorithms
manually to structure the information in application.
• Python collections are pre defined implementations of these algorithms to structure the
data.

Note: The complete functionality of all data structures and algorithms given as 4 simple
collection objects.
List 1.
Tuple2.
Set 3.
4. Dictionary

Array v/s List:

• Python is not allowedthe programmer to create traditional arrays for data processing.
• Python doesn’t supportArrays.
• Array is static (Size isfixed) where as Python is dynamic. This is the one reason that why
python is not allowedarrays.
• In any programminglanguage only arrays can process one dimensional, two dimensional
and multi dimensionaldata easily using indexing.

As Python doesn’t supportArrays, we use third party modules (Numpy & Pandas) to
process elements like arrays.

[Link] Contact – 98859 46789 Page - 151

List Collection

List:
• List is a linear data structure.
• List is an Object contains multiple data items (elements).
• Square brackets are used to enclose the elements of List.
• The elements in List are separated with comma (,) operator.
• List can accept heterogeneous data elements.
• List is allowed to store duplicate elements.

Code:
l1 = [10,20,30,40,50]
print("L1 list :",l1)

l2 = [10,20,10,"abc",34.56]
print("L2 list :",l2)

Accessing Elements: We can access elements of List in 2 ways such as Indexing & Slicing.

Indexing:
• Python index starts from 0 to size-1.
• We can access only one element through indexing.
• Python supports negative indexing also
• Some of the examples as follow.

Code:
l = [10,20,30,40,50]
print("List is :", l)
print("Length :", len(l))
print("l[2] :", l[2])
print("l[-2] :", l[-2])
print("l[len(l)-2] :", l[len(l)-2])
print("l[-(len(l)-3)] :", l[-(len(l)-3)])

[Link] Contact – 98859 46789 Page - 152

Output:
List is : [10, 20, 30, 40, 50]
Length : 5
l[2] : 30
l[-2] : 40
l[len(l)-2] : 40
l[-(len(l)-3)] : 40

Slicing:
• To access more than one element at a time from the collection.
• Slicing representation is as same as range() object

Syntax:
[start-index : stop-index : step]
Start index default value is 0
• Stop index default value is length-1
• Step value modified by 1
•
• When we don’t specify the values of start, stop and step, it will consider default values
and process all elements of List.
• Start index is includes where as stop index value excludes.

Code:
l = [10,20,30,40,50]
print("List is :", l)
print("Length :", len(l))
print("l[:] :", l[:])
print("l[: :] :", l[: :])
print("l[0:len(l):1] :", l[0:len(l):1])
print("l[Link] :", l[Link])
print("l[-5:-2] :", l[-5:-2])

Output:
List is : [10, 20, 30, 40, 50]
Length : 5
l[:] : [10, 20, 30, 40, 50]
l[: :] : [10, 20, 30, 40, 50]
l[0:len(l):1] : [10, 20, 30, 40, 50]
l[Link] : [10, 30, 50]
l[-5:-2] : [10, 20, 30]

[Link] Contact – 98859 46789 Page - 153

List methods:
• List is a pre-defined Object (class).
• List class is providing set of pre-defined methods(dynamic), we access using list object
address.
• Using list functionality, we can process the list elements easily.
• The functionality is used to append, insert, remove, pop, sort, reverse and update the list
as follows.

append(): Function that adds an element at the end of the List and returns the complete list
with appended element.

l = [10,20,30]
print("List :", l)
[Link](40)
print("After append 40 :", l)

count(): Function that returns the specified element count in the List

l = [10, 20, 10, 40, 10]

print("List :", l)
print("Count of 10 :", [Link](10))
print("Count of 40 :", [Link](40))
print("Count of 50 :", [Link](50))

index():
• Function that returns index value of specified element.
• List supports duplicate elements.
• If the specified element is duplicated, it return first occurrence of index.
• Raises an exception if the specified element is not present in the list.

l = [10, 20, 10, 40, 20, 50]

print("List :", l)
print("index of 40 :", [Link](40))
print("index of 20 :", [Link](20))
print("index of 70 :", [Link](70))

Output:
List : [10, 20, 10, 40, 20, 50]
index of 40 : 3
index of 20 : 1
ValueError: 70 is not in list

[Link] Contact – 98859 46789 Page - 154

Insert():
• Function that is used to insert element at specified index.
• After insertion, other elements in the list will shift to right.
• Element will be appended if the specified index is not present in that List.

l = [10,20,10,40]
print("List :", l)
print("insert 50 @ index : 2 :")
[Link](2,50)
print("List :", l)

print("insert 70 @ index : -4 :")

[Link](-4,70)
print("List :", l)

print("insert 90 @ index : 12 :") # append if out of bounds

[Link](12,90)
print("List :", l)

Output:
List : [10, 20, 10, 40]
insert 50 @ index : 2 :
List : [10, 20, 50, 10, 40]
insert 70 @ index : -4 :
List : [10, 70, 20, 50, 10, 40]
insert 90 @ index : 12 :
List : [10, 70, 20, 50, 10, 40, 90]

Deleting elements:
• We can remove the elements of List in many ways.
• List object is providing different methods to remove elements.

pop([index]) :
• Removes the last element from the List when we don’t specify the index.
• Index argument is optional
• We can remove the element by specifying its index also
• Raises Exception if the specified index is not present.

Code:
l= [10, 20, 30, 40, 50]
print("List is :", l)

[Link] Contact – 98859 46789 Page - 155

print("pop() :", [Link]())
print("List is :", l)
print("pop(1) :", [Link](1))
print("List is :", l)
print("pop(4) :", [Link](4))
print("List is :", l)

Output:
List is : [10, 20, 30, 40, 50]
pop() : 50
List is : [10, 20, 30, 40]
pop(1) : 20
List is : [10, 30, 40]
IndexError: pop index out of range

remove(element):
• Removes specified element from the List.
• List allows duplicates.
• Remove the first occurrence of element if the element is duplicated.
• Raises Exception if the specified element is not present in the list.

l = [10, 20, 30, 40, 50, 20]

print("List is :", l)
print("remove(30) :")
[Link](30)
print("List is :", l)
print("remove(20) :")
[Link](20)
print("List is :", l)
print("remove(70) :")
[Link](70)
print("List is :", l)

Output:
List is : [10, 20, 30, 40, 50, 20]
remove(30) :
List is : [10, 20, 40, 50, 20]
remove(20) :
List is : [10, 40, 50, 20]
remove(70) : ValueError: [Link](x): x not in list

[Link] Contact – 98859 46789 Page - 156

clear():
• Removes all elements of List.
• Return an empty List.
• The memory allocated to list will not be de-allocated.

Code:
l = [10,20,30,40,50]
print("List is :", l)

print("clear list :")

[Link]()
print("List is :", l)

print("append(20) :")
[Link](20)
print("List is :", l)

Output:
List is : [10, 20, 30, 40, 50]
clear list :
List is : []
append(20) :
List is : [20]

del:
• It is a keyword.
• It is used to release the memory of Object(here list variable)

Code:
l = [10,20,30,40,50]
print("List is :", l)

print("del list :")

del l
print("List is :", l)

Output:
List is : [10, 20, 30, 40, 50]
del list :
NameError: name 'l' is not defined

[Link] Contact – 98859 46789 Page - 157

extend():
• It is used to merge lists.
• One list will be appended to another list
• List1 will be modified where as List2 remains same.

Code:
l1 = [10, 20, 30]
print("L1 is :", l1)

l2 = [23.45, 56.78]
print("L2 is :", l2)
print("l1 extends l2 :")
[Link](l2)
print("L1 after extend :", l1)

copy():
• A function that is used to copy all elements of List to another list.
• Returns a duplicate copy of specified list.
• Copied list get different memory location.
• List is Mutable (we will discuss later). Hence the location must be different for duplicate
Lists.

Code:
src = [10,20,30]
print("Source list is :", src)
print("Source list location :", id(src))
cpy = [Link]()
print("Copied list is :", cpy)
print("Copied list location :", id(cpy))

Output:
Source list is : [10, 20, 30]
Source list location : 58932360
Copied list is : [10, 20, 30]
Copied list location : 14314432

Note: Only Lists get different memory locations with same set of elements. The duplicates in
both the Lists have same memory locations as follows.

List Operations using operators:

• Lists can be concatenated using + operator. List repetition is possible using * operator.
• “in” operator is used to test whether the element is present or not in the list.
• “in” operator can be used to iterate the list using ‘for’ loop.
• “not in” operator can be used to check whether the element is not present or not in the
List.

Code:
print("List operations using operators :")
a1 = [1,2,3]
a2 = [4,5,6]
print("a1 list :", a1)
print("a2 list :", a2)
print("a1=a1+a2 :")

print("20 is not present :", 20 not in a1)

print("6 is not present :", 6 not in a1)

Output:
List operations using operators :
a1 list : [1, 2, 3] a2 list : [4, 5, 6]
a1=a1+a2 : a1 list : [1, 2, 3, 4, 5,
6] a2 list : [4, 5, 6] a2=a2*3 : a2
list : [4, 5, 6, 4, 5, 6, 4, 5, 6] a1
list : [1, 2, 3, 4, 5, 6] 5 is present
: True 7 is present : False 20 is
not present : True
6 is not present : False

sort():
• sort all elements in the specified list
• All elements in the list should be of same type
• Heterogeneous elements list cannot sort.

Code:
a1 = [10, 40, 20, 50, 30]
print("a1 List is :",a1)
[Link]()
print("Sorted a1 list is :", a1)

a2 = [34.56, 23, "abc"]

[Link] Contact – 98859 46789 Page - 160

print("a2 List is :",a2)
[Link]() # sorting possible only on homogenous data elements
print("Sorted a2 list is :", a2)

Output:
a1 List is : [10, 40, 20, 50, 30]
Sorted a1 list is : [10, 20, 30, 40, 50]
a2 List is : [34.56, 23, 'abc']
TypeError: '<' not supported between instances of 'str' and 'int'

reverse(): Reverse the elements in specified list.

a1 = [10, 40, 20, 50, 30]
print("a1 List is :",a1)
[Link]()
print("Reversed a1 list is :", a1)
a2 = [34.56, 23, "abc"]
print("a2 List is :",a2)
[Link]()
print("Reversed a2 list is :", a2)

Built in Functions can be used with List as follows:

all() : return True if all elements of the List are true (or if the list is empty)
>>> a = [1, 2, 0]
>>> all(a)
False
>>> a = [1, 2, 3]
>>> all(a)
True
>>> a = []
>>> all(a)
True

any() : Return True if any one of List element is True. Returns False if the List is empty.
>>> arr = [1,2,0]
>>> any(arr)
True
>>> arr = [1,2,3]
>>> any(arr)
True
>>> arr = []
>>> any(arr)
False

[Link] Contact – 98859 46789 Page - 161

list():
• List is a class.
• list() is a constructor
• list() is used to construct any empty list object.

arr = list()
print("List is :", arr)
print("Length :", len(arr))
print("Any :", any(arr))

Output:
List is : []
Length : 0
Any : False

We can append elements to empty list by reading at runtime.

arr = list()
print("Initially :", arr)
print("Enter5 elements :")
foriinrange(5):
ele=input()
[Link](ele)
print("Later:", arr)

Output:
Initially : []
Enter5elements :
10
23.42
g
abc
10
Later:['10','23.42', 'g', 'abc', '10']

Sumoflistelements:
print("Sumof list elements")
arr = list()
n=int(input("Enter size : "))
print("Enter%d elements :" %n)
foriinrange(n):
ele=int(input())
[Link](ele)

[Link] Contact – 98859 46789 Page - 162

#logic
res=0
for ele in arr:
res=res+ele
print("Sum is :", res)

Output:
Sum of list elements
Enter size : 5
Enter 5 elements :
6
4
2
8
3
Sumis: 23

max():Returnsthelargest element from the List

min():Returnsminimum element from List
sorted():Returnsanew sorted list of elements (doesn’t sort the list itself)
sum():Returnsthesum of all elements in the List

>>>List=[6,3,8,2,9]
>>> min(List)
2
>>> max(List)
9
>>> sum(List)
28
>>> sorted(List)
[2,3, 6,8, 9]
>>> print(List)
[6,3, 8,2, 9]

Note: We can process elements of collection using Iterators.

# Using for loop:
arr = [10,20,30,40,50]
print("Elements are :")
for ele in arr :
print(ele)

[Link] Contact – 98859 46789 Page - 163

Nested Lists:
• Defining a List as an element inside another list.
• List is an object; hence we connect the nested list by storing the address.

a = [10,20,30,[40,50,60]]
print("List is :", a)
# access using indexing
print("a[1] :",a[1])
print("a[3] :",a[3])

# negative indexing
print("a[-2] :", a[-2])
print("a[-1] :", a[-1])

# using len()
print("len(a) :", len(a))
print("a[len(a)-1] :",

a[len(a)-1])
a = [10,20,30,[40,50,60]]
print("List is :", a)
# access sub list
print("a[3][0] :", a[3][0])
print("a[-1][0] :", a[-1][0])
print("a[3][-3] :", a[3][-3])
print("a[-1][-3] :", a[-1][-3])

# using len()
print("len(a[-1]) :", len(a[-1]))
print("a[len(a)-1] :", a[len(a)-1])
print("a[len(a)-1][len(a[-1])-1]) :",a[len(a)-1][len(a[-1])-1])

[Link] Contact – 98859 46789 Page - 164

• Using index, we can access only one element at a time.
• Through slicing, we can access multiple elements either from list or sub list.

a = [10,20,30,[40,50,60]]
print("List is :", a)
# list slicing
print("a[:] :", a[:])
print("a[: :] :", a[: :])
print("a[0:len(a):1] :", a[0:len(a):1])
print("a[2:len(a)] :", a[2:len(a)])

a = [10,20,30,[40,50,60]]
print("List is :", a)
# sub list slicing
print("a[-1][:] :", a[-1][:])
print("a[-1][1:3] :", a[-1][1:3])
print("a[len(a)-1][0:len(a[-1])] :", a[len(a)-1][0:len(a[-1])])

• Every element in python is an Object.

• An address will store into the location instead of value.

a = [10,20,[30,40]]
print(id(a))
print(id(a[0]))
print(id(a[1]))
print(id(a[2]))
print(id(a[2][0]))
print(id(a[2][1]))

[Link] Contact – 98859 46789 Page - 165

List Mutability:
• List is Mutable
• Mutable object can be modified.
• Address remains same after modification of Mutable object

a = [10, 20]
print("List is :",a)
print("Address :",id(a))
[Link](30)
print("After append, List is :",a)
print("Address :",id(a))
[Link]()
print("After pop, List is :",a)
print("Address :",id(a))

• In Python, Strings, Integers, Floats all elements are Immutable objects.

• Immutable object get another location when we modify.

a = [10,20]
print("List is :", a)
print("Address of a :",id(a))
print("a[0] :", a[0])
print("a[0] address :", id(a[0]))

a[0]=a[0]+5
print("List is :", a)
print("Address of a :",id(a))
print("a[0] :", a[0])
print("a[0] address :", id(a[0]))

• Immutable objects cannot be duplicated.

• Contents with same values will share the memory.

a = [10, 20, 10]

print("List is :", a)
print("id(a[0]) :",id(a[0]))
print("id(a[1]) :",id(a[1]))
print("id(a[2]) :",id(a[2]))

a[2]=a[2]+10
print("id(a[1]) :",a[2])
print("id(a[2]) :",id(a[2]))

Output:
List is : [10, 20, 10]
id(a[0]) : 1647965392
id(a[1]) : 1647965552
id(a[2]) : 1647965392
id(a[1]) : 20
id(a[2]) : 1647965552

[Link] Contact – 98859 46789 Page - 167

• List is Mutable - We can modify the List
• List elements either Mutable or Immutable
LIST = [10, "abc" , [20,30,40] , 23.45]

tuple:
• It is an ordered collection It
• allows duplicates It allows
• heterogeneous elements tuple
• can be represented using ( )

t = (10, 20, 30, 40, 50)

print(t)
t = (10, 20, 10, "abc", 23.45)
print(t)

Output:
(10, 20, 30, 40, 50)
(10, 20, 10, 'abc', 23.45)

Tuple elements can be processed using indexing or slicing.

t = (10, 20, 30, 40, 50)
print("Tuple :",t)
print("t[2] :", t[2])
print("t[-4] :", t[-4])

[Link] Contact – 98859 46789 Page - 168

print("Length :", len(t))
print("t[0:len(t):2] :", t[0:len(t):2])

Output:
Tuple : (10, 20, 30, 40, 50)
t[2] : 30
t[-4] : 20
Length : 5
t[0:len(t):2] : (10, 30, 50)

Note: Tuple is Immutable object. Once the object has been created, cannot be modified.

We can modify the List as well as List elements as follows: List object is providing modification
methods such as append(), pop(), remove(), reverse(), sort()…..
a = [10, 20, 30]
print("List is :",a)
[Link](40) #modifying list
print("List is :",a)
[Link](20)
print("List is :",a)
a[0]=a[0]+5 #modifying list element
print("List is :",a)

Output:
List is : [10, 20, 30]
List is : [10, 20, 30, 40]
List is : [10, 30, 40]
List is : [15, 30, 40]

• Tuple cannot be modified.

• Modification methods are not present in Tuple Object (Immutable)
• Only 2 methods are present in the tuple object.

t = (10, 20, 30)

print(t[0])
10
t[0]=t[0]+5
TypeError: 'tuple' object does not support item assignment

[Link] Contact – 98859 46789 Page - 169

• Tuple elements either Mutable or Immutable.
• Hence we can store a List(Mutable) inside the Tuple.
• We can modify the List(Mutable) which inside the Tuple.

Code:
t = (10,20,[30,40])
print("t[2] :", t[2])
t[2].append(50)
print("After append :", t)
t[2].remove(30)
print("After removal :", t)
print("t[2][1] :", t[2][1])
t[2][1]=t[2][1]+5
print("After modify list element :", t)

Output:
t[2] : [30, 40]
After append : (10, 20, [30, 40, 50])
After removal : (10, 20, [40, 50])
t[2][1] : 50
After modify list element: (10, 20, [40, 55])

List Tuple
List is Mutable Tuple is Immutable
List elements either Mutable or Immutable Tuple elements either Mutable or Immutable
List is ordered and allow duplicates Tuple is ordered and allow duplicates
List allow heterogeneous elements Tuple allow heterogeneous elements
List elements can access using Indexing and Tuple elements can access using indexing and
slicing slicing
Modification methods are present – append(), Modification methods not present – only
pop(), remove()…. index() and count() are given
List and List element can modify Tuple and Tuple elements cannot modify

[Link] Contact – 98859 46789 Page - 170

Set:
• Set is not an ordered collection
• Set element will be processed randomly on access.
• Set can be represented by { }

s = {10, 20, 30, 40, 50}

print(s)
{40, 10, 50, 20, 30}

We can store heterogeneous elements into set

s = {10, 2.3, "abc"}
print(s)
{2.3, 'abc', 10}

Set elements are unique. Duplicates will be removed automatically at the time of creation.
s = {10, 20, 10, 20, 30}
print(s)
{10, 20, 30}

• Set doesn't support indexing.

• Set elements are random; hence we cannot access a particular element through indexing.

s = {10,20,30}
print(s[1])
TypeError: 'set' object does not support indexing

Set functionality:
• 'set' is a class.
• 'set' object providing pre-defined functions to process the elements

s = {10,20,30,40,50}
print("Set :",s)
[Link](60)
print("Set after adding :",s)
[Link](20)
[Link](40)
print("Set after deleting :",s)

Output:
Set : {40, 10, 50, 20, 30}
Set after adding : {40, 10, 50, 20, 60, 30}
Set after deleting : {10, 50, 60, 30}

[Link] Contact – 98859 46789 Page - 171

• Set is Mutable. Hence it is allowed to modify the set after creation.
• add() & discard() function in the above example explains how to modify the set after
creation.

s = {10,20,30}
print("Set :", s)
print("Address :", id(s))

[Link](40)
[Link](10)
print("Set after modify :",s)
print("Address after modify :", id(s))

Output:
Set : {10, 20, 30}
Address : 54403960
Set after modify : {40, 20, 30}
Address after modify : 54403960

• Set is allowed to store only Immutable objects.

• Immutable objects are - Numbers, Strings and Tuple
• Mutable objects - list , set ...

s = {10, 2.34, (10, 20, 30)}

print(s)
{2.34, 10, (10, 20, 30)}

Note: Trying to store a list(mutable) inside the Set result Error

>>> s = {10,[20,30]}
TypeError: unhashable type: 'list'

Set cannot store inside another set(Mutable):

s = {10,{20,30}}
TypeError: unhashable type: 'set'

• Set Object is providing pre-defined functionality to perform all mathematical set

operations such as union, intersection, difference, symmetric_difference and so one.
• We can also perform the same set operations using operators.

s1 = {1,2,3,4}
s2 = {3,4,5,6}
print("s1 :",s1)

[Link] Contact – 98859 46789 Page - 172

print("s2 :",s2)

print("Union :", [Link](s2))

print("Union :", s1|s2)
print("Intersection :", [Link](s2))
print("Intersection :", s1&s2)
print("Difference : ", [Link](s2))
print("Difference : ", s1-s2)
print("Symmetric difference :", s1.symmetric_difference(s2))
print("Symmetric difference :", s1^s2)

Output:
s1 : {1, 2, 3, 4}
s2 : {3, 4, 5, 6}
Union : {1, 2, 3, 4, 5, 6}
Union : {1, 2, 3, 4, 5, 6}
Intersection : {3, 4}
Intersection : {3, 4}
Difference : {1, 2}
Difference : {1, 2}
Symmetric difference : {1, 2, 5, 6}
Symmetric difference : {1, 2, 5, 6}

We can construct the collection of object by calling constructor.

my_list = list()
my_set = set()

• We can construct one collection object by passing another collection as an input.

• If we pass List as input to Set, all duplicates will be removed.

my_list = [10, 20, 30, 20, 10]

print("List is :", my_list)
my_set = set(my_list)
print("Set is :", my_set)

Output:
List is : [10, 20, 30, 20, 10]
Set is : {10, 20, 30}

[Link] Contact – 98859 46789 Page - 173

type():
• A pre-defined function that returns identity of class if we specify an Object.
• We can create collection object in 2 ways.

#List construction:
#1. Initializing with empty list
l1 = [ ]
print(type(l1))

output:
<class 'list'>

#2. Calling constructor

l2 = list()
print(type(l2))

output:
<class 'list'>

#Tuple construction:
#1. Initializing with empty list
t1 = ()
print(type(t1))
<class 'tuple'>

#2. Calling constructor

t2 = tuple()
print(type(t2))
<class 'tuple'>

Set construction:
• Empty set can be constructed only through constructor.
• Direct assignment of empty set becomes dictionary.
• We represent the elements of Dictionary using { }

s = set()
print(type(s))
s={}
print(type(s))

Output:
<class 'set'>
<class 'dict'>

[Link] Contact – 98859 46789 Page - 174

When we remove all elements from List or Tuple it will show the empty collection using
symbols
l = [10, 20, 30, 40]
print(l)
[Link]()
print(l)

Output:
[10, 20, 30, 40]
[]

But when we empty a set it will show the collection type using its identity.
s = {10, 20, 30, 40}
print(s)
[Link]()
print(s)

Output:
{40, 10, 20, 30}
set()

• Set is allowed to store only Immutable objects such as Numbers, Strings and Tuples.
• List should not be the element of Set because it is Mutable object.

s = {10,20,(30,40)}
print(s)
s = {10,20,[30,40]}
print(s)
Output:
{10, 20, (30, 40)}
TypeError: unhashable type: 'list'

Can we store a set inside another set?

• Not allowed.
• Set is Mutable – we can modify the set after creation
• Set elements must be Immutable.
• We cannot a store a set(mutable) inside another set(allows only immutable)

s= {10, 20, {30, 40}}

print(s)
Output: TypeError: unhashable type: 'set'

[Link] Contact – 98859 46789 Page - 175

Dictionary:
• Set of elements(key, value pairs) represents using { }
• Set stores the elements(only values) directly
o set = {ele1 , ele2 , ele3 ....}
• Dictionary stores the elements using keys.
o dict = {key : ele , key : ele , key : ele }
• Dictionary is an ordered collection.

emp = {101:"amar", 102:"annie", 103:"hareen"}

print("Dictionary :", emp)
Output: Dictionary : {101: 'amar', 102: 'annie', 103: 'hareen'}

Elements can be heterogeneous. Keys can be heterogeneous

d = {10:"abc", "xyz":2.34, 1.23:None}
print(d)

Output: {10: 'abc', 'xyz': 2.34, 1.23: None}

Keys must be unique. When we store the data using duplicate key, existing data will be
replaced.
accounts ={101:"harin", 102:"kiritin", 102:"ramya"}
print(accounts)

• Elements can be duplicated.

• for example, in Banking application, we process the accounts using account numbers.
• Account numbers are unique (keys)
• Account data can be duplicates (name, pin, balance....)

accounts ={101:"harin", 102:"kiritin", 103:"harin"}

print(accounts)

Dictionary object is providing set of functions which are used process elements of that
dictionary.
accounts ={101:"harin", 102:"kiritin", 103:"ramya", 104:"annie"}
print("Accounts :", accounts)
#list of keys will be returned
print("Keys :", [Link]())
#returns list of values
print("Values :", [Link]())
[Link](102)
print("After removal of 102 :", accounts)
[Link]()

[Link] Contact – 98859 46789 Page - 176

print("After removal of last inserted element :", accounts)
print("Value at 103 :", [Link](103))

Output:
Accounts : {101: 'harin', 102: 'kiritin', 103: 'ramya', 104: 'annie'}
Keys : dict_keys([101, 102, 103, 104])
Values : dict_values(['harin', 'kiritin', 'ramya', 'annie'])
After removal of 102 : {101: 'harin', 103: 'ramya', 104: 'annie'}
After removal of last inserted element : {101: 'harin', 103: 'ramya'}
Value at 103 : ramya

We can iterate the dictionary using keys. For loop can iterate all keys of input dictionary.
accounts ={101:"harin", 102:"kiritin", 103:"ramya", 104:"annie"}
print("Account numbers are :")
for accno in accounts:
print(accno)
print("Account holder names are :")
for accno in accounts:
name = [Link](accno)
print(name)

Format the above program using string format specifiers:

accounts ={101:"harin", 102:"kiritin", 103:"ramya", 104:"annie"}
print("Account details are :")
for accno in accounts:
name = [Link](accno)
print("%d --> %s" %(accno, name))

Update(): A pre-defined method is used to update the dictionary

keys = [101, 102, 103, 104]
values = ["harin","kiritin","ramya","annie"]
accounts = dict() #create an empty dictionary
foriin range(len(keys)):
key = keys[i]
value = values[i]
[Link]({key:value})
print("Account details are :")
foraccno in accounts:
name = [Link](accno)
print("%d --> %s" %(accno, name))

[Link] Contact – 98859 46789 Page - 177

File Handling in Python

Files:
• We can store the information of application in 2 ways permanently
o File System
o Database management system
• Database is structured and object oriented; hence we can store and process the data
more effectively.
• File system is the basic data storage option.
• Some of the files(CSV) are used to store the information in more structured format like
database.
• Files are named locations on disk to store information. Files store in Secondary memory
(Hard disk) and Processed from Primary memory (RAM).

open(): A pre-defined function used to open a file in different modes

open(path , mode)

Basic modes: It is a string type value represents the operation to be performed on file data.

Read mode(“r”):
• Opens file in read mode.
• If file is present; it opens and return pointer to that file.
• If file is not present, raises Exception : FileNotFoundError.

Writer mode(“w”):
• Opens file in write mode.
• Iffile is present, it opens and removes existing content.
• Iffile is not present, it creates the new file with specified name.

Append mode(“a”) :
• Opens file in append mode.
• If file is present, it will place the cursor at the end of existing data to add new contents.
• If file is not present, it creates new file.

[Link] Contact – 98859 46789 Page - 178

Opening a file in read mode:
• After working with any resource(file, database, server…) from the application must be
released manually(closing statements)
• Improper shutdown of resources results loss of data.

Code:
try:
src = open(file="[Link]", mode="r")
print("File is present")

except FileNotFoundError:
print("Exception : No such file")

Reading information from the file:

• read() method is belongs to File object.
• Once the file has opened successfully, we need to call read() method on file object.
• read() method returns the complete content of file as an object.
• Wecan display the complete content of that data object in a single instance

try:
src=open(file="d:/[Link]", mode="r")
print("File is present")

data=[Link]()
print(data)

exceptFileNotFoundError:
print("Exception : No such file")

Wecanfind the size(number of characters) of file using len() function:

try:
src=open(file="d:/[Link]", mode="r")
print("File is present")
data=[Link]()
n=len(data)
print(n)

exceptFileNotFoundError:
print("Exception : No such file")

[Link] Contact – 98859 46789 Page - 179

Read file character by character:
• Read()functionreturnthecomplete data as object.
• Wecanprocessthedataobject character by character using for loop.
• Wecaneasilyiteratethefileusing pre-defined for loop.

try:
src=open(file="d:/[Link]",mode="r")
print("File is present")

data = [Link]()
for ch in data:
print(ch)

except FileNotFoundError:
print("Exception : No such file")

Find the length of file without using len() function:

•Length of the file is nothing but the number of characters in that file.
• We can count the characters while iterating the data object using loop.

try:
src=open(file="d:/[Link]",mode="r")
print("File is present")

data = [Link]()
count=0
for ch in data:
count=count+1

print("Length is : ", count)

except FileNotFoundError:
print("Exception : No such file")

Closing the file:

• It is important to close every resource which is opened.
• We use finally block to close the file
• Close()methodisusedtoclose the file.

src = None
try:
src = open(file="d:/[Link]", mode="r")

[Link] Contact – 98859 46789 Page - 180

print("File is opened")

except FileNotFoundError:
print("Exception : No such file")

finally:
if(src != None):
[Link]()
print("File closed")

How canweprocess the file line by line?

• Forloop can iterate the file line by line by taking file object name directly as an input.
• read()method is not required to process the data line by line.

src = None
try:
src=open(file="d:/[Link]", mode="r")
print("Fileis opened")
#data=[Link]()

forlineinsrc:

print(line)

exceptFileNotFoundError:
print("Exception : No such file")

finally:
if(src!=None):
[Link]()
print("File closed")

Countnumber of lines in the file:

src = None
try:
src=open(file="d:/[Link]", mode="r")
print("Fileis opened")

count=0
forlineinsrc:
print(line)
count=count+1

[Link] Contact – 98859 46789 Page - 181

print("Num of lines : ", count)

except FileNotFoundError:
print("Exception : No such file")

finally:
if(src != None):
[Link]()
print("File closed")

Closing with with-keyword:

• The best way of closing a file by using ‘with’ statement.
• We don’t need to call close() method explicitly to release that resource.

with open("d:/[Link]" , "r") as src :

data = [Link]()
print(data)

Writing to Files:
• File object is providing write() method to write contents into file.
• We use either write mode or append mode to write the information.
• If we open the file in write mode and the file is not present ; It creates the new file with
specified name.

with open("./[Link]" , "w") as file :

[Link]("This is online\n")
[Link]("Python session\n")
[Link]("Learning Files concept\n")
print("content written")

Output:

Copy the complete file:

src = None
dest = None
try:
src = open(file="d:/[Link]", mode="r")
dest = open(file="d:/[Link]", mode="w")

[Link] Contact – 98859 46789 Page - 182

for line in src:
[Link](line)

print("Datacopied")

exceptFileNotFoundError:
print("Exception:No such file")

finally:
if(src != None):
[Link]()
print("srcFileclosed")

if(dest != None):
[Link]()
print("destFileclosed")

tell():Methodbelongs to File object. It returns the current position (value) on the file.
seek():Methodbelongs to File object. It is used to sets the cursor position to specific location.
class Source:
file = None
def main():
try:
[Link]=open("./[Link]" , "r")
data=[Link]()
print(data)
print("Cursorat : ",[Link]())
[Link](0)
print("Cursorat : ",[Link]())

data=[Link]()
print(data)

finally:
[Link]!= None:
[Link]()
return
[Link]()

finally:
[Link] != None:
[Link]()
return
[Link]()

csv module

CSV file reading:

• CSVStandsfor “Comma Separated Values”
• CSVisanalternate to MS-Excel sheet
• Textfilealways stores textual information. It is not recommended to store and process
recordtypeinformation using Text File.
• CSVfilestores information in tabular form(Rows and Columns)

Creating [Link]:
• Open notepad file.
• Write records information by separating with comma
101,amar,5000
102,annie,8000
103,hareen,7500
103,satya,6500
• Save the file with .csv extension
• Close the file and re-open the file.
• File will be opened with MS-Excel software by default.

[Link] Contact – 98859 46789 Page - 184

[Link] file:

Read information of CSV file: csv: A pre-

definedmodulebelongs to python library.
• It is providingpre-definedfunctionality to process the information of CSV file.
• Reader()isamethodbelongs to csv module
• Reader()methodreturnsthe CSV file data as an Object to process.

import csv
class ReadCSV:
file = None
def main():
try:
[Link]=open("./[Link]" , "r")
print("File opened")

table=[Link]([Link])
print("Records are :")
for record in table:
print(record)

except Exception as e:
print("Exception :", e)

finally:
if [Link] != None:
[Link]()

return
[Link]()

[Link] Contact – 98859 46789 Page - 185

Using nested forloop, we can split the record into fields also:
table=[Link]([Link])
print("Recordsinformation :")
forrecordintable:
forfieldinrecord:
print(field)

Construct Dictionary object from CSV file:

• CreateoneCSVfile with account details.
• ReadCSVfile
• CreateanEmptydictionary
• Defineaclasswith identity Account.
• ConstructAccount object and update the object into dictionary.
• Finally,whenwespecify the account number(key), we have to display value(account
details).

[Link] file:

[Link] Contact – 98859 46789 Page - 186

import csv
class Account:
def __init__(self, accno, name, balance):
[Link] = accno
[Link] = name
[Link] = balance
return

class Bank:
accs_dict = dict()
def details():
while True:
num = int(input("Enter account number : "))
try:
record = Bank.accs_dict.get(num)
print("Details are :")
print("Name : ", [Link])
print("Balance :", [Link])
except Exception as e :
print("Exception :", e)

ch=input("Doyouwanttocheckanotherrecord(y/n) : ")
if ch=='n':
break
return
class CSVtoDict:
file = None
def main():

try:
[Link] = open("./[Link]" , "r")
print("File opened")
table = [Link]([Link])
for record in table:

num = int(record[0])
name = record[1]
balance = int(record[2])

obj = Account(num, name, balance)

Bank.accs_dict.update({num : obj})
print(record , " updated to dictionary")

[Link] Contact – 98859 46789 Page - 187

[Link]()

except Exception as e:
print("Exception :", e)

finally:
if [Link] != None:
[Link]()
print("File closed")
return
[Link]()

Output:
File opened
['1001', 'amar', '5000'] updated to dictionary
['1002', 'annie', '8000'] updated to dictionary
['1003', 'hareen', '7500'] updated to dictionary
['1004', 'satya', '9000'] updated to dictionary
Enter account number : 1002
Details are :
Name : annie
Balance : 8000
Do you want to check another record(y/n) : y
Enter account number : 1004
Details are :
Name : satya
Balance : 9000
Do you want to check another record(y/n) : n
File closed

Write code for following:

[Link] Contact – 98859 46789 Page - 188

pickle module

Serialization and De-Serialization:

• In Object oriented applications, we store information in the form of Objects.
• We use files to store information in textual format.
• Object contains the information – using dynamic variables – also called state of object.
• If we want to store Object state(information) into File is called Serialization.
• Converting “Object State” into “Persistent State” is called Serialization.
o Java: Serialization & De-Serialization
o .Net: Marshalling & Deflating
o Python: Pickling & UN pickling

Pickle:
o “pickle” is the pre-define module providing functionality to perform Serialization and De-
serialization
o “dump()” method is used to write the object information into file.
o “load()” method is used to read the object from the file

Notes:
o Serialized data will be in binary format.
o We need to open file in (write binary) mode to write the object data.
o We cannot open binary file directly(nothing can see). Data will in symbolic format.

Why object data in binary form?

o Static variables are used to store common information of all objects which is free access
to everyone.
o Dynamic variables (stored in object) always store specific information of Object.
o Object data is secured; hence we need to protect the data while converting into file.
Hence they provided binary file format.

How can we check the data of binary file?

o We need to perform de-serialization programmatically to get the actual information of
that binary file.
o [Link]() function is used to perform de-serialization.
o Load() function returns Object form of that binary data.

[Link] Contact – 98859 46789 Page - 189

Code: We use 3 files to implement
1. [Link] file to specify Employee object
2. [Link] file
3. [Link] file

[Link]:
class Employee :
def __init__(self, num, name, salary):
[Link] = num
[Link] = name
[Link] = salary
return

[Link]:
import pickle
from emp import Employee
class Serialization:
file = None
def main():
try :
[Link] = open("./[Link]", mode="wb")
print("File is ready")

obj = Employee(101, "Amar", 45000)

[Link](obj, [Link])
print("Object is serialized successfully")

except Exception as e:
print("Exception :", e)

finally:
if [Link] != None:
[Link]()
print("File closed")
return
[Link]()

[Link] Contact – 98859 46789 Page - 190

Run serialize file:

[Link]:
import pickle
from emp import Employee
class DeSerialization:
file = None
def main():
try :
[Link] = open("./[Link]", mode="rb")
print("File is ready")
obj = [Link]([Link])
print("Object is De-serialized successfully")
print("Employee details are :")
print("Emp num :", [Link])
print("Emp name :", [Link])
print("Emp salary :", [Link])

except Exception as e:
print("Exception :", e)

finally:
if [Link] != None:
[Link]()
print("File closed")
return

[Link]()

Run [Link]:

[Link] Contact – 98859 46789 Page - 191

Lambda Expressions

Lambda expressions:
• Expression is a line of code.
• Expression is a collection of operands and operators.
• 'lambda' is a keyword.
• 'lambda' expressions are used to define a function with single line

Generally we define function as follows:

def display(name):
print("Hello %s" %name)
return

display("Amar")

We define above function with lambda expression as follows:

display = lambda name : print("Hello %s" %name)
display("Amar")

Biggest of 2 numbers code snippet:

def big(a,b):
if a>b:
return a
else:
return b
print("Big one is :" , big(10,20))

Writing the above code using lambda expression:

big = lambda a, b : a if a>b else b
print("Big one is :" , big(10,20))

Even number program code:

def even(num):
if num%2==0:
return True
else:
return False

print("4 is even : ", even(4))

print("7 is even : ", even(7))

[Link] Contact – 98859 46789 Page - 192

Lambda expression foe above code:
even = lambda num : num%2==0
print("4 is even : ", even(4))
print("7 is even : ", even(7))

Biggest of 3 numbers code:

def big(a,b,c):
if a>b and a>c:
return a
elif b>c:
return b
else:
return c

print(big(10,30,20))
print(big(30,40,50))

Lambda expression:
big = lambda a,b,c : a if a>b and a>c else b if b>c else c
print(big(10,30,20))
print(big(30,40,50))

Leap year program:

• 4 divisibles - leap
• 400 divisibles - leap
• 100 divisibles - not leap

def leap(n):
if n%400==0:
return "leap"
elif n%4==0 and n%100!=0:
return "leap"
else:
return "not"

print("16 is :",leap(16))
print("31 is :",leap(31))
print("200 is :",leap(200))
print("2400 is :",leap(2400))

Write Lambda expression for above code:

[Link] Contact – 98859 46789 Page - 193

map() and filter() with lambda
Square each element in a list:
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))

Filter Words Starting with 'A' using filter() and Lambda

words = ["apple", "banana", "cherry", "apricot", "date"]
a_words = list(filter(lambda x: [Link]('a'), words))
print(a_words)

Convert a list of strings to uppercase:

words = ['apple', 'banana', 'cherry']
uppercase_words = list(map(lambda x: [Link](), words))

Calculate the lengths of strings in a list:

words = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), words))

Round floating-point numbers in a list:

floats = [3.14159, 2.71828, 1.41421]
rounded = list(map(lambda x: round(x, 2), floats))

Apply a custom function to each element:

def double_and_add_ten(x):
return x * 2 + 10

numbers = [1, 2, 3, 4, 5]
result = list(map(double_and_add_ten, numbers))

Filter positive numbers from a list.

numbers = [-1, 2, -3, 4, -5]
positive_numbers = list(filter(lambda x: x > 0, numbers))

Filter prime numbers from a list.

numbers = [2, 3, 4, 5, 6, 7, 8, 9, 10]
prime_numbers = list(filter(lambda x: all(x % i != 0 for i in range(2, int(x**0.5) + 1)), numbers))

[Link] Contact – 98859 46789 Page - 194

Filter even numbers from a list:
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

Filter strings with more than 5 characters from a list:

words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
long_words = list(filter(lambda x: len(x) > 5, words))

Filter items with values greater than 3 in a dictionary:

data = {'a': 2, 'b': 4, 'c': 1, 'd': 5}
filtered_data = dict(filter(lambda item: item[1] > 3, [Link]()))

Filter items with keys that start with 'a' in a dictionary:

data = {'apple': 2, 'banana': 4, 'cherry': 1, 'date': 5}
filtered_data = dict(filter(lambda item: item[0].startswith('a'), [Link]()))

Filter Even Values in a Dictionary using filter() and Lambda

data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
even_values = dict(filter(lambda item: item[1] % 2 == 0, [Link]()))
print(even_values)

Join Elements in a List of Strings using map() and Lambda

words = ["Hello", "World", "Python"]
joined_words = list(map(lambda x: ' '.join(x), words))
print(joined_words)

Filter Prime Numbers using filter() and Lambda

def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True

numbers = range(1, 20)

primes = list(filter(lambda x: is_prime(x), numbers))
print(primes)

[Link] Contact – 98859 46789 Page - 195

Command Line arguments

• In machine, all programs run by OS.

• We can run every program manually from OS environment
• Command prompt(DOS) is called OS environment.

Note: Passing input(arguments) from the command line while invoking the application is called
Command line arguments.

Run Python code from command line:

• OS invokes python interpreter then interpreter executes the code.
• Python interpreter is dependent to OS(at the time of installation, we download python
based on OS)

Code:
class CmdLine:
def main():
print("Manaul execution of Python script")
return

[Link]()

Run:

• In other languages such as C, C++ and Java; Program execution starts from main()
method.
• Main() is responsible for collecting all these input arguments into a String type array.
• Arguments will be in String format.

[Link] Contact – 98859 46789 Page - 196

Why command line arguments are String type?
• Only a String can able to store any kind of data (int, float, char, string..)
• We collect the input into String type and process by converting into corresponding type
using conversion methods.

Note: In python programming, main() method is optional. Main() is not responsible to collect
arguments. All command line arguments will store into “argv” list object automatically.

[Link]:
• ‘sys’ is a pre-defined module
• ‘argv’ is a list belongs to ‘sys’ module.
• ‘argv’ holds command line arguments implicitly.

How can we pass command line arguments?

At command line, we can pass arguments by leaving the spaces between arguments followed by
file name
cmd/> python [Link] arg1 arg2 arg3

Memory allocation:

[Link] Contact – 98859 46789 Page - 197

Python provides various ways to dealing with command line arguments.
The 3 command types are:
1. Using [Link]
2. Using getopt module
3. Using argparse module

Code:
importsys
classCmdLine:
defmain():
count = len([Link])
print("Arguments count :",count)
return

[Link]()

Run:

Displayarguments: (including file name)

import sys
classCmdLine:
defmain():
arr=[Link] # 'argv' address will store into 'arr'
iflen(arr)==1:
print("No arguments to display")
else:
print("Arguments are :")
forele in arr:
print(ele)
return
[Link]()

[Link] Contact – 98859 46789 Page - 198

Run:

Display arguments: (excluding file name)

import sys
class CmdLine:
def main():
arr = [Link]
if len(arr)==1:
print("No arguments to display")
else:
print("Arguments are :")
for i in range(1, len(arr)):
print(arr[i])
return

[Link]()

Run:

Program to take input (2 numbers) from command line and divide

import sys
class Divide:
def main():
try:
arr=[Link]
s1=arr[1]
s2=arr[2]
x=int(s1)
y=int(s2)

[Link] Contact – 98859 46789 Page - 199

z = x/y
print("Result :",z)

except IndexError :
print("Exception : Insufficient values")

except ValueError :
print("Exception : Invalid Input")

except ZeroDivisionError :
print("Exception : Division by zero")

return
[Link]()

Above code can be written as:

import sys
class Divide:
def main():
arr=[Link]
if len(arr)>2:
try:
res=int(arr[1])/int(arr[2])
print("Result :", res)
exceptException as msg:
print("Exception :", msg)
else:
print("Insufficient input")

return

[Link]()

[Link] Contact – 98859 46789 Page - 200

PIP
pip:
• PIP is a package manager.
• It is also called Python Package Installer (PyPI)
• A pre-defined script that can install every third party module or package of Python into
system easily.
• We need to install pip first.
• Download [Link] file and run as script.

Open the link which is showing [Link] Script:

Save the content of script with same name:

[Link] Contact – 98859 46789 Page - 201

Run from command line as a Script – Maintain data connection:
• [Link] program collect the required information from the internet in the process of
installation.
• At the time of installation, in case any old version exists will be un installed automatically.

Installing other packages using PIP

Installing mysql and connector:

cmd/> pip install mysqlclient
cmd/> pip install mysql-connector-python

Installing Numpy and Pandas:

• The important modules to process the information like one dimensional, two
dimensional and Multi dimensional.
• These modules must be installed before use.

cmd:/ pip install numpy

dmd:/ pip install pandas

[Link] Contact – 98859 46789 Page - 202

Database Connectivity

Introduction:
• We use programming languages to develop applications
• Applications are used to store(maintain) information for processing.
• We can store information in 2 ways
o File System
o Database management systems
• Traditional file system is not secured and structured.
• DBMS is an application – It is object oriented, structured and secured.

To develop complete application, we use follow the architecture called 3-tier architecture:

DBMS:
• DBMS(for example, mysql) is an application software.
•Database Repository is a collection of Databases.
•Database is a collection of Tables & Table is a collection of records
•Record is a collection of fields.
• We need to maintain separate database to each application.

Python-MySQL connectivity:
• MySQL is simple and open source.
• Download and install the MySQL server

[Link] Contact – 98859 46789 Page - 203

Python-MySQL-Connector:
• After installation of MySQL, we need to install connector from the same website.
• Connector installs a package which contains pre-defined programs to implement
Python-Database connection applications.
• MySQL connection programs are not directly available with Python installation.
• Connector installation provides [Link] package which contains pre-defined
programs for connection, to execute sql statements in communication.

Opening Client:

Executing SQL commands: Mainly we use 3 types of SQL statements to communicate with
database
1. DDL commands : Data Definition languages
a. Create or Drop tables

2. DML commands : Data Manipulation language

a. Insert , Delete and Update records

3. DRL commands : Data retrieval language

a. Select – fetching the data

mysql> create database student;

mysql> use student;

Database changed

mysql> create table account(num int, name varchar(20), balance int);

mysql> show tables;
+-------------------+
| Tables_in_student |
+-------------------+
| account |
+-------------------+

Inserting records:
mysql> insert into account values(101, 'amar', 5000);
mysql> insert into account values(102, 'annie', 9000);
mysql> insert into account values(103, 'hareen', 7000);

mysql> select * from account;

+------+--------+---------+
| num | name | balance |
+------+--------+---------+
| 101 | amar | 5000 |
| 102 | annie | 9000 |
| 103 | hareen | 7000 |
+------+--------+---------+

mysql> select * from account where num=103;

+------+--------+---------+
| num | name | balance |
+------+--------+---------+
| 103 | hareen | 7000 |
+------+--------+---------+

mysql> select name,balance from account where num=102;

+-------+---------+
| name | balance |
+-------+---------+
| annie | 9000 |
+-------+---------+

mysql> update account set balance=balance+1500 where num=101;

mysql> select * from account;
+------+--------+---------+
| num | name | balance |
+------+--------+---------+
| 101 | amar | 6500 |
| 102 | annie | 9000 |
| 103 | hareen | 7000 |
+------+--------+---------+

mysql> delete from account where num=102;

mysql> select * from account;
+------+--------+---------+
| num | name | balance |
+------+--------+---------+
| 101 | amar | 6500 |
| 103 | hareen | 7000 |
+------+--------+---------+

[Link] Contact – 98859 46789 Page - 206

mysql> delete from account;
mysql> select * from account;
Empty set (0.00 sec)

mysql> drop table account;

mysql> show tables;
Empty set (0.00 sec)

[Link]:
• connector is a sub module in mysql package.
• It is available only when we install python-mysql-connector.
• After installation, we are checking whether the module has installed or not by importing.

connect():
• It is belongs to connector module.
• It returns connection object if the specified input is valid.
• Input arguments are username, password, host address and database name.

• On success,returnsconnection object
• On failure,raisesasexception

Connecting to Database:
import [Link]
classDB:
con = None
def main():
try:
[Link]=[Link](user='root', password='root',
host='[Link]', database='student')
print("Connectedtodatabase")

[Link] Contact – 98859 46789 Page - 207

except Exception as msg:
print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Database released")

return
[Link]()
Output:

Executing SQL statements

DDL commands:
Create:
• Once connection is ready, we need to get cursor object.
• Cursor() method belongs to connection object.
• On call, it returns cursor object.

execute():
• Pre-defined method belongs to cursor object.
• Using execute() method, we can execute any query in the database.

Code:
import [Link]
class DB:
con = None
def main():
try :
[Link] = [Link](user='root', password='root',
host='[Link]', database='student')
print("Connected to database")
cur = [Link]()
query = "create table account(no int, name varchar(20), balance int)"
[Link](query)
print("Table created successfully")

except Exception as msg:

[Link] Contact – 98859 46789 Page - 208

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Database released")

return

[Link]()

Output:

In database:

Inserting records:
• ‘insert’ is DML command.
• DML commands such as insert, delete and update transactions need to commit after
execution.
• commit() method belongs to connection object.
• Without commit the DML transaction, the database will not be effected.
Code:
import [Link]
class DB:
con = None
def main():
try :
[Link] = [Link](user='root', password='root',
host='[Link]', database='student')
print("Connected to database")
cur = [Link]()
query = "insert into account values(101, 'amar', 7000)"

[Link] Contact – 98859 46789 Page - 209

[Link](query)
print("Record inserted....")
[Link]()
print("Transaction committed")

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Database released")

return

[Link]()

Output:

In database:

Fetching information from the table:

• cursor() object is empty as soon as it has created.
• When we execute any “select” query, the information returned by the query will store
into cursor object.
• Cursor object is providing 2 functions fetchone() and fetchall() to get the information.
• fetchone(): returns either first record of specified record(where clause)
• fetchall(): returns all records from that table.

[Link] Contact – 98859 46789 Page - 210

Fetching first record:

import [Link]
classDB:
con = None
def main():
try:
[Link]=[Link](user='root', password='root',
host='[Link]', database='student')
print("Connectedtodatabase")
cur = [Link]()
query="select*fromaccount"
[Link](query)
record = [Link]()
print("Firstrecorddetails : ", record)

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Databasereleased")

return
[Link]()

[Link] Contact – 98859 46789 Page - 211

Output:
Connected to database
First record details : (101, 'amar', 7000)
Database released

Fetching the details of specified record using where clause:

import [Link]
class DB:
con = None
def main():
try :
[Link] = [Link](user='root', password='root',
host='[Link]', database='student')
print("Connected to database")
cur = [Link]()
query = "select * from account where no=102"
[Link](query)

record = [Link]()
print("102 record details : ")
print("Account Number :", record[0])
print("Name :", record[1])
print("Balance :", record[2])

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Database released")

return
[Link]()

Output:
Connected to database
102 record details :
Account Number : 102
Name : annie
Balance : 6000
Database released

[Link] Contact – 98859 46789 Page - 212

Fetching the complete table information:
• Table is in two dimensional format.
• A set of records will be returned as an object.
• Using for loop, we can access records
• Using nested for loop; we can process fields of each record.

import [Link]
class DB:
con = None
def main():
try :
[Link] = [Link](user='root', password='root',
host='[Link]', database='student')
print("Connected to database")
cur = [Link]()

query = "select * from account"

[Link](query)

table = [Link]()
print("Table details :")
for record in table:
print(record)

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Database released")

return

[Link]()

Output:
Connected to database
Table details :
(101, 'amar', 7000)
(102, 'annie', 6000)
(103, 'hareen', 9000)
Database released

[Link] Contact – 98859 46789 Page - 213

Using nested loop, we can process each record elements as follows:
query = "select * from account"
[Link](query)
table = [Link]()
print("Table details :")
for record in table:

for field in record:

print(field)

Update the table record:

Before update, the table:

import [Link]
classDB:
con = None
def main():
try:
[Link]=[Link](user='root', password='root',
host='[Link]', database='student')
print("Connectedtodatabase")
cur = [Link]()
query="updateaccountset balance = balance+1500 where no=102"
[Link](query)
[Link]()
print("Record updated")

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Databasereleased")

[Link] Contact – 98859 46789 Page - 214

return
[Link]()

Output:
Connected to database
Record updated
Database released

Table after updation:

Static Query v/s Dynamic Query:

• In all the above applications, we executed static queries.
• Static queries always execute with fixed set of values.
• Dynamic queries need to construct at runtime.
• We collect the user input to perform database operations and construct the query
dynamically based on the input values.
• We can construct the Query(string) in 2 ways
o Using concatenation
o Using format specifiers

Static Queries:
1. ins_query = "insert into account values(101, 'amar', 5000)"
2. sel_query = "select * from account where no=102"
3. upd_query = "update account set balance=balance+3000 where no=103"
4. del_query = "delete from account where no=104"

Dynamic Queries:
Construct delete query by collecting record number as input:
num = int(input("Enter record num to delete : "))
del_query = "delete from account where no=" + str(num)
print(del_query)
# or
del_query = "delete from account where no=%d" %num
print(del_query)

[Link] Contact – 98859 46789 Page - 215

Fetching specific record by reading the record number from end user:
import [Link]
classDB:
con = None
def main():
try:
[Link]=[Link](user='root', password='root',
host='[Link]', database='student')
print("Connectedtodatabase")
cur = [Link]()
num=int(input("Enteraccount number : "))
#query="select*fromaccount where no=%d" %num
query="select*fromaccount where no=" + str(num)
[Link](query)
record = [Link]()
print("Detailsare:",record)

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Databasereleased")

return
[Link]()

Output:

[Link] Contact – 98859 46789 Page - 216

Update (change balance of) specific record by collecting record number and balance to set
from the enduser:
import [Link]
classDB:
con = None
def main():
try:
[Link]=[Link](user='root', password='root',
host='[Link]', database='student')
print("Connected to database")
cur = [Link]()
num=int(input("Enteraccountnumber : "))
amt=int(input("Enterdepositamount : "))
#query="updateaccountsetbalance = balance+%d where no=%d" %d(amt,num)
query="updateaccountsetbalance=balance+" + str(amt) + " where no=" + str(num)
[Link](query)

[Link]()
print("Record updated")

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Database released")

return

[Link]()

Output:
Connected to database
Enter account number : 101
Enter deposit amount : 1200
Record updated
Database released

Note: Go and Checktheupdatedrecord in MySql Database

[Link] Contact – 98859 46789 Page - 217

Insert(alldetails)record into table by collecting no, name and balance.
import [Link]
classDB:
con = None
def main():
try:
[Link]=[Link](user='root', password='root',
host='[Link]', database='student')
print("Connectedtodatabase")
cur = [Link]()
print("EnterAccountdetails : ")
num=int(input("AccountNum : "))
name = input("Name : ")
bal=int(input("Balance:"))
#query="insertintoaccount values(%d,'%s',%d)" %(num,name,bal)
query="insertintoaccount values(" + str(num) + ",'" + name + "'," + str(bal) + ")"
print("Query is :", query)

[Link](query)
print("Record inserted....")
[Link]()
print("Transactioncommitted")

except Exception as msg:

print("Exception :",msg)

finally:
if [Link] != None:
[Link]()
print("Databasereleased")

return

[Link]()

Output:GoandChecktheupdated records indatabase.

[Link] Contact – 98859 46789 Page - 218

tkinter – GUI

tkinter:
• “tkinter” is a pre-defined module.
• “tkinter” providing set of classes to implement GUI programming.
• GUI programming is “Windows” based.
• “Tk” class belongs to “tkinter” module. Instantiation(Object Creation) of Tk class results a
Window(Frame)

Creating Frame:
from tkinter import Tk
root = Tk()

Defining Custom Frame by inheriting the functionality:

from tkinter import Tk
class MyFrame(Tk):
pass

class Create:
def main():
obj = MyFrame()
return

[Link]()

Components:
• Components such as Buttons, Labels, Entry fields, Checkboxes provided as pre-defined
classes.
• Component classes belong to “tkinter” module only.
• Object creation of Component class results the Component.
• We need to arrange the component on the Frame using Layout structure.

Layout:
• The arrangement of components on window.
• Python library is pre-defined layout structures.
• Every Component class has dynamic functionality to layout that component.

Create Button:
from tkinter import Tk, Button
root = Tk()
[Link]("GUI")
b = Button(root, text="Click Me")

[Link] Contact – 98859 46789 Page - 219

Note: In the above application, Button is not displayed on Frame. After creation of Button, we
need to arrange that Button on Frame using Layout functionality.

pack(): A function that arranges the component top centered to window.

from tkinter import Tk, Button
root = Tk()
[Link]("GUI")
b= Button(root, text="Click Me")
[Link]()

geometry():
• A function is belongs to Tk class
• It is used to set Width & Height of Frame
• It is dynamic function; hence we need to call on object.
o geometry(“width x height”)

from tkinter import Tk, Button

root = Tk()
[Link]("GUI")
[Link]("500x300")
b= Button(root, text="Click Me")
[Link]()

[Link] Contact – 98859 46789 Page - 220

Events:
• Event is an Action which is performed on component
• For example,
o clicking a button.
o Select checkbox
o Select radiobutton
• When action performed on Button, it executes the function which is specified by
“command” argument of that Button.

from tkinter import Tk, Button

def display():
print("Button clicked")
return

root = Tk()
[Link]("GUI")
[Link]("500x300")

b= Button(root, text="Click Me", command=display)

[Link]()

• We can set properties such as Font, Color, Background color to components.

• We can set properties using pre-defined arguments of that Component.

from tkinter import Tk, Button

def display():
print("Button clicked")
return

root = Tk()
[Link]("GUI")
[Link]("500x300")

b=Button(root, text="Click Me", bg="light blue",

fg="red", font="Times 30", command=display)
[Link]()

[Link] Contact – 98859 46789 Page - 221

Code:
from tkinter import Tk, Label, Entry, Button
def disp():

name = [Link]()
print("Hello %s, welcome" %name)
return

root = Tk()
[Link]("GUI")
[Link]("500x300")

l=Label(root, text="Enter Name :", font="Times 20")

[Link]()
e=Entry(root, font="Times 20")
[Link]()
b=Button(root, text="display", font="Times 15", command=disp)
[Link]()

place() function is used to place the component at specified x, y co-ordinates

from tkinter import Tk, Label, Entry, Button
def fun():

print("Button clicked")
return

root = Tk()
[Link]("GUI")

[Link] Contact – 98859 46789 Page - 222

[Link]("500x300")
b = Button(root, text="click", font="Times 20", command=fun)
[Link](x=200, y=100)

grid():
• Layout method belongs to component object.
• grid() method arrange the components in table(rows and columns) format.
• We need to specify row value and column value of component

Code:
from tkinter import *
def details():

name = [Link]()
loc = [Link]()
print("%s live in %s" %(name,loc))
return

root = Tk()
[Link]("GUI")
l1 = Label(root, text="Enter Name :", font="Times 20")
l2 = Label(root, text="Enter Loc :", font="Times 20")
e1 = Entry(root, font="Times 20")
e2 = Entry(root, font="Times 20")
b1 = Button(root, text="details", font="Times 15", command=details)
b2 = Button(root, text="exit", font="Times 15", command=quit)
[Link](row=0, column=0)
[Link](row=0, column=1)
[Link](row=1, column=0)
[Link](row=1, column=1)
[Link](row=2, column=0)
[Link](row=2, column=1)

Output:

[Link] Contact – 98859 46789 Page - 223

Code:
from tkinter import Tk, Label, Button, Entry
def func():
name = [Link]()
print("Hello " + name + ", welcome to GUI")
return

window = Tk()
[Link]("Grid Layout")
l = Label(window, text="Enter Name :", font="Times 25")
[Link](row=0, column=0)
e = Entry(window, font="Times 25", fg="red")
[Link](row=0, column=1)
b = Button(window, text="Click", font="Times 20", command=func)
[Link](row=0, column=2)

StringVar class:
• It is belongs to tkinter module
• It is used to set dynamic text(values) to components
• To assign StringVar object we use “textvariable” argument of that component instead of
“text” argument.

[Link] Contact – 98859 46789 Page - 224

from tkinter import Tk, Label, Button, Entry, StringVar
def func():
name = [Link]()
[Link]("Hello " + name + ", Welcome")
return

window = Tk()
msg = StringVar()
[Link]("Dynamic Text")
[Link]("750x300")
l = Label(window, text="Enter Name :", font="Times 20")
[Link](x=50, y=50)
e = Entry(window, font="Times 20", fg="red")
[Link](x=250, y=50)
b = Button(window, text="Click", font="Times 15", command=func)
[Link](x=600, y=50)
res = Label(window, textvariable=msg, font="Times 20", fg="blue")
[Link](x=150, y=175)

Output:

Simplecalculator program:

[Link] Contact – 98859 46789 Page - 225

Code:
from tkinter import *
def add():

s1 = [Link]()
s2 = [Link]()

if len(s1)==0 or len(s2)==0 :
[Link]("Error : Empty input")
else:
try :
x = int(s1)
y = int(s2)
z = x+y
[Link]("")
[Link](str(z))

except ValueError :
[Link]("Error : Invalid Input")
return

window = Tk()
[Link]("Calculator")
err = StringVar()
res = StringVar()
l1 = Label(window, text="Enter Input :", font="Times 15")
[Link](row=0, column=0)
e1 = Entry(window, font="Times 15")
[Link](row=0, column=1)
l2 = Label(window, text=" + ", font="Times 15")
[Link](row=0, column=2)
e2 = Entry(window, font="Times 15")
[Link](row=0, column=3)
l3 = Label(window, text=" = ", font="Times 15")
[Link](row=0, column=4)
e3 = Entry(window, font="Times 15", textvariable=res)

[Link] Contact – 98859 46789 Page - 226

[Link](row=0, column=5)

b1 = Button(window, text="add", font="Times 15", command=add)

[Link](row=0, column=6)
l4 = Label(window, textvariable=err, font="Times 15", fg="red")
[Link](row=1, column=3)

Output:

Write code for the following calculator program:

[Link] Contact – 98859 46789 Page - 227

Python - Regular expressions
Regular Expression:
• Regular expression is a set of characters or set of operators and special symbols.
• Regular expressions are used to process Strings.
• Regular expressions are used to filter required information.

"re" is a pre-defined module provides functions to perform regular expressions.

"re" is providing :
1. match()
2. search()
3. findall()
4. split()
5. compile()
6. sub()

match( ) :
• It is used to test whether the input string starts with given "pattern" or not.
• On success, it returns match object.
• On failure, it returns None

import re
line = "Java and Python gives Jython"
res = [Link](r'Java' , line)
print("Success : ",res)
res = [Link](r'Python' , line)
print("Failure : ",res)

search() :
• It is used to find specified pattern in the input string.
• On success, it returns match object.
• On failure, it returns None

import re
line = "Java and Python gives Jython"
res = [Link](r'hon' , line)
print("Success : ",res)

start() and end() : search object providing pre-defined functionality to get start index and end
index of specified pattern.

findall():
• It returns a list of duplicates patterns available in the given input string.
• It returns a list.
• On failure, it returns empty list.

import re
line = "Java and Python gives Jython"
l = [Link](r'on' , line)
print("List :" , l)
print("Count :", len(l))

split() :
• It is used to split the string into tokens(words).
• It returns a list of tokens.
• We can process the list using its functionality.

import re
line = "Java and Python gives Jython"
tokens = [Link](r' ' , line)
print("Tokens :" , tokens)
print("Count :" , len(tokens))
print("Index of Python :" , [Link]('Python'))

Display tokens using loop:

import re
line = "Java and Python gives Jython"
tokens = [Link](r' ' , line)
print("List of tokens :")
forelement in tokens:
print(element)

[Link] Contact – 98859 46789 Page - 229

Note : We can use any "delimeter" to split the input string.
import re
line = "RAMAYANA"
a1 = [Link](r'A' , line)
print("List : " , a1)
a2 = [Link](r'A' , line , 2)
print("List : " , a2)

compile() :
• We can construct a pattern object with a specified pattern.
• Pattern object can be used to perform all the other operations easily.
• Instead of specifying the same pattern everywhere, we just call 're' functionality on
pattern object.

import re
line = "Java and Python gives JavaPython"
found = [Link](r'Python' , line)

if found:
print("String starts with specified pattern")
else:
print("String not starts with Python")

found = [Link](r'Python' , line)

if found:
print("Pattern found @ index : " , [Link]())
else:
print("Search failed")

duplicates = [Link](r'Python' , line)

if duplicates :
print("Duplicates present for Python")

Above program can be written using compile() object.

import re
line = "Java and Python gives JavaPython"
pattern = [Link]("Python")
found = [Link](line)
iffound:
print("String starts with specified pattern")
else:
print("String not starts with Python")

[Link] Contact – 98859 46789 Page - 230

found = [Link](line)
if found:
print("Pattern found @ index : " , [Link]())
else:
print("Search failed")
duplicates = [Link](line)
if duplicates :
print("Duplicates present for Python")
Note : It is possible to construct a regular expression with operators and special symbols also.
Split the string into characters : (include and exclude spaces)

import re
line = "Python and R"
res = [Link](r'.' , line)
print(res)
res = [Link](r'\w' , line)
print(res)

Split the string into words : (include and exclude spaces)

import re
line = "Python and R"
res = [Link](r'\w*' , line)
print(res)
res = [Link](r'\w+' , line)
print(res)

Mail IDs extraction :

import re
data = "abc@[Link] xyz@[Link] nit@[Link]"
res = [Link](r'@\w+' , data)
print(res)
res = [Link](r'@(\w+)' , data)
print(res)
res = [Link](r'@\w+.\w+' , data)
print(res)
res = [Link](r'@\w+.(\w+)' , data)
print(res)

Date extraction :
import re
data = "ab12-04-1987 23-ab09-2003 31-03-2005ab"
res = [Link](r'\d{2}-\d{2}-\d{4}' , data)
print(res)

[Link] Contact – 98859 46789 Page - 231

Date time and Calendar Modules

Display the current date and time:

import datetime
now = [Link]()
print("Current date and time:")
print(now)

Display the current date:

import datetime
date = [Link]()
print("Today's date:")
print(date)

Display the current time:

import datetime
time = [Link]().time()
print("Current time:")
print(time)

Create a date object from a string:

import datetime
date_str = "2022-05-01"
date_obj = [Link](date_str, "%Y-%m-%d").date()
print("Date object:")
print(date_obj)

Calculate the difference between two dates:

import datetime
date1 = [Link](2022, 5, 1)
date2 = [Link](2023, 5, 1)
delta = date2 - date1
print("Days between the two dates:")
print([Link])

Convert a date to a string:

import datetime
date = [Link]()
date_str = [Link]("%Y-%m-%d")
print("Date as string:")
print(date_str)

[Link] Contact – 98859 46789 Page - 232

Convert a time object to a string:
import datetime time =
[Link]().time()
time_str =
[Link]("%H:%M:%S")
print("Time as string:") print(time_str)

Display a calendar for a specific year and month:

import calendar
year = 2023
month = 5
cal = [Link](year, month)
print(cal)

Display the calendar for an entire year:

import calendar
year = 2023
cal = [Link](year)
print(cal)

Determine if a year is a leap year:

import calendar
year = 2024
is_leap = [Link](year)
ifis_leap:
print(f"{year} is a leap year.")
else:
print(f"{year} is not a leap year.")

Determine the first weekday of a specific year:

import calendar
year = 2023
weekday = [Link]()
print(f"The first weekday of {year} is {weekday}.")

[Link] Contact – 98859 46789 Page - 233

OS Module

OS Module:The os module in Python provides a way of interacting with the underlying

operating system. It allows you to perform various operations such as navigating the file system,
creating and deleting directories, changing permissions, and much more.

Get the current working directory: Create a new directory:

import os import os
cwd = [Link]() dir_path = "/path/to/new/directory"
print(f"Current working directory: {cwd}") [Link](dir_path)
print(f"Created directory: {dir_path}")

List the files in a directory:

import os
dir_path = "/path/to/directory"
files = [Link](dir_path)
print(f"Files in {dir_path}:")
for file in files:
print(file)

Rename a file:
import os
old_file_path = "/path/to/old/file"
new_file_path = "/path/to/new/file"
[Link](old_file_path, new_file_path)
print(f"Renamed file from {old_file_path} to {new_file_path}")

Delete a file: Change the current working directory:

import os import os
file_path = "/path/to/file" [Link]("/new/working/directory")
[Link](file_path) print(f"Changed working directory to: {[Link]()}")
print(f"Deleted file: {file_path}")

Check if a file exists: Check if a path is a directory:

import os import os
file_path = "/path/to/file" dir_path = "/path/to/directory"
[Link](file_path): if [Link](dir_path):
print(f"{file_path} exists.") print(f"{dir_path} is a directory.")
else: else:
print(f"{file_path} does not exist.") print(f"{dir_path} is not a directory.")

[Link] Contact – 98859 46789 Page - 234

Python Numpy Tutorial

Introduction to Numpy:
• Python is a great general-purpose programming language.
• With the help of a few popular libraries (numpy, scipy, matplotlib) it becomes a powerful
environment for scientific computing.
• NumPy is a module for Python.
• The name is an acronym for "Numeric Python" or "Numerical Python".
• It is an extension module for Python, mostly written in C.
• This makes sure that the precompiled mathematical and numerical functions and
functionalities of Numpy guarantee great execution speed.
• NumPy enriches the programming language Python with powerful data structures,
implementing multi-dimensional arrays and matrices.
• The implementation is even aiming at huge matrices and arrays, better know under the
heading of "big data".

Installing other modules using pip:

cmd/> pip install <module-name>

# Create one dimensional array from a list

import numpy as np
my_list = [0,1,2,3,4]
my_arr = [Link](my_list)
print(type(my_arr))
print(my_arr)

Numpy − Ndarray Object

• ndarray() constructor is used to create an empty array
• ndarray() is belongs to NUMPY module.
• We need to specify the shape of array and type of array in the construction.

We can specify the type in the construction of Array:

importnumpy as np
arr = [Link](shape=(5),dtype=int)
print("Size :",[Link])
print("Datatype :",[Link])

[Link] Contact – 98859 46789 Page - 235

Display elements using for-loop :
import numpy as np
my_list = [0,1,2,3,4]
my_arr = [Link](my_list)
print("Elements : ")
for ele in my_arr :

print(ele)

Createone dimensional array from a list

importnumpy as np
my_list= [0,1,2,3,4]
my_array = [Link](my_list)
print(my_array)

Perform Element-Wise Addition of Two Arrays:

arr1 = [Link]([1, 2, 3])
arr2 = [Link]([4, 5, 6])
result = arr1 + arr2
print(result)

Perform Matrix Multiplication:

matrix1 = [Link]([[1, 2], [3, 4]])
matrix2 = [Link]([[5, 6], [7, 8]])
result = [Link](matrix1, matrix2)
print(result)

Generate a Sequence of Numbers:

sequence = [Link](1, 11) # Generates numbers from 1 to 10
print(sequence)

Calculate Mean, Median, and Standard Deviation:

data = [Link]([10, 20, 30, 40, 50])
mean = [Link](data)
median = [Link](data)
std_dev = [Link](data)
print("Mean:", mean)
print("Median:", median)
print("Standard Deviation:", std_dev)

[Link] Contact – 98859 46789 Page - 236

Reshape a NumPy Array:
arr = [Link]([1, 2, 3, 4, 5, 6])
reshaped = [Link](2, 3)
print(reshaped)

Transpose a Matrix:
import numpy as np
matrix = [Link]([[1, 2, 3], [4, 5, 6]])
transposed = [Link](matrix)
print(transposed)

Calculate Element-Wise Multiplication of Arrays:

import numpy as np
arr1 = [Link]([1, 2, 3])
arr2 = [Link]([4, 5, 6])
result = arr1 * arr2
print(result)

Find the Maximum and Minimum Values in an Array:

import numpy as np
arr = [Link]([3, 1, 4, 1, 5, 9, 2, 6, 5])
max_value = [Link](arr)
min_value = [Link](arr)
print("Max:", max_value)
print("Min:", min_value)

# Create two dimensional array from a nested list

import numpy as np
my_list = [[1,2,3],[4,5,6],[7,8,9]]
my_array = [Link](my_list)
print(my_array)

NumPy − Data Types

• In the definition of variable, it is recommended to specify its data type.
• Python object type need not be specified.
• If we don’t specify the type of elements which are storing in NUMPY object, it will
consider a default type.

Code:
importnumpy as np
arr = [Link](shape=(5))
print("Size :",[Link])
print("Datatype :",[Link])

[Link] Contact – 98859 46789 Page - 237

You may also specify the data type by setting the dtype argument. Some of the most
commonly used numpy dtypes are: 'float', 'int', 'bool', 'str' and 'object'.
import numpy as np
my_list = [[1,2,3],[4,5,6],[7,8,9]]
my_array = [Link](my_list, dtype=float)
print(my_array)

The decimal point after each number is indicative of the float datatype. You can also
convert it to a different datatype using the astype method.
import numpy as np
my_list = [[1,2,3],[4,5,6],[7,8,9]]
float_array = [Link](my_list, dtype=float)
print(float_array)
int_array = float_array.astype(int)
print(int_array)

# Convert to int then to str datatype

import numpy as np
my_list = [[1,2,3],[4,5,6],[7,8,9]]
float_array = [Link](my_list, dtype=float)
str_array = float_array.astype(int).astype(str)
print(str_array)

We can check the size, dimension and type of elements using pre-defined variables of
array object.
import numpy as np
my_list = [[1,2,3],[4,5,6],[7,8,9]]
my_array = [Link](my_list)
print(my_array)
print('Shape : ', my_array.shape)
print('Datatype : ', my_array.dtype)
print('Size : ', my_array.size)
print('Num Dimensions : ', my_array.ndim)

We can extract a set of elements from the array as follows :

import numpy as np
my_list = [[1,2,3],[4,5,6],[7,8,9]]
my_array = [Link](my_list)
print(my_array)
print("2x2 Array ")

[Link] Contact – 98859 46789 Page - 238

res = my_array[:2,:2]
print(res)
print("2x3 Array ")
res = my_array[:2,:3]
print(res)

print("3x2 Array ")

res = my_array[:3,:2]
print(res)

Display the elements of 2 Dimensional array:

import numpy as np
my_list = [[1,2,3],[4,5,6],[7,8,9]]
my_array = [Link](my_list)
print("Elements : ")
foriinrange(3):

forjin range(3):
print(my_array[i,j], end=' ')
print()

Matrixaddition program:
importnumpy as np
#Define two matrices
a= [Link]([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b= [Link]([[9, 8, 7], [6, 5, 4], [3, 2, 1]])

#Add the matrices

c= a + b
#Print the result
print(c)

[Link] Contact – 98859 46789 Page - 239

Python - Pandas

Introduction
• Pandas is a package/Module.
•Pandas is an open source
•Pandas is a collection (data structure).
•Pandas widely used in data analysis tools.
•Panda’s library uses most of the functionalities of Numpy library.

Pandas deals with 3 types of structures.

• Series: 1Dimensional data structure
• Data Frame: 2 Dimensional
• Panel: 3 Dimensional

Creating Series object: By default the datatype of series object is float like numpy array.
import pandas
s = [Link]()
print(s)

• In pandas, collection elements automatically get its index.

• If we store any object type(string), the dtype converts into object from default type(float).
• Every element in series is associated with default index value starts from 0.

importpandas as pd
importnumpy as np
arr=[Link](['a', 'b', 'c', 'd', 'e'])
s=[Link](arr)
print(s)

Output:
0 a
1 b
2 c
3 d
4 e
dtype:object

dtypes:
• Ifwe store integers, the dtype become int
• Ifwe store integers and floats, the dtype become float
• Ifwe store integers, floats, Strings…, the dtype become ‘Object’

[Link] Contact – 98859 46789 Page - 240

import pandas as pd
import numpy as np
arr = [Link]([10, 20, 30, 40, 50])
s = [Link](arr)
print(s)

Output:
0 10
1 20
2 30
3 40
4 50
dtype: int32

import pandas as pd
import numpy as np
arr = [Link]([10, 23.45, 30, "python"])
s = [Link](arr)
print(s)
Output:
0 10
1 23.45
2 30
3 python
dtype: object

• Series elements automatically assigned with index values starts with 0.

• We can specify the index explicitly.
• By using the argument ‘index’ of Series constructor, we can set index values.

import pandas as pd
import numpy as np
arr = [Link](['a', 'b', 'c', 'd', 'e'])
s = [Link](arr, index=[1,2,3,4,5])
print(s)
Output:
1 a
2 b
3 c
4 d
5 e
dtype: object

[Link] Contact – 98859 46789 Page - 241

Keys can be heterogeneous. When we specify the key set explicitly, we can provide
different types of keys for different elements.

importpandas as pd
importnumpy as np
arr=[Link](['a', 'b', 'c', 'd', 'e'])
s=[Link](arr, index=[10,23.45,'g',"key",20])
print(s)

Output:
10 a
23.45 b
g c
key d
20 e
dtype:object

Keyscanbe duplicated. We can see the accessibility of elements using duplicate keys
later.
importpandas as pd
importnumpy as np
arr = [Link](['a', 'b', 'c', 'd', 'e'])
s = [Link](arr, index=[10, 20, 10, 20, 10])
print(s)

Output:
10 a
20 b
10 c
20 d
10 e
dtype: object

• We can create series object from dictionary.

• Dictionary is a collection of keys and values.
• Dictionary keys become index in Pandas object.
• Values become elements in pandas object.

import pandas as pd
dictionary = {10:'A', 20:'B', 30:'C', 40:'D'}
s = [Link](dictionary)
print(s)

[Link] Contact – 98859 46789 Page - 242

Output:
10 A
20 B
30 C
40 D
dtype: object

Storing Scalar values into Series object:

import pandas as pd
s = [Link](5, index=[1,2,3,4,5])
print(s)

Output:
1 5
2 5
3 5
4 5
5 5
dtype: int64

We can process elements using loops:

• When we iterate elements using for loop, it returns only elements instead of index
values.
• Internally it process elements using their index only.

import pandas as pd
import numpy as np
List = [10,20,30,40,50]
arr = [Link](List)
series = [Link](arr)

print("Series object elements :")

for ele in series:
print(ele)

Output:
Series object elements :
10
20
30
40
50

[Link] Contact – 98859 46789 Page - 243

Access elements using indexing:

import pandas as pd
import numpy as np
arr = [Link]([10,20,30,40,50])
series = [Link](arr)
print("Series elements through indexing :")
print(series[2])
print(series[4])

Output: Series elements through

indexing : 30 50

• We can process elements through slicing.

• When we don’t specify the bounds, all elements will be processed.
• We can use negative indexing also to access the elements.

import pandas as pd
import numpy as np
arr = [Link]([10,20,30,40,50])
series = [Link](arr)
print("Series elements through slicing :")
print(series[:])
print()

print(series[1:4])
print()

• We can access elements with any type of index value.

• If the index is string type, we must specify the index value in quotes.

import pandas as pd
import numpy as np
arr = [Link]([10,20,30,40,50])
series = [Link](arr, index=['a', 'b', 'c', 'd', 'e'])
print(series['a'])
print(series['d'])
Output: 10 40

[Link] Contact – 98859 46789 Page - 244

When we access elements with duplicate keys, it display all elements associated with
duplicate keys.

import pandas as pd
import numpy as np
arr = [Link](['a', 'b', 'c', 'd', 'e'])
series = [Link](arr, index=[10,20,10,20,10])
print(series[10])
print(series[20])

Output:
10 a
10 c
10 e
dtype: object
20 b
20 d
dtype: object

Python – Data Frames:

• A data frame is a two dimensional data structure.
• In a frame, data is aligned in 2 dimensional format(rows & columns)
• DataFrame class is pre-defined in pandas module.
• By calling the constructor, we can create DataFrame object.
import pandas as pd
frame = [Link]()
print(frame)
Output:
Empty DataFrame
Columns: []
Index: []

• Indexing is applicable by default to rows.

• We generally assign column name for 2 dimensional data.
• The following table makes you understand that labels required only for columns.

[Link] Contact – 98859 46789 Page - 245

By default, indexing is applicable for both rows and columns:
• We create simple frame from 2 dimensional data.
• We use nested list to create the frame.
import pandas as pd
data = [[10,"abc"],[20,"xyz"],[30,"lmn"]]
frame = [Link](data)
print(frame)

Output:
0 1
010 abc
1 20 xyz
230 lmn

When we specify one dimensional list to create the frame, each element consider as one
row.
import pandas as pd
data = [10,20,30,40,50]
frame = [Link](data)
print(frame)
Output:
0
0 10
1 20
2 30
3 40
4 50

• We can set identities only to columns not to the rows.

• Row values represent index values.
• DataFrame constructor is providing only ‘columns’ argument by which we can specify the
names.

import pandas as pd
data = [[21,'amar'],[19,'annie'],[22,'hareen']]
frame = [Link](data, columns=['Age', 'Name'])
print(frame)
Output:
Age Name
0 21 amar
1 19 annie
2 22 hareen

[Link] Contact – 98859 46789 Page - 246

We can specify the datatype in the construction of Frame object.
import pandas as pd
data = [[21,'amar'],[19,'annie'],[22,'hareen']]
frame = [Link](data, columns=['Age', 'Name'], dtype=float)
print(frame)

Output:
Age Name
0 21.0 amar
1 19.0 annie
2 22.0 hareen

• We can construct the DataFrame from dictionary object.

• Column name we specify as key and Column values we must specify as List.
• By using comma separator, we can give number of columns in a single set/dictionary.

import pandas as pd
data = {'Name':['Syam', 'Ricky', 'Raksha', 'Kiritin'], 'Age':[21, 19, 23, 21]}
frame = [Link](data)
print(frame)

Output:
Age Name
021 Syam
1 19 Ricky
2 23 Raksha
3 21 Kiritin

[Link] Contact – 98859 46789 Page - 247

Python - MatPlotLib

Matplotlib:
• Open source module(package)
• Need to install using PIP.
• Matplotlib providing functionality for data visualization

Note: Compare to theoretical representation, we are easily understand visual representation.

If the things are more visualized then we can understand easily.

Visualization:
• Graphics provides an excellent approach for representing the data.
• The final results of anything are recommended to represent as a graph.
• With little knowledge of python pre-defined module called matplotlib, we can easily plot
graphs.

Pyplot:
• A module belongs to matplotlib package.
• Need to import from matplotlib
• Using plot() method of pyplot module, we can plot graphs

Plot():
• A method belongs to pyplot
• Plot() takes x-axis and y-axis values to plot.
• Show() method must be called to display the graph

from matplotlib import pyplot

x = [1, 2, 3]
y = [4, 5, 1]
[Link](x,y)
[Link]()

[Link] Contact – 98859 46789 Page - 248

• It is possible to set title to the Graph.
• We also give labels to x-axis and y-axis

from matplotlib import pyplot as plt

x = [5, 10, 15]
y = [3, 6, 2]
[Link](x,y)
[Link]("Custom Graph")
[Link]("y-axis")
[Link]("x-axis")
[Link]()

Notes:
• If we give only one set of values to generate the graph, it plots the x-axis range
automatically.
• What we provided will assume as sequence of y-axis values.
• X axis range starts with 0

from matplotlib import pyplot as plt

data = [4, 2, 8, 6, 1] # assume as y-axis
[Link](data)
[Link]("y-axis")
[Link]("x-axis")
[Link]()

[Link] Contact – 98859 46789 Page - 249

from matplotlib import pyplot as plt
data = [10, 20, 50, 70, 90]
[Link](data) [Link]("y-axis")
[Link]("x-axis") [Link]()

Format the plot:

• With the optional third argument, we can represent the format string.
• Format string is the combination and color and line type of plot.
• Default format string is ‘b-‘
• ‘b-‘ represents solid blue color line.

B : Blue marker

from matplotlib import pyplot as plt

x = [3,6,2,8,4]
y = [3,4,5,6,7]
[Link](x, y, 'ro')
[Link]("y-axis")
[Link]("x-axis")
[Link]()

[Link] Contact – 98859 46789 Page - 251

Garbage Collection

GarbageCollection:
• Python is fully Object Oriented Programming Language.
• InOOP application, data stores in the form of Objects.
• Weaccess the objects information using references.
• Garbage collection is the mechanism of deleting unreferenced objects.
• Anobject is said to be eligible for Garbage Collection when no pointer is pointing to that
object.
• Inpython garbage collection mechanism is much faster compare to other languages.

Inthefollowing program, object get different memory locations

class Test:
def__init__(self):
print("Constructed :",id(self))
return

classGCDemo:
defmain():
x=Test()
y=Test()
z=Test()
return
[Link]()

As soon the object is unused, GC will destroy that object. The same memory is allocated to
newly created object.

class Test:
def__init__(self):
print("Constructed :",id(self))
return

classGCDemo:
defmain():
Test()
Test()
Test()
return
[Link]()

[Link] Contact – 98859 46789 Page - 252

• Defining a variable inside the function is called Local variable.
• Local variable memory is not permanent
• Local variable will be deleted as soon as function execution completed.
• If the local variable is pointing to any object, then the object become unreferenced once
local variable memory will be released.
• The object pointing by local variables will be deleted as soon as function execution
completes.

class Test:
def fun():
x = []
[Link](10)
print("Address of x :", id(x))
return

class GCDemo:
def main():
[Link]()
[Link]()
[Link]()
return
[Link]()

• If the object is pointing to itself is called 'self referenced object'.

• “self” is pointing objects will not garbage collected as soon as they are unreferenced.

class Test:
def fun():
x = []
[Link](x)
print("Address of x :", id(x))
return

class GCDemo:
def main():
[Link]()
[Link]()
[Link]()
return
[Link]()

[Link] Contact – 98859 46789 Page - 253

Manual Garbage collection:
• In the above application, self referenced objects will not be garbage collected as soon as
they are unreferenced.
• To destroy such type of object manual garbage collection is required.
• We can reuse the memory quickly by deleting the unused objects.
• 'gc' is a pre-defined module providing functionality to implement manual garbage
collection.
• collect() method of gc module is used to destroy objects
import time
class Test:
def fun():
x = []
[Link](x)
print("Address of x :", id(x))
return
class GCDemo:
def main():
for i in range(20):
[Link]()
[Link](1)
return
[Link]()

• In the above application, all objects get different memory.

• These unused objects will be deleted with manual garbage collection as follows
import time
import gc
class Test:
def fun():
x = []
[Link](x)
print("Address of x :", id(x))
return
class GCDemo:
def main():
for i in range(20):
[Link]()
[Link]()
[Link](1)
return

[Link]()

[Link] Contact – 98859 46789 Page - 254

Nested Functions, Decorators and Closures

Nested Function:
o Anestedfunctionisa function defined inside another function.
o Thenestedfunctionhas access to the variables in the outer function's scope.

Simple Nested Function:

def outer_function():
def inner_function():
print("Thisisaninnerfunction.")
inner_function()

outer_function()

ReturningaNestedFunction:
def outer_function(x):
def inner_function(y):
return x + y
return inner_function

closure=outer_function(10)
result = closure(5)
print(result)

Using Arguments from Outer Function:

def exponentiate(base):
def power(exponent):
return base ** exponent
return power

square = exponentiate(2)
cube = exponentiate(3)
print(square(3))
print(cube(2))

[Link] Contact – 98859 46789 Page - 255

Closure:
• A closure is a function object that remembers values in the enclosing scope even if they
are not present in memory.
• It is a record that stores a function together with an environment
• A closure is created by returning a function object that accesses a variable in its
enclosing scope.

def outer(msg):

def inner():
print(msg)
return

return inner

print_msg = outer("Hello")
print_msg()

Decorator:
• A decorator is a special kind of function that takes another function and extends or
modifies its behavior without changing its source code.
• A decorator is defined using the @decorator_name syntax and is applied to a function by
placing it above the function definition.
• Decorators can be used to add logging, timing, validation, and other functionality to a
function without modifying the function's code directly.

defmy_decorator(func):
defwrapper():
print("Before the function is called.")
func()
print("After the function is called.")
return wrapper

@my_decorator
defsay_hello():
print("Hello!")

say_hello()

[Link] Contact – 98859 46789 Page - 256

Python Basics: Variables and Operators
No ratings yet
Python Basics: Variables and Operators
257 pages
Python Scripting Basics in CSE-111
No ratings yet
Python Scripting Basics in CSE-111
35 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
55 pages
Python Basics Cheat Sheet
No ratings yet
Python Basics Cheat Sheet
16 pages
Python Basics and Git Introduction
No ratings yet
Python Basics and Git Introduction
70 pages
Python Programming Basics Explained
No ratings yet
Python Programming Basics Explained
7 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
12 pages
Introduction to Python Programming Basics
No ratings yet
Introduction to Python Programming Basics
15 pages
Basic Elements of Python Programming
No ratings yet
Basic Elements of Python Programming
111 pages
Python Basics: Variables and Input
No ratings yet
Python Basics: Variables and Input
40 pages
Introduction to Programming Concepts
No ratings yet
Introduction to Programming Concepts
44 pages
Python Programming Basics and Concepts
No ratings yet
Python Programming Basics and Concepts
111 pages
Python Programming Basics: Variables & Types
No ratings yet
Python Programming Basics: Variables & Types
40 pages
Python Programming Lab Manual 01
No ratings yet
Python Programming Lab Manual 01
7 pages
Python Basics: Data Types and Variables
No ratings yet
Python Basics: Data Types and Variables
150 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
15 pages
Understanding Python Interpreter and Modes
No ratings yet
Understanding Python Interpreter and Modes
22 pages
Python Output for String Check
No ratings yet
Python Output for String Check
8 pages
Python Code for Printing Letters
No ratings yet
Python Code for Printing Letters
187 pages
Introduction to Python Programming Basics
No ratings yet
Introduction to Python Programming Basics
60 pages
Python Programming Constructs Overview
No ratings yet
Python Programming Constructs Overview
73 pages
Python Programming Language Overview
No ratings yet
Python Programming Language Overview
120 pages
Fundamentals of Programming Languages
No ratings yet
Fundamentals of Programming Languages
21 pages
Understanding Variables in Python Programming
No ratings yet
Understanding Variables in Python Programming
17 pages
Python Programming Guide and Features
No ratings yet
Python Programming Guide and Features
55 pages
Introduction To Programming 2 - Python - Week 1
No ratings yet
Introduction To Programming 2 - Python - Week 1
42 pages
Python Programming Basics Explained
No ratings yet
Python Programming Basics Explained
26 pages
FOP in Python: Overview and Usage
No ratings yet
FOP in Python: Overview and Usage
7 pages
Casting User Input to Integer in Python
No ratings yet
Casting User Input to Integer in Python
28 pages
Understanding Programming Languages Basics
No ratings yet
Understanding Programming Languages Basics
25 pages
Python Compiler Overview and Features
No ratings yet
Python Compiler Overview and Features
23 pages
Python Programming Basics and Concepts
No ratings yet
Python Programming Basics and Concepts
45 pages
Python Helper Methods Overview
No ratings yet
Python Helper Methods Overview
37 pages
1 Sequence
No ratings yet
1 Sequence
43 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
242 pages
Python Programming Notes Module 1
No ratings yet
Python Programming Notes Module 1
25 pages
Python Basics: Features and Syntax Guide
No ratings yet
Python Basics: Features and Syntax Guide
20 pages
Introduction to Python Programming Basics
No ratings yet
Introduction to Python Programming Basics
74 pages
Introduction to Python Programming Basics
No ratings yet
Introduction to Python Programming Basics
11 pages
Python Programming Methodologies
No ratings yet
Python Programming Methodologies
62 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
29 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
12 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
23 pages
Python Programming Basics Overview
No ratings yet
Python Programming Basics Overview
60 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
7 pages
Introduction to Python Programming Basics
No ratings yet
Introduction to Python Programming Basics
64 pages
Python Basics: Data Types & Variables
No ratings yet
Python Basics: Data Types & Variables
10 pages
Bca Python 4th Sem
No ratings yet
Bca Python 4th Sem
26 pages
Python Programming Basics Guide
No ratings yet
Python Programming Basics Guide
12 pages
Introduction to Python Programming Basics
No ratings yet
Introduction to Python Programming Basics
23 pages
CS111: Intro to Python Programming
No ratings yet
CS111: Intro to Python Programming
15 pages
Python Programming Basics for Beginners
No ratings yet
Python Programming Basics for Beginners
68 pages
Complete Python Notes
No ratings yet
Complete Python Notes
76 pages
Week1 Python Basics
No ratings yet
Week1 Python Basics
17 pages
02 Python Intro Installation Identifiers Variables SS
No ratings yet
02 Python Intro Installation Identifiers Variables SS
40 pages
Python Basics for Machine Learning
No ratings yet
Python Basics for Machine Learning
86 pages
Python Unit-1
No ratings yet
Python Unit-1
39 pages
Python Essentials for Beginners Course
No ratings yet
Python Essentials for Beginners Course
28 pages
Introduction to Python Programming
No ratings yet
Introduction to Python Programming
32 pages
Applications of Multiplexers & Demultiplexers
No ratings yet
Applications of Multiplexers & Demultiplexers
10 pages
CASIO - XJV1 Projector Manual
No ratings yet
CASIO - XJV1 Projector Manual
102 pages
Computer Science Books Inventory
0% (1)
Computer Science Books Inventory
29 pages
File System Concepts and Operations
No ratings yet
File System Concepts and Operations
30 pages
MyISAM and InnoDB Storage Engines Overview
No ratings yet
MyISAM and InnoDB Storage Engines Overview
2 pages
FPE R63 and R43 Specifications Overview
No ratings yet
FPE R63 and R43 Specifications Overview
25 pages
Fuzzy Logic in Pattern Recognition
No ratings yet
Fuzzy Logic in Pattern Recognition
20 pages
Network Security Audit Checklist
No ratings yet
Network Security Audit Checklist
10 pages
ARM Processor Overview and Instruction Set
No ratings yet
ARM Processor Overview and Instruction Set
9 pages
Java Arrays: Basics and Examples
No ratings yet
Java Arrays: Basics and Examples
15 pages
OCNA Wireless Certification Course Guide
No ratings yet
OCNA Wireless Certification Course Guide
162 pages
Android App Development Lab Manual
No ratings yet
Android App Development Lab Manual
59 pages
Industry 4.0: Transforming Manufacturing
No ratings yet
Industry 4.0: Transforming Manufacturing
6 pages
Understanding the Domain Name System
No ratings yet
Understanding the Domain Name System
13 pages
IPC Mechanisms in Operating Systems
No ratings yet
IPC Mechanisms in Operating Systems
25 pages
Token Separation in Compiler Design
82% (11)
Token Separation in Compiler Design
47 pages
Professional Report Creation in Word
No ratings yet
Professional Report Creation in Word
2 pages
Azure Exam
No ratings yet
Azure Exam
28 pages
Arduino Web Server for Analog Inputs
No ratings yet
Arduino Web Server for Analog Inputs
6 pages
Computer Science Loop Practice XI
No ratings yet
Computer Science Loop Practice XI
5 pages
Effective ChatGPT Coding Prompts
No ratings yet
Effective ChatGPT Coding Prompts
4 pages
Intel® Product Compatibility Tool
No ratings yet
Intel® Product Compatibility Tool
5 pages
Modern C++ Programming Essentials
No ratings yet
Modern C++ Programming Essentials
10 pages
Micron 4Gb-16Gb NAND Flash Memory Specs
No ratings yet
Micron 4Gb-16Gb NAND Flash Memory Specs
134 pages
Defining Network Source of Truth in IaC
No ratings yet
Defining Network Source of Truth in IaC
98 pages
MiCOM P633 Order Form and Configurator
No ratings yet
MiCOM P633 Order Form and Configurator
14 pages
Comprehensive ADB Commands Guide
67% (3)
Comprehensive ADB Commands Guide
6 pages
Women's Safety App Micro Project Report
100% (1)
Women's Safety App Micro Project Report
45 pages
S7-1500F Safety PLC Workshop Guide
No ratings yet
S7-1500F Safety PLC Workshop Guide
93 pages
Movilizer Demo User Setup Guide
No ratings yet
Movilizer Demo User Setup Guide
45 pages