INTRODUCTION

WHAT IS PYTHON?

Python is a powerful modern computer programming language. It allows

some similarities to Fortran, one of the earliest programming languages, but it is
much more powerful than Fortran.
Python allows you to use variables without declaring them and it relies on
indentation as a control structure. You are not forced to define classes in
Python(unlike Java) but you are free to do so when convenient.

WHY PYTHON?
1. Simple syntax
2. Free, Open source

3. Interpreted Language
4. Good support
5. Short programs
6. Multi-platform support

TWO MODES OF PYTHON:

 Interactive Mode

 Script Mode
1.PROGRAM TO FIND THE GCD OF TWO NUMBERS:

n1= int(input("enter a number:"))

n2=int(input("enter another number:"))

rem =n1%n2

while rem!=0:

n1 = n2

n2 = rem

rem = n1% n2

print ("gcd of the given number is :",n2)

OUTPUT:

COMPUTE GCD OF TWO NUMBERS

Enter a number:54

Enter the another number:24

GCD of given number is:6

Enter a number:54

Enter the another number:45

GCD of given number is:9

 2. FIND THE SQUARE ROOT OF THE NUMBER

(NEWTON’S METHOD):

def newtonSqrt(n):

approx = 0.5 * n

better = 0.5 * (approx + n/approx)

while better != approx:

approx = better

better = 0.5 * (approx + n/approx)

return approx

n=int(input('Enter upper limit:'))

for i in range (1,n):

print('square root of ',i,'is:',newtonSqrt(i))

OUTPUT:

Enter upper limit: 5

square root of 1 is 1.0

square root of 2 is 1.414213562373095

square root of 3 is 1.7320508075688772

square root of 4 is 2.0

 3.TO COMPUTE EXPONENTATION
(POWER OF A NUMBER):
n=int(input(“enter a number:”))

e=int(input(“enter exponent:”))

r=n

for i in range (1,e):

r=n*r

print(‘exponentiation is :’,r)
OUTPUT:

Enter number:25

Enter exponent:2

Exponent is :625
4.TO FIND THE MAXIMUM AND MINIMUM OF A LIST OF
NUMBERS:

list=[]

n=int(input("enter the upper limit"))

for i in range(0,n):

a=int(input("enter the numbers"))

list.append(a)

maxno =list[0]

minno =list[0]

for i in range(len(list)):

if list[i]>maxno:

maxno=list[i]

if list[i]<minno:

minno=list[i]

print("maximum number of the list:",maxno)

print("minimum number of the list:",minno)

OUTPUT:

enter the upper limit:

enter the numbers:

maximum number of the list: 9

minimum number of the list: 1

 5a.TO IMPLEMENT LINEAR SEARCH:

list = [14, 20, 58, 90, 3, 17]

x = int(input("Enter number to search: "))

found = False

for i in range(len(list)):

if(list[i] == x):

found = True

print("%d found at %dth position"%(x,i))

break

else:

print("%d is not in list"%x)

OUTPUT:

Enter number to search: 90

90 found at 4th position

 5b. IMPLEMENT BINARY SEARCH:

def Binary_search(arr,start,last,element):

mid =(int)(start+last)/2

if(start>last):

print "Element not found"

elif (element>arr[mid]):

start = mid+1

Binary_search(arr,start,last,element)

elif (element<arr[mid]):

last = mid-1

Binary_search(arr,start,last,element)

else:

print "Element is present at index " + str(mid)

arr = [2,14,19,21,99,100,102,103,104,181]

element = 100

start = 0

last = len(arr)-1

Binary_search(arr,start,last,element)
OUTPUT:

Element is present at index 5

 6a.TO IMPLEMENT SELECTION SORT:

def ssort (alist):

for i in range (len (alist)):

least=i

for k in range (i+1,len (alist)):

if alist [k]<alist [least]:

least=k

swap (alist ,least,i)

def swap(a,x,y):

tmp =a[x]

a[x]=a[y]

a[y]=tmp

return (a,x,y)

a=[]

n= int(input ("enter the upper limit:"))

for i in range (n):

a.append(int(input ()))

ssort(a)

print ("after sorting ",a)

OUTPUT:

enter the upper limit:9

after sorting [1, 2, 3, 3, 4, 5, 5, 7, 8]

 6b.TO IMPLEMENT INSERTION SORT:

def isort(a):

for index in range(1,len(a)):

currentvalue =a[index]

position=index

while position>0 and a[position-1]>currentvalue:

a[position]=a[position-1]

position=position-1

a[position]=currentvalue

a=[]

n=int(input('Enter the upper limit:'))

for index in range(n):

a.append(int(input()))

isort(a)

print ("List after insertion:",a)

OUTPUT:

Enter the upper limit:5

List after insertion: [2, 3, 5, 6, 8]

 7.TO IMPLEMENT MERGE SORT:

def mergesort(alist):

print("splitting",alist)

if len(alist)>1:

mid = len(alist)//2

lefthalf = alist[:mid]

righthalf = alist[mid:]

mergesort(lefthalf)

mergesort(righthalf)

i=0

j=0

k=0

while i < len(lefthalf) and j < len(righthalf):

if lefthalf[i] < righthalf[j] :

alist[k] = lefthalf[i]

i=i+1

k=k+1

else:

alist[k] = righthalf[j]

j = j+1

k = k+1

while i <len(lefthalf):

alist[k] = lefthalf[i]
 i = i+1

k = k+1

while j <len(righthalf):

alist[k] = righthalf[j]

j = j+1

k = k+1

print("merging",alist)

alist=[13,2,17,76,82,12,7]

mergesort (alist)

print (alist)
OUTPUT:
splitting [13, 2, 17, 76, 82, 12, 7]
splitting [13, 2, 17]
splitting [13]
merging [13]
splitting [2, 17]
splitting [2]
merging [2]
splitting [17]
merging [17]
merging [2, 17]
merging [2, 13, 17]
splitting [76, 82, 12, 7]
splitting [76, 82]
splitting [76]
merging [76]
splitting [82]
merging [82]
merging [76, 82]
splitting [12, 7]
splitting [12]
merging [12]
splitting [7]
merging [7]
merging [7, 12]
merging [7, 76, 82, 12]
merging [2, 13, 17, 7, 76, 82, 12]
[2, 13, 17, 7, 76, 82, 12]
 8. FIRST n PRIME NUMBERS

n=int(input('enter the upper limit:'))

for num in range(1,n):

for i in range(2,num):

if num%i == 0:

j=num/i

print('%d equals %d * %d'%(num,i,j))

break

else:

print(num, 'is a prime number')

OUTPUT:

Enter the upper limit:6

1 is a prime number

2 is a prime number

3 is a prime number

4 equals 2*2

5 is a prime number

6 equals 2*3
 9. MULTIPLY MATRICES:

A=[[1,2],

[3,4]]

B=[[1,2],

[3,4]]

C=[[0,0],

[0,0]]

For i in range (len(a)):

For j in range(len(b[0])):

For k in range(len(b)):

C[i][j] += a[i][k] * b[k][j]

Print (“resultant matrix”)

For r in c:

Print(r)
OUTPUT:
Resultant matrix

[7, 10]

[15, 22]
 10.COMMAND LINE ARGUMENTS (WORD COUNT)

import sys

parser = argparse.ArgumentParser()

parser.add_argument('--words','-w', action='store_true')

parser.add_argument('--lines','-l', action='store_true')

parser.add_argument('filename')

args = parser.parse_args()

if args.words:

print "words in a file: {}" .format(print_words(args.filename))

elif args.lines:

print "lines in a file: {}" .format(print_lines(args.filename))

else:

print "words in a file: {}" .format(print_words(args.filename))

print "lines in a file: {}" .format(print_lines(args.filename))

OUTPUT:

Python main .py -i input.txt

Word in a file 23

Lines in a file 1
11.TO FIND THE MOST FREQUENT WORDS IN A TEXT
READ FROM A FILE:
def main():

filename =input ("enter a filename: ").strip()

infile=open(filename, "r")

wordcounts={}

for line in infile :

processLine(line.lower(),wordcounts)

pairs=list(wordcounts.items())

items =[[x,y] for(y,x) in pairs]

items.sort()

for i in range (len(items)-1,len(items)-11,-1):

print(items[i][1]+ "\t" + str(items[i][0]))

def processLine (line,wordcounts):

line=replacepunctuations (line)

words =line.split()

for word in words:

if word in wordcounts:

wordcounts[word] += 1

else:

wordcounts[word]=1

def replacepunctuations(line):

for ch in line:

if ch in "-@#$%^&*()_+=_<>?/,.;:!{}[]'\"":

line=line.replace(ch,"")

return line
main()

OUTPUT:
enter a filename: cse.txt

hi 1

how 1

are 1

you 1
 12. SIMULATE ELLIPTICAL ORBITS IN PYGAME

import math
import random
import pygame
class Particle ():
def __init__ (self, x, y, colour=0x000000):
self.x = x
self.y = y s
elf.vx = 0
self.vy = 0
self.colour = colour
def apply_gravity (self, target):
dsqd = (self.x - target.x) ** 2 + (self.y - target.y) ** 2
#g = G*m/dsqd * normalized (self - target)
if dsqd == 0:
return

self.vx += -1 / dsqd * (self.x - target.x) / dsqd ** 0.5

self.vy += -1 / dsqd * (self.y - target.y) / dsqd ** 0.5

def update (self):

self.x += self.vx

self.y += self.vy

pygame.init()

window = pygame.display.set_mode ((600, 400))

main_surface = pygame.Surface ((600, 400))

colours = [0x000000, 0x111111, 0x222222, 0x333333, 0x444444, 0x555555,

0x666666,

0x777777, 0x888888, 0x999999, 0xaaaaaa, 0xbbbbbb] + [0xFF0000,

0x00FF00, 0x0000FF, 0xFFFF00, 0xFF00FF, 0x00FFFF, 0x888888,
0xFFFFFF, 0x808000, 0x008080, 0x800080,

0x800000]

#colours = [0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0xFF00FF,

0x00FFFF, 0x888888

0xFFFFFF, 0x808000, 0x008080, 0x800080, 0x800000]

particles = [Particle (200, 100, colours [i]) for i in range (20)]

earth = Particle (200, 200)

for i, p in enumerate (particles):

p.vx = i / 100

while (True):

# main_surface.fill(0x000000)

pygame.draw.circle (main_surface, 0x00FF00, (earth.x, earth.y), 5, 2)

for p in particles:

p.apply_gravity (earth)

p.update ()

pygame.draw.circle (main_surface, p.colour, (int (p.x), int (p.y)), 5, 2)

window.blit(main_surface, (0, 0)) pygame.

display.flip()
OUTPUT:
 13. SIMULATE BOUNCING BALL
import sys
import pygame
pygame.init()
size = width, height = 320, 240
speed = [2, 2]
black = 0, 0, 0
screen = pygame.display.set_mode(size)
ball = pygame.image.load('C:\\Users\\admin\\Desktop//ball.jpg')
ballrect = ball.get_rect()
while 1:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit() ballrect = ballrect.move(speed)
if ballrect.left < 0 or ballrect.right > width:
speed[0] = -speed[0]
if ballrect.top < 0 or ballrect.bottom > height:
speed[1] = -speed[1] screen.fill(black) screen.blit(ball, ballrect)
pygame.display.flip()
OUTPUT: